neo4j-core 3.1.1 → 4.0.0

data/lib/neo4j-server/cypher_transaction.rb

@@ -1,61 +1,79 @@
-module Neo4j::Server
-  class CypherTransaction
-    include Neo4j::Transaction::Instance
-    include Neo4j::Core::CypherTranslator
-    include Resource
+module Neo4j
+  module Server
+    # The CypherTransaction object lifecycle is as follows:
+    # * It is initialized with the transactional endpoint URL and the connection object to use for communication. It does not communicate with the server to create this.
+    # * The first query within the transaction sets the commit and execution addresses, :commit_url and :exec_url.
+    # * At any time, `failure` can be called to mark a transaction failed and trigger a rollback upon closure.
+    # * `close` is called to end the transaction. It calls `_commit_tx` or `_delete_tx`.
+    #
+    # If a transaction is created and then closed without performing any queries, an OpenStruct is returned that behaves like a successfully closed query.
+    class CypherTransaction
+      include Neo4j::Transaction::Instance
+      include Neo4j::Core::CypherTranslator
+      include Resource
 
-    attr_reader :commit_url, :exec_url
+      attr_reader :commit_url, :exec_url, :base_url, :connection
 
-    class CypherError < StandardError
-      attr_reader :code, :status
-      def initialize(code, status, message)
-        super(message)
-        @code = code
-        @status = status
+      def initialize(url, session_connection)
+        @base_url = url
+        @connection = session_connection
+        register_instance
       end
-    end
 
-    def initialize(db, response, url, connection)
-      @connection = connection
-      @commit_url = response.body['commit']
-      @exec_url = response.headers['Location']
-      raise "NO ENDPOINT URL #{@connection} : HEAD: #{response.headers.inspect}" if !@exec_url || @exec_url.empty?
-      init_resource_data(response.body, url)
-      expect_response_code(response,201)
-      register_instance
-    end
+      ROW_REST = %w(row REST)
+      def _query(cypher_query, params = nil)
+        fail 'Transaction expired, unable to perform query' if expired?
+        statement = {statement: cypher_query, parameters: params, resultDataContents: ROW_REST}
+        body = {statements: [statement]}
 
-    def _query(cypher_query, params=nil)
-      statement = { statement: cypher_query, parameters: params, resultDataContents: ['row', 'REST'] }
-      body = { statements: [statement] }
-      response = @connection.post(@exec_url, body)
-      _create_cypher_response(response)
-    end
+        response = exec_url && commit_url ? connection.post(exec_url, body) : register_urls(body)
+        _create_cypher_response(response)
+      end
 
-    def _create_cypher_response(response)
-      first_result = response.body['results'][0]
+      def _delete_tx
+        _tx_query(:delete, exec_url, headers: resource_headers)
+      end
 
-      cr = CypherResponse.new(response, true)
-      if !response.body['errors'].empty?
-        first_error = response.body['errors'].first
-        cr.set_error(first_error['message'], first_error['code'], first_error['code'])
-      else
-        cr.set_data(first_result['data'], first_result['columns'])
+      def _commit_tx
+        _tx_query(:post, commit_url, nil)
       end
-      cr
-    end
 
-    def _delete_tx
-      response = @connection.delete(@exec_url, headers: resource_headers)
-      expect_response_code(response,200)
-      response
-    end
+      private
 
-    def _commit_tx
-      response = @connection.post(@commit_url)
+      def _tx_query(action, endpoint, headers = {})
+        return empty_response if !commit_url || expired?
+        response = connection.send(action, endpoint, headers)
+        expect_response_code(response, 200)
+        response
+      end
+
+      def register_urls(body)
+        response = connection.post(base_url, body)
+        @commit_url = response.body['commit']
+        @exec_url = response.headers['Location']
+        fail "NO ENDPOINT URL #{connection} : HEAD: #{response.headers.inspect}" if !exec_url || exec_url.empty?
+        init_resource_data(response.body, base_url)
+        expect_response_code(response, 201)
+        response
+      end
+
+      def _create_cypher_response(response)
+        first_result = response.body['results'][0]
 
