neo4j-core 8.1.4 → 9.0.0.alpha.1

data/lib/neo4j-server/cypher_transaction.rb

@@ -1,100 +0,0 @@
-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 :query_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` or `delete`.
-    #
-    # 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 < Neo4j::Transaction::Base
-      include Resource
-
-      attr_reader :commit_url, :query_url
-
-      def connection
-        @session.connection
-      end
-
-      def base_url
-        require 'uri'
-        URI(@session.instance_variable_get('@resource_url')).tap do |uri|
-          uri.path = ''
-        end.to_s
-      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]}
-
-        response = @query_url ? query(body) : start(body)
-
-        create_cypher_response(response)
-      end
-
-      def start(body)
-        request(:post, start_url, 201, body).tap do |response|
-          @commit_url = response.body[:commit]
-          @query_url = response.headers[:Location]
-
-          fail "NO ENDPOINT URL #{connection} : HEAD: #{response.headers.inspect}" if !@query_url || @query_url.empty?
-
-          init_resource_data(response.body, base_url)
-        end
-      end
-
-      def start_url
-        @session.resource_data.fetch(:transaction) || base_url
-      end
-
-      def query(body)
-        request(:post, @query_url, 200, body)
-      end
-
-      EMPTY_RESPONSE = OpenStruct.new(status: 200, body: '')
-
-      def delete
-        return EMPTY_RESPONSE if !@commit_url || expired?
-
-        request(:delete, @query_url, 200, nil, resource_headers)
-      end
-
-      def commit
-        return EMPTY_RESPONSE if !@commit_url || expired?
-
-        request(:post, @commit_url, 200, nil, resource_headers)
-      end
-
-      private
-
-      def request(action, endpoint_url, expected_code = 200, body = nil, headers = {})
-        connection.send(action, endpoint_url, body, headers).tap do |response|
-          expect_response_code!(response, expected_code)
-        end
-      end
-
-      def create_cypher_response(response)
-        CypherResponse.new(response, true).tap do |cypher_response|
-          if response.body[:errors].empty?
-            cypher_response.set_data(response.body[:results][0])
-          else
-            first_error = response.body[:errors].first
-            tx_cleanup!(first_error)
-            cypher_response.set_error(first_error)
-          end
-        end
-      end
-
-      def tx_cleanup!(first_error)
-        autoclosed!
-        mark_expired if first_error[:message] =~ /Unrecognized transaction id/
-      end
-
-      def empty_response
-        OpenStruct.new(status: 200, body: '')
-      end
-    end
-  end
-end

data/lib/neo4j-server/label.rb

@@ -1,40 +0,0 @@
-module Neo4j
-  class Label
-    class << self
-      def constraints(session = Neo4j::Session.current)
-        session.connection.get(CONSTRAINT_PATH).body
-      end
-
-      def constraint?(label_name, property, session = Neo4j::Session.current)
-        label_constraints = session.connection.get("#{CONSTRAINT_PATH}/#{label_name}").body
-        !label_constraints.select { |c| c[:label] == label_name.to_s && c[:property_keys].first == property.to_s }.empty?
-      end
-
-      def indexes(session = Neo4j::Session.current)
-        session.connection.get(INDEX_PATH).body
-      end
-
-      def index?(label_name, property, session = Neo4j::Session.current)
-        label_indexes = session.connection.get("#{INDEX_PATH}/#{label_name}").body
-        !label_indexes.select { |i| i[:label] == label_name.to_s && i[:property_keys].first == property.to_s }.empty?
-      end
-
-      def drop_all_indexes(session = Neo4j::Session.current)
-        indexes.each do |i|
-          begin
-            session._query_or_fail("DROP INDEX ON :`#{i[:label]}`(#{i[:property_keys].first})")
-          rescue Neo4j::Server::CypherResponse::ResponseError
-            # This will error on each constraint. Ignore and continue.
-            next
-          end
-        end
-      end
-
-      def drop_all_constraints(session = Neo4j::Session.current)
-        constraints.each do |c|
-          session._query_or_fail("DROP CONSTRAINT ON (n:`#{c[:label]}`) ASSERT n.`#{c[:property_keys].first}` IS UNIQUE")
-        end
-      end
-    end
-  end
-end

data/lib/neo4j-server/resource.rb

