neo4j-core 5.1.14 → 6.0.0.alpha.1

data/lib/neo4j/core/cypher_session/responses.rb

@@ -0,0 +1,27 @@
+require 'neo4j/core/cypher_session/result'
+
+module Neo4j
+  module Core
+    class CypherSession
+      module Responses
+        MAP = {}
+
+        class Base
+          class CypherError < StandardError; end
+
+          include Enumerable
+
+          def each
+            results.each do |result|
+              yield result
+            end
+          end
+
+          def results
+            fail '#results not implemented!'
+          end
+        end
+      end
+    end
+  end
+end

data/lib/neo4j/core/cypher_session/responses/embedded.rb

@@ -0,0 +1,77 @@
+require 'neo4j/core/cypher_session/responses'
+
+module Neo4j
+  module Core
+    class CypherSession
+      module Responses
+        class Embedded < Base
+          attr_reader :results, :request_data
+
+          def initialize(execution_results)
+            @results = execution_results.map do |execution_result|
+              result_from_execution_result(execution_result)
+            end
+          end
+
+          private
+
+          def result_from_execution_result(execution_result)
+            columns = execution_result.columns.to_a
+            rows = execution_result.map do |execution_result_row|
+              columns.map { |column| wrap_entity(execution_result_row[column]) }
+            end
+            Result.new(columns, rows)
+          end
+
+          def wrap_entity(entity)
+            if entity.is_a?(Array) ||
+               entity.is_a?(Java::ScalaCollectionConvert::Wrappers::SeqWrapper)
+              entity.to_a.map { |e| wrap_entity(e) }
+            elsif entity.is_a?(Java::OrgNeo4jKernelImplCore::NodeProxy)
+              wrap_node(entity)
+            elsif entity.is_a?(Java::OrgNeo4jKernelImplCore::RelationshipProxy)
+              wrap_relationship(entity)
+            elsif entity.respond_to?(:path_entities)
+              wrap_path(entity)
+            else
+              wrap_value(entity)
+            end
+          end
+
+          def wrap_node(entity)
+            ::Neo4j::Core::Node.new(entity.get_id,
+                                    entity.get_labels.map(&:to_s),
+                                    get_entity_properties(entity)).wrap
+          end
+
+          def wrap_relationship(entity)
+            ::Neo4j::Core::Relationship.new(entity.get_id,
+                                            entity.get_type.name,
+                                            get_entity_properties(entity)).wrap
+          end
+
+          def wrap_path(entity)
+            ::Neo4j::Core::Path.new(entity.nodes.map(&method(:wrap_node)),
+                                    entity.relationships.map(&method(:wrap_relationship)),
+                                    nil).wrap
+          end
+
+          def wrap_value(entity)
+            if entity.is_a?(Java::ScalaCollectionConvert::Wrappers::MapWrapper)
+              entity.each_with_object({}) { |(k, v), r| r[k.to_sym] = v }
+            else
+              # Convert from Java?
+              entity
+            end
+          end
+
+          def get_entity_properties(entity)
+            entity.get_property_keys.each_with_object({}) do |key, result|
+              result[key.to_sym] = entity.get_property(key)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/neo4j/core/cypher_session/responses/http.rb

