neo4j-ruby-driver 4.4.0-java

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

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Exceptions
+      # A <em>SessionExpiredException</em> indicates that the session can no longer satisfy the criteria under which it
+      # was acquired, e.g. a server no longer accepts write requests. A new session needs to be acquired from the driver
+      # and all actions taken on the expired session must be replayed.
+      # @since 1.1
+      class SessionExpiredException < Neo4jException
+      end
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Exceptions
+      # The provided token has expired.
+      # <p>
+      # The current driver instance is considered invalid. It should not be used anymore. The client must create a new driver instance with a valid token.
+      # <p>
+      # Error code: Neo.ClientError.Security.TokenExpired
+      class TokenExpiredException < SecurityException
+      end
+    end
+  end
+end

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

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Exceptions
+      # This exception indicates a user is nesting new transaction with an on-going transaction (unmanaged and/or auto-commit).
+      class TransactionNestingException < ClientException
+      end
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Exceptions
+      # A <em>TransientException</em> signals a temporary fault that may be worked around by retrying.
+      # The error code provided can be used to determine further detail for the problem.
+      # @since 1.0
+      class TransientException < Neo4jException
+      end
+    end
+  end
+end

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

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Exceptions
+      # Thrown if the remote server cannot be verified as Neo4j.
+      class UntrustedServerException < RuntimeError
+      end
+    end
+  end
+end

data/lib/neo4j/driver/exceptions/value/lossy_coercion.rb

@@ -0,0 +1,15 @@
+module Neo4j
+  module Driver
+    module Exceptions
+      module Value
+        # A <em>LossyCoercion</em> exception indicates that the conversion cannot be achieved without losing precision.
+        # @since 1.0
+        class LossyCoercion < ValueException
+          def initialize(source_type_name, destination_type_name)
+            super("Cannot coerce #{source_type_name} to #{destination_type_name} without losing precision")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/neo4j/driver/exceptions/value/not_multi_valued.rb

@@ -0,0 +1,13 @@
+module Neo4j
+  module Driver
+    module Exceptions
+      module Value
+        # A <em>NotMultiValued</em> exception indicates that the value does not consist of multiple values, a.k.a. not a map
+        # or array.
+        # @since 1.0
+        class NotMultiValued < ValueException
+        end
+      end
+    end
+  end
+end

data/lib/neo4j/driver/exceptions/value/uncoercible.rb

@@ -0,0 +1,15 @@
+module Neo4j
+  module Driver
+    module Exceptions
+      module Value
+        # A <em>Uncoercible</em> exception indicates that the conversion cannot be achieved.
+        # @since 1.0
+        class Uncoercible < ValueException
+          def initialize(source_type_name, destination_type_name)
+            super("Cannot coerce #{source_type_name} to #{destination_type_name}")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/neo4j/driver/exceptions/value/unsizable.rb

@@ -0,0 +1,12 @@
+module Neo4j
+  module Driver
+    module Exceptions
+      module Value
+        # An <em>Unsizable</em> exception indicates that the value does not have a size.
+        # @since 1.0
+        class Unsizable < ValueException
+        end
+      end
+    end
+  end
+end

data/lib/neo4j/driver/exceptions/value/value_exception.rb