@@ -1,57 +0,0 @@
-module Neo4j
-  module Server
-    module Resource
-      class ServerException < Exception
-      end
-
-      attr_reader :resource_data, :resource_url
-
-      def init_resource_data(resource_data, resource_url)
-        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_data = resource_data
-        @resource_url = resource_url
-
-        self
-      end
-
-      def wrap_resource(connection)
-        CypherTransaction.new(resource_url(:transaction), connection)
-      end
-
-      def resource_url(key = nil)
-        return @resource_url if key.nil?
-        resource_data.fetch key
-      rescue KeyError
-        raise "No resource key '#{key}', available #{@resource_data.keys.inspect}"
-      end
-
-      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
-
-      def handle_response_error!(response, msg = 'Error for request')
-        fail ServerException, "#{msg} #{response.env && response.env[:url].to_s}, #{response.status}"
-      end
-
-      def response_exception(response)
-        return nil if response.body.nil? || response.body.empty?
-        JSON.parse(response.body)[:exception]
-      end
-
-      def resource_headers
-        {'Content-Type' => 'application/json', 'Accept' => 'application/json; charset=UTF-8', 'User-Agent' => ::Neo4j::Session.user_agent_string}
-      end
-
-      def resource_url_id(url = resource_url)
-        url.match(%r{/(\d+)$})[1].to_i
-      end
-
-      def convert_from_json_value(value)
-        JSON.parse(value, quirks_mode: true)
-      end
-    end
-  end
-end

data/lib/neo4j/entity_equality.rb

@@ -1,8 +0,0 @@
-module Neo4j
-  module EntityEquality
-    def ==(other)
-      other.class == self.class && other.neo_id == neo_id
-    end
-    alias eql? ==
-  end
-end

data/lib/neo4j/entity_marshal.rb

@@ -1,20 +0,0 @@
-module Neo4j
-  # To support Ruby marshaling
-  module EntityMarshal
-    def marshal_dump
-      marshal_instance_variables.map(&method(:instance_variable_get))
-    end
-
-    def marshal_load(array)
-      marshal_instance_variables.zip(array).each do |var, value|
-        instance_variable_set(var, value)
-      end
-    end
-
-    private
-
-    def marshal_instance_variables
-      self.class::MARSHAL_INSTANCE_VARIABLES
-    end
-  end
-end

data/lib/neo4j/label.rb

