neo4j-core 3.1.1 → 4.0.0

data/lib/neo4j-embedded/to_java.rb

@@ -1,22 +1,23 @@
-module Neo4j::Embedded
-  # A Utility class for translating Ruby object to Neo4j Java types
-  # @private
-  module ToJava
-    def type_to_java(type)
-      Java::OrgNeo4jGraphdb::DynamicRelationshipType.withName(type.to_s)
-    end
+module Neo4j
+  module Embedded
+    # A Utility class for translating Ruby object to Neo4j Java types
+    # @private
+    module ToJava
+      def type_to_java(type)
+        Java::OrgNeo4jGraphdb::DynamicRelationshipType.withName(type.to_s)
+      end
 
-    module_function :type_to_java
+      module_function :type_to_java
 
-    def types_to_java(types)
-      types.inject([]) { |result, type| result << type_to_java(type) }.to_java(Java::OrgNeo4jGraphdb::RelationshipType)
-    end
+      def types_to_java(types)
+        types.inject([]) { |result, type| result << type_to_java(type) }.to_java(Java::OrgNeo4jGraphdb::RelationshipType)
+      end
 
-    module_function :types_to_java
+      module_function :types_to_java
 
 
-    def dir_from_java(dir)
-      case dir
+      def dir_from_java(dir)
+        case dir
         when Java::OrgNeo4jGraphdb::Direction::OUTGOING then
           :outgoing
         when Java::OrgNeo4jGraphdb::Direction::BOTH then
@@ -24,14 +25,14 @@ module Neo4j::Embedded
         when Java::OrgNeo4jGraphdb::Direction::INCOMING then
           :incoming
         else
-          raise "unknown direction '#{dir} / #{dir.class}'"
+          fail "unknown direction '#{dir} / #{dir.class}'"
+        end
       end
-    end
 
-    module_function :dir_from_java
+      module_function :dir_from_java
 
-    def dir_to_java(dir)
-      case dir
+      def dir_to_java(dir)
+        case dir
         when :outgoing then
           Java::OrgNeo4jGraphdb::Direction::OUTGOING
         when :both then
@@ -39,11 +40,11 @@ module Neo4j::Embedded
         when :incoming then
           Java::OrgNeo4jGraphdb::Direction::INCOMING
         else
-          raise "unknown direction '#{dir}', expects argument: outgoing, :incoming or :both"
+          fail "unknown direction '#{dir}', expects argument: outgoing, :incoming or :both"
+        end
       end
-    end
-
-    module_function :dir_to_java
 
+      module_function :dir_to_java
+    end
   end
 end

data/lib/neo4j-server.rb

@@ -9,4 +9,4 @@ require 'neo4j-server/cypher_session'
 require 'neo4j-server/cypher_node_uncommited'
 require 'neo4j-server/cypher_relationship'
 require 'neo4j-server/cypher_response'
-require 'neo4j-server/cypher_transaction'
+require 'neo4j-server/cypher_transaction'

data/lib/neo4j-server/cypher_authentication.rb

@@ -1,123 +1,125 @@
-module Neo4j::Server
-  # Neo4j 2.2 has an authentication layer. This class provides methods for interacting with it.
-  class CypherAuthentication
-    class InvalidPasswordError < RuntimeError; end
-    class PasswordChangeRequiredError < RuntimeError; end
-    class MissingCredentialsError < RuntimeError; end
+module Neo4j
+  module Server
+    # Neo4j 2.2 has an authentication layer. This class provides methods for interacting with it.
+    class CypherAuthentication
+      class InvalidPasswordError < RuntimeError; end
+      class PasswordChangeRequiredError < RuntimeError; end
+      class MissingCredentialsError < RuntimeError; end
 
-    attr_reader :connection, :url, :params, :token
+      attr_reader :connection, :url, :params, :token
 
