neo4j-ruby-driver 4.4.0-java

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: bab0100e6ebde4c4522a587dc4f5d3448cd2ba9d014814c427d907432ebc3627
+  data.tar.gz: 4907a712afbce45c27b89672258c288303b757e88913c0037bf9edb078bc5e17
+SHA512:
+  metadata.gz: 00eb88088196a005182e951e23b034ae14268023db985432770b9ead9b558925bd214491d3e2c7841697b3fcc4163e5bd35d3c3ff708a834322e2039e7fe4566
+  data.tar.gz: 6b25acdd0734c8876e7380293763093382ae2d1561f601ef48373b0e79c742e2d9a201bb55156eae3e8af0df543087ecd3c79ab9534731a83a9c7d80c24f7530

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2018 Heinrich Klobuczek
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,72 @@
+# Neo4j::Driver
+
+home  :: https://github.com/neo4jrb/neo4j-ruby-driver
+
+This repository contains 2 implementation of a neo4j driver for ruby:
+- based on official java implementation. It provides a thin wrapper over the java driver (only on jruby).
+- pure ruby implmementation. Available on all ruby versions >= 3.1.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'neo4j-ruby-driver'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install neo4j-ruby-driver
+
+## Server Compatibility
+
+The compatibility with Neo4j Server versions is documented in the [Neo4j Knowledge Base](https://neo4j.com/developer/kb/neo4j-supported-versions/).
+
+## Usage
+
+The API is to highest possible degree consistent with the official java driver. 
+At this moment [The Neo4j Drivers Manual v4.4](https://neo4j.com/docs/java-manual/current/) along with the ruby version of the [code fragments](https://github.com/neo4jrb/neo4j-ruby-driver/blob/master/docs/dev_manual_examples.rb) and the ruby specs provide the only documentation. 
+
+[Neo4j Java Driver 4.3 API](https://neo4j.com/docs/api/java-driver/current/) can be helpful as well..
+
+## Development
+
+This gem includes 2 different implementations: java driver wrapper and pure ruby driver
+
+    $ bin/setup 
+     
+## Testing
+
+To run the tests the following tools need to be installed:
+
+    $ brew install python
+    $ pip3 install --user git+https://github.com/klobuczek/boltkit@1.3#egg=boltkit
+    $ neoctrl-install -e 4.4.5 servers
+    $ neoctrl-configure servers/neo4j-enterprise-4.4.5 dbms.directories.import= dbms.default_listen_address=::
+    $ neoctrl-set-initial-password pass servers/neo4j-enterprise-4.4.5
+    $ neoctrl-start servers/neo4j-enterprise-4.4.5
+
+To run the tests:
+```console
+$ bin/setup
+$ rspec spec
+```
+
+In case of heap space memory error (`org.neo4j.driver.exceptions.DatabaseException: Java heap space`), you should limit the dbms memory, for example:
+
+```console
+$ neoctrl-configure servers/neo4j-enterprise-4.4.5 dbms.memory.pagecache.size=600m dbms.memory.heap.max_size=600m dbms.memory.heap.initial_size=600m dbms.directories.import= dbms.connectors.default_listen_address=::
+```
+
+## Contributing
+
+Suggestions, improvements, bug reports and pull requests are welcome on GitHub at https://github.com/neo4jrb/neo4j-ruby-driver.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+

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

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Neo4j::Driver::Ext
+  module AsyncConverter
+    include ExceptionMapper
+
+    private
+
+    class Variable
+      def initialize(condition = ::Async::Condition.new)
+        @condition = condition
+        @value = nil
+      end
+
+      def resolve(value = true)
+        @value = value
+        condition = @condition
+        @condition = nil
+
+        self.freeze
+
+        condition.signal(value)
+      end
+
+      def resolved?
+        @condition.nil?
+      end
+
+      def value
+        @condition&.wait
+        return @value
+      end
+
+      def wait
+        self.value
+      end
+    end
+
+    def to_future(completion_stage)
+      Concurrent::Promises.resolvable_future.tap do |future|
+        completion_stage.then_apply(&future.method(:fulfill)).exceptionally { |e| future.reject(mapped_exception(e.cause)) }
+      end
+    end
+
+    def to_async(completion_stage)
+      variable = Variable.new
+      completion_stage.when_complete do |value, error|
+        variable.resolve([value, error])
+      end
+      value, error = variable.wait
+      raise mapped_exception(e.cause) if error
+      value
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Ext
+      module AuthTokens
+        include NeoConverter
+
+        def basic(username, password, realm = nil)
+          Neo4j::Driver::Internal::Validator.require_non_nil_credentials!(username, password)
+          super
+        end
+
+        def custom(principal, credentials, realm, scheme, **parameters)
+          super(principal, credentials, realm, scheme, to_neo(parameters))
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Ext
+      module Bookmark
+        module ClassMethods
+          def from(*values)
+            super(java.util.HashSet.new(values))
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Ext
+      module ConfigConverter
+        include NeoConverter
+
+        private
+
+        def to_java_config(builder_class, **hash)
+          apply_to(builder_class.builder, **hash).build
+        end
+
+        def apply_to(builder, **hash)
+          hash.compact.reduce(builder) { |object, key_value| object.send(*config_method(*key_value)) }
+        end
+
+        def config_method(key, value)
+          method = :"with_#{key}"
+          unit = nil
+          case key.to_s
+          when 'encryption', 'driver_metrics', 'hostname_verification'
+            method = :"without_#{key}" unless value
+            value = nil
+          when 'timeout'
+            value = java.time.Duration.ofMillis(Driver::Internal::DurationNormalizer.milliseconds(value))
+          when /time(out)?$/
+            value = Driver::Internal::DurationNormalizer.milliseconds(value) || -1
+            unit = java.util.concurrent.TimeUnit::MILLISECONDS
+          when 'logger'
+            method = :with_logging
+            value = Neo4j::Driver::Ext::Logger.new(value)
+          when 'resolver'
+            proc = value
+            value = ->(address) { java.util.HashSet.new(proc.call(address)) }
+          when 'bookmarks'
+            return [method, *value]
+          when 'trust_strategy'
+            value = trust_strategy(**value)
+          when 'revocation_strategy'
+            method = case value
+                     when Neo4j::Driver::Internal::RevocationStrategy::NO_CHECKS
+                       'without_certificate_revocation_checks'
+                     else
+                       "with_#{value}_revocation_checks"
+                     end
+          else
+            value = to_neo(value, skip_unknown: true)
+          end
+          [method, value, unit].compact
+        end
+
+        def trust_strategy(**config)
+          strategy = config.delete(:strategy)
+          trust_strategy =
+            case strategy
+            when :trust_custom_certificates
+              Config::TrustStrategy
+                .trust_custom_certificate_signed_by(*config.delete(:cert_files).map(&java.io.File.method(:new)))
+            else
+              Config::TrustStrategy.send(strategy)
+            end
+          apply_to(trust_strategy, **config)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Ext
+      module ExceptionCheckable
+        include ExceptionMapper
+
+        def check
+          yield
+        rescue Java::JavaLang::RuntimeException => e
+          raise mapped_exception(e)
+        end
+
+        def reverse_check
+          yield
+        rescue Neo4j::Driver::Exceptions::ServiceUnavailableException => e
+          raise(throwable(e.cause) || Java::OrgNeo4jDriverExceptions::ServiceUnavailableException.new(e.message))
+        rescue Neo4j::Driver::Exceptions::Neo4jException,
+          Neo4j::Driver::Exceptions::NoSuchRecordException,
+          Neo4j::Driver::Exceptions::UntrustedServerException,
+          Neo4j::Driver::Exceptions::IllegalStateException => e
+          raise(throwable(e.cause) || e)
+        end
+
+        private
+
+        def throwable(e)
+          e if e.is_a? Java::JavaLang::Throwable
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Ext
+      module ExceptionMapper
+        java_import org.neo4j.driver.exceptions.AuthenticationException
+        java_import org.neo4j.driver.exceptions.AuthorizationExpiredException
+        java_import org.neo4j.driver.exceptions.ClientException
+        java_import org.neo4j.driver.exceptions.ConnectionReadTimeoutException
+        java_import org.neo4j.driver.exceptions.DatabaseException
+        java_import org.neo4j.driver.exceptions.DiscoveryException
+        java_import org.neo4j.driver.exceptions.FatalDiscoveryException
+        java_import org.neo4j.driver.exceptions.ProtocolException
+        java_import org.neo4j.driver.exceptions.ResultConsumedException
+        java_import org.neo4j.driver.exceptions.SecurityException
+        java_import org.neo4j.driver.exceptions.ServiceUnavailableException
+        java_import org.neo4j.driver.exceptions.SessionExpiredException
+        java_import org.neo4j.driver.exceptions.TokenExpiredException
+        java_import org.neo4j.driver.exceptions.TransactionNestingException
+        java_import org.neo4j.driver.exceptions.TransientException
+        java_import org.neo4j.driver.exceptions.UntrustedServerException
+
+        def mapped_exception(exception)
+          mapped_neo4j_exception_class(exception)&.new(*arguments(exception)) ||
+            mapped_runtime_exception_class(exception)&.new(exception.message) || exception
+        end
+
+        def arguments(e)
+          [e.code, e.message, e.suppressed.map(&method(:mapped_exception))]
+        end
+
+        private
+
+        def mapped_neo4j_exception_class(exception_class)
+          case exception_class
+          when AuthenticationException
+            Neo4j::Driver::Exceptions::AuthenticationException
+          when AuthorizationExpiredException
+            Neo4j::Driver::Exceptions::AuthorizationExpiredException
+          when FatalDiscoveryException
+            Neo4j::Driver::Exceptions::FatalDiscoveryException
+          when ResultConsumedException
+            Neo4j::Driver::Exceptions::ResultConsumedException
+          when TokenExpiredException
+            Neo4j::Driver::Exceptions::TokenExpiredException
+          when SecurityException
+            Neo4j::Driver::Exceptions::SecurityException
+          when TransactionNestingException
+            Neo4j::Driver::Exceptions::TransactionNestingException
+          when ClientException
+            Neo4j::Driver::Exceptions::ClientException
+          when ConnectionReadTimeoutException
+            Neo4j::Driver::Exceptions::ConnectionReadTimeoutException
+          when DatabaseException
+            Neo4j::Driver::Exceptions::DatabaseException
+          when DiscoveryException
+            Neo4j::Driver::Exceptions::DiscoveryException
+          when ProtocolException
+            Neo4j::Driver::Exceptions::ProtocolException
+          when ServiceUnavailableException
+            Neo4j::Driver::Exceptions::ServiceUnavailableException
+          when SessionExpiredException
+            Neo4j::Driver::Exceptions::SessionExpiredException
+          when TransientException
+            Neo4j::Driver::Exceptions::TransientException
+          else
+            nil
+          end
+        end
+
+        def mapped_runtime_exception_class(exception_class)
+          case exception_class
+          when Java::OrgNeo4jDriverExceptions::NoSuchRecordException
+            Neo4j::Driver::Exceptions::NoSuchRecordException
+          when Java::OrgNeo4jDriverExceptions::UntrustedServerException
+            Neo4j::Driver::Exceptions::UntrustedServerException
+          when Java::JavaLang::IllegalStateException
+            Neo4j::Driver::Exceptions::IllegalStateException
+          when Java::JavaLang::IllegalArgumentException
+            ArgumentError
+          else
+            nil
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Ext
+      module GraphDatabase
+        extend AutoClosable
+        include ConfigConverter
+        include ExceptionCheckable
+
+        auto_closable :driver, :routing_driver
+
+        def driver(uri, auth_token = Neo4j::Driver::AuthTokens.none, **config)
+          check do
+            java_method(:driver, [java.lang.String, org.neo4j.driver.AuthToken, org.neo4j.driver.Config])
+              .call(uri.to_s, auth_token, to_java_config(Neo4j::Driver::Config, **config))
+          end
+        end
+
+        def routing_driver(routing_uris, auth_token, **config)
+          check do
+            super(routing_uris.map { |uri| java.net.URI.create(uri.to_s) }, auth_token,
+                  to_java_config(Neo4j::Driver::Config, **config))
+          end
+        end
+      end
+    end
+  end
+end

data/jruby/neo4j/driver/ext/internal/async/internal_async_session.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Ext
+      module Internal
+        module Async
+          module InternalAsyncSession
+            include ConfigConverter
+            include RunOverride
+            include AsyncConverter
+
+            def run_async(statement, parameters = {}, config = {})
+              to_future(
+                java_method(:runAsync, [org.neo4j.driver.Query, org.neo4j.driver.TransactionConfig])
+                  .call(to_statement(statement, parameters), to_java_config(Neo4j::Driver::TransactionConfig, config)))
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+# 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.DatabaseNameUtil.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

@@ -0,0 +1,15 @@
+# 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/metrics/internal_connection_pool_metrics.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Ext
+      module Internal
+        module Metrics
+          module InternalConnectionPoolMetrics
+            def address
+              java_class.declared_method('getAddress').tap { |m| m.accessible = true }.invoke(java_object)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+# 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) { super(Java::JavaUtilConcurrent::TimeUnit::MILLISECONDS) }
+            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

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Ext
+      module InternalDriver
+        extend AutoClosable
+        include ConfigConverter
+        include ExceptionCheckable
+        include AsyncConverter
+
+        auto_closable :session
+
+        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
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Ext
+      module InternalEntity
+        include MapConverter
+
+        alias properties to_h
+
+        def [](key)
+          get(key.to_s).as_ruby_object
+        end
+
+        def ==(other)
+          java_method(:isEqual).call(other)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Ext
+      module InternalKeys
+        include ExceptionCheckable
+
+        def keys
+          check { super.map(&:to_sym) }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Ext
+      module InternalNode
+        def labels
+          super.map(&:to_sym)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Ext
+      module InternalRecord
+        include MapConverter
+        include InternalKeys
+
+        def values
+          java_send(:values).map(&:as_ruby_object)
+        end
+
+        def [](key)
+          case key
+          when Integer
+            java_method(:get, [Java::int]).call(key)
+          else
+            java_method(:get, [java.lang.String]).call(key.to_s)
+          end.as_ruby_object
+        end
+
+        def first
+          java_method(:get, [Java::int]).call(0).as_ruby_object
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Ext
+      module InternalRelationship
+        def type
+          super.to_sym
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Ext
+      module InternalResult
+        include Enumerable
+        include ExceptionCheckable
+        include InternalKeys
+
+        %i[has_next? next single consume peek].each do |method|
+          define_method(method) do |*args, &block|
+            check { super(*args, &block) }
+          end
+        end
+
+        def each(&block)
+          check { stream.for_each(&block) }
+        end
+      end
+    end
+  end
+end