neo4j-core 3.0.0.alpha.1

data/lib/neo4j-server/cypher_session.rb

@@ -0,0 +1,156 @@
+module Neo4j::Server
+
+  # Plugin
+  Neo4j::Session.register_db(:server_db) do |endpoint_url|
+    response = HTTParty.get(endpoint_url)
+    raise "Server not available on #{endpoint_url} (response code #{response.code})" unless response.code == 200
+    root_data = JSON.parse(response.body)
+    Neo4j::Server::CypherSession.new(root_data['data'])
+  end
+
+  class CypherSession < Neo4j::Session
+    include Resource
+    include Neo4j::Core::CypherTranslator
+
+    alias_method :super_query, :query
+
+    def initialize(data_url)
+      Neo4j::Session.register(self)
+      initialize_resource(data_url)
+    end
+
+    def to_s
+      "CypherSession #{@resource_url}"
+    end
+
+    def initialize_resource(data_url)
+      response = HTTParty.get(data_url)
+      expect_response_code(response,200)
+      data_resource = JSON.parse(response.body)
+      raise "!!!!NO data_resource for #{response.body}" unless data_resource
+      # store the resource data
+      init_resource_data(data_resource, data_url)
+    end
+
+    def close
+      super
+      Neo4j::Transaction.unregister_current
+    end
+
+    def begin_tx
+      tx = wrap_resource(self, 'transaction', CypherTransaction, nil, :post)
+      Thread.current[:neo4j_curr_tx] = tx
+      tx
+    end
+
+    def create_node(props=nil, labels=[])
+      l = labels.empty? ? "" : ":" + labels.map{|k| "`#{k}`"}.join(':')
+      q = "CREATE (n#{l} #{cypher_prop_list(props)}) RETURN ID(n)"
+      cypher_response = _query_or_fail(q, true)
+      CypherNode.new(self, cypher_response)
+    end
+
+    def load_node(neo_id)
+      cypher_response = _query("START n=node(#{neo_id}) RETURN n")
+      if (!cypher_response.error?)
+        CypherNode.new(self, neo_id)
+      elsif (cypher_response.error_status == 'EntityNotFoundException')
+        return nil
+      else
+        cypher_response.raise_error
+      end
+    end
+
+    def load_relationship(neo_id)
+      cypher_response = _query("START r=relationship(#{neo_id}) RETURN r")
+      if (!cypher_response.error?)
+        CypherRelationship.new(self, neo_id)
+      elsif (cypher_response.error_msg =~ /not found/)  # Ugly that the Neo4j API gives us this error message
+        return nil
+      else
+        cypher_response.raise_error
+      end
+    end
+
+    def create_label(name)
+      CypherLabel.new(self, name)
+    end
+
+    def indexes(label)
+      response = HTTParty.get("#{@resource_url}schema/index/#{label}")
+      expect_response_code(response, 200)
+      data_resource = JSON.parse(response.body)
+
+      property_keys = data_resource.map do |row|
+        row['property-keys'].map(&:to_sym)
+      end
+
+      {
+          property_keys: property_keys
+      }
+    end
+
+    def find_all_nodes(label_name)
+      response = _query_or_fail("MATCH (n:`#{label_name}`) RETURN ID(n)")
+      search_result_to_enumerable(response)
+    end
+
+    def find_nodes(label_name, key, value)
+      response = _query_or_fail <<-CYPHER
+        MATCH (n:`#{label_name}`)
+        WHERE n.#{key} = '#{value}'
+        RETURN ID(n)
+      CYPHER
+      search_result_to_enumerable(response)
+    end
+
+    def query(*params, &query_dsl)
+      result = super
+      if result.error?
+        raise Neo4j::Session::CypherError.new(result.error_msg, result.error_code, result.error_status)
+      end
+      result.to_hash_enumeration
+    end
+
+    # TODO remove this function and do not use cypher DSL internally
+    def _query_internal(*params, &query_dsl)
+      super_query(*params, &query_dsl)
+    end
+
+    def _query_or_fail(q, single_row = false, params=nil)
+      response = _query(q, params)
+      response.raise_error if response.error?
+      single_row ? response.first_data : response
+    end
+
+    def query_default_return
+      " RETURN ID(n)"
+    end
+
+    def _query(q, params=nil)
+      curr_tx = Neo4j::Transaction.current
+      if (curr_tx)
+        curr_tx._query(q, params)
+      else
+        url = resource_url('cypher')
+        q = params.nil? ? {query: q} : {query: q, params: params}
+        response = HTTParty.post(url, headers: resource_headers, body: q.to_json)
+        CypherResponse.create_with_no_tx(response)
+      end
+    end
+
+    def search_result_to_enumerable(response)
+      return [] unless response.data
+
+      Enumerator.new do |yielder|
+        response.data.each do |data|
+          yielder << CypherNode.new(self, data[0]).wrapper
+        end
+      end
+    end
+
+
+
+
+  end
+end