-    # @param [String] url_string The server address with protocol and port.
-    # @param [Faraday::Connection] session_connection A Faraday::Connection object. This is either an existing object, likely the
-    # same object used by the server for data, or a new one created specifically for auth tasks.
-    # @param [Hash] params_hash Faraday connection options. In particularly, we're looking for basic_auth creds.
-    def initialize(url_string, session_connection = new_connection, params_hash = {})
-      @url = url_string
-      @connection = session_connection
-      @params = params_hash
-    end
+      # @param [String] url_string The server address with protocol and port.
+      # @param [Faraday::Connection] session_connection A Faraday::Connection object. This is either an existing object, likely the
+      # same object used by the server for data, or a new one created specifically for auth tasks.
+      # @param [Hash] params_hash Faraday connection options. In particularly, we're looking for basic_auth creds.
+      def initialize(url_string, session_connection = new_connection, params_hash = {})
+        @url = url_string
+        @connection = session_connection
+        @params = params_hash
+      end
 
-    # Set the username and password used to communicate with the server.
-    def basic_auth(username, password)
-      params[:basic_auth] ||= {}
-      params[:basic_auth][:username] = username
-      params[:basic_auth][:password] = password
-    end
+      # Set the username and password used to communicate with the server.
+      def basic_auth(username, password)
+        params[:basic_auth] ||= {}
+        params[:basic_auth][:username] = username
+        params[:basic_auth][:password] = password
+      end
 
-    # POSTs to the password change endpoint of the API. Does not invalidate tokens.
-    # @param [String] old_password The current password.
-    # @param [String] new_password The password you want to use.
-    # @return [Hash] The response from the server.
-    def change_password(old_password, new_password)
-      connection.post("#{url}/user/neo4j/password", { 'password' => old_password, 'new_password' => new_password }).body
-    end
+      # POSTs to the password change endpoint of the API. Does not invalidate tokens.
+      # @param [String] old_password The current password.
+      # @param [String] new_password The password you want to use.
+      # @return [Hash] The response from the server.
+      def change_password(old_password, new_password)
+        connection.post("#{url}/user/neo4j/password",  'password' => old_password, 'new_password' => new_password).body
+      end
 
-    # Uses the given username and password to obtain a token, then adds the token to the connection's parameters.
-    # @return [String] An access token provided by the server.
-    def authenticate
-      auth_response = auth_connection("#{url}/authentication")
-      auth_hash = if auth_response.body.empty?
-                    nil
-                  elsif auth_response.body.is_a?(String)
-                    JSON.parse(auth_response.body)['errors'][0]['code'] == 'Neo.ClientError.Security.AuthorizationFailed' ? auth_attempt : nil
-                  else
-                    auth_response
-                  end
-      return nil if auth_hash.nil?
-      add_auth_headers(token_or_error(auth_hash))
-    end
+      # Uses the given username and password to obtain a token, then adds the token to the connection's parameters.
+      # @return [String] An access token provided by the server.
+      def authenticate
+        auth_response = auth_connection("#{url}/authentication")
+        auth_hash = if auth_response.body.empty?
+                      nil
+                    elsif auth_response.body.is_a?(String)
+                      JSON.parse(auth_response.body)['errors'][0]['code'] == 'Neo.ClientError.Security.AuthorizationFailed' ? auth_attempt : nil
+                    else
+                      auth_response
+                    end
+        return nil if auth_hash.nil?
+        add_auth_headers(token_or_error(auth_hash))
+      end
 
-    # Invalidates the existing token, which will invalidate all conncetions using this token, applies for a new token, adds this into
-    # the connection headers.
-    # @param [String] password The current server password.
-    def reauthenticate(password)
-      invalidate_token(password)
-      add_auth_headers(token_or_error(auth_attempt))
-    end
+      # Invalidates the existing token, which will invalidate all conncetions using this token, applies for a new token, adds this into
+      # the connection headers.
+      # @param [String] password The current server password.
+      def reauthenticate(password)
+        invalidate_token(password)
+        add_auth_headers(token_or_error(auth_attempt))
+      end
 
-    # Requests a token from the authentication endpoint using the given username and password.
-    # @return [Faraday::Response] The server's response, to be interpreted.
-    def auth_attempt
-      begin
-        user = params[:basic_auth][:username]
-        pass = params[:basic_auth][:password]
-      rescue NoMethodError
-        raise MissingCredentialsError, 'Neo4j authentication is enabled, username/password are required but missing'
+      # Requests a token from the authentication endpoint using the given username and password.
+      # @return [Faraday::Response] The server's response, to be interpreted.
+      def auth_attempt
+        begin
+          user = params[:basic_auth][:username]
+          pass = params[:basic_auth][:password]
+        rescue NoMethodError
+          raise MissingCredentialsError, 'Neo4j authentication is enabled, username/password are required but missing'
+        end
+        connection.post("#{url}/authentication",  'username' => user, 'password' => pass)
       end
