neo4j-core 3.1.1 → 4.0.0

data/lib/neo4j-server/cypher_node_uncommited.rb

@@ -1,12 +1,14 @@
-module Neo4j::Server
-  class CypherNodeUncommited
-    def initialize(db, data)
-      @db = db
-      @data = data
-    end
+module Neo4j
+  module Server
+    class CypherNodeUncommited
+      def initialize(db, data)
+        @db = db
+        @data = data
+      end
 
-    def [](key)
-      @data[key.to_s]
+      def [](key)
+        @data[key.to_s]
+      end
     end
   end
-end
+end

data/lib/neo4j-server/cypher_relationship.rb

@@ -1,131 +1,130 @@
-module Neo4j::Server
-
-  class CypherRelationship < Neo4j::Relationship
-    include Neo4j::Server::Resource
-    include Neo4j::Core::CypherTranslator
-    include Neo4j::Core::ActiveEntity
-
-    def initialize(session, value)
-      @session = session
-      @response_hash = value
-      @rel_type = @response_hash['type']
-      @props = @response_hash['data']
-      @start_node_neo_id = @response_hash['start'].match(/\d+$/)[0].to_i
-      @end_node_neo_id = @response_hash['end'].match(/\d+$/)[0].to_i
-      @id = @response_hash['id']
-    end
+module Neo4j
+  module Server
+    class CypherRelationship < Neo4j::Relationship
+      include Neo4j::Server::Resource
+      include Neo4j::Core::CypherTranslator
+      include Neo4j::Core::ActiveEntity
+
+      def initialize(session, value)
+        @session = session
+        @response_hash = value
+        @rel_type = @response_hash['type']
+        @props = @response_hash['data']
+        @start_node_neo_id = @response_hash['start'].is_a?(Integer) ? @response_hash['start'] : @response_hash['start'].match(/\d+$/)[0].to_i
+        @end_node_neo_id = @response_hash['end'].is_a?(Integer) ? @response_hash['end'] : @response_hash['end'].match(/\d+$/)[0].to_i
+        @id = @response_hash['id']
+      end
 
-    def ==(o)
-      o.class == self.class && o.neo_id == neo_id
-    end
-    alias_method :eql?, :==
+      def ==(other)
+        other.class == self.class && other.neo_id == neo_id
+      end
+      alias_method :eql?, :==
 
-    def id
-      @id
-    end
+      attr_reader :id
 
-    def neo_id
-      id
-    end
+      def neo_id
+        id
+      end
 
-    def inspect
-      "CypherRelationship #{neo_id}"
-    end
+      def inspect
+        "CypherRelationship #{neo_id}"
+      end
+
+      def load_resource
+        return if resource_data_present?
 
-    def load_resource
-      if resource_data.nil? || resource_data.empty?
         @resource_data = @session._query_or_fail("#{match_start} RETURN n", true, neo_id: neo_id) # r.first_data
       end
-    end
 
-    def start_node_neo_id
-      @start_node_neo_id
-    end
+      attr_reader :start_node_neo_id
 
-    def end_node_neo_id
-      @end_node_neo_id
-    end
+      attr_reader :end_node_neo_id
 
-    def _start_node_id
-      @start_node_neo_id ||= get_node_id(:start)
-    end
+      def _start_node_id
+        @start_node_neo_id ||= get_node_id(:start)
+      end
 
-    def _end_node_id
-      @end_node_neo_id ||= get_node_id(:end)
-    end
+      def _end_node_id
+        @end_node_neo_id ||= get_node_id(:end)
+      end
 
-    def _start_node
-      @_start_node ||= Neo4j::Node._load(start_node_neo_id)
-    end
+      def _start_node
+        @_start_node ||= Neo4j::Node._load(start_node_neo_id)
+      end
 
-    def _end_node
-      load_resource
-      @_end_node ||= Neo4j::Node._load(end_node_neo_id)
-    end
+      def _end_node
+        load_resource
+        @_end_node ||= Neo4j::Node._load(end_node_neo_id)
+      end
 
