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

data/ruby/neo4j/driver/internal/util/iterables.rb

@@ -1,35 +0,0 @@
-module Neo4j::Driver
-  module Internal
-    module Util
-      class Iterables
-        EMPTY_QUEUE = Queue.new
-
-        class << self
-          def single(it)
-            if it.empty?
-              raise ArgumentError, 'Given iterable is empty'
-            end
-
-            result = it.first
-
-            if it.size > 1
-              raise ArgumentError, "Given iterable contains more than one element: #{it}"
-            end
-
-            result
-          end
-
-          def map(alternating_key_value)
-            out = {}
-
-            (0...alternating_key_value.length).step(2) do |i|
-              out[i] = out[i+1]
-            end
-
-            out
-          end
-        end
-      end
-    end
-  end
-end

data/ruby/neo4j/driver/internal/util/lock_util.rb

@@ -1,23 +0,0 @@
-module Neo4j::Driver
-  module Internal
-    module Util
-      class LockUtil
-        class << self
-          def execute_with_lock(lock)
-            lock.lock
-            begin
-              yield
-            ensure
-              lock.unlock
-            end
-          end
-
-          def execute_with_lock_async(lock)
-            lock.lock
-            Concurrent::Promises.fulfilled_future(lock).then_flat { yield }.on_fulfillment! { lock.unlock }
-          end
-        end
-      end
-    end
-  end
-end

data/ruby/neo4j/driver/internal/util/metadata_extractor.rb

@@ -1,107 +0,0 @@
-module Neo4j::Driver
-  module Internal
-    module Util
-      class MetadataExtractor
-        def initialize(result_available_after_metadata_key, result_consumed_after_metadata_key)
-          @result_available_after_metadata_key = result_available_after_metadata_key
-          @result_consumed_after_metadata_key = result_consumed_after_metadata_key
-        end
-
-        def extract_query_keys(metadata)
-          metadata[:fields]&.map(&:to_sym) || []
-        end
-
-        def extract_query_id(metadata)
-          metadata[:qid]
-        end
-
-        def extract_result_available_after(metadata)
-          metadata[@result_available_after_metadata_key]
-        end
-
-        def extract_summary(query, connection, result_available_after, metadata)
-          server_info = Summary::InternalServerInfo.new(connection.server_agent, connection.server_address.to_s, connection.server_version, connection.protocol.version)
-          db_info = self.class.extract_database_info(metadata)
-          Summary::InternalResultSummary.new(
-            query, server_info, db_info, self.class.extract_query_type(metadata), self.class.extract_counters(metadata),
-            self.class.extract_plan(metadata), self.class.extract_profiled_plan(metadata),
-            self.class.extract_notifications(metadata), result_available_after,
-            self.class.extract_result_consumed_after(metadata, @result_consumed_after_metadata_key))
-        end
-
-        class << self
-          def extract_database_info(metadata)
-            metadata[:db]&.then(&Summary::InternalDatabaseInfo.method(:new)) ||
-              Summary::InternalDatabaseInfo::DEFAULT_DATABASE_INFO
-          end
-
-          def extract_bookmarks(metadata)
-            bookmark_value = metadata[:bookmark]
-
-            return InternalBookmark.parse(bookmark_value) if bookmark_value&.is_a? String
-
-            InternalBookmark.empty
-          end
-
-          def extract_neo4j_server_version(metadata)
-            server_value = extract_server(metadata)
-            server = Util::ServerVersion.version(server_value)
-            return server if Util::ServerVersion::NEO4J_PRODUCT.casecmp?(server.product)
-            raise Neo4j::Driver::Exceptions::UntrustedServerException, "Server does not identify as a genuine Neo4j instance: #{server.product}"
-          end
-
-          def extract_server(metadata)
-            metadata[:server].tap do |version_value|
-              unless version_value
-                raise Neo4j::Driver::Exceptions::UntrustedServerException, 'Server provides no product identifier'
-              end
-            end
-          end
-
-          def extract_query_type(metadata)
-            metadata[:type]
-          end
-
-          def extract_counters(metadata)
-            counters_value = metadata[:stats]
-            counters_value &&
-              Summary::InternalSummaryCounters.new(
-                *%i[
-                nodes-created
-                nodes-deleted
-                relationships-created
-                relationships-deleted
-                properties-set
-                labels-added
-                labels-removed
-                indexes-added
-                indexes-removed
-                constraints-added
-                constraints-removed
-                system-updates
-            ].map { |key| counters_value[key].to_i }
-              )
-          end
-
-          def extract_plan(metadata)
-            metadata[:plan]&.then(&Summary::InternalPlan::EXPLAIN_PLAN_FROM_VALUE)
-          end
-
-          def extract_profiled_plan(metadata)
-            metadata[:profile]&.then(&Summary::InternalProfiledPlan::PROFILED_PLAN_FROM_VALUE)
-          end
-
-          def extract_notifications(metadata)
-            metadata[:notifications]&.then do |notifications|
-              notifications.map(&Summary::InternalNotification::VALUE_TO_NOTIFICATION)
-            end
-          end
-
-          def extract_result_consumed_after(metadata, key)
-            metadata[key]&.to_i
-          end
-        end
-      end
-    end
-  end
-end