-      expect_response_code(response,200)
-      response
+        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
+          expired if first_error['message'].match(/Unrecognized transaction id/)
+          cr.set_error(first_error['message'], first_error['code'], first_error['code'])
+        end
+        cr
+      end
+
+      def empty_response
+        OpenStruct.new(status: 200, body: '')
+      end
     end
   end
-end
+end

data/lib/neo4j-server/resource.rb

@@ -1,44 +1,39 @@
 module Neo4j
   module Server
     module Resource
-
       class ServerException < Exception
       end
 
       attr_reader :resource_data, :resource_url
 
       def init_resource_data(resource_data, resource_url)
-        raise "Exception #{resource_data['exception']}" if resource_data['exception']
+        fail "Exception #{resource_data['exception']}" if resource_data['exception']
+        fail "Expected @resource_data to be Hash got #{resource_data.inspect}" unless resource_data.respond_to?(:[])
+
         @resource_url = resource_url
         @resource_data = resource_data
-        raise "expected @resource_data to be Hash got #{@resource_data.class}" unless @resource_data.respond_to?(:[])
+
         self
       end
 
-
-      def wrap_resource(db, rel, resource_class, verb = :get, statement = {}, connection)
-        url = resource_url(rel)
-        payload = statement.empty? ? nil : statement
-        response = case verb
-          when :get then connection.get(url, payload)
-          when :post then connection.post(url, payload)
-          else raise "Illegal verb #{verb}"
-        end
-        response.status == 404 ? nil : resource_class.new(db, response, url, connection)
+      def wrap_resource(connection = Neo4j::Session.current)
+        url = resource_url('transaction')
+        CypherTransaction.new(url, connection)
       end
 
-      def resource_url(rel = nil)
-        return @resource_url if rel.nil?
-        url = resource_data[rel.to_s]
-        raise "No resource rel '#{rel}', available #{@resource_data.keys.inspect}" unless url
-        url
+      def resource_url(key = nil)
+        return @resource_url if key.nil?
+
+        @resource_data.fetch key.to_s
+      rescue KeyError
+        raise "No resource key '#{key}', available #{@resource_data.keys.inspect}"
       end
 
-      def handle_response_error(response, msg="Error for request" )
-        raise ServerException.new("#{msg} #{response.env && response.env[:url].to_s}, #{response.status}, #{response.status}")
+      def handle_response_error(response, msg = 'Error for request')
+        fail ServerException, "#{msg} #{response.env && response.env[:url].to_s}, #{response.status}, #{response.status}"
       end
 
-      def expect_response_code(response, expected_code, msg="Error for request" )
+      def expect_response_code(response, expected_code, msg = 'Error for request')
         handle_response_error(response, "Expected response code #{expected_code} #{msg}") unless response.status == expected_code
         response
       end
@@ -57,7 +52,7 @@ module Neo4j
       end
 
       def convert_from_json_value(value)
-        JSON.parse(value, :quirks_mode => true)
+        JSON.parse(value, quirks_mode: true)
       end
     end
   end

data/lib/neo4j/entity_equality.rb

@@ -1,9 +1,8 @@
 module Neo4j
   module EntityEquality
-    def ==(o)
-      o.class == self.class && o.neo_id == neo_id
+    def ==(other)
+      other.class == self.class && other.neo_id == neo_id
     end
     alias_method :eql?, :==
-
   end
-end
+end

data/lib/neo4j/label.rb

@@ -7,23 +7,23 @@ module Neo4j
 
     # @abstract
     def name
-      raise 'not implemented'
+      fail 'not implemented'
     end
 
     # @abstract
     def create_index(*properties)
-      raise 'not implemented'
+      fail 'not implemented'
     end
 
     # @abstract
     def drop_index(*properties)