-    def get_node_id(direction)
-      load_resource
-      resource_url_id(resource_url(direction))
-    end
+      def get_node_id(direction)
+        load_resource
+        resource_url_id(resource_url(direction))
+      end
 
-    def get_property(key)
-      @session._query_or_fail("#{match_start} RETURN n.`#{key}`", true, neo_id: neo_id )
-    end
+      def get_property(key)
+        @session._query_or_fail("#{match_start} RETURN n.`#{key}`", true, neo_id: neo_id)
+      end
 
-    def set_property(key,value)
-      @session._query_or_fail("#{match_start} SET n.`#{key}` = {value}", false, { value: value, neo_id: neo_id })
-    end
+      def set_property(key, value)
+        @session._query_or_fail("#{match_start} SET n.`#{key}` = {value}", false,  value: value, neo_id: neo_id)
+      end
 
-    def remove_property(key)
-      @session._query_or_fail("#{match_start} REMOVE n.`#{key}`", false, neo_id: neo_id)
-    end
+      def remove_property(key)
+        @session._query_or_fail("#{match_start} REMOVE n.`#{key}`", false, neo_id: neo_id)
+      end
 
-    # (see Neo4j::Relationship#props)
-    def props
-      if @props
-        @props
-      else
-        hash = @session._query_entity_data("#{match_start} RETURN n", nil, neo_id: neo_id)
-        @props = Hash[hash['data'].map{ |k, v| [k.to_sym, v] }]
+      # (see Neo4j::Relationship#props)
+      def props
+        if @props
+          @props
+        else
+          hash = @session._query_entity_data("#{match_start} RETURN n", nil, neo_id: neo_id)
+          @props = Hash[hash['data'].map { |k, v| [k.to_sym, v] }]
+        end
       end
-    end
 
-    # (see Neo4j::Relationship#props=)
-    def props=(properties)
-      @session._query_or_fail("#{match_start} SET n = { props }", false, { props: properties, neo_id: neo_id })
-      properties
-    end
+      # (see Neo4j::Relationship#props=)
+      def props=(properties)
+        @session._query_or_fail("#{match_start} SET n = { props }", false,  props: properties, neo_id: neo_id)
+        properties
+      end
 
-    # (see Neo4j::Relationship#update_props)
-    def update_props(properties)
-      return if properties.empty?
-      q = "#{match_start} SET " + properties.keys.map do |k|
-        "n.`#{k}`= #{escape_value(properties[k])}"
-      end.join(',')
-      @session._query_or_fail(q, false, neo_id: neo_id)
-      properties
-    end
+      # (see Neo4j::Relationship#update_props)
+      def update_props(properties)
+        return if properties.empty?
+        q = "#{match_start} SET " + properties.keys.map do |k|
+          "n.`#{k}`= #{escape_value(properties[k])}"
+        end.join(',')
+        @session._query_or_fail(q, false, neo_id: neo_id)
+        properties
+      end
 
-    def rel_type
-      @rel_type.to_sym
-    end
+      def rel_type
+        @rel_type.to_sym
+      end
 
-    def del
-      @session._query("#{match_start} DELETE n", neo_id: neo_id).raise_unless_response_code(200)
-    end
-    alias_method :delete, :del
-    alias_method :destroy, :del
+      def del
+        @session._query("#{match_start} DELETE n", neo_id: neo_id)
+      end
+      alias_method :delete, :del
+      alias_method :destroy, :del
 
-    def exist?
-      response = @session._query("#{match_start} RETURN n", neo_id: neo_id)
-      # binding.pry
-      (response.data.nil? || response.data.empty?) ? false : true
-    end
+      def exist?
+        response = @session._query("#{match_start} RETURN n", neo_id: neo_id)
+        # binding.pry
+        (response.data.nil? || response.data.empty?) ? false : true
+      end
 
-    private
+      private
 