@@ -1,90 +0,0 @@
-module Neo4j
-  # A label is a named graph construct that is used to group nodes.
-  # See Neo4j::Node how to create and delete nodes
-  # @see http://docs.neo4j.org/chunked/milestone/graphdb-neo4j-labels.html
-  class Label
-    class InvalidQueryError < StandardError; end
-
-    # @abstract
-    def name
-      fail 'not implemented'
-    end
-
-    # @abstract
-    def create_index(*properties)
-      fail 'not implemented'
-    end
-
-    # @abstract
-    def drop_index(*properties)
-      fail 'not implemented'
-    end
-
-    # List indices for a label
-    # @abstract
-    def indexes
-      fail 'not implemented'
-    end
-
-    # Creates a neo4j constraint on a property
-    # See http://docs.neo4j.org/chunked/stable/query-constraints.html
-    # @example
-    #   label = Neo4j::Label.create(:person, session)
-    #   label.create_constraint(:name, {type: :unique}, session)
-    #
-    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
-                 fail "Not supported constrain #{constraints.inspect} for property #{property} (expected :type => :unique)"
-               end
-      session._query_or_fail(cypher)
-    end
-
-    # Drops a neo4j constraint on a property
-    # See http://docs.neo4j.org/chunked/stable/query-constraints.html
-    # @example
-    #   label = Neo4j::Label.create(:person, session)
-    #   label.create_constraint(:name, {type: :unique}, session)
-    #   label.drop_constraint(:name, {type: :unique}, session)
-    #
-    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
-                 fail "Not supported constrain #{constraint.inspect}"
-               end
-      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/'
-
-      # Returns a label of given name that can be used to specifying constraints
-      # @param [Symbol,String] name the name of the label
-      def create(name, session = Neo4j::Session.current)
-        session.create_label(name)
-      end
-
-      # @return [Enumerable<Neo4j::Node>] all nodes having given label. Nodes can be wrapped in your own model ruby classes.
-      def find_all_nodes(label_name, session = Neo4j::Session.current)
-        session.find_all_nodes(label_name)
-      end
-
-      # @return [Enumerable<Neo4j::Node>] all nodes having given label and properties. Nodes can be wrapped in your own model ruby classes.
-      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,216 +0,0 @@
-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
-      def wrapper
-        self
-      end
-
-      def neo4j_obj
-        self
-      end
-    end
-
-    include EntityEquality
-    include Wrapper
-    include PropertyContainer
-    include EntityMarshal
-
-    # @return [Hash<Symbol, Object>] all properties of the node
-    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)
-      fail 'not implemented'
-    end
-
-    # Refresh the properties by reading it from the database again next time an property value is requested.
-    def refresh
-      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)
-      fail 'not implemented'
-    end
-
-    # Directly remove the property on the node (low level method, may need transaction)
-    def remove_property(key)
-      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)
-      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)
-      fail 'not implemented'
-    end
-
-    # Creates a relationship of given type to other_node with optionally properties
-    # @param [Symbol] type the type of the relation between the two nodes
-    # @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)
-      fail 'not implemented'
-    end
-
-
-    # Returns an enumeration of relationships.
-    # It always returns relationships of depth one.
-    #
-    # @param [Hash] match the options to create a message with.
-    # @option match [Symbol] :dir dir the direction of the relationship, allowed values: :both, :incoming, :outgoing.
-    # @option match [Symbol] :type the type of relationship to navigate
-    # @option match [Symbol] :between return all the relationships between this and given node
-    # @return [Enumerable<Neo4j::Relationship>] of Neo4j::Relationship objects
-    #
-    # @example Return both incoming and outgoing relationships of any type
-    #   node_a.rels
-    #
-    # @example All outgoing or incoming relationship of type friends
-    #   node_a.rels(type: :friends)
-    #
-    # @example All outgoing relationships between me and another node of type friends
-    #   node_a.rels(type: :friends, dir: :outgoing, between: node_b)
-    #
-    def rels(match = {dir: :both})
-      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)
-      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)
-      fail 'not implemented'
-    end
-
-    # Removes given labels
-    def remove_label(*labels)
-      fail 'not implemented'
-    end
-
-    #
-    # @return [Array<Symbol>]all labels on the node
-    def labels
-      fail 'not implemented'
-    end
-
-    # Deletes this node from the database
-    def del
-      fail 'not implemented'
-    end
-
-    # @return [Boolean] true if the node exists in the database
-    def exist?
-      fail 'not implemented'
-    end
-
-    # Returns the only node of a given type and direction that is attached to this node, or nil.
-    # This is a convenience method that is used in the commonly occuring situation where a node has exactly zero or one relationships of a given type and direction to another node.
-    # Typically this invariant is maintained by the rest of the code: if at any time more than one such relationships exist, it is a fatal error that should generate an exception.
-    #
-    # This method reflects that semantics and returns either:
-    # * nil if there are zero relationships of the given type and direction,
-    # * the relationship if there's exactly one, or
-    # * throws an exception in all other cases.
-    #
-    # This method should be used only in situations with an invariant as described above. In those situations, a "state-checking" method (e.g. #rel?) is not required,
-    # because this method behaves correctly "out of the box."
-    #
-    # @param (see #rel)
-    def node(specs = {})
-      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 = {})
-      fail 'not implemented'
-    end
-
-    def _rel(spec = {})
-      fail 'not implemented'
-    end
-
-    # Returns true or false if there is one or more relationships
-    # @return [Boolean]
-    def rel?(spec = {})
-      fail 'not implemented'
-    end
-
-    # Works like #rels method but instead returns the nodes.
-    # It does try to load a Ruby wrapper around each node
-    # @abstract
-    # @param (see #rels)
-    # @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)}
-    end
-
-    class << self
-      # Creates a node
-      def create(props = nil, *labels_or_db)
-        session = if labels_or_db.last.is_a?(Neo4j::Session)
-                    labels_or_db.pop
-                  else
-                    Neo4j::Session.current!
-                  end
-
-        session.create_node(props, labels_or_db)
-      end
-
-      # Loads a node from the database with given id
-      def load(neo_id, session = Neo4j::Session.current!)
-        node = _load(neo_id, session)
-        node && node.wrapper
-      end
-
-      # Same as #load but does not try to return a wrapped node
-      # @return [Neo4j::Node] an unwrapped node
-      def _load(neo_id, session = Neo4j::Session.current!)
-        session.load_node(neo_id)
-      end
-
-      # Find the node with given label and value
-      def find_nodes(label, value = nil, session = Neo4j::Session.current!)
-        session.find_nodes(label, value)
-      end
-
-      def validate_match!(match)
-        invalid_match_keys = match.keys - %i[type dir between]
-        fail "Invalid match keys: #{invalid_match_keys.inspect}" if !invalid_match_keys.empty?
-
-        fail "Invalid dir: #{match[:dir]}" if ![nil, :incoming, :outgoing, :both].include?(match[:dir])
-      end
-    end
-
-    def initialize
-      fail "Can't instantiate abstract class" if abstract_class?
-    end
-
-    private
-
-    def abstract_class?
-      self.class == Node
-    end
-  end
-end