neo4j-core 3.0.0.alpha.1

data/lib/neo4j-embedded/property.rb

@@ -0,0 +1,43 @@
+
+# TODO code duplication with the Neo4j::PropertyContainer,
+# This module should extend that module by adding transaction around methods
+module Neo4j::Embedded::Property
+  include Neo4j::PropertyValidator
+  include Neo4j::PropertyContainer
+  extend Neo4j::Core::TxMethods
+
+  # inherit the []= method but add auto transaction around it
+  tx_methods :[]=
+
+  def [](key)
+    return nil unless has_property?(key.to_s)
+    get_property(key.to_s)
+  end
+  tx_methods :[]
+
+  def props
+    property_keys.inject({}) do |ret, key|
+      ret[key.to_sym] = get_property(key)
+      ret
+    end
+  end
+  tx_methods :props
+
+
+  def props=(hash)
+    property_keys.each do |key|
+      remove_property(key)
+    end
+
+    hash.each_pair do |k,v|
+      set_property(k,v)
+    end
+    hash
+  end
+  tx_methods :props=
+
+
+  def neo_id
+    get_id
+  end
+end

data/lib/neo4j-embedded/to_java.rb

@@ -0,0 +1,49 @@
+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_function :type_to_java
+
+    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
+
+
+    def dir_from_java(dir)
+      case dir
+        when Java::OrgNeo4jGraphdb::Direction::OUTGOING then
+          :outgoing
+        when Java::OrgNeo4jGraphdb::Direction::BOTH then
+          :both
+        when Java::OrgNeo4jGraphdb::Direction::INCOMING then
+          :incoming
+        else
+          raise "unknown direction '#{dir} / #{dir.class}'"
+      end
+    end
+
+    module_function :dir_from_java
+
+    def dir_to_java(dir)
+      case dir
+        when :outgoing then
+          Java::OrgNeo4jGraphdb::Direction::OUTGOING
+        when :both then
+          Java::OrgNeo4jGraphdb::Direction::BOTH
+        when :incoming then
+          Java::OrgNeo4jGraphdb::Direction::INCOMING
+        else
+          raise "unknown direction '#{dir}', expects argument: outgoing, :incoming or :both"
+      end
+    end
+
+    module_function :dir_to_java
+
+  end
+end

data/lib/neo4j-server.rb

@@ -0,0 +1,10 @@
+require 'httparty'
+require 'json'
+require 'neo4j-server/resource'
+require 'neo4j-server/cypher_node'
+require 'neo4j-server/cypher_label'
+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'

data/lib/neo4j-server/cypher_label.rb

@@ -0,0 +1,28 @@
+module Neo4j::Server
+  class CypherLabel
+    extend Forwardable
+    def_delegator :@session, :query_cypher_for
+    attr_reader :name
+
+    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 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
+
+    def indexes
+      @session.indexes(@name)
+    end
+  end
+end

data/lib/neo4j-server/cypher_node.rb