-    def match_start(identifier = 'n')
-      "MATCH (node)-[#{identifier}]-() WHERE ID(#{identifier}) = {neo_id}"
+      def match_start(identifier = 'n')
+        "MATCH (node)-[#{identifier}]-() WHERE ID(#{identifier}) = {neo_id}"
+      end
+
+      def resource_data_present?
+        !resource_data.nil? && !resource_data.empty?
+      end
     end
   end
 end

data/lib/neo4j-server/cypher_response.rb

@@ -1,225 +1,226 @@
-module Neo4j::Server
-  class CypherResponse
-    attr_reader :data, :columns, :error_msg, :error_status, :error_code, :response
-
-    class ResponseError < StandardError
-      attr_reader :status, :code
-
-      def initialize(msg, status, code)
-        super(msg)
-        @status = status
-        @code = code
+module Neo4j
+  module Server
+    class CypherResponse
+      attr_reader :data, :columns, :error_msg, :error_status, :error_code, :response
+
+      class ResponseError < StandardError
+        attr_reader :status, :code
+
+        def initialize(msg, status, code)
+          super(msg)
+          @status = status
+          @code = code
+        end
       end
-    end
 
 
-    class HashEnumeration
-      include Enumerable
-      extend Forwardable
-      def_delegator :@response, :error_msg
-      def_delegator :@response, :error_status
-      def_delegator :@response, :error_code
-      def_delegator :@response, :columns
-      def_delegator :@response, :struct
+      class HashEnumeration
+        include Enumerable
+        extend Forwardable
+        def_delegator :@response, :error_msg
+        def_delegator :@response, :error_status
+        def_delegator :@response, :error_code
+        def_delegator :@response, :columns
+        def_delegator :@response, :struct
 
-      def initialize(response, query)
-        @response = response
-        @query = query
-      end
+        def initialize(response, query)
+          @response = response
+          @query = query
+        end
 
-      def to_s
-        @query
-      end
+        def to_s
+          @query
+        end
 
-      def inspect
-        "Enumerable query: '#{@query}'"
-      end
+        def inspect
+          "Enumerable query: '#{@query}'"
+        end
 
-      def each(&block)
-        @response.each_data_row do |row|
-          yield(row.each_with_index.each_with_object(struct.new) do |(value, i), result|
-            result[columns[i].to_sym] = value
-          end)
+        def each(&block)
+          @response.each_data_row do |row|
+            yield(row.each_with_index.each_with_object(struct.new) do |(value, i), result|
+              result[columns[i].to_sym] = value
+            end)
+          end
         end
       end
-    end
 
-    def to_struct_enumeration(cypher = '')
-      HashEnumeration.new(self, cypher)
-    end
+      def to_struct_enumeration(cypher = '')
+        HashEnumeration.new(self, cypher)
+      end
 
-    def to_node_enumeration(cypher = '', session = Neo4j::Session.current)
-      Enumerator.new do |yielder|
-        @result_index = 0
-        self.to_struct_enumeration(cypher).each do |row|
-          @row_index = 0
-          yielder << row.each_pair.each_with_object(@struct.new) do |(column, value), result|
-            result[column] = map_row_value(value, session)
-            @row_index += 1
+      def to_node_enumeration(cypher = '', session = Neo4j::Session.current)
+        Enumerator.new do |yielder|
+          @result_index = 0
+          to_struct_enumeration(cypher).each do |row|
+            @row_index = 0
+            yielder << row.each_pair.each_with_object(@struct.new) do |(column, value), result|
+              result[column] = map_row_value(value, session)
+              @row_index += 1
+            end
+            @result_index += 1
           end
-          @result_index += 1
         end
       end
-    end
 
-    def map_row_value(value, session)
-      if value.is_a?(Hash)
-        hash_value_as_object(value, session)
-      elsif value.is_a?(Array)
-        value.map {|v| map_row_value(v, session) }
-      else
-        value
+      def map_row_value(value, session)
+        if value.is_a?(Hash)
+          hash_value_as_object(value, session)
+        elsif value.is_a?(Array)
+          value.map { |v| map_row_value(v, session) }
+        else
+          value
+        end
       end
