neo4j-java-driver 0.1.1-java

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

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Ext
+      module RunOverride
+        include ExceptionCheckable
+        extend AutoClosable
+
+        auto_closable :begin_transaction
+
+        # work around jruby issue https://github.com/jruby/jruby/issues/5603
+        Struct.new('Wrapper', :object)
+
+        def write_transaction
+          super { |tx| Struct::Wrapper.new(yield(tx)) }.object
+        end
+
+        # end work around
+
+        def run(statement, parameters = {})
+          check { java_method(:run, [java.lang.String, java.util.Map]).call(statement, to_neo(parameters)) }
+        end
+
+        def begin_transaction # (config = nil)
+          check { super }
+        end
+
+        def close
+          check { super }
+        end
+
+        private
+
+        def to_neo(object)
+          case object
+          when Hash
+            object.map { |key, value| [key.to_s, to_neo(value)] }.to_h
+          when Types::ByteArray
+            object.to_java_bytes
+          when Date
+            Java::JavaTime::LocalDate.of(object.year, object.month, object.day)
+          when ActiveSupport::Duration
+            Java::OrgNeo4jDriverInternal::InternalIsoDuration.new(
+              *Driver::Internal::DurationNormalizer.normalize(object)
+            )
+          when Types::Point
+            Java::OrgNeo4jDriverV1::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
+            to_zoned_date_time(object, object.formatted_offset)
+          else
+            object
+          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/jruby/neo4j/driver/ext/start_end_naming.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Ext
+      module StartEndNaming
+        def start_node
+          java_send(:start)
+        end
+
+        def end_node
+          java_send(:end)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Ext
+      module Statement
+        def parameters
+          super.as_ruby_object
+        end
+      end
+    end
+  end
+end

data/lib/loader.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require 'zeitwerk'
+
+class Loader
+  def self.load
+    loader = Zeitwerk::Loader.new
+    loader.tag = 'neo4j-ruby-driver'
+    loader.push_dir(File.expand_path(__dir__))
+    loader.push_dir(File.dirname(File.dirname(caller_locations(1..1).first.path)))
+    loader.ignore(File.expand_path('neo4j-java-driver_jars.rb', __dir__))
+    loader.ignore(File.expand_path('neo4j_ruby_driver.rb', __dir__))
+    loader.ignore(File.expand_path('org', __dir__))
+    loader.inflector = Zeitwerk::GemInflector.new(File.expand_path('neo4j/driver', __dir__))
+    loader.setup
+    loader.eager_load
+  end
+end

data/lib/neo4j/driver/auto_closable.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module AutoClosable
+      def auto_closable(*methods)
+        prepend with_block_definer(methods)
+      end
+
+      private
+
+      def with_block_definer(methods)
+        Module.new do
+          methods.each do |method|
+            define_method(method) do |*args, &block|
+              closable = super(*args)
+              if block
+                begin
+                  block.arity.zero? ? closable.instance_eval(&block) : block.call(closable)
+                ensure
+                  closable&.close
+                end
+              else
+                closable
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/neo4j/driver/exceptions/authentication_exception.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Exceptions
+      class AuthenticationException < Neo4jException
+      end
+    end
+  end
+end

data/lib/neo4j/driver/exceptions/client_exception.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Exceptions
+      class ClientException < Neo4jException
+      end
+    end
+  end
+end

data/lib/neo4j/driver/exceptions/database_exception.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Exceptions
+      class DatabaseException < Neo4jException
+      end
+    end
+  end
+end

data/lib/neo4j/driver/exceptions/illegal_state_exception.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Exceptions
+      class IllegalStateException < RuntimeError
+      end
+    end
+  end
+end

data/lib/neo4j/driver/exceptions/neo4j_exception.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Exceptions
+      class Neo4jException < RuntimeError
+        attr_reader :code, :cause
+
+        def initialize(*args)
+          @code = args.shift if args.count > 1
+          message = args.shift
+          @cause = args.shift
+          super(message)
+        end
+      end
+    end
+  end
+end