@@ -0,0 +1,140 @@
+module Neo4j::Server
+  class CypherNode < Neo4j::Node
+    include Neo4j::Server::Resource
+    include Neo4j::Core::CypherTranslator
+
+    def initialize(session, id)
+      @session = session
+      @id = id
+    end
+
+    def neo_id
+      @id
+    end
+
+    def inspect
+      "CypherNode #{neo_id} (#{object_id})"
+    end
+
+    # TODO, needed by neo4j-cypher
+    def _java_node
+      self
+    end
+
+    # (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)
+      CypherRelationship.new(@session, id)
+    end
+
+    # (see Neo4j::Node#props)
+    def props
+      props = @session._query_or_fail("START n=node(#{neo_id}) RETURN n", true)['data']
+      props.keys.inject({}){|hash,key| hash[key.to_sym] = props[key]; hash}
+    end
+
+    # (see Neo4j::Node#remove_property)
+    def remove_property(key)
+      @session._query_or_fail("START n=node(#{neo_id}) REMOVE n.`#{key}`")
+    end
+
+    # (see Neo4j::Node#set_property)
+    def set_property(key,value)
+      @session._query_or_fail("START n=node(#{neo_id}) SET n.`#{key}` = { value }", false, value: value)
+      value
+    end
+
+    # (see Neo4j::Node#props=)
+    def props=(properties)
+      @session._query_or_fail("START n=node(#{neo_id}) SET n = { props }", false, {props: properties})
+      properties
+    end
+
+    # (see Neo4j::Node#get_property)
+    def get_property(key)
+      @session._query_or_fail("START n=node(#{neo_id}) RETURN n.`#{key}`", true)
+    end
+
+    # (see Neo4j::Node#labels)
+    def labels
+      r = @session._query_or_fail("START n=node(#{neo_id}) RETURN labels(n) as labels", true)
+      r.map(&:to_sym)
+    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")
+    end
+
+    # (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 == 'EntityNotFoundException')
+        return false
+      else
+        response.raise_error
+      end
+    end
+
+
+    # (see Neo4j::Node#node)
+    def node(match={})
+      result = match(CypherNode, "ID(p)", 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
+    end
+
+    # (see Neo4j::Node#rel)
+    def rel(match={})
+      result = match(CypherRelationship, "ID(r)", 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
+    end
+
+    # (see Neo4j::Node#rel?)
+    def rel?(match={})
+      result = match(CypherRelationship, "ID(r)", match)
+      !!result.first
+    end
+
+    # (see Neo4j::Node#nodes)
+    def nodes(match={})
+      match(CypherNode, "ID(p)", match)
+    end
+
+
+    # (see Neo4j::Node#rels)
+    def rels(match = {dir: :both})
+      match(CypherRelationship, "ID(r)", 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] ? ",p=node(#{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}"
+      r = @session._query(cypher)
+      r.raise_error if r.error?
+      _map_result(r, clazz)
+    end
+
+    # @private
+    def _map_result(r, clazz)
+      r.data.map do |rel|
+        next if r.uncommited? ? rel['row'].first.nil? : rel.first.nil?
+        id = r.uncommited? ? rel['row'].first : rel.first
+        clazz.new(@session, id)
+      end.compact
+    end
+
+  end
+end

data/lib/neo4j-server/cypher_node_uncommited.rb

@@ -0,0 +1,12 @@
+module Neo4j::Server
+  class CypherNodeUncommited
+    def initialize(db, data)
+      @db = db
+      @data = data
+    end
+
+    def [](key)
+      @data[key.to_s]
+    end
+  end
+end

data/lib/neo4j-server/cypher_relationship.rb

@@ -0,0 +1,82 @@
+module Neo4j::Server
+
+  class CypherRelationship < Neo4j::Relationship
+    include Neo4j::Server::Resource
+
+    def initialize(session, id)
+      @session = session
+      @id = id
+    end
+
+    def ==(o)
+      o.class == self.class && o.neo_id == neo_id
+    end
+    alias_method :eql?, :==
+
+    def neo_id
+      @id
+    end
+
+    def inspect
+      "CypherRelationship #{neo_id}"
+    end
+
+    def load_resource
+      id = neo_id
+      unless @resource_data
+        r = @session._query_internal{ rel(id) }
+        @resource_data = r.first_data
+      end
+    end
+
+    def start_node
+      load_resource
+      id = resource_url_id(resource_url(:start))
+      Neo4j::Node.load(id)
+    end
+
+    def end_node
+      load_resource
+      id = resource_url_id(resource_url(:end))
+      Neo4j::Node.load(id)
+    end
+
+    def get_property(key)
+      id = neo_id
+      r = @session._query_internal{rel(id)[key]}
+      expect_response_code(r.response, 200)
+      r.first_data
+    end
+
+    def set_property(key,value)
+      id = neo_id
+      r = @session._query_internal{rel(id)[key]=value}
+      expect_response_code(r.response, 200)
+    end
+
+    def remove_property(key)
+      id = neo_id
+      r = @session._query_internal{rel(id)[key]=:NULL}
+      expect_response_code(r.response, 200)
+    end
+
+    def del
+      id = neo_id
+      @session._query_internal{rel(id).del}.raise_unless_response_code(200)
+    end
+
+    def exist?
+      id = neo_id
+      response = @session._query_internal{rel(id)}
+
+      if (!response.error?)
+        return true
+      elsif (response.error_status == 'BadInputException') # TODO see github issue neo4j/1061
+        return false
+      else
+        response.raise_error
+      end
+    end
+
+  end
+end

data/lib/neo4j-server/cypher_response.rb

@@ -0,0 +1,113 @@
+module Neo4j::Server
+  class CypherResponse
+    attr_reader :data, :columns, :error_msg, :error_status, :error_code, :response
+
+    class ResponseError < StandardError
+      attr_reader :status, :code
+
+      def initialize(msg, status, code)
+        super(msg)
+        @status = status
+        @code = code
+      end
+    end
+
+
+    class HashEnumeration
+      include Enumerable
+      extend Forwardable
+      def_delegator :@response, :error_msg
+      def_delegator :@response, :error_status
+      def_delegator :@response, :error_code
+      def_delegator :@response, :data
+      def_delegator :@response, :columns
+
+      def initialize(response)
+        @response = response
+      end
+
+      def each()
+        data.each do |row|
+          row.each_with_index do |row, i|
+            yield columns[i].to_sym => row[i]
+          end
+        end
+      end
+    end
+
+    def to_hash_enumeration
+      HashEnumeration.new(self)
+    end
+
+    def initialize(response, uncommited = false)
+      @response = response
+      @uncommited = uncommited
+    end
+
+
+    def first_data
+      if uncommited?
+        @data.first['row'].first
+      else
+        @data[0][0]
+      end
+    end
+
+    def error?
+      !!@error
+    end
+
+    def uncommited?
+      @uncommited
+    end
+
+    def raise_unless_response_code(code)
+      raise "Response code #{response.code}, expected #{code} for #{response.request.path}, #{response.body}" unless response.code == code
+    end
+
+    def set_data(data, columns)
+      @data = data
+      @columns = columns
+      self
+    end
+
+    def set_error(error_msg, error_status, error_core)
+      @error = true
+      @error_msg = error_msg
+      @error_status = error_status
+      @error_code = error_core
+      self
+    end
+
+    def raise_error
+      raise "Tried to raise error without an error" unless @error
+      raise ResponseError.new(@error_msg, @error_status, @error_code)
+    end
+
+    def self.create_with_no_tx(response)
+      case response.code
+        when 200
+          CypherResponse.new(response).set_data(response['data'], response['columns'])
+        when 400
+          CypherResponse.new(response).set_error(response['message'], response['exception'], response['fullname'])
+        else
+          raise "Unknown response code #{response.code} for #{response.request.path.to_s}"
+      end
+    end
+
+    def self.create_with_tx(response)
+      raise "Unknown response code #{response.code} for #{response.request.path.to_s}" unless response.code == 200
+
+      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
+  end
+end