neo4j-core 3.0.8 → 3.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 282dbe05a1e9fe442230e3fc5a4e0f7f7555b53e
-  data.tar.gz: ece1c98b2675ccc0a4c6b20d993f8a7e11802a99
+  metadata.gz: 6f4890cd93db0d6c36f8208fc1e9389c587edaf2
+  data.tar.gz: dea68555caf4904ac68214b6cea915cb1c8462e9
 SHA512:
-  metadata.gz: e0eb0f57bb90a510bbb08ee600e57560df6810196e693b9abba495e616a62f0e4ff682be5cc48d45160b2222653dc3e5bd0bbbbb0a2df5ca08a01273a422cd42
-  data.tar.gz: 16f6b02085a574f7d303574db967f6b12ea42d447349428d5d82e18c579b34e4c4d27e3bd800a0dc0573cf39e42802fa1bc1b9dd43d4569b1908e494f3691525
+  metadata.gz: 3e34f33523134c71bb13aa7858a3f2444bcfb252f39d2dc54c41417d8c291347e47a8730c200639e1cb0ef7094b1c84941312b1210877c46f4471c4bcaca84ce
+  data.tar.gz: 2a0cb02bb6ea67c92e9964643c5743a2bca5b35385cc7079b02433c283014eb929c6d403f1ef148b66b8d3eda9a2d214be9f5d6c23e3db621d120764c6dee40d

data/Gemfile

@@ -14,6 +14,8 @@ group 'development' do
   gem 'yard'
   gem 'simplecov'
   gem 'pry'
+  gem 'pry-rescue'
+  gem 'pry-stack_explorer', platform: :ruby
 end
 
 group 'test' do
@@ -21,4 +23,3 @@ group 'test' do
   gem "rspec", "~> 3.0"
   gem 'rspec-its'
 end
-

data/lib/neo4j-core/cypher_translator.rb

@@ -1,47 +1,52 @@
 module Neo4j::Core
   module CypherTranslator
     # Cypher Helper