data/lib/neo4j-server/cypher_transaction.rb

@@ -0,0 +1,81 @@
+module Neo4j::Server
+  class CypherTransaction
+    attr_reader :commit_url, :exec_url
+
+    include Resource
+    include Neo4j::Core::CypherTranslator
+
+    class CypherError < StandardError
+      attr_reader :code, :status
+      def initialize(code, status, message)
+        super(message)
+        @code = code
+        @status = status
+      end
+    end
+
+    def initialize(db, response, url)
+      @commit_url = response['commit']
+      @exec_url = response.headers['location']
+      init_resource_data(response, url)
+      expect_response_code(response,201)
+      Neo4j::Transaction.register(self)
+    end
+
+    def _query(cypher_query, params=nil)
+      statement = {statement: cypher_query}
+      body = {statements: [statement]}
+
+      if params
+        # TODO can't get this working for some reason using parameters
+        #props = params.keys.inject({}) do|ack, k|
+        #  ack[k] = {name: params[k]}
+        #  ack
+        #end
+        #statement[:parameters] = props
+
+        # So we have to do this workaround
+        params.each_pair do |k,v|
+          statement[:statement].gsub!("{ #{k} }", escape_value(v))
+        end
+      end
+      response = HTTParty.post(@exec_url, headers: resource_headers, body: body.to_json)
+
+      first_result = response['results'][0]
+      cr = CypherResponse.new(response, true)
+
+      if (response['errors'].empty?)
+        cr.set_data(first_result['data'], first_result['columns'])
+      else
+        first_error = response['errors'].first
+        cr.set_error(first_error['message'], first_error['status'], first_error['code'])
+      end
+      cr
+    end
+
+    def success
+      # this is need in the Java API
+    end
+
+    def failure
+      @failure = true
+    end
+
+    def failure?
+      !!@failure
+    end
+
+    def finish
+      Neo4j::Transaction.unregister(self)
+      if failure?
+        response = HTTParty.delete(@exec_url, headers: resource_headers)
+      else
+        response = HTTParty.post(@commit_url, headers: resource_headers)
+      end
+      expect_response_code(response,200)
+      response
+    end
+
+
+  end
+end

data/lib/neo4j-server/resource.rb

@@ -0,0 +1,73 @@
+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 #{response['exception']}" if resource_data['exception']
+        @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, args=nil, verb=:get, payload=nil)
+        url = resource_url(rel, args)
+        response = HTTParty.send(verb, url, headers: {'Content-Type' => 'application/json'}, body: payload)
+        response.code == 404 ? nil : resource_class.new(db, response, url)
+      end
+
+      def resource_url(rel=nil, args=nil)
+        return @resource_url unless rel
+        url = @resource_data[rel.to_s]
+        raise "No resource rel '#{rel}', available #{@resource_data.keys.inspect}" unless url
+        return url unless args
+        if (args.is_a?(Hash))
+          args.keys.inject(url){|ack, key| ack.sub("{#{key}}",args[key].to_s)}
+        else
+          "#{url}/#{args.to_s}"
+        end
+      end
+
+      def handle_response_error(response, msg="Error for request", url = response.request.path.to_s )
+        raise ServerException.new("#{msg} #{url}, #{response.code}, #{response.body}")
+      end
+
+      def expect_response_code(response, expected_code, msg="Error for request", url=response.request.path.to_s )
+        handle_response_error(response, "Expected response code #{expected_code} #{msg}",url) unless response.code == expected_code
+        response
+      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'}
+      end
+
+      def resource_url_id(url = @resource_url)
+        url.match(/\/(\d+)$/)[1].to_i
+      end
+
+      def convert_from_json_value(value)
+        JSON.parse(value, :quirks_mode => true)
+      end
+
+      def convert_to_json_value(value)
+        case value
+          when String
+            %Q["#{value}"]
+          else
+            value.to_s
+        end
+      end
+    end
+  end
+end

data/lib/neo4j/entity_equality.rb

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

data/lib/neo4j/label.rb