-    end
-
-    def hash_value_as_object(value, session)
-      return value unless value['labels'] || value['type'] || is_transaction_response?
-      obj_type, data =  if is_transaction_response?
-                          add_transaction_entity_id
-                          [(mapped_rest_data['start'] ? CypherRelationship : CypherNode), mapped_rest_data]
-                        else value['labels'] || value['type']
-                          add_entity_id(value)
-                          [(value['labels'] ? CypherNode : CypherRelationship), value]
-                        end
-      obj_type.new(session, data).wrapper
-    end
 
-    attr_reader :struct
+      def hash_value_as_object(value, session)
+        return value unless value['labels'] || value['type'] || transaction_response?
+
+        is_node, data =  if transaction_response?
+                           add_transaction_entity_id
+                           [!mapped_rest_data['start'], mapped_rest_data]
+                         elsif value['labels'] || value['type']
+                           add_entity_id(value)
+                           [value['labels'], value]
+                         end
+        (is_node ? CypherNode : CypherRelationship).new(session, data).wrapper
+      end
 
-    def initialize(response, uncommited = false)
-      @response = response
-      @uncommited = uncommited
-    end
+      attr_reader :struct
 
-    def entity_data(id=nil)
-      if uncommited?
-        data = @data.first['row'].first
-        data.is_a?(Hash) ? {'data' => data, 'id' => id} : data
-      else
-        data = @data[0][0]
-        data.is_a?(Hash) ? add_entity_id(data) : data
+      def initialize(response, uncommited = false)
+        @response = response
+        @uncommited = uncommited
       end
-    end
 
-    def first_data(id = nil)
-      if uncommited?
-        data = @data.first['row'].first
-        #data.is_a?(Hash) ? {'data' => data, 'id' => id} : data
-      else
-        data = @data[0][0]
-        data.is_a?(Hash) ? add_entity_id(data) : data
+      def entity_data(id = nil)
+        if @uncommited
+          data = @data.first['row'].first
+          data.is_a?(Hash) ? {'data' => data, 'id' => id} : data
+        else
+          data = @data[0][0]
+          data.is_a?(Hash) ? add_entity_id(data) : data
+        end
       end
-    end
 
-    def add_entity_id(data)
-      data.merge!({'id' => data['self'].split('/')[-1].to_i})
-    end
+      def first_data(id = nil)
+        if @uncommited
+          data = @data.first['row'].first
+          # data.is_a?(Hash) ? {'data' => data, 'id' => id} : data
+        else
+          data = @data[0][0]
+          data.is_a?(Hash) ? add_entity_id(data) : data
+        end
+      end
 
-    def add_transaction_entity_id
-      mapped_rest_data.merge!({'id' => mapped_rest_data['self'].split('/').last.to_i})
-    end
+      def add_entity_id(data)
+        data.merge!('id' => self.class.id_from_url(data['self']))
+      end
 
-    def error?
-      !!@error
-    end
+      def add_transaction_entity_id
+        mapped_rest_data.merge!('id' => mapped_rest_data['self'].split('/').last.to_i)
+      end
 
-    def uncommited?
-      @uncommited
-    end
+      def error?
+        !!@error
+      end
 
-    def has_data?
-      !response.body['data'].nil?
-    end
+      def data?
+        !response.body['data'].nil?
+      end
 
-    def raise_unless_response_code(code)
-      raise "Response code #{response.code}, expected #{code} for #{response.request.path}, #{response.body}" unless response.status == code
-    end
+      def raise_unless_response_code(code)
+        fail "Response code #{response.status}, expected #{code} for #{response.headers['location']}, #{response.body}" unless response.status == code
+      end
 
-    def each_data_row
-      if uncommited?
-        data.each{|r| yield r['row']}
-      else
-        data.each{|r| yield r}
+      def each_data_row
+        if @uncommited
+          data.each { |r| yield r['row'] }
+        else
+          data.each { |r| yield r }
+        end
       end
-    end
 