-     def escape_value(value)
-       result = case value
-         when String
-           sanitized = sanitize_escape_sequences(value)
-           "'#{escape_quotes(sanitized)}'"
-         else
-           value
-       end
-       result
-     end
-
-     # Only following escape sequence characters are allowed in Cypher:
-     #
-     # \t Tab
-     # \b Backspace
-     # \n Newline
-     # \r Carriage return
-     # \f Form feed
-     # \' Single quote
-     # \" Double quote
-     # \\ Backslash
-     #
-     # From:
-     # http://docs.neo4j.org/chunked/stable/cypher-expressions.html#_note_on_string_literals
-     SANITIZE_ESCAPED_REGEXP = /(?<!\\)\\(\\\\)*(?![futbnr'"\\])/
-     def sanitize_escape_sequences(s)
-       s.gsub SANITIZE_ESCAPED_REGEXP, ''
-     end
-
-     def escape_quotes(s)
-       s.gsub("'", %q(\\\'))
-     end
+    def escape_value(value)
+      if value.is_a?(String) || value.is_a?(Symbol)
+        "'#{escape_quotes(sanitize_escape_sequences(value.to_s))}'"
+      else
+        value
+      end
+    end
 
-    # Cypher Helper
-    def cypher_prop_list(props)
-      return "" unless props
+    # Like escape_value but it does not wrap the value in quotes
+    def create_escape_value(value)
+      if value.is_a?(String) || value.is_a?(Symbol)
+        "#{sanitize_escape_sequences(value.to_s)}"
+      else
+        value
+      end
+    end
+
+    # Only following escape sequence characters are allowed in Cypher:
+    #
+    # \t Tab
+    # \b Backspace
+    # \n Newline
+    # \r Carriage return
+    # \f Form feed
+    # \' Single quote
+    # \" Double quote
+    # \\ Backslash
+    #
+    # From:
+    # http://docs.neo4j.org/chunked/stable/cypher-expressions.html#_note_on_string_literals
+    SANITIZE_ESCAPED_REGEXP = /(?<!\\)\\(\\\\)*(?![futbnr'"\\])/
+    EMPTY_PROPS = ''
 
-      properties_to_set = props.reject {|k,v| v.nil? }
+    def sanitize_escape_sequences(s)
+     s.gsub SANITIZE_ESCAPED_REGEXP, EMPTY_PROPS
+    end
 
-      list = properties_to_set.map{|k,v| "#{k} : #{escape_value(v)}"}.join(',')
-      "{#{list}}"
+    def escape_quotes(s)
+     s.gsub("'", %q(\\\'))
+    end
+
+    # Cypher Helper
+    def cypher_prop_list(props)
+      return nil unless props
+      props.reject! {|k,v| v.nil? }
+      { props: props.each { |k, v|  props[k] = create_escape_value(v) } }
     end
 
     # Stolen from keymaker
@@ -51,11 +56,19 @@ module Neo4j::Core
     end
 
     def self.sanitized_column_names(response_body)
-      response_body.columns.map do |column|
-        column[/[^\.]+$/]
-      end
+      response_body.columns.map { |column| column[/[^\.]+$/] }
     end
 
-  end
+    def cypher_string(labels, props)
+      "CREATE (n#{label_string(labels)} #{prop_identifier(props)}) RETURN ID(n)"
+    end
 
+    def label_string(labels)
+      labels.empty? ? '' : ":#{labels.map{|k| "`#{k}`"}.join(':')}"
+    end
+
+    def prop_identifier(props)
+      '{props}' unless props.nil?
+    end
+  end
 end

data/lib/neo4j-core/version.rb

@@ -1,5 +1,5 @@
 module Neo4j
   module Core
-    VERSION = "3.0.8"
+    VERSION = "3.1.0"
   end
 end

data/lib/neo4j-server.rb

@@ -4,6 +4,7 @@ require 'faraday_middleware'
 require 'neo4j-server/resource'
 require 'neo4j-server/cypher_node'
 require 'neo4j-server/cypher_label'
+require 'neo4j-server/cypher_authentication'
 require 'neo4j-server/cypher_session'
 require 'neo4j-server/cypher_node_uncommited'
 require 'neo4j-server/cypher_relationship'

data/lib/neo4j-server/cypher_authentication.rb

@@ -0,0 +1,101 @@
+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
+
+    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
+
+    # 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
+
+    # 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 = connection.get("#{url}/authentication")
+      return nil if auth_response.body.empty?
+      auth_body = JSON.parse(auth_response.body)
+      token = auth_body['errors'][0]['code'] == 'Neo.ClientError.Security.AuthorizationFailed' ? obtain_token : nil
+      add_auth_headers(token) unless token.nil?
+    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(obtain_token)
+    end
+
+    # Requests a token from the authentication endpoint using the given username and password.
+    # @return [String] A plain-text token.
+    def obtain_token
+      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
+      auth_response = connection.post("#{url}/authentication", { 'username' => user, 'password' => pass })
+      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
+      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
+
+    # Stores an authentication token in the properly-formatted 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
+
+    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
+
+    def new_connection
+      self.class.new_connection
+    end
+
+    def token_hash(token)
+      Base64.strict_encode64(":#{token}")
+    end
+  end
+end

data/lib/neo4j-server/cypher_node.rb

@@ -32,18 +32,21 @@ module Neo4j::Server
 
     # (see Neo4j::Node#create_rel)
     def create_rel(type, other_node, props = nil)
-      q = "START a=node(#{neo_id}), b=node(#{other_node.neo_id}) CREATE (a)-[r:`#{type}` #{cypher_prop_list(props)}]->(b) RETURN ID(r)"
-      id = @session._query_or_fail(q, true)
+      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
 
+    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
+
     # (see Neo4j::Node#props)
     def props
       if @props
         @props
       else
-        hash = @session._query_entity_data("START n=node(#{neo_id}) RETURN n")
+        hash = @session._query_entity_data("#{match_start} RETURN n")
         @props = Hash[hash['data'].map{ |k, v| [k.to_sym, v] }]
       end
     end
@@ -55,26 +58,26 @@ module Neo4j::Server
     # (see Neo4j::Node#remove_property)
     def remove_property(key)
       refresh
-      @session._query_or_fail("START n=node(#{neo_id}) REMOVE n.`#{key}`")
+      @session._query_or_fail("#{match_start} REMOVE n.`#{key}`")
     end
 
     # (see Neo4j::Node#set_property)
     def set_property(key,value)
       refresh
-      @session._query_or_fail("START n=node(#{neo_id}) SET n.`#{key}` = { value }", false, value: value)
+      @session._query_or_fail("#{match_start} SET n.`#{key}` = { value }", false, value: value)
       value
     end
 
     # (see Neo4j::Node#props=)
     def props=(properties)
       refresh
-      @session._query_or_fail("START n=node(#{neo_id}) SET n = { props }", false, {props: properties})
+      @session._query_or_fail("#{match_start} SET n = { props }", false, {props: properties})
       properties
     end
 
     def remove_properties(properties)
       refresh
-      q = "START n=node(#{neo_id}) REMOVE " + properties.map do |k|
+      q = "#{match_start} REMOVE " + properties.map do |k|
         "n.`#{k}`"
       end.join(', ')
       @session._query_or_fail(q)
@@ -89,7 +92,7 @@ module Neo4j::Server
       remove_properties(removed_keys) unless removed_keys.empty?
       properties_to_set = properties.keys - removed_keys
       return if properties_to_set.empty?
-      q = "START n=node(#{neo_id}) SET " + properties_to_set.map do |k|
+      q = "#{match_start} SET " + properties_to_set.map do |k|
         "n.`#{k}`= #{escape_value(properties[k])}"
       end.join(',')
       @session._query_or_fail(q)
@@ -101,14 +104,13 @@ module Neo4j::Server
       if @props
         @props[key.to_sym]
       else
-        @session._query_or_fail("START n=node(#{neo_id}) RETURN n.`#{key}`", true)
+        @session._query_or_fail("#{match_start} RETURN n.`#{key}`", true)
       end
     end
 
     # (see Neo4j::Node#labels)
     def labels
-      @labels ||= @session._query_or_fail("START n=node(#{neo_id}) RETURN labels(n) as labels", true)
-
+      @labels ||= @session._query_or_fail("#{match_start} RETURN labels(n) as labels", true)
       @labels.map(&:to_sym)
     end
 
@@ -117,63 +119,40 @@ module Neo4j::Server
     end
 
     def add_label(*labels)
-      @session._query_or_fail("START n=node(#{neo_id}) SET n #{_cypher_label_list(labels)}")
+      @session._query_or_fail("#{match_start} SET n #{_cypher_label_list(labels)}")
     end
 
     def remove_label(*labels)
-      @session._query_or_fail("START n=node(#{neo_id}) REMOVE n #{_cypher_label_list(labels)}")
+      @session._query_or_fail("#{match_start} REMOVE n #{_cypher_label_list(labels)}")
     end
 
     def set_label(*label_names)
-      label_as_symbols = label_names.map(&:to_sym)
-      to_keep = labels & label_as_symbols
-      to_remove = labels - to_keep
-      to_set = label_as_symbols - to_keep
-
-      # no change ?
-      return if to_set.empty? && to_remove.empty?
-
-      q = "START n=node(#{neo_id})"
-      q += " SET n #{_cypher_label_list(to_set)}" unless to_set.empty?
-      q += " REMOVE n #{_cypher_label_list(to_remove)}" unless to_remove.empty?
-
+      q = "#{match_start} #{remove_labels_if_needed} #{set_labels_if_needed(label_names)}" 
       @session._query_or_fail(q)
     end
 
     # (see Neo4j::Node#del)
     def del
-      @session._query_or_fail("START n = node(#{neo_id}) MATCH n-[r]-() DELETE r")
-      @session._query_or_fail("START n = node(#{neo_id}) DELETE n")
+      @session._query_or_fail("#{match_start} MATCH n-[r]-() DELETE r")
+      @session._query_or_fail("#{match_start} DELETE n")
     end
+
     alias_method :delete, :del
     alias_method :destroy, :del
 
-
     # (see Neo4j::Node#exist?)
     def exist?
-      response = @session._query("START n=node(#{neo_id}) RETURN ID(n)")
-      if (!response.error?)
-        return true
-      elsif (response.error_status =~ /EntityNotFound/)
-        return false
-      else
-        response.raise_error
-      end
+      @session._query("#{match_start} RETURN ID(n)").data.empty? ? false : true
     end
 
-
     # (see Neo4j::Node#node)
     def node(match={})
-      result = match(CypherNode, "p as result LIMIT 2", match)
-      raise "Expected to only find one relationship from node #{neo_id} matching #{match.inspect} but found #{result.count}" if result.count > 1
-      result.first
+      ensure_single_relationship { match(CypherNode, "p as result LIMIT 2", match) }
     end
 
     # (see Neo4j::Node#rel)
     def rel(match={})
-      result = match(CypherRelationship, "r as result LIMIT 2", match)
-      raise "Expected to only find one relationship from node #{neo_id} matching #{match.inspect} but found #{result.count}" if result.count > 1
-      result.first
+      ensure_single_relationship { match(CypherRelationship, "r as result LIMIT 2", match) }
     end
 
     # (see Neo4j::Node#rel?)
@@ -187,7 +166,6 @@ module Neo4j::Server
       match(CypherNode, "p as result", match)
     end
 
-
     # (see Neo4j::Node#rels)
     def rels(match = {dir: :both})
       match(CypherRelationship, "r as result", match)
@@ -200,9 +178,9 @@ module Neo4j::Server
                 both:     ->(rel) {"-#{rel}-"} }
 
       cypher_rel = match[:type] ? "[r:`#{match[:type]}`]" : '[r]'
-      between_id = match[:between] ? ",p=node(#{match[:between].neo_id}) " : ""
+      between_id = match[:between] ? "MATCH (p) WHERE ID(p) = #{match[:between].neo_id}" : ""
       dir_func = to_dir[match[:dir] || :both]
-      cypher = "START n=node(#{neo_id}) #{between_id} MATCH (n)#{dir_func.call(cypher_rel)}(p) RETURN #{returns}"
+      cypher = "#{match_start} #{between_id} MATCH (n)#{dir_func.call(cypher_rel)}(p) RETURN #{returns}"
       r = @session._query(cypher)
       r.raise_error if r.error?
       _map_result(r)
@@ -211,5 +189,33 @@ module Neo4j::Server
     def _map_result(r)
       r.to_node_enumeration.map { |rel| rel.result }
     end
+
+    private
+
+    def remove_labels_if_needed
+      if labels.empty?
+        ""
+      else
+        " REMOVE n #{_cypher_label_list(labels)}"
+      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)}"
+      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 match_start(identifier = 'n')
+      "MATCH (#{identifier}) WHERE ID(#{identifier}) = #{neo_id}"
+    end
   end
 end