neo4j-ruby-driver 1.7.4 → 4.4.0

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

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

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

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

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

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

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

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

@@ -0,0 +1,26 @@
+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/{lib → ruby}/neo4j/driver/version.rb

@@ -2,6 +2,6 @@
 
 module Neo4j
   module Driver
-    VERSION = '1.7.4'
+    VERSION = '4.4.0'
   end
 end

data/ruby/neo4j/driver.rb

@@ -0,0 +1,29 @@
+# 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 'connection_pool'
+require 'bigdecimal'
+require 'date'
+require 'loader'
+
+Loader.load
+
+module Neo4j
+  module Driver
+    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