-      connection.post("#{url}/authentication", { 'username' => user, 'password' => pass })
-    end
 
-    # Takes a response object from the server and returns a token or fails with an error.
-    # Todo: more error states!
-    # @param [Farday::Response] auth_response The response after attempting authentication
-    # @return [String] An authentication token.
-    def token_or_error(auth_response)
-      begin
-        raise PasswordChangeRequiredError, "Server requires a password change, please visit #{url}" if auth_response.body['password_change_required']
-        raise InvalidPasswordError, "Neo4j server responded with: #{auth_response.body['errors'][0]['message']}" if auth_response.status.to_i == 422
-      rescue NoMethodError
-        raise 'Unexpected auth response, please open an issue at https://github.com/neo4jrb/neo4j-core/issues'
+      # Takes a response object from the server and returns a token or fails with an error.
+      # TODO: more error states!
+      # @param [Farday::Response] auth_response The response after attempting authentication
+      # @return [String] An authentication token.
+      def token_or_error(auth_response)
+        begin
+          fail PasswordChangeRequiredError, "Server requires a password change, please visit #{url}" if auth_response.body['password_change_required']
+          fail InvalidPasswordError, "Neo4j server responded with: #{auth_response.body['errors'][0]['message']}" if auth_response.status.to_i == 422
+        rescue NoMethodError
+          raise 'Unexpected auth response, please open an issue at https://github.com/neo4jrb/neo4j-core/issues'
+        end
+        auth_response.body['authorization_token']
       end
-      auth_response.body['authorization_token']
-    end
 
-    # Invalidates tokens as described at http://neo4j.com/docs/snapshot/rest-api-security.html#rest-api-invalidating-the-authorization-token
-    # @param [String] current_password The current password used to connect to the database
-    def invalidate_token(current_password)
-      connection.post("#{url}/user/neo4j/authorization_token", { 'password' => current_password }).body
-    end
+      # Invalidates tokens as described at http://neo4j.com/docs/snapshot/rest-api-security.html#rest-api-invalidating-the-authorization-token
+      # @param [String] current_password The current password used to connect to the database
+      def invalidate_token(current_password)
+        connection.post("#{url}/user/neo4j/authorization_token",  'password' => current_password).body
+      end
 
-    # Stores an authentication token in the properly-formatted header.
-    # This does not do any checking that what it has been given is a token. Whatever param is given will be base64 encoded and used as the header.
-    # @param [String] token The authentication token provided by the database.
-    def add_auth_headers(token)
-      @token = token
-      connection.headers['Authorization'] = "Basic realm=\"Neo4j\" #{token_hash(token)}"
-    end
+      # Stores an authentication token in the properly-formatted header.
+      # This does not do any checking that what it has been given is a token. Whatever param is given will be base64 encoded and used as the header.
+      # @param [String] token The authentication token provided by the database.
+      def add_auth_headers(token)
+        @token = token
+        connection.headers['Authorization'] = "Basic realm=\"Neo4j\" #{token_hash(token)}"
+      end
 
-    private
+      private
 
-    # Makes testing easier, we can stub this method to simulate different responses
-    def auth_connection(url)
-      connection.get(url)
-    end
+      # Makes testing easier, we can stub this method to simulate different responses
+      def auth_connection(url)
+        connection.get(url)
+      end
 
-    def self.new_connection
-      conn = Faraday.new do |b|
-        b.request :json
-        b.response :json, :content_type => "application/json"
-        b.use Faraday::Adapter::NetHttpPersistent
+      def self.new_connection
+        conn = Faraday.new do |b|
+          b.request :json
+          b.response :json, content_type: 'application/json'
+          b.use Faraday::Adapter::NetHttpPersistent
+        end
+        conn.headers = {'Content-Type' => 'application/json'}
+        conn
       end
-      conn.headers = { 'Content-Type' => 'application/json' }
-      conn
-    end
 
-    def new_connection
-      self.class.new_connection
-    end
+      def new_connection
+        self.class.new_connection
+      end
 
-    def token_hash(token)
-      ::Base64.strict_encode64(":#{token}")
+      def token_hash(token)
+        ::Base64.strict_encode64(":#{token}")
+      end
     end
   end