@@ -0,0 +1,88 @@
+module Neo4j
+  class Label
+
+    # @abstract
+    def name
+      raise 'not implemented'
+    end
+
+    # @abstract
+    def create_index(*properties)
+      raise 'not implemented'
+    end
+
+    # @abstract
+    def drop_index(*properties)
+      raise 'not implemented'
+    end
+
+    # List indices for a label
+    # @abstract
+    def indexes
+      raise 'not implemented'
+    end
+
+    class << self
+      include Neo4j::Core::CypherTranslator
+
+      def create(name, session = Neo4j::Session.current)
+        session.create_label(name)
+      end
+
+      def query(label_name, query, session = Neo4j::Session.current)
+        cypher = "MATCH (n:`#{label_name}`)"
+        cypher += condition_to_cypher(query) if query[:conditions] && !query[:conditions].empty?
+        cypher += session.query_default_return
+        cypher += order_to_cypher(query) if query[:order]
+
+        response = session._query_or_fail(cypher)
+        session.search_result_to_enumerable(response) # TODO make it work in Embedded and refactor
+      end
+
+
+      def find_all_nodes(label_name, session = Neo4j::Session.current)
+        session.find_all_nodes(label_name)
+      end
+
+      def find_nodes(label_name, key, value, session = Neo4j::Session.current)
+        session.find_nodes(label_name, key, value)
+      end
+
+      private
+
+      def condition_to_cypher(query)
+        conditions = query[:conditions]
+        " WHERE " + conditions.keys.map do |k|
+          "n.#{k}=#{escape_value(conditions[k])}"
+        end.join(" AND ")
+      end
+
+      def order_to_cypher(query)
+        cypher = " ORDER BY "
+        order = query[:order]
+
+        handleHash = Proc.new do |hash|
+          if (hash.is_a?(Hash))
+            k, v = hash.first
+            raise "only :asc or :desc allowed in order, got #{query.inspect}" unless [:asc, :desc].include?(v)
+            v.to_sym == :asc ? "n.`#{k}`" : "n.`#{k}` DESC"
+          else
+            "n.`#{hash}`" unless hash.is_a?(Hash)
+          end
+        end
+
+        case order
+          when Array
+            cypher += order.map(&handleHash).join(', ')
+          when Hash
+            cypher += handleHash.call(order)
+          else
+            cypher += "n.`#{order}`"
+        end
+
+        cypher
+      end
+    end
+  end
+
+end

data/lib/neo4j/node.rb

@@ -0,0 +1,185 @@
+module Neo4j
+
+  # 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
+  end
+
+  # The base class for both the Embedded and Server Neo4j Node
+  # Notice this class is abstract and can't be instantiated
+  class Node
+    include EntityEquality
+    include Wrapper
+    include PropertyContainer
+
+    # @return [Hash] all properties of the node
+    def props()
+      raise 'not implemented'
+    end
+
+    # replace all properties with new properties
+    # @param hash a hash of properties the node should have
+    def props=(hash)
+      raise 'not implemented'
+    end
+
+    # Directly remove the property on the node (low level method, may need transaction)
+    def remove_property(key)
+      raise 'not implemented'
+    end
+
+    # Directly set the property on the node (low level method, may need transaction)
+    # @param [Hash, String] key
+    # @param value see Neo4j::PropertyValidator::VALID_PROPERTY_VALUE_CLASSES for valid values
+    def set_property(key, value)
+      raise 'not implemented'
+    end
+
+    # Directly get the property on the node (low level method, may need transaction)
+    # @param [Hash, String] key
+    # @return the value of the key
+    def get_property(key, value)
+      raise '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] props optionally properties for the created relationship
+    def create_rel(type, other_node, props = nil)
+      raise 'not implemented'
+    end
+
+
+    # Returns an enumeration of relationships.
+    # It always returns relationships of depth one.
+    #
+    # @param [Hash] opts the options to create a message with.
+    # @option opts [Symbol] :dir dir the direction of the relationship, allowed values: :both, :incoming, :outgoing.
+    # @option opts [Symbol] :type the type of relationship to navigate
+    # @option opts [Symbol] :between return all the relationships between this and given node
+    # @return [Enumerable] 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})
+      raise 'not implemented'
+    end
+
+    # Adds one or more Neo4j labels on the node
+    def add_label(*labels)
+      raise 'not implemented'
+    end
+
+    # @return all labels on the node
+    def labels()
+      raise 'not implemented'
+    end
+
+    # Deletes this node from the database
+    def del()
+      raise 'not implemented'
+    end
+
+    # @return true if the node exists in the database
+    def exist?
+      raise 'not implemented'
+    end
+
+    # @returns all the Neo4j labels for this node
+    def labels
+      raise '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 = {})
+      raise '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'
+    end
+
+    # Returns true or false if there is one or more relationships
+    # Same as `!! #rel()`
+    def rel?(spec = {})
+      raise 'not implemented'
+    end
+
+    # Same as Neo4j::Node#exist?
+    def exist?
+      raise '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] an Enumeration of either Neo4j::Node objects or wrapped Neo4j::Node objects
+    # @notice it's possible that the same node is returned more then 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 = Neo4j::Core::ArgumentHelper.session(labels_or_db)
+        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 = session.load_node(neo_id)
+        node && node.wrapper
+      end
+
+      # Checks if the given entity node or entity id (Neo4j::Node#neo_id) exists in the database.
+      # @return [true, false] if exist
+      def exist?(entity_or_entity_id, session = Neo4j::Session.current)
+        session.node_exist?(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
+    end
+
+    def initialize
+      raise "Can't instantiate abstract class" if abstract_class?
+      puts "Instantiated!"
+    end
+
+    private
+    def abstract_class?
+      self.class == Node
+    end
+
+
+  end
+
+end