@@ -0,0 +1,12 @@
+module Neo4j
+  module Driver
+    module Exceptions
+      module Value
+        # A <em>ValueException</em> indicates that the client has carried out an operation on values incorrectly.
+        # @since 1.0
+        class ValueException < ClientException
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,97 @@
+module Neo4j::Driver
+  module Internal
+    # Holds a host and port pair that denotes a Bolt server address.
+    class BoltServerAddress
+      attr_reader :host, :connection_host, :port
+      delegate :hash, to: :attributes
+
+      DEFAULT_PORT = 7687
+
+      class << self
+        def host_from(uri)
+          uri&.host || (raise invalid_address_format(uri))
+        end
+
+        def port_from(uri)
+          uri&.port || DEFAULT_PORT
+        end
+
+        def uri_from(address)
+          scheme_split = address.split('://')
+
+          if scheme_split.length == 1
+            # URI can't parse addresses without scheme, prepend fake "bolt://" to reuse the parsing facility
+            scheme = 'bolt://'
+            host_port = host_port_from(scheme_split.first)
+          elsif scheme_split.length == 2
+            scheme = "#{scheme_split.first}://"
+            host_port = host_port_from(scheme_split.second)
+          else
+            raise invalid_address_format(address)
+          end
+
+          URI(scheme + host_port)
+        end
+
+        def host_port_from(address)
+          # expected to be an IPv6 address like [::1] or [::1]:7687
+          return address if address.start_with?('[')
+
+          contains_single_colon = address.index(':') == address.rindex(':')
+
+          # expected to be an IPv4 address with or without port like 127.0.0.1 or 127.0.0.1:7687
+          return address if contains_single_colon
+
+          # address contains multiple colons and does not start with '['
+          # expected to be an IPv6 address without brackets
+          "[#{address}]"
+        end
+
+        def invalid_address_format(address)
+          ArgumentError.new("Invalid address format #{address}")
+        end
+
+        def require_valid_port(port)
+          return port if port >= 0 && port <= 65_535
+
+          raise ArgumentError, "Illegal port: #{port}"
+        end
+      end
+
+      def initialize(uri: nil, host: self.class.host_from(uri), port: self.class.port_from(uri), connection_host: host)
+        @host = Validator.require_non_nil!(host)
+        @connection_host = Validator.require_non_nil!(connection_host)
+        @port = self.class.require_valid_port(port)
+      end
+
+      LOCAL_DEFAULT = new(host: 'localhost', port: DEFAULT_PORT)
+
+      def self.from(address)
+        address.is_a?(BoltServerAddress) ? address : new(address.host, address.port)
+      end
+
+      def eql?(other)
+        attributes.eql?(other&.attributes)
+      end
+
+      def to_s
+        "#{host}#{"(#{connection_host})" unless host == connection_host}:#{port}"
+      end
+
+      # Create a stream of unicast addresses.
+      # <p>
+      # While this implementation just returns a stream of itself, the subclasses may provide multiple addresses.
+
+      # @return stream of unicast addresses.
+      def unicast_stream
+        [self]
+      end
+
+      private
+
+      def attributes
+        [@host, @connection_host, @port]
+      end
+    end
+  end
+end

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

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Internal
+      module DurationNormalizer
+        class << self
+          def normalize(object)
+            parts = object.parts.to_h
+            parts.default = 0
+            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
+
+          def milliseconds(duration)
+            duration&.in_milliseconds&.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/validator.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Internal
+      module Validator
+        def self.require_hash_parameters!(parameters)
+          require_hash!(parameters) do
+            "The parameters should be provided as Map type. Unsupported parameters type: #{parameters.class.name}"
+          end
+        end
+
+        def self.require_hash!(obj)
+          raise(ArgumentError, yield) unless obj.nil? || obj.is_a?(Hash)
+        end
+
+        def self.require_non_nil!(obj, message = nil)
+          raise ArgumentError, [message, "can't be nil"].compact.join(' ') if obj.nil?
+          obj
+        end
+
+        def self.require_non_nil_credentials!(username, password)
+          require_non_nil! username, "Username"
+          require_non_nil! password, "Password"
+        end
+      end
+    end
+  end
+end

data/lib/neo4j/driver/summary/query_type.rb

@@ -0,0 +1,12 @@
+module Neo4j
+  module Driver
+    module Summary
+      module QueryType
+        READ_ONLY = 'r'
+        READ_WRITE = 'rw'
+        WRITE_ONLY = 'w'
+        SCHEMA_WRITE = 's'
+      end
+    end
+  end
+end

data/lib/neo4j/driver/synchronizable.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Synchronizable
+      def sync(*methods)
+        prepend with_sync_wrapper(methods)
+      end
+
+      private
+
+      def with_sync_wrapper(methods)
+        Module.new do
+          methods.each do |method|
+            define_method(method) do |*args, **kwargs, &block|
+              Sync { super(*args, **kwargs, &block) }
+            end
+          end
+        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

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

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

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

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Types
+      class Point
+        attr_accessor :srid, :x, :y, :z
+
+        SRID = {
+          'WGS-84': 4326,
+          'WGS-84-3D': 4979,
+          cartesian: 7203,
+          'cartesian-3D': 9157
+        }.with_indifferent_access.freeze
+
+        def initialize(args)
+          self.x = args[:longitude] || args[:x]
+          self.y = args[:latitude] || args[:y]
+          self.z = args[:height] || args[:z]
+          self.srid = args[:srid] || SRID[args[:crs] || implied_crs(args[:longitude] || args[:latitude])]
+        end
+
+        def coordinates
+          [x, y, z].compact.map(&:to_f)
+        end
+
+        private
+
+        def implied_crs(geo)
+          if geo
+            z ? :'WGS-84-3D' : :'WGS-84'
+          else
+            z ? :'cartesian-3D' : :cartesian
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Types
+      class Time
+        include Comparable
+
+        delegate :hash, :to_a, to: :significant
+
+        class << self
+          def parse(date)
+            new(::Time.parse(date))
+          end
+        end
+
+        def initialize(time)
+          @time = time
+        end
+
+        def significant
+          self.class.significant_fields.map(&method(:send))
+        end
+
+        def <=>(other)
+          return unless other.is_a?(self.class)
+
+          self.class.significant_fields.reduce(0) do |acc, elem|
+            acc.zero? ? send(elem) <=> other.send(elem) : (break acc)
+          end
+        end
+
+        def eql?(other)
+          other.is_a?(self.class) && self.class.significant_fields.all? { |elem| send(elem).eql?(other.send(elem)) }
+        end
+
+        def +(numeric)
+          self.class.new(@time + numeric)
+        end
+      end
+    end
+  end
+end

data/lib/neo4j/driver/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    VERSION = '4.4.0'
+  end
+end

data/lib/neo4j_ruby_driver.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+  end
+end
+
+require 'active_support/concern'
+require 'active_support/core_ext/hash/indifferent_access'
+require 'active_support/isolated_execution_state' if Gem::Requirement.create('>= 7').satisfied_by?(Gem.loaded_specs["activesupport"].version) # TODO: this should not be necessary https://github.com/rails/rails/issues/43851
+require 'active_support/core_ext/numeric/time'
+require 'active_support/duration'
+require 'active_support/time'
+require 'neo4j/driver'
+require 'uri'