-end
+end

data/lib/neo4j-server/cypher_label.rb

@@ -1,32 +1,34 @@
-module Neo4j::Server
-  class CypherLabel < Neo4j::Label
-    extend Forwardable
-    def_delegator :@session, :query_cypher_for
-    attr_reader :name
+module Neo4j
+  module Server
+    class CypherLabel < Neo4j::Label
+      extend Forwardable
+      def_delegator :@session, :query_cypher_for
+      attr_reader :name
 
-    def initialize(session, name)
-      @name = name
-      @session = session
-    end
+      def initialize(session, name)
+        @name = name
+        @session = session
+      end
 
-    def create_index(*properties)
-      response = @session._query("CREATE INDEX ON :`#{@name}`(#{properties.join(',')})")
-      response.raise_error if response.error?
-    end
+      def create_index(*properties)
+        response = @session._query("CREATE INDEX ON :`#{@name}`(#{properties.join(',')})")
+        response.raise_error if response.error?
+      end
 
-    def drop_index(*properties)
-      properties.each do |property|
-        response = @session._query("DROP INDEX ON :`#{@name}`(#{property})")
-        response.raise_error if response.error? && !response.error_msg.match(/No such INDEX ON/)
+      def drop_index(*properties)
+        properties.each do |property|
+          response = @session._query("DROP INDEX ON :`#{@name}`(#{property})")
+          response.raise_error if response.error? && !response.error_msg.match(/No such INDEX ON/)
+        end
       end
-    end
 
-    def indexes
-      @session.indexes(@name)
-    end
+      def indexes
+        @session.indexes(@name)
+      end
 
-    def uniqueness_constraints
-      @session.uniqueness_constraints(@name)
+      def uniqueness_constraints
+        @session.uniqueness_constraints(@name)
+      end
     end
   end
 end

data/lib/neo4j-server/cypher_node.rb

@@ -1,218 +1,221 @@
-module Neo4j::Server
-  class CypherNode < Neo4j::Node
-    include Neo4j::Server::Resource
-    include Neo4j::Core::CypherTranslator
-    include Neo4j::Core::ActiveEntity
-
-    def initialize(session, value)
-      @session = session
-
-      @id = if value.is_a?(Hash)
-        hash = value['data']
-        @props = Hash[hash.map{ |k, v| [k.to_sym, v] }]
-        @labels = value['metadata']['labels'].map(&:to_sym) if value['metadata']
-        value['id'] # value['self'].match(/\d+$/)[0].to_i
-      else
-        value
+module Neo4j
+  module Server
+    class CypherNode < Neo4j::Node
+      include Neo4j::Server::Resource
+      include Neo4j::Core::CypherTranslator
+      include Neo4j::Core::ActiveEntity
+
+      def initialize(session, value)
+        @session = session
+
+        @neo_id = if value.is_a?(Hash)
+                    hash = value['data']
+                    @props = Hash[hash.map { |k, v| [k.to_sym, v] }]
+                    @labels = value['metadata']['labels'].map!(&:to_sym) if value['metadata']
+                    value['id'] # value['self'].match(/\d+$/)[0].to_i
+                  else
+                    value
+                  end
       end
-    end
 
-    def neo_id
-      @id
-    end
+      attr_reader :neo_id
 
-    def inspect
-      "CypherNode #{neo_id} (#{object_id})"
-    end
+      def inspect
+        "CypherNode #{neo_id} (#{object_id})"
+      end
 
-    # TODO, needed by neo4j-cypher
-    def _java_node
-      self
-    end
+      # TODO, needed by neo4j-cypher
+      def _java_node
+        self
+      end
 
-    # (see Neo4j::Node#create_rel)
-    def create_rel(type, other_node, props = nil)
-      id = @session._query_or_fail(rel_string(type, other_node, props), true, cypher_prop_list(props))
-      data_hash = { 'type' => type, 'data' => props, 'start' => self.neo_id.to_s, 'end' => other_node.neo_id.to_s, 'id' => id }
-      CypherRelationship.new(@session, data_hash)
-    end
+      # (see Neo4j::Node#create_rel)
+      def create_rel(type, other_node, props = nil)
+        ids_hash = {start_neo_id: neo_id, end_neo_id: other_node.neo_id}
+        props_with_ids = props.nil? ? ids_hash : cypher_prop_list(props).merge(ids_hash)
+        id = @session._query_or_fail(rel_string(type, other_node, props), true, props_with_ids)
+        data_hash = {'type' => type, 'data' => props, 'start' => neo_id, 'end' => other_node.neo_id, 'id' => id}
+        CypherRelationship.new(@session, data_hash)
+      end
 