-      raise 'not implemented'
+      fail 'not implemented'
     end
 
     # List indices for a label
     # @abstract
     def indexes
-      raise 'not implemented'
+      fail 'not implemented'
     end
 
     # Creates a neo4j constraint on a property
@@ -34,11 +34,11 @@ module Neo4j
     #
     def create_constraint(property, constraints, session = Neo4j::Session.current)
       cypher = case constraints[:type]
-        when :unique
-          "CREATE CONSTRAINT ON (n:`#{name}`) ASSERT n.`#{property}` IS UNIQUE"
-        else
-          raise "Not supported constrain #{constraints.inspect} for property #{property} (expected :type => :unique)"
-      end
+               when :unique
+                 "CREATE CONSTRAINT ON (n:`#{name}`) ASSERT n.`#{property}` IS UNIQUE"
+               else
+                 fail "Not supported constrain #{constraints.inspect} for property #{property} (expected :type => :unique)"
+               end
       session._query_or_fail(cypher)
     end
 
@@ -51,10 +51,10 @@ module Neo4j
     #
     def drop_constraint(property, constraint, session = Neo4j::Session.current)
       cypher = case constraint[:type]
-                 when :unique
-                   "DROP CONSTRAINT ON (n:`#{name}`) ASSERT n.`#{property}` IS UNIQUE"
-                 else
-                   raise "Not supported constrain #{constraint.inspect}"
+               when :unique
+                 "DROP CONSTRAINT ON (n:`#{name}`) ASSERT n.`#{property}` IS UNIQUE"
+               else
+                 fail "Not supported constrain #{constraint.inspect}"
                end
       session._query_or_fail(cypher)
     end
@@ -78,9 +78,6 @@ module Neo4j
       def find_nodes(label_name, key, value, session = Neo4j::Session.current)
         session.find_nodes(label_name, key, value)
       end
-
     end
-
   end
-
 end

data/lib/neo4j/node.rb

@@ -1,9 +1,7 @@
 module Neo4j
-
   # The base class for both the Embedded and Server Neo4j Node
   # Notice this class is abstract and can't be instantiated
   class Node
-
     # A module that allows plugins to register wrappers around Neo4j::Node objects
     module Wrapper
       # Used by Neo4j::NodeMixin to wrap nodes
@@ -21,44 +19,44 @@ module Neo4j
     include PropertyContainer
 
     # @return [Hash<Symbol, Object>] all properties of the node
-    def props()
-      raise 'not implemented'
+    def props
+      fail 'not implemented'
     end
 
     # replace all properties with new properties
     # @param [Hash<Symbol, Object>] properties a hash of properties the node should have
     def props=(properties)
-      raise 'not implemented'
+      fail 'not implemented'
     end
 
     # Refresh the properties by reading it from the database again next time an property value is requested.
     def refresh
-      raise 'not implemented'
+      fail 'not implemented'
     end
 
     # Updates the properties, keeps old properties
     # @param [Hash<Symbol, Object>] properties hash of properties that should be updated on the node
     def update_props(properties)
-      raise 'not implemented'
+      fail 'not implemented'
     end
 
     # Directly remove the property on the node (low level method, may need transaction)
     def remove_property(key)
-      raise 'not implemented'
+      fail 'not implemented'
     end
 
     # Directly set the property on the node (low level method, may need transaction)
     # @param [Symbol, String] key
     # @param value see Neo4j::PropertyValidator::VALID_PROPERTY_VALUE_CLASSES for valid values
     def set_property(key, value)
-      raise 'not implemented'
+      fail 'not implemented'
     end
 
     # Directly get the property on the node (low level method, may need transaction)
     # @param [Symbol, String] key
     # @return the value of the key
     def get_property(key, value)
-      raise 'not implemented'
+      fail 'not implemented'
     end
 
     # Creates a relationship of given type to other_node with optionally properties
