neospace 0.0.1 → 1.7.0

data/ffi/neo4j/driver/internal/value/unbound_relationship_value.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Internal
+      module Value
+        module UnboundRelationshipValue
+          CODE = :r
+          extend StructureValue
+
+          def self.to_ruby_value(id, type, properties)
+            Types::Relationship.new(id, nil, nil, type, properties)
+          end
+        end
+      end
+    end
+  end
+end

data/ffi/neo4j/driver/internal/value/value_adapter.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Internal
+      module Value
+        module ValueAdapter
+          class << self
+            def to_ruby(value)
+              case Bolt::Value.type(value)
+              when :bolt_null
+                nil
+              when :bolt_boolean
+                Bolt::Boolean.get(value) == 1
+              when :bolt_integer
+                Bolt::Integer.get(value)
+              when :bolt_float
+                Bolt::Float.get(value)
+              when :bolt_bytes
+                Types::Bytes.new(Array.new(Bolt::Value.size(value)) { |i| Bolt::Bytes.get(value, i) }.pack('C*'))
+              when :bolt_string
+                Bolt::String.get(value).read_string(Bolt::Value.size(value)).force_encoding(Encoding::UTF_8)
+              when :bolt_dictionary
+                Array.new(Bolt::Value.size(value)) do |i|
+                  [to_ruby(Bolt::Dictionary.key(value, i)).to_sym, to_ruby(Bolt::Dictionary.value(value, i))]
+                end.to_h
+              when :bolt_list
+                Array.new(Bolt::Value.size(value)) { |i| to_ruby(Bolt::List.value(value, i)) }
+              when :bolt_structure
+                StructureValue.to_ruby(value)
+              else
+                raise Exception, 'unsupported neo4j type'
+              end
+            end
+
+            def to_neo(value, object)
+              case object
+              when nil
+                Bolt::Value.format_as_null(value)
+              when TrueClass
+                Bolt::Value.format_as_boolean(value, 1)
+              when FalseClass
+                Bolt::Value.format_as_boolean(value, 0)
+              when Integer
+                Bolt::Value.format_as_integer(value, object)
+              when Float
+                Bolt::Value.format_as_float(value, object)
+              when Types::Bytes
+                Bolt::Value.format_as_bytes(value, object, object.size)
+              when String
+                object = object.encode(Encoding::UTF_8) unless object.encoding == Encoding::UTF_8
+                Bolt::Value.format_as_string(value, object, object.bytesize)
+              when Hash
+                Bolt::Value.format_as_dictionary(value, object.size)
+                object.each_with_index do |(key, elem), index|
+                  key = key.to_s
+                  Bolt::Dictionary.set_key(value, index, key, key.bytesize)
+                  to_neo(Bolt::Dictionary.value(value, index), elem)
+                end
+              when Types::Path
+                Exceptions::ClientException.unable_to_convert(object)
+              when Enumerable
+                object = object.to_a
+                Bolt::Value.format_as_list(value, object.size)
+                object.each_with_index { |elem, index| to_neo(Bolt::List.value(value, index), elem) }
+              when Date
+                DateValue.to_neo(value, object)
+              when ActiveSupport::Duration
+                DurationValue.to_neo(value, object)
+              when Neo4j::Driver::Types::Point
+                case object.coordinates.size
+                when 2
+                  Point2DValue
+                when 3
+                  Point3DValue
+                else
+                  raise Exception
+                end&.to_neo(value, object)
+              when Types::OffsetTime
+                OffsetTimeValue.to_neo(value, object)
+              when Types::LocalTime
+                LocalTimeValue.to_neo(value, object)
+              when Types::LocalDateTime
+                LocalDateTimeValue.to_neo(value, object)
+              when ActiveSupport::TimeWithZone
+                TimeWithZoneIdValue.to_neo(value, object)
+              when Time
+                TimeWithZoneOffsetValue.to_neo(value, object)
+              else
+                Exceptions::ClientException.unable_to_convert(object)
+              end
+              value
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/ffi/neo4j/driver/net/server_address.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Net
+      module ServerAddress
+        def self.of(host, port)
+          Internal::BoltServerAddress.new(host, port)
+        end
+      end
+    end
+  end
+end

data/ffi/neo4j/driver/statement.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    class Statement
+      attr_reader :text, :parameters
+
+      def initialize(text, parameters = nil)
+        Internal::Validator.require_hash_parameters!(parameters)
+        @text = text
+        @parameters = parameters || {}
+      end
+    end
+  end
+end

data/ffi/neo4j/driver/summary/statement_type.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Summary
+      module StatementType
+        READ_ONLY = 'r'
+        READ_WRITE = 'rw'
+        WRITE_ONLY = 'w'
+        SCHEMA_WRITE = 's'
+      end
+    end
+  end
+end

data/ffi/neo4j/driver/types/entity.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Types
+      class Entity
+        attr_reader :id, :properties
+        delegate :[], to: :properties
+
+        def initialize(id, properties)
+          @id = id
+          @properties = properties
+        end
+
+        def ==(other)
+          self.class == other.class && id == other.id
+        end
+      end
+    end
+  end
+end

data/ffi/neo4j/driver/types/node.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Types
+      class Node < Entity
+        attr_reader :labels
+
+        def initialize(id, labels, properties)
+          super(id, properties)
+          @labels = labels
+        end
+      end
+    end
+  end
+end

data/ffi/neo4j/driver/types/path.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Types
+      class Path < Array
+        attr_reader :modes, :relationships
+
+        class Segment
+          attr_reader :start_node, :relationship, :end_node
+
+          def initialize(start_node, relationship, end_node)
+            @start_node = start_node
+            @relationship = relationship
+            @end_node = end_node
+          end
+        end
+
+        def initialize(nodes, relationships)
+          super()
+          @nodes = nodes
+          @relationships = relationships
+        end
+
+        def start_node
+          @nodes.first
+        end
+
+        def end_node
+          @nodes.last
+        end
+      end
+    end
+  end
+end

data/ffi/neo4j/driver/types/relationship.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Types
+      class Relationship < Entity
+        attr_accessor :start_node_id, :end_node_id
+        attr_reader :type
+
+        def initialize(id, start_node_id, end_node_id, type, properties)
+          super(id, properties)
+          @start_node_id = start_node_id
+          @end_node_id = end_node_id
+          @type = type.to_sym
+        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,15 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Exceptions
+      class ClientException < Neo4jException
+        class << self
+          def unable_to_convert(object)
+            raise self, "Unable to convert #{object.class.name} to Neo4j Value."
+          end
+        end
+      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,23 @@
+# frozen_string_literal: true
+
+module Neo4j
+  module Driver
+    module Exceptions
+      class Neo4jException < RuntimeError
+        attr_reader :code, :cause, :suppressed
+
+        def initialize(*args)
+          @code = args.shift if args.count > 1
+          message = args.shift
+          @cause = args.shift
+          @suppressed = args.shift
+          super(message)
+        end
+
+        def add_suppressed(exception)
+          (@suppressed ||= []) << exception
+        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