-    def rel_string(type, other_node, props)
-      "MATCH (a), (b) WHERE ID(a) = #{neo_id} AND ID(b) = #{other_node.neo_id} CREATE (a)-[r:`#{type}` #{prop_identifier(props)}]->(b) RETURN ID(r)"
-    end
+      def rel_string(type, other_node, props)
+        "MATCH (a), (b) WHERE ID(a) = {start_neo_id} AND ID(b) = {end_neo_id} CREATE (a)-[r:`#{type}` #{prop_identifier(props)}]->(b) RETURN ID(r)"
+      end
 
-    # (see Neo4j::Node#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::Node#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
 
-    def refresh
-      @props = nil
-    end
+      def refresh
+        @props = nil
+      end
 
-    # (see Neo4j::Node#remove_property)
-    def remove_property(key)
-      refresh
-      @session._query_or_fail("#{match_start} REMOVE n.`#{key}`", false, { neo_id: neo_id })
-    end
+      # (see Neo4j::Node#remove_property)
+      def remove_property(key)
+        refresh
+        @session._query_or_fail("#{match_start} REMOVE n.`#{key}`", false,  neo_id: neo_id)
+      end
 
-    # (see Neo4j::Node#set_property)
-    def set_property(key,value)
-      refresh
-      @session._query_or_fail("#{match_start} SET n.`#{key}` = { value }", false, { value: value, neo_id: neo_id })
-      value
-    end
+      # (see Neo4j::Node#set_property)
+      def set_property(key, value)
+        refresh
+        @session._query_or_fail("#{match_start} SET n.`#{key}` = { value }", false,  value: value, neo_id: neo_id)
+        value
+      end
 
-    # (see Neo4j::Node#props=)
-    def props=(properties)
-      refresh
-      @session._query_or_fail("#{match_start} SET n = { props }", false, { props: properties, neo_id: neo_id })
-      properties
-    end
+      # (see Neo4j::Node#props=)
+      def props=(properties)
+        refresh
+        @session._query_or_fail("#{match_start} SET n = { props }", false,  props: properties, neo_id: neo_id)
+        properties
+      end
 
-    def remove_properties(properties)
-      refresh
-      q = "#{match_start} REMOVE " + properties.map do |k|
-        "n.`#{k}`"
-      end.join(', ')
-      @session._query_or_fail(q, false, neo_id: neo_id)
-    end
+      def remove_properties(properties)
+        refresh
+        q = "#{match_start} REMOVE " + properties.map do |k|
+          "n.`#{k}`"
+        end.join(', ')
+        @session._query_or_fail(q, false, neo_id: neo_id)
+      end
 
-    # (see Neo4j::Node#update_props)
-    def update_props(properties)
-      refresh
-      return if properties.empty?
-
-      removed_keys = properties.keys.select{|k| properties[k].nil?}
-      remove_properties(removed_keys) unless removed_keys.empty?
-      properties_to_set = properties.keys - removed_keys
-      return if properties_to_set.empty?
-      props_list = cypher_prop_list(properties)[:props].merge({ neo_id: neo_id })
-      @session._query_or_fail("#{match_start} SET #{cypher_properties(properties_to_set)}", false, props_list)
-      properties
-    end
+      # (see Neo4j::Node#update_props)
+      def update_props(properties)
+        refresh
+        return if properties.empty?
+
+        removed_keys = properties.keys.select { |k| properties[k].nil? }
+        remove_properties(removed_keys) unless removed_keys.empty?
+        properties_to_set = properties.keys - removed_keys
+        return if properties_to_set.empty?
+        props_list = cypher_prop_list(properties)[:props].merge(neo_id: neo_id)
+        @session._query_or_fail("#{match_start} SET #{cypher_properties(properties_to_set)}", false, props_list)
+        properties
+      end
 