@@ -0,0 +1,104 @@
+require 'neo4j/core/cypher_session/responses'
+
+module Neo4j
+  module Core
+    class CypherSession
+      module Responses
+        class HTTP < Base
+          attr_reader :results, :request_data
+
+          def initialize(faraday_response, request_data)
+            @request_data = request_data
+
+            validate_faraday_response!(faraday_response)
+
+            @results = faraday_response.body[:results].map do |result_data|
+              result_from_data(result_data[:columns], result_data[:data])
+            end
+          end
+
+          def result_from_data(columns, entities_data)
+            rows = entities_data.map do |entity_data|
+              wrap_entity entity_data[:row], entity_data[:rest]
+            end
+
+            Result.new(columns, rows)
+          end
+
+          def wrap_entity(row_data, rest_data)
+            row_data.each_with_index.map do |row_datum, i|
+              rest_datum = rest_data[i]
+
+              if rest_datum.is_a?(Array)
+                wrap_entity(row_datum, rest_datum)
+              elsif (ident = identify_entity(rest_datum))
+                send("wrap_#{ident}", rest_datum, row_datum)
+              else
+                row_datum
+              end
+            end
+          end
+
+          private
+
+          def identify_entity(rest_datum)
+            self_string = rest_datum[:self]
+            if self_string
+              type = self_string.split('/')[-2]
+              if type == 'node'
+                :node
+              elsif type == 'relationship'
+                :relationship
+              end
+            elsif [:nodes, :relationships, :start, :end, :length].all? { |k| rest_datum.key?(k) }
+              :path
+            end
+          end
+
+          def wrap_node(rest_datum, _)
+            metadata_data = rest_datum[:metadata]
+            ::Neo4j::Core::Node.new(id_from_rest_datum(rest_datum),
+                                    metadata_data && metadata_data[:labels],
+                                    rest_datum[:data]).wrap
+          end
+
+          def wrap_relationship(rest_datum, _)
+            metadata_data = rest_datum[:metadata]
+            ::Neo4j::Core::Relationship.new(id_from_rest_datum(rest_datum),
+                                            metadata_data && metadata_data[:type],
+                                            rest_datum[:data]).wrap
+          end
+
+          def wrap_path(rest_datum, row_datum)
+            nodes = rest_datum[:nodes].each_with_index.map do |url, i|
+              Node.from_url(url, row_datum[2 * i])
+            end
+            relationships = rest_datum[:relationships].each_with_index.map do |url, i|
+              Relationship.from_url(url, row_datum[(2 * i) + 1])
+            end
+
+            ::Neo4j::Core::Path.new(nodes, relationships, rest_datum[:directions]).wrap
+          end
+
+          def id_from_rest_datum(rest_datum)
+            if rest_datum[:metadata]
+              rest_datum[:metadata][:id]
+            else
+              rest_datum[:self].split('/').last.to_i
+            end
+          end
+
+          def validate_faraday_response!(faraday_response)
+            if error = faraday_response.body[:errors][0]
+              fail CypherError, "#{ANSI::CYAN}#{error[:code]}#{ANSI::CLEAR}: #{error[:message]}"
+            end
+
+            return if (200..299).include?(status = faraday_response.status)
+
+            fail CypherError, "Expected 200-series response for #{faraday_response.env.url} (got #{status})"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/neo4j/core/cypher_session/result.rb

@@ -0,0 +1,39 @@
+require 'neo4j/core/node'
+require 'neo4j/core/relationship'
+require 'neo4j/core/path'
+
+module Neo4j
+  module Core
+    class CypherSession
+      class Result
+        attr_reader :columns, :rows
+
+        def initialize(columns, rows)
+          @columns = columns.map(&:to_sym)
+          @rows = rows
+          @struct_class = Struct.new(*@columns)
+        end
+
+        include Enumerable
+
+        def each
+          structs.each do |struct|
+            yield struct
+          end
+        end
+
+        def structs
+          @structs ||= rows.map do |row|
+            @struct_class.new(*row)
+          end
+        end
+
+        def hashes
+          @hashes ||= rows.map do |row|
+            Hash[@columns.zip(row)]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/neo4j/core/instrumentable.rb

@@ -0,0 +1,36 @@
+require 'active_support/notifications'
+
+module Neo4j
+  module Core
+    module Instrumentable
+      def self.included(base)
+        base.send :include, InstanceMethods
+        base.extend ClassMethods
+      end
+
+      module InstanceMethods
+      end
+
+      module ClassMethods
+        def instrument(name, label, arguments, &block)
+          # defining class methods
+          klass = class << self; self; end
+          klass.instance_eval do
+            define_method("subscribe_to_#{name}") do |&b|
+              ActiveSupport::Notifications.subscribe(label) do |a, start, finish, id, payload|
+                b.call block.call(a, start, finish, id, payload)
+              end
+            end
+
+            define_method("instrument_#{name}") do |*args, &b|
+              hash = arguments.each_with_index.each_with_object({}) do |(argument, i), result|
+                result[argument.to_sym] = args[i]
+              end
+              ActiveSupport::Notifications.instrument(label, hash) { b.call }
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/neo4j/core/node.rb