data/ruby/neo4j/driver/internal/util/mutex.rb

@@ -1,9 +0,0 @@
-module Neo4j::Driver::Internal
-  module Util
-    class Mutex < Mutex
-      def synchronize
-        owned? ? yield : super
-      end
-    end
-  end
-end

data/ruby/neo4j/driver/internal/util/preconditions.rb

@@ -1,16 +0,0 @@
-module Neo4j::Driver
-  module Internal
-    module Util
-      class Preconditions
-        # Assert that given expression is true.
-
-        # @param expression the value to check.
-        # @param message the message.
-        # @throws IllegalArgumentException if given value is {@code false}.
-        def self.check_argument(expression, message)
-          raise ArgumentError, message unless expression
-        end
-      end
-    end
-  end
-end

data/ruby/neo4j/driver/internal/util/result_holder.rb

@@ -1,72 +0,0 @@
-module Neo4j::Driver
-  module Internal
-    module Util
-      class ResultHolder
-        attr :error
-
-        def self.successful(result = nil)
-          new.tap { |holder| holder.succeed(result) }
-        end
-
-        def self.failed(error)
-          new.tap { |holder| holder.fail(error) }
-        end
-
-        def succeed(result = nil)
-          if @completed
-            false
-          else
-            @result = result
-            true
-          end
-        ensure
-          @completed = true
-        end
-
-        def fail(error)
-          if @completed
-            false
-          else
-            @error = error
-            true
-          end
-        ensure
-          @completed = true
-        end
-
-        def result!
-          raise @error if @error
-          @result
-        end
-
-        def then
-          @error ? self : ResultHolder.successful(yield(@result))
-        end
-
-        # &block returns a ResultHolder
-        def compose
-          @error ? self : yield(@result)
-        end
-
-        def chain
-          ResultHolder.successful(yield(@result, @error))
-        rescue => error
-          ResultHolder.failed(error)
-        end
-
-        def side
-          yield(@result, @error)
-          self
-        end
-
-        def copy_to(result_holder)
-          if @error
-            result_holder.fail(@error)
-          else
-            result_holder.succeed(@result)
-          end
-        end
-      end
-    end
-  end
-end

data/ruby/neo4j/driver/internal/util/server_version.rb

@@ -1,60 +0,0 @@
-module Neo4j::Driver
-  module Internal
-    module Util
-      class ServerVersion < Struct.new(:product, :major, :minor, :patch)
-        include Comparable
-        NEO4J_PRODUCT = 'Neo4j'
-        V4_4_0 = new(NEO4J_PRODUCT, 4, 4, 0)
-        V4_3_0 = new(NEO4J_PRODUCT, 4, 3, 0)
-        V4_2_0 = new(NEO4J_PRODUCT, 4, 2, 0)
-        V4_1_0 = new(NEO4J_PRODUCT, 4, 1, 0)
-        V4_0_0 = new(NEO4J_PRODUCT, 4, 0, 0)
-        V3_5_0 = new(NEO4J_PRODUCT, 3, 5, 0)
-        V3_4_0 = new(NEO4J_PRODUCT, 3, 4, 0)
-        V_IN_DEV = new(NEO4J_PRODUCT)
-        NEO4J_IN_DEV_VERSION_STRING = "#{NEO4J_PRODUCT}/dev"
-        PATTERN = Regexp.new '([^/]+)/(\\d+)\\.(\\d+)(?:\\.)?(\\d*)(\\.|-|\\+)?([0-9A-Za-z\-.]*)?'
-
-        def <=>(other)
-          unless product == other.product
-            raise ArgumentError, "Comparing different products #{product}  with #{other.product}"
-          end
-          values <=> other.values
-        end
-
-        def to_s
-          major || minor || patch ? "#{product}/#{major}.#{minor}.#{patch}" : NEO4J_IN_DEV_VERSION_STRING
-        end
-
-        def self.version(server)
-          PATTERN.match(server) do |matchdata|
-            product = matchdata[1]
-            major = matchdata[2].to_i
-            minor = matchdata[3].to_i
-            patch = matchdata[4].to_i
-            return new(product, major, minor, patch)
-          end
-          return V_IN_DEV if server.casecmp?(NEO4J_IN_DEV_VERSION_STRING)
-          raise ArgumentError, "Cannot parse #{server}"
-        end
-
-        def self.from_bolt_protocol_version(protocol_version)
-          case protocol_version
-          when Messaging::V4::BoltProtocolV4::VERSION
-            V4_0_0
-          when Messaging::V41::BoltProtocolV41::VERSION
-            V4_1_0
-          when Messaging::V42::BoltProtocolV42::VERSION
-            V4_2_0
-          when Messaging::V43::BoltProtocolV43::VERSION
-            V4_3_0
-          when Messaging::V44::BoltProtocolV44::VERSION
-            V4_4_0
-          else
-            V_IN_DEV
-          end
-        end
-      end
-    end
-  end
-end