data/lib/neo4j/driver/exceptions/no_such_record_exception.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Exceptions
+      class NoSuchRecordException < RuntimeError
+        EMPTY = 'Cannot retrieve a single record, because this result is empty.'
+        TOO_MANY = 'Expected a result with a single record, but this result ' \
+          'contains at least one more. Ensure your query returns only one record.'
+        NO_MORE = 'No more records'
+        NO_PEEK_PAST = 'Cannot peek past the last record'
+
+        class << self
+          def empty
+            new(EMPTY)
+          end
+
+          def too_many
+            new(TOO_MANY)
+          end
+
+          def no_more
+            new(NO_MORE)
+          end
+
+          def no_peek_past
+            new(NO_PEEK_PAST)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/neo4j/driver/exceptions/protocol_exception.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Exceptions
+      class ProtocolException < Neo4jException
+      end
+    end
+  end
+end

data/lib/neo4j/driver/exceptions/security_exception.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Exceptions
+      class SecurityException < Neo4jException
+      end
+    end
+  end
+end

data/lib/neo4j/driver/exceptions/service_unavailable_exception.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Exceptions
+      class ServiceUnavailableException < Neo4jException
+      end
+    end
+  end
+end

data/lib/neo4j/driver/exceptions/session_expired_exception.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Exceptions
+      class SessionExpiredException < Neo4jException
+      end
+    end
+  end
+end

data/lib/neo4j/driver/exceptions/transient_exception.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Exceptions
+      class TransientException < Neo4jException
+      end
+    end
+  end
+end

data/lib/neo4j/driver/exceptions/untrusted_server_exception.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Exceptions
+      class UntrustedServerException < RuntimeError
+      end
+    end
+  end
+end

data/lib/neo4j/driver/internal/duration_normalizer.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Internal
+      module DurationNormalizer
+        class << self
+          def normalize(object)
+            parts = object.parts
+            months_i, months_remainder_seconds = divmod(months(parts), ActiveSupport::Duration::SECONDS_PER_MONTH)
+            months_days, months_remainder_seconds =
+              months_remainder_seconds.divmod(ActiveSupport::Duration::SECONDS_PER_DAY)
+            days_i, days_remainder_seconds = divmod(months_days + days(parts), ActiveSupport::Duration::SECONDS_PER_DAY)
+            seconds_i, nonanoseconds = divmod(months_remainder_seconds + days_remainder_seconds + seconds(parts),
+                                              1_000_000_000)
+            [months_i, days_i, seconds_i, nonanoseconds.round]
+          end
+
+          private
+
+          def divmod(number, factor)
+            number_i, remainder = number.divmod(1)
+            [number_i.to_i, remainder * factor]
+          end
+
+          def months(parts)
+            parts[:years] * 12 + parts[:months]
+          end
+
+          def days(parts)
+            parts[:weeks] * 7 + parts[:days]
+          end
+
+          def seconds(parts)
+            parts[:hours] * ActiveSupport::Duration::SECONDS_PER_HOUR +
+              parts[:minutes] * ActiveSupport::Duration::SECONDS_PER_MINUTE + parts[:seconds]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/neo4j/driver/internal/ruby_signature.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Internal
+      module RubySignature
+        class << self
+          def session(args)
+            [
+              args.empty? || args.first.is_a?(String) ? Neo4j::Driver::AccessMode::WRITE : args.shift, # mode
+              args # bookmarks
+            ]
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Types
+      class ByteArray < String
+        def self.from_bytes(bytes)
+          new(bytes.pack('C*'))
+        end
+
+        def to_bytes
+          unpack('C*')
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Types
+      class LocalDateTime < Time
+        class << self
+          FIELDS = %i[year month day hour min sec nsec].freeze
+
+          def significant_fields
+            FIELDS
+          end
+        end
+
+        delegate(*significant_fields, to: :@time)
+        delegate :to_i, to: :@time
+      end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Types
+      class LocalTime < Time
+        class << self
+          FIELDS = %i[hour min sec nsec].freeze
+
+          def significant_fields
+            FIELDS
+          end
+        end
+
+        delegate(*significant_fields, to: :@time)
+      end
+    end
+  end
+end