@@ -66,7 +64,7 @@ module Neo4j
     # @param [Neo4j::Node] other_node the other node
     # @param [Hash<Symbol, Object>] props optionally properties for the created relationship
     def create_rel(type, other_node, props = nil)
-      raise 'not implemented'
+      fail 'not implemented'
     end
 
 
@@ -89,45 +87,45 @@ module Neo4j
     #   node_a.rels(type: :friends, dir: :outgoing, between: node_b)
     #
     def rels(match = {dir: :both})
-      raise 'not implemented'
+      fail 'not implemented'
     end
 
     # Adds one or more Neo4j labels on the node
     # @param [Array<Symbol>] labels one or more labels to add
     def add_label(*labels)
-      raise 'not implemented'
+      fail 'not implemented'
     end
 
     # Sets label on the node. Any old labels will be removed
     # @param [Array<Symbol>] labels one or more labels to set
     def set_label(*labels)
-      raise 'not implemented'
+      fail 'not implemented'
     end
 
     # Removes given labels
     def remove_label(*labels)
-      raise 'not implemented'
+      fail 'not implemented'
     end
 
     #
     # @return [Array<Symbol>]all labels on the node
-    def labels()
-      raise 'not implemented'
+    def labels
+      fail 'not implemented'
     end
 
     # Deletes this node from the database
-    def del()
-      raise 'not implemented'
+    def del
+      fail 'not implemented'
     end
 
     # @return true if the node exists in the database
     def exist?
-      raise 'not implemented'
+      fail 'not implemented'
     end
 
     # @return all the Neo4j labels for this node
     def labels
-      raise 'not implemented'
+      fail 'not implemented'
     end
 
     # Returns the only node of a given type and direction that is attached to this node, or nil.
@@ -144,27 +142,27 @@ module Neo4j
     #
     # @param (see #rel)
     def node(specs = {})
-      raise 'not implemented'
+      fail 'not implemented'
     end
 
     # Same as #node but returns the relationship. Notice it may raise an exception if there are more then one relationship matching.
     def rel(spec = {})
-      raise 'not implemented'
+      fail 'not implemented'
     end
 
     def _rel(spec = {})
-      raise 'not implemented'
+      fail 'not implemented'
     end
 
     # Returns true or false if there is one or more relationships
     # @return [Boolean]
     def rel?(spec = {})
-      raise 'not implemented'
+      fail 'not implemented'
     end
 
     # @return [Boolean] true if the node exists
     def exist?
-      raise 'not implemented'
+      fail 'not implemented'
     end
 
     # Works like #rels method but instead returns the nodes.
@@ -174,12 +172,12 @@ module Neo4j
     # @return [Enumerable<Neo4j::Node>] an Enumeration of either Neo4j::Node objects or wrapped Neo4j::Node objects
     # @note it's possible that the same node is returned more than once because of several relationship reaching to the same node, see #outgoing for alternative
     def nodes(specs = {})
-      #rels(specs).map{|n| n.other_node(self)}
+      # rels(specs).map{|n| n.other_node(self)}
     end
 
     class << self
       # Creates a node
-      def create(props=nil, *labels_or_db)
+      def create(props = nil, *labels_or_db)
         session = Neo4j::Core::ArgumentHelper.session(labels_or_db)
         session.create_node(props, labels_or_db)
       end
@@ -197,21 +195,19 @@ module Neo4j
       end
 
       # Find the node with given label and value
-      def find_nodes(label, value=nil, session = Neo4j::Session.current!)
+      def find_nodes(label, value = nil, session = Neo4j::Session.current!)
         session.find_nodes(label, value)
       end
     end
 
     def initialize
-      raise "Can't instantiate abstract class" if abstract_class?
+      fail "Can't instantiate abstract class" if abstract_class?
     end
 
     private
+
     def abstract_class?
       self.class == Node
     end
-
-
   end
-
-end
+end