data/ruby/neo4j/driver/logging1.rb

@@ -1,51 +0,0 @@
-module Neo4j
-  module Driver
-    module Logging1
-      # Obtain a {@link Logger} instance by class, its name will be the fully qualified name of the class.
-
-      # @param clazz class whose name should be used as the {@link Logger} name.
-      # @return {@link Logger} instance
-      private
-
-      def log(clazz)
-        canonical_name = clazz.canonical_name
-        log(canonical_name.nil? ? clazz.name : canonical_name)
-      end
-
-      # Create logging implementation that uses SLF4J.
-
-      # @return new logging implementation.
-      # @throws IllegalStateException if SLF4J is not available.
-      def slf4j
-        unavailability_error = Internal::Logging::Slf4jLogging.check_availability
-
-        raise unavailability_error unless unavailability_error.nil?
-
-        Slf4jLogging.new
-      end
-
-      # Create logging implementation that uses {@link java.util.logging}.
-
-      # @param level the log level.
-      # @return new logging implementation.
-      def java_util_logging(level)
-        Internal::Logging::JULogging.new(level)
-      end
-
-      # Create logging implementation that uses {@link java.util.logging} to log to {@code System.err}.
-
-      # @param level the log level.
-      # @return new logging implementation.
-      def console(level)
-        Internal::Logging::ConsoleLogging.new(level)
-      end
-
-      # Create logging implementation that discards all messages and logs nothing.
-
-      # @return new logging implementation.
-      def none
-        Internal::Logging::DevNullLogging::DEV_NULL_LOGGING
-      end
-    end
-  end
-end

data/ruby/neo4j/driver/net/server_address.rb

@@ -1,9 +0,0 @@
-module Neo4j::Driver
-  module Net
-    module ServerAddress
-      def self.of(host, port)
-        Internal::BoltServerAddress.new(host: host, port: port)
-      end
-    end
-  end
-end

data/ruby/neo4j/driver/query.rb

@@ -1,48 +0,0 @@
-module Neo4j
-  module Driver
-    # The components of a Cypher query, containing the query text and parameter map.
-
-    # @see Session
-    # @see Transaction
-    # @see Result
-    # @see Result#consume()
-    # @see ResultSummary
-    # @since 1.0
-    class Query < Struct.new(:text, :parameters)
-      def initialize(text, **parameters)
-        super(self.class.validated_query_text(text), Values.value(parameters))
-      end
-
-      # @param newText the new query text
-      # @return a new Query object with updated text
-      def with_text(new_text)
-        new(new_text, parameters)
-      end
-
-      def with_parameters(new_parameters)
-        new(text, new_parameters)
-      end
-
-      # Create a new query with new parameters derived by updating this'
-      # query's parameters using the given updates.
-
-      # Every update key that points to a null value will be removed from
-      # the new query's parameters. All other entries will just replace
-      # any existing parameter in the new query.
-
-      # @param updates describing how to update the parameters
-      # @return a new query with updated parameters
-      def with_updated_parameters(**updates)
-        with_parameters(parameters.merge(updates))
-      end
-
-      private
-
-      def self.validated_query_text(query)
-        Internal::Util::Preconditions.check_argument(query, 'Cypher query text should not be nil')
-        Internal::Util::Preconditions.check_argument(query.present?, 'Cypher query text should not be an empty string')
-        query
-      end
-    end
-  end
-end

data/ruby/neo4j/driver/records.rb