-    def set_data(data, columns)
-      @data = data
-      @columns = columns
-      @struct = columns.empty? ? Object.new : Struct.new(*columns.map(&:to_sym))
-      self
-    end
+      def set_data(data, columns)
+        @data = data
+        @columns = columns
+        @struct = columns.empty? ? Object.new : Struct.new(*columns.map(&:to_sym))
+        self
+      end
 
-    def set_error(error_msg, error_status, error_core)
-      @error = true
-      @error_msg = error_msg
-      @error_status = error_status
-      @error_code = error_core
-      self
-    end
+      def set_error(error_msg, error_status, error_core)
+        @error = true
+        @error_msg = error_msg
+        @error_status = error_status
+        @error_code = error_core
+        self
+      end
 
-    def raise_error
-      raise "Tried to raise error without an error" unless @error
-      raise ResponseError.new(@error_msg, @error_status, @error_code)
-    end
+      def raise_error
+        fail 'Tried to raise error without an error' unless @error
+        fail ResponseError.new(@error_msg, @error_status, @error_code)
+      end
 
-    def raise_cypher_error
-      raise "Tried to raise error without an error" unless @error
-      raise Neo4j::Session::CypherError.new(@error_msg, @error_code, @error_status)
-    end
+      def raise_cypher_error
+        fail 'Tried to raise error without an error' unless @error
+        fail Neo4j::Session::CypherError.new(@error_msg, @error_code, @error_status)
+      end
 
 
-    def self.create_with_no_tx(response)
-      case response.status
+      def self.create_with_no_tx(response)
+        case response.status
         when 200
           CypherResponse.new(response).set_data(response.body['data'], response.body['columns'])
         when 400
           CypherResponse.new(response).set_error(response.body['message'], response.body['exception'], response.body['fullname'])
         else
-          raise "Unknown response code #{response.status} for #{response.env[:url].to_s}"
+          fail "Unknown response code #{response.status} for #{response.env[:url]}"
+        end
       end
-    end
 
-    def self.create_with_tx(response)
-      raise "Unknown response code #{response.status} for #{response.request_uri}" unless response.status == 200
+      def self.create_with_tx(response)
+        fail "Unknown response code #{response.status} for #{response.request_uri}" unless response.status == 200
 
-      first_result = response.body['results'][0]
-      cr = CypherResponse.new(response, true)
+        first_result = response.body['results'][0]
+        cr = CypherResponse.new(response, true)
 
-      if (response.body['errors'].empty?)
-        cr.set_data(first_result['data'], first_result['columns'])
-      else
-        first_error = response.body['errors'].first
-        cr.set_error(first_error['message'], first_error['status'], first_error['code'])
+        if response.body['errors'].empty?
+          cr.set_data(first_result['data'], first_result['columns'])
+        else
+          first_error = response.body['errors'].first
+          cr.set_error(first_error['message'], first_error['status'], first_error['code'])
+        end
+        cr
       end
-      cr
-    end
 
-    def is_transaction_response?
-      self.response.respond_to?('body') && !self.response.body['commit'].nil?
-    end
+      def transaction_response?
+        response.respond_to?('body') && !response.body['commit'].nil?
+      end
 
-    def rest_data
-      @result_index = @row_index = 0
-      mapped_rest_data
-    end
+      def rest_data
+        @result_index = @row_index = 0
+        mapped_rest_data
+      end
 
-    def rest_data_with_id
-      rest_data.merge!({'id' => mapped_rest_data['self'].split('/').last.to_i})
-    end
+      def rest_data_with_id
+        rest_data.merge!('id' => mapped_rest_data['self'].split('/').last.to_i)
+      end
+
+      class << self
+        def id_from_url(url)
+          url.split('/')[-1].to_i
+        end
+      end
 
-    private
+      private
 
-    def row_index
-      @row_index
-    end
+      attr_reader :row_index
 
-    def result_index
-      @result_index
-    end
+      attr_reader :result_index
 
-    def mapped_rest_data
-      self.response.body['results'][0]['data'][result_index]['rest'][row_index]
+      def mapped_rest_data
+        response.body['results'][0]['data'][result_index]['rest'][row_index]
+      end
     end
   end
-end
+end