neo4j-java-driver 0.1.1-java

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 2420844cd278e077b7afec48f624b6af9d86844cf8276b7a04322ab7b6c7d257
+  data.tar.gz: dbb48e01991356e19df8e4214e6c15bc7a7c6b0d530a339ce1b3d204256b19d4
+SHA512:
+  metadata.gz: e2775629940356371ce687ec466cc8e6c2e74f8e302df8f4316d4dfd521e032d403b67e26db483559abf4a4fae5ab3ed6fddf2da1c458e111402c0dd65628beb
+  data.tar.gz: a89828e1144078ab4c01f7971ebdfb755171219ef84de6c366920ee8d3729c82fb3e2f721d366ba74fe17b69774c62b10bf5953949f9a0cc5b8a0ec72a3a13c7

data/Gemfile

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
+
+git_source(:github) { |repo_name| "https://github.com/#{repo_name}" }
+
+# Specify your gem's dependencies in neo4j-driver.gemspec
+gemspec

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,68 @@
+# Neo4j::Driver
+
+Proposal for an API for neo4j ruby driver. This gem contains reference implementation in jruby with most of the features
+completed.
+The proposed API is heavilly inspired but the java and javascipt driver. Please add comments and suggestions if you feel there 
+is better idiomatic alternative in ruby.
+
+The file `doc/dev_manual_examples_spec.rb` contains all the code examples included in the 
+[Chapter 4. Drivers][https://neo4j.com/docs/developer-manual/3.4/drivers/] of the Developer Manual and should be 
+reviewed side by side with that manual.
+
+## 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
+
+## Usage
+
+Refer to https://neo4j.com/docs/developer-manual/3.4/drivers/.
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. 
+In order to run test by running `rake spec` you may have to set your own `NEO4J_BOLT_URL` URI or it will
+fallback to `bolt://localhost:7687`.
+You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+This gem includes 2 different implementations: java driver based and another one using seabolt via ffi
+
+For java driver based:
+
+    $ rvm use jruby-9.2.5.0
+    $ bundle
+    $ rspec
+    
+FFI based:
+
+    $ rvm use 2.5.3 # or jruby-9.2.5.0
+    $ SEABOLT_LIB=~/seabolt/build/dist/lib/libseabolt17.dylib bundle
+    $ SEABOLT_LIB=~/seabolt/build/dist/lib/libseabolt17.dylib rspec
+     
+Please note that seabolt for now has to be installed separately: https://github.com/neo4j-drivers/seabolt      
+    
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/neo4j-driver.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+
+
+[https://neo4j.com/docs/developer-manual/3.4/drivers/]: https://neo4j.com/docs/developer-manual/3.4/drivers/
+
+[https://neo4j.com/docs/developer-manual/3.4/drivers/]: https://neo4j.com/docs/developer-manual/3.4/drivers/

data/Rakefile

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+require 'neo4j/rake_tasks'
+
+if RUBY_PLATFORM.match?(/java/) && ENV['SEABOLT_LIB']&.length&.positive?
+  require 'jars/installer'
+  task :install_jars do
+    Jars::Installer.vendor_jars!('jruby')
+  end
+end
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/jruby/neo4j/driver.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require 'active_support/core_ext/hash/keys'
+require 'date'
+require 'loader'
+require 'neo4j-java-driver_jars'
+
+module Neo4j
+  module Driver
+    include_package 'org.neo4j.driver.v1'
+
+    module Net
+      include_package 'org.neo4j.driver.v1.net'
+    end
+
+    module Summary
+      include_package 'org.neo4j.driver.v1.summary'
+    end
+
+    module Types
+      include_package 'org.neo4j.driver.v1.types'
+    end
+
+    # Workaround for missing zeitwerk support in jruby-9.2.8.0
+    if RUBY_PLATFORM.match?(/java/)
+      module Ext
+        module Internal
+          module Summary
+          end
+        end
+      end
+    end
+    # End workaround
+  end
+end
+
+Loader.load
+
+Java::OrgNeo4jDriverInternal::InternalDriver.prepend Neo4j::Driver::Ext::InternalDriver
+Java::OrgNeo4jDriverInternal::InternalNode.include Neo4j::Driver::Ext::MapAccessor
+Java::OrgNeo4jDriverInternal::InternalPath.include Neo4j::Driver::Ext::MapAccessor
+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.include Neo4j::Driver::Ext::MapAccessor
+Java::OrgNeo4jDriverInternal::InternalStatementResult.prepend Neo4j::Driver::Ext::InternalStatementResult
+Java::OrgNeo4jDriverInternal::ExplicitTransaction.prepend Neo4j::Driver::Ext::RunOverride
+Java::OrgNeo4jDriverInternal::NetworkSession.prepend Neo4j::Driver::Ext::RunOverride
+Java::OrgNeo4jDriverInternalSummary::InternalResultSummary.prepend Neo4j::Driver::Ext::Internal::Summary::InternalResultSummary
+Java::OrgNeo4jDriverInternalValue::ValueAdapter.include Neo4j::Driver::Ext::RubyConverter
+Java::OrgNeo4jDriverV1::GraphDatabase.singleton_class.prepend Neo4j::Driver::Ext::GraphDatabase
+Java::OrgNeo4jDriverV1::Statement.prepend Neo4j::Driver::Ext::Statement
+Java::OrgNeo4jDriverV1Exceptions::Neo4jException.include Neo4j::Driver::Ext::ExceptionMapper

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

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Ext
+      module ExceptionCheckable
+        def check
+          yield
+        rescue Java::OrgNeo4jDriverV1Exceptions::Neo4jException => e
+          e.reraise
+        rescue Java::OrgNeo4jDriverV1Exceptions::NoSuchRecordException => e
+          raise Neo4j::Driver::Exceptions::NoSuchRecordException, e.message
+        rescue Java::OrgNeo4jDriverV1Exceptions::UntrustedServerException => e
+          raise Neo4j::Driver::Exceptions::UntrustedServerException, e.message
+        rescue Java::JavaLang::IllegalStateException => e
+          raise Neo4j::Driver::Exceptions::IllegalStateException, e.message
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+java_import org.neo4j.driver.v1.exceptions.AuthenticationException
+java_import org.neo4j.driver.v1.exceptions.ClientException
+java_import org.neo4j.driver.v1.exceptions.DatabaseException
+java_import org.neo4j.driver.v1.exceptions.ProtocolException
+java_import org.neo4j.driver.v1.exceptions.SecurityException
+java_import org.neo4j.driver.v1.exceptions.ServiceUnavailableException
+java_import org.neo4j.driver.v1.exceptions.SessionExpiredException
+java_import org.neo4j.driver.v1.exceptions.TransientException
+java_import org.neo4j.driver.v1.exceptions.UntrustedServerException
+
+module Neo4j
+  module Driver
+    module Ext
+      module ExceptionMapper
+        def reraise
+          raise mapped_exception&.new(code, message, self) || self
+        end
+
+        private
+
+        def mapped_exception
+          case self
+          when AuthenticationException
+            Neo4j::Driver::Exceptions::AuthenticationException
+          when ClientException
+            Neo4j::Driver::Exceptions::ClientException
+          when DatabaseException
+            Neo4j::Driver::Exceptions::DatabaseException
+          when ProtocolException
+            Neo4j::Driver::Exceptions::ProtocolException
+          when SecurityException
+            Neo4j::Driver::Exceptions::SecurityException
+          when ServiceUnavailableException
+            Neo4j::Driver::Exceptions::ServiceUnavailableException
+          when SessionExpiredException
+            Neo4j::Driver::Exceptions::SessionExpiredException
+          when TransientException
+            Neo4j::Driver::Exceptions::TransientException
+          else
+            nil
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Ext
+      module GraphDatabase
+        extend AutoClosable
+        include ExceptionCheckable
+
+        auto_closable :driver
+
+        def driver(uri, auth_token = Neo4j::Driver::AuthTokens.none, config = {})
+          check do
+            java_method(:driver, [java.lang.String, org.neo4j.driver.v1.AuthToken, org.neo4j.driver.v1.Config])
+              .call(uri, auth_token, to_java_config(config))
+          end
+        end
+
+        private
+
+        def to_java_config(hash)
+          hash.reduce(Neo4j::Driver::Config.build) { |object, key_value| object.send(*config_method(*key_value)) }
+              .to_config
+        end
+
+        def config_method(key, value)
+          method = :"with_#{key}"
+          unit = nil
+          case key.to_s
+          when 'encryption'
+            unless value
+              method = :without_encryption
+              value = nil
+            end
+          when 'load_balancing_strategy'
+            value = load_balancing_strategy(value)
+          when /Time(out)?$/i
+            unit = java.util.concurrent.TimeUnit::SECONDS
+          end
+          [method, value, unit].compact
+        end
+
+        def load_balancing_strategy(value)
+          case value
+          when :least_connected
+            Config::LoadBalancingStrategy::LEAST_CONNECTED
+          when :round_robin
+            Config::LoadBalancingStrategy::ROUND_ROBIN
+          else
+            raise ArgumentError
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Ext
+      module Internal
+        module Summary
+          module InternalResultSummary
+            %i[result_available_after result_consumed_after].each do |method|
+              define_method(method) { super(Java::JavaUtilConcurrent::TimeUnit::MILLISECONDS) }
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Ext
+      module InternalDriver
+        extend AutoClosable
+
+        auto_closable :session
+
+        def session(*args)
+          java_method(:session, [org.neo4j.driver.v1.AccessMode, java.lang.Iterable])
+            .call(*Neo4j::Driver::Internal::RubySignature.session(args))
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Ext
+      module InternalRecord
+        def values
+          java_send(:values).map(&:as_ruby_object)
+        end
+
+        define_method(:[]) do |key|
+          java_method(:get, [key.is_a?(Integer) ? Java::int : java.lang.String]).call(key).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_statement_result.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Ext
+      module InternalStatementResult
+        include Enumerable
+        include ExceptionCheckable
+
+        %i[has_next? next keys single consume].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

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

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Ext
+      module MapAccessor
+        def properties
+          as_map.to_hash.symbolize_keys
+        end
+
+        def [](key)
+          get(key.to_s).as_ruby_object
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Ext
+      module RubyConverter
+        def as_ruby_object
+          case type_constructor
+          when Java::OrgNeo4jDriverInternalTypes::TypeConstructor::LIST
+            java_method(:asList, [org.neo4j.driver.v1.util.Function]).call(&:as_ruby_object).to_a
+          when Java::OrgNeo4jDriverInternalTypes::TypeConstructor::MAP
+            as_map(->(x) { x.as_ruby_object }, nil).to_hash.symbolize_keys
+          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
+            ActiveSupport::Duration.parse(as_iso_duration.to_s)
+          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
+            Types::ByteArray.new(String.from_java_bytes(as_byte_array))
+          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