@@ -1,13 +0,0 @@
-module Neo4j
-  module Driver
-    # Static utility methods for retaining records
-
-    # @see Result#list()
-    # @since 1.0
-    class Records
-      def self.column(index, map_function)
-        java.util.function.Function.new.apply{ |record| map_function.apply(record[index]) }
-      end
-    end
-  end
-end

data/ruby/neo4j/driver/transaction_config.rb

@@ -1,50 +0,0 @@
-module Neo4j
-  module Driver
-    # Configuration object containing settings for transactions.
-    # Instances are immutable and can be reused for multiple transactions.
-    # <p>
-    # Configuration is supported for:
-    # <ul>
-    # <li>queries executed in auto-commit transactions - using various overloads of {@link Session#run(String, TransactionConfig)} and
-    # {@link AsyncSession#runAsync(String, TransactionConfig)}</li>
-    # <li>transactions started by transaction functions - using {@link Session#readTransaction(TransactionWork, TransactionConfig)},
-    # {@link Session#writeTransaction(TransactionWork, TransactionConfig)}, {@link AsyncSession#readTransactionAsync(AsyncTransactionWork, TransactionConfig)} and
-    # {@link AsyncSession#writeTransactionAsync(AsyncTransactionWork, TransactionConfig)}</li>
-    # <li>unmanaged transactions - using {@link Session#beginTransaction(TransactionConfig)} and {@link AsyncSession#beginTransactionAsync(TransactionConfig)}</li>
-    # </ul>
-    # <p>
-    # Creation of configuration objects can be done using the builder API:
-    # <pre>
-    # {@code
-    # Map<String, Object> metadata = new HashMap<>();
-    # metadata.put("type", "update user");
-    # metadata.put("application", "my application");
-    #  TransactionConfig config = TransactionConfig.builder()
-    #                  .withTimeout(Duration.ofSeconds(4))
-    #                  .withMetadata(metadata)
-    #                  .build();
-    #  }
-    #  </pre>
-    # @see Session
-    class TransactionConfig < Hash
-      EMPTY = new
-
-      def initialize(timeout: nil, metadata: {})
-        Internal::Util::Preconditions.check_argument(timeout.nil? || timeout.positive?, 'Transaction timeout should be positive')
-        Internal::Validator.require_non_nil!(metadata)
-        merge!(timeout: timeout, metadata: metadata)
-      end
-
-      def self.empty
-        EMPTY
-      end
-
-      # Check if this configuration object contains any values.
-
-      # @return {@code true} when no values are configured, {@code false otherwise}.
-      def empty?
-        fetch(:timeout).nil? && fetch(:metadata).blank?
-      end
-    end
-  end
-end

data/ruby/neo4j/driver/values.rb

@@ -1,26 +0,0 @@
-module Neo4j
-  module Driver
-    module Values
-      def self.value(value)
-        this_method = method(:value)
-        case value
-        when nil, TrueClass, FalseClass, Integer, Float, String, Symbol, Bookmark, ActiveSupport::Duration,
-          Types::Point, Types::Time, Time, Date
-          value
-        when Hash
-          value.transform_keys(&this_method).transform_values(&this_method)
-        when Internal::InternalPath
-          nonconvertible(value)
-        when Enumerable
-          value.map(&this_method)
-        else
-          nonconvertible(value)
-        end
-      end
-
-      def self.nonconvertible(value)
-        raise Exceptions::ClientException, "Unable to convert #{value.class.name} to Neo4j Value."
-      end
-    end
-  end
-end

data/ruby/neo4j/driver.rb

@@ -1,28 +0,0 @@
-# frozen_string_literal: true
-
-require 'active_support/core_ext/array/grouping'
-require 'active_support/core_ext/hash/keys'
-require 'active_support/logger'
-require 'async/io'
-require 'async/io/stream'
-require 'async/queue'
-require 'bigdecimal'
-require 'connection_pool'
-require 'neo4j-ruby-driver_loader'
-
-module Neo4j
-  module Driver
-    Loader.load
-
-    Record = Neo4j::Driver::Internal::InternalRecord
-    Result = Neo4j::Driver::Internal::InternalResult
-    Transaction = Neo4j::Driver::Internal::InternalTransaction
-
-    module Types
-      Entity = Neo4j::Driver::Internal::InternalEntity
-      Node = Neo4j::Driver::Internal::InternalNode
-      Path = Neo4j::Driver::Internal::InternalPath
-      Relationship = Neo4j::Driver::Internal::InternalRelationship
-    end
-  end
-end