@@ -0,0 +1,28 @@
+require 'neo4j/core/wrappable'
+
+module Neo4j
+  module Core
+    class Node
+      attr_reader :id, :labels, :properties
+      alias_method :props, :properties
+
+      include Wrappable
+
+      def initialize(id, labels, properties = {})
+        @id = id
+        @labels = labels.map(&:to_sym) unless labels.nil?
+        @properties = properties
+      end
+
+      class << self
+        def from_url(url, properties = {})
+          id = url.split('/')[-1].to_i
+          labels = nil # unknown
+          properties = properties
+
+          new(id, labels, properties)
+        end
+      end
+    end
+  end
+end

data/lib/neo4j/core/path.rb

@@ -0,0 +1,15 @@
+module Neo4j
+  module Core
+    class Path
+      attr_reader :nodes, :relationships, :directions
+
+      include Wrappable
+
+      def initialize(nodes, relationships, directions)
+        @nodes = nodes
+        @relationships = relationships
+        @directions = directions
+      end
+    end
+  end
+end

data/lib/neo4j/core/relationship.rb

@@ -0,0 +1,25 @@
+module Neo4j
+  module Core
+    class Relationship
+      attr_reader :id, :type, :properties
+
+      include Wrappable
+
+      def initialize(id, type, properties)
+        @id = id
+        @type = type.to_sym unless type.nil?
+        @properties = properties
+      end
+
+      class << self
+        def from_url(url, properties = {})
+          id = url.split('/')[-1].to_i
+          type = nil # unknown
+          properties = properties
+
+          new(id, type, properties)
+        end
+      end
+    end
+  end
+end

data/lib/neo4j/core/wrappable.rb

@@ -0,0 +1,35 @@
+module Neo4j
+  module Core
+    module Wrappable
+      def self.included(base)
+        base.send :include, InstanceMethods
+        base.extend ClassMethods
+      end
+
+      module InstanceMethods
+        def wrap
+          self.class.wrap(self)
+        end
+      end
+
+      module ClassMethods
+        def wrapper_callback(proc)
+          fail 'Callback already specified!' if @wrapper_callback
+          @wrapper_callback = proc
+        end
+
+        def clear_wrapper_callback
+          @wrapper_callback = nil
+        end
+
+        def wrap(node)
+          if @wrapper_callback
+            @wrapper_callback.call(node)
+          else
+            node
+          end
+        end
+      end
+    end
+  end
+end

data/lib/neo4j/label.rb

@@ -59,6 +59,13 @@ module Neo4j
       session._query_or_fail(cypher)
     end
 
+    private
+
+    def validate_index_options!(options)
+      return unless options[:type] && options[:type] != :exact
+      fail "Type #{options[:type]} is not supported"
+    end
+
     class << self
       INDEX_PATH = '/db/data/schema/index/'
       CONSTRAINT_PATH = '/db/data/schema/constraint/'

data/lib/neo4j/session.rb

@@ -149,8 +149,8 @@ module Neo4j
 
       # Registers a callback which will be called immediately if session is already available,
       # or called when it later becomes available.
-      def on_session_available
-        yield Neo4j::Session.current if Neo4j::Session.current
+      def on_next_session_available
+        return yield(Neo4j::Session.current) if Neo4j::Session.current
 
         add_listener do |event, data|
           yield data if event == :session_available
@@ -185,7 +185,7 @@ module Neo4j
 
       # @private
       def _notify_listeners(event, data)
-        _listeners.each { |li| li.call(event, data) }
+        _listeners.shift.call(event, data) until _listeners.empty?
       end
 
       # @private

data/lib/neo4j/transaction.rb

@@ -21,18 +21,6 @@ module Neo4j
       end
       alias_method :failure?, :failed?
 
-      def autoclosed!
-        @autoclosed = true if transient_failures_autoclose?
-      end
-
-      def transient_failures_autoclose?
-        Neo4j::Session.current.version >= '2.2.6'
-      end
-
-      def autoclosed?
-        !!@autoclosed
-      end
-
       def mark_expired
         @expired = true
       end
@@ -73,18 +61,7 @@ module Neo4j
         return if @pushed_nested >= 0
         fail "Can't commit transaction, already committed" if @pushed_nested < -1
         Neo4j::Transaction.unregister(self)
-        post_close!
-      end
-
-      private
-
-      def post_close!
-        return if autoclosed?
-        if failed?
-          delete
-        else
-          commit
-        end
+        failed? ? delete : commit
       end
     end