-    # (see Neo4j::Node#get_property)
-    def get_property(key)
-      @props ? @props[key.to_sym] : @session._query_or_fail("#{match_start} RETURN n.`#{key}`", true, neo_id: neo_id)
-    end
+      # (see Neo4j::Node#get_property)
+      def get_property(key)
+        @props ? @props[key.to_sym] : @session._query_or_fail("#{match_start} RETURN n.`#{key}`", true, neo_id: neo_id)
+      end
 
-    # (see Neo4j::Node#labels)
-    def labels
-      @labels ||= @session._query_or_fail("#{match_start} RETURN labels(n) as labels", true, neo_id: neo_id)
-      @labels.map(&:to_sym)
-    end
+      # (see Neo4j::Node#labels)
+      def labels
+        @labels ||= @session._query_or_fail("#{match_start} RETURN labels(n) as labels", true, neo_id: neo_id).map!(&:to_sym)
+      end
 
-    def _cypher_label_list(labels)
-      ':' + labels.map{|label| "`#{label}`"}.join(':')
-    end
+      def _cypher_label_list(labels_list)
+        ':' + labels_list.map { |label| "`#{label}`" }.join(':')
+      end
 
-    def add_label(*labels)
-      @session._query_or_fail("#{match_start} SET n #{_cypher_label_list(labels)}", false, neo_id: neo_id)
-    end
+      def add_label(*new_labels)
+        @session._query_or_fail("#{match_start} SET n #{_cypher_label_list(new_labels)}", false, neo_id: neo_id)
+        new_labels.each { |label| labels << label }
+      end
 
-    def remove_label(*labels)
-      @session._query_or_fail("#{match_start} REMOVE n #{_cypher_label_list(labels)}", false, neo_id: neo_id)
-    end
+      def remove_label(*target_labels)
+        @session._query_or_fail("#{match_start} REMOVE n #{_cypher_label_list(target_labels)}", false, neo_id: neo_id)
+        target_labels.each { |label| labels.delete(label) } unless labels.nil?
+      end
 
-    def set_label(*label_names)
-      q = "#{match_start} #{remove_labels_if_needed} #{set_labels_if_needed(label_names)}"
-      @session._query_or_fail(q, false, neo_id: neo_id)
-    end
+      def set_label(*label_names)
+        q = "#{match_start} #{remove_labels_if_needed} #{set_labels_if_needed(label_names)}"
+        @session._query_or_fail(q, false, neo_id: neo_id)
+      end
 
-    # (see Neo4j::Node#del)
-    def del
-      @session._query_or_fail("#{match_start} OPTIONAL MATCH n-[r]-() DELETE n, r", false, neo_id: neo_id)
-    end
+      # (see Neo4j::Node#del)
+      def del
+        @session._query_or_fail("#{match_start} OPTIONAL MATCH n-[r]-() DELETE n, r", false, neo_id: neo_id)
+      end
 
-    alias_method :delete, :del
-    alias_method :destroy, :del
+      alias_method :delete, :del
+      alias_method :destroy, :del
 
-    # (see Neo4j::Node#exist?)
-    def exist?
-      @session._query("#{match_start} RETURN ID(n)", neo_id: neo_id).data.empty? ? false : true
-    end
+      # (see Neo4j::Node#exist?)
+      def exist?
+        @session._query("#{match_start} RETURN ID(n)", neo_id: neo_id).data.empty? ? false : true
+      end
 
-    # (see Neo4j::Node#node)
-    def node(match={})
-      ensure_single_relationship { match(CypherNode, "p as result LIMIT 2", match) }
-    end
+      # (see Neo4j::Node#node)
+      def node(match = {})
+        ensure_single_relationship { match(CypherNode, 'p as result LIMIT 2', match) }
+      end
 
-    # (see Neo4j::Node#rel)
-    def rel(match={})
-      ensure_single_relationship { match(CypherRelationship, "r as result LIMIT 2", match) }
-    end
+      # (see Neo4j::Node#rel)
+      def rel(match = {})
+        ensure_single_relationship { match(CypherRelationship, 'r as result LIMIT 2', match) }
+      end
 
-    # (see Neo4j::Node#rel?)
-    def rel?(match={})
-      result = match(CypherRelationship, "r as result", match)
-      !!result.first
-    end
+      # (see Neo4j::Node#rel?)
+      def rel?(match = {})
+        result = match(CypherRelationship, 'r as result', match)
+        !!result.first
+      end
 
-    # (see Neo4j::Node#nodes)
-    def nodes(match={})
-      match(CypherNode, "p as result", match)
-    end
+      # (see Neo4j::Node#nodes)
+      def nodes(match = {})
+        match(CypherNode, 'p as result', match)
+      end
 
-    # (see Neo4j::Node#rels)
-    def rels(match = {dir: :both})
-      match(CypherRelationship, "r as result", match)
-    end
+      # (see Neo4j::Node#rels)
+      def rels(match = {dir: :both})
+        match(CypherRelationship, 'r as result', match)
+      end
 
-    # @private
-    def match(clazz, returns, match={})
-      to_dir = {outgoing: ->(rel) {"-#{rel}->"},
-                incoming: ->(rel) {"<-#{rel}-"},
-                both:     ->(rel) {"-#{rel}-"} }
-
-      cypher_rel = match[:type] ? "[r:`#{match[:type]}`]" : '[r]'
-      between_id = match[:between] ? "MATCH (p) WHERE ID(p) = #{match[:between].neo_id}" : ""
-      dir_func = to_dir[match[:dir] || :both]
-      cypher = "#{match_start} #{between_id} MATCH (n)#{dir_func.call(cypher_rel)}(p) RETURN #{returns}"
-      r = @session._query(cypher, neo_id: neo_id)
-      r.raise_error if r.error?
-      _map_result(r)
-    end
+      # @private
+      def match(clazz, returns, match = {})
+        to_dir = {outgoing: ->(rel) { "-#{rel}->" },
+                  incoming: ->(rel) { "<-#{rel}-" },
+                  both:     ->(rel) { "-#{rel}-" }}
+
+        cypher_rel = match[:type] ? "[r:`#{match[:type]}`]" : '[r]'
+        between_id = match[:between] ? "MATCH (p) WHERE ID(p) = #{match[:between].neo_id}" : ''
+        dir_func = to_dir[match[:dir] || :both]
+        cypher = "#{match_start} #{between_id} MATCH (n)#{dir_func.call(cypher_rel)}(p) RETURN #{returns}"
+        r = @session._query(cypher, neo_id: neo_id)
+        r.raise_error if r.error?
+        _map_result(r)
+      end
 
-    def _map_result(r)
-      r.to_node_enumeration.map { |rel| rel.result }
-    end
+      def _map_result(r)
+        r.to_node_enumeration.map(&:result)
+      end
 
-    private
+      private
 
-    def cypher_properties(properties_to_set)
-      properties_to_set.map! { |k| "n.`#{k}` = {`#{k}`}"}.join(',')
-    end
+      def cypher_properties(properties_to_set)
+        properties_to_set.map! { |k| "n.`#{k}` = {`#{k}`}" }.join(',')
+      end
 
-    def remove_labels_if_needed
-      if labels.empty?
-        ""
-      else
-        " REMOVE n #{_cypher_label_list(labels)}"
+      def remove_labels_if_needed
+        if labels.empty?
+          ''
+        else
+          " REMOVE n #{_cypher_label_list(labels)}"
+        end
       end
-    end
 
-    def set_labels_if_needed(label_names)
-      if label_names.empty?
-        ""
-      else
-        " SET n #{_cypher_label_list(label_names.map(&:to_sym).uniq)}"
+      def set_labels_if_needed(label_names)
+        if label_names.empty?
+          ''
+        else
+          " SET n #{_cypher_label_list(label_names.map(&:to_sym).uniq)}"
+        end
       end
-    end
 
-    def ensure_single_relationship(&block)
-      result = yield
-      raise "Expected to only find one relationship from node #{neo_id} matching #{match.inspect} but found #{result.count}" if result.count > 1
-      result.first
-    end
+      def ensure_single_relationship(&block)
+        result = yield
+        fail "Expected to only find one relationship from node #{neo_id} matching #{match.inspect} but found #{result.count}" if result.count > 1
+        result.first
+      end
 
-    def match_start(identifier = 'n')
-      "MATCH (#{identifier}) WHERE ID(#{identifier}) = {neo_id}"
+      def match_start(identifier = 'n')
+        "MATCH (#{identifier}) WHERE ID(#{identifier}) = {neo_id}"
+      end
     end
   end
 end