neo4j-core 3.0.0.alpha.13 → 3.0.0.alpha.14

data/lib/neo4j-embedded/embedded_node.rb

@@ -8,6 +8,10 @@ module Neo4j::Embedded
       @match = match
     end
 
+    def inspect
+      "Enumerable<Neo4j::Relationship>"
+    end
+
     def each(&block)
       @node._rels(@match).each {|r| block.call(r.wrapper)}
     end
@@ -28,6 +32,10 @@ module Neo4j::Embedded
       @match = match
     end
 
+    def inspect
+      "Enumerable<Neo4j::Node>"
+    end
+
     def each(&block)
       @node._rels(@match).each {|r| block.call(r.other_node(@node))}
     end
@@ -48,6 +56,10 @@ module Neo4j::Embedded
           include Neo4j::EntityEquality
           extend Neo4j::Core::TxMethods
 
+          def inspect
+            "EmbeddedNode neo_id: #{neo_id}"
+          end
+
           def exist?
             !!graph_database.get_node_by_id(neo_id)
           rescue Java::OrgNeo4jGraphdb.NotFoundException

data/lib/neo4j-embedded/embedded_node.rb~

@@ -0,0 +1,201 @@
+module Neo4j::Embedded
+  class RelsIterator
+    include Enumerable
+    extend Neo4j::Core::TxMethods
+
+    def initialize(node, match)
+      @node = node
+      @match = match
+    end
+
+    def inspect
+      "Enumerable<Neo4j::Relationship>"
+    end
+
+    def each(&block)
+      @node._rels(@match).each {|r| block.call(r.wrapper)}
+    end
+    tx_methods :each
+
+    def empty?
+      first == nil
+    end
+
+  end
+
+  class NodesIterator
+    include Enumerable
+    extend Neo4j::Core::TxMethods
+
+    def initialize(node, match)
+      @node = node
+      @match = match
+    end
+
+    def each(&block)
+      @node._rels(@match).each {|r| block.call(r.other_node(@node))}
+    end
+    tx_methods :each
+
+    def empty?
+      first == nil
+    end
+
+  end
+
+  class EmbeddedNode
+    class << self
+      # This method is used to extend a Java Neo4j class so that it includes the same mixins as this class.
+      def extend_java_class(java_clazz)
+        java_clazz.class_eval do
+          include Neo4j::Embedded::Property
+          include Neo4j::EntityEquality
+          extend Neo4j::Core::TxMethods
+
+          def inspect
+            "EmbeddedNode neo_id: #{neo_id}"
+          end
+
+          def exist?
+            !!graph_database.get_node_by_id(neo_id)
+          rescue Java::OrgNeo4jGraphdb.NotFoundException
+            nil
+          end
+          tx_methods :exist?
+
+          def labels
+            _labels.iterator.map{|x| x.name.to_sym}
+          end
+          tx_methods :labels
+
+          alias_method :_labels, :getLabels
+
+          def _java_label(label_name)
+            Java::OrgNeo4jGraphdb.DynamicLabel.label(label_name)
+          end
+
+
+          def _add_label(*label_name)
+            label_name.each do |name|
+              addLabel(_java_label(name))
+            end
+          end
+
+          alias_method :add_label, :_add_label
+          tx_methods :add_label
+
+          def _remove_label(*label_name)
+            label_name.each do |name|
+              removeLabel(_java_label(name))
+            end
+          end
+
+          alias_method :remove_label, :_remove_label
+          tx_methods :remove_label
+
+          def set_label(*label_names)
+            label_as_symbols = label_names.map(&:to_sym)
+            to_keep = labels & label_as_symbols
+            to_remove = labels - to_keep
+            _remove_label(*to_remove)
+            to_add = label_as_symbols - to_keep
+            _add_label(*to_add)
+          end
+          tx_methods :set_label
+
+          def del
+            _rels.each { |r| r.del }
+            delete
+            nil
+          end
+          tx_methods :del
+
+          def create_rel(type, other_node, props = nil)
+            rel = create_relationship_to(other_node.neo4j_obj, ToJava.type_to_java(type))
+            props.each_pair { |k, v| rel[k] = v } if props
+            rel
+          end
+          tx_methods :create_rel
+
+
+          def rels(match={})
+            RelsIterator.new(self, match)
+          end
+
+          def nodes(match={})
+            NodesIterator.new(self, match)
+          end
+
+          def node(match={})
+            rel = _rel(match)
+            rel && rel.other_node(self).wrapper
+          end
+          tx_methods :node
+
+          def rel?(match={})
+            _rels(match).has_next
+          end
+          tx_methods :rel?
+
+          def rel(match={})
+            _rel(match)
+          end
+          tx_methods :rel
+
+          def _rel(match={})
+            dir = match[:dir] || :both
+            rel_type = match[:type]
+
+            rel = if rel_type
+                     get_single_relationship(ToJava.type_to_java(rel_type), ToJava.dir_to_java(dir))
+                  else
+                     iter = get_relationships(ToJava.dir_to_java(dir)).iterator
+                     if (iter.has_next)
+                       first = iter.next
+                       raise "Expected to only find one relationship from node #{neo_id} matching #{match.inspect}" if iter.has_next
+                       first
+                     end
+                   end
+
+            between_id = match[:between] && match[:between].neo_id
+
+            if (rel && between_id)
+              rel.other_node(self).neo_id == between_id ? rel : nil
+            else
+              rel
+            end
+          end
+
+          def _rels(match={})
+            dir = match[:dir] || :both
+            rel_type = match[:type]
+
+            rels = if rel_type
+              get_relationships(ToJava.type_to_java(rel_type), ToJava.dir_to_java(dir)).iterator
+            else
+              get_relationships(ToJava.dir_to_java(dir)).iterator
+            end
+
+            between_id = match[:between] && match[:between].neo_id
+
+            if (between_id)
+              rels.find_all{|r| r.end_node.neo_id == between_id || r.start_node.neo_id == between_id}
+            else
+              rels
+            end
+
+          end
+
+          def class
+            Neo4j::Node
+          end
+
+          include Neo4j::Node::Wrapper
+        end
+      end
+    end
+
+    extend_java_class(Java::OrgNeo4jKernelImplCore::NodeProxy)
+  end
+
+end

data/lib/neo4j-embedded/embedded_relationship.rb

@@ -18,6 +18,10 @@ module Neo4j::Embedded
           end
           tx_methods :exist?
 
+          def inspect
+            "EmbeddedRelationship neo_id: #{neo_id}"
+          end
+
           def start_node
             _start_node.wrapper
           end
@@ -27,6 +31,10 @@ module Neo4j::Embedded
             getStartNode
           end
 
+          def rel_type
+            getType().name().to_sym
+          end
+
           def del
             delete
           end

data/lib/neo4j-embedded/embedded_relationship.rb~

@@ -0,0 +1,62 @@
+module Neo4j::Embedded
+  class EmbeddedRelationship
+    class << self
+      # This method is used to extend a Java Neo4j class so that it includes the same mixins as this class.
+      def extend_java_class(java_clazz)
+        java_clazz.class_eval do
+          include Neo4j::Embedded::Property
+          include Neo4j::EntityEquality
+          include Neo4j::Relationship::Wrapper
+          extend Neo4j::Core::TxMethods
+
+          alias_method :_other_node, :getOtherNode
+
+          def exist?
+            !!graph_database.get_relationship_by_id(neo_id)
+          rescue Java::OrgNeo4jGraphdb.NotFoundException
+            nil
+          end
+          tx_methods :exist?
+
+          def start_node
+            _start_node.wrapper
+          end
+          tx_methods :start_node
+
+          def _start_node
+            getStartNode
+          end
+
+          def rel_type
+            getType().name().to_sym
+          end
+
+          def del
+            delete
+          end
+          tx_methods :del
+
+          def other_node(n)
+            _other_node(n.neo4j_obj).wrapper
+          end
+          tx_methods :other_node
+
+          def end_node
+            _end_node.wrapper
+          end
+          tx_methods :end_node
+
+          def _end_node
+            getEndNode
+          end
+
+        end
+      end
+    end
+
+    extend_java_class(Java::OrgNeo4jKernelImplCore::RelationshipProxy)
+
+  end
+
+
+end

data/lib/neo4j-embedded/embedded_session.rb

@@ -21,6 +21,11 @@ module Neo4j::Embedded
       @db_location = db_location
       @auto_commit = !!config[:auto_commit]
       Neo4j::Session.register(self)
+      @query_builder = Neo4j::Core::QueryBuilder.new
+    end
+
+    def inspect
+      "#{self.class} db_location: '#{@db_location}', running: #{running?}"
     end
 
     def start
@@ -80,15 +85,17 @@ module Neo4j::Embedded
       nil
     end
 
-    def query(*params, &query_dsl)
-      begin
-        result = super
-        raise CypherError.new(result.error_msg, result.error_code, result.error_status) if result.respond_to?(:error?) && result.error?
-        # TODO ugly, the server database must convert the result
-        result.respond_to?(:to_hash_enumeration) ? result.to_hash_enumeration : result.to_a
-      rescue Exception => e
-        raise CypherError.new(e,nil,nil)
+    def query(*params)
+      query_hash = @query_builder.to_query_hash(params, :to_node)
+      cypher = @query_builder.to_cypher(query_hash)
+
+      result = _query(cypher, query_hash[:params])
+      if result.respond_to?(:error?) && result.error?
+        raise Neo4j::Session::CypherError.new(result.error_msg, result.error_code, result.error_status)
       end
+
+      map_return_procs = @query_builder.to_map_return_procs(query_hash)
+      ResultWrapper.new(result, map_return_procs, cypher)
     end
 
     def find_all_nodes(label)
@@ -105,12 +112,13 @@ module Neo4j::Embedded
     # @return (see #query)
     def _query(q, params={})
       engine = Java::OrgNeo4jCypherJavacompat::ExecutionEngine.new(@graph_db)
-      result = engine.execute(q, Neo4j::Core::HashWithIndifferentAccess.new(params))
-      Neo4j::Cypher::ResultWrapper.new(result)
+      engine.execute(q, Neo4j::Core::HashWithIndifferentAccess.new(params))
+    rescue Exception => e
+        raise Neo4j::Session::CypherError.new(e.message, e.class, 'cypher error')
     end
 
-    def query_default_return
-      " RETURN n"
+    def query_default_return(as)
+      " RETURN #{as}"
     end
 
     def _query_or_fail(q)

data/lib/neo4j-embedded/embedded_session.rb~

@@ -0,0 +1,145 @@
+# Plugin
+
+Neo4j::Session.register_db(:embedded_db) do |*args|
+  Neo4j::Embedded::EmbeddedSession.new(*args)
+end
+
+
+module Neo4j::Embedded
+  class EmbeddedSession < Neo4j::Session
+
+    class Error < StandardError
+    end
+
+    attr_reader :graph_db, :db_location
+    extend Forwardable
+    extend Neo4j::Core::TxMethods
+    def_delegator :@graph_db, :begin_tx
+
+
+    def initialize(db_location, config={})
+      @db_location = db_location
+      @auto_commit = !!config[:auto_commit]
+      Neo4j::Session.register(self)
+      @query_builder = Neo4j::Core::QueryBuilder.new
+    end
+
+    def start
+      raise Error.new("Embedded Neo4j db is already running") if running?
+      puts "Start embedded Neo4j db at #{db_location}"
+      factory = Java::OrgNeo4jGraphdbFactory::GraphDatabaseFactory.new
+      @graph_db = factory.newEmbeddedDatabase(db_location)
+      Neo4j::Session._notify_listeners(:session_available, self)
+    end
+
+    def factory_class
+      Java::OrgNeo4jGraphdbFactory::GraphDatabaseFactory
+      Java::OrgNeo4jTest::ImpermanentGraphDatabase
+    end
+
+    def close
+      super
+      shutdown
+    end
+
+    def shutdown
+      graph_db && graph_db.shutdown
+      @graph_db = nil
+    end
+
+    def running?
+      !!graph_db
+    end
+
+    def create_label(name)
+      EmbeddedLabel.new(self, name)
+    end
+
+    def load_node(neo_id)
+      _load_node(neo_id)
+    end
+    tx_methods :load_node
+
+    # Same as load but does not return the node as a wrapped Ruby object.
+    #
+    def _load_node(neo_id)
+      return nil if neo_id.nil?
+      @graph_db.get_node_by_id(neo_id.to_i)
+    rescue Java::OrgNeo4jGraphdb.NotFoundException
+      nil
+    end
+
+    def load_relationship(neo_id)
+      _load_relationship(neo_id)
+    end
+    tx_methods :load_relationship
+
+    def _load_relationship(neo_id)
+      return nil if neo_id.nil?
+      @graph_db.get_relationship_by_id(neo_id.to_i)
+    rescue Java::OrgNeo4jGraphdb.NotFoundException
+      nil
+    end
+
+    def query(*params)
+      query_hash = @query_builder.to_query_hash(params, :to_node)
+      cypher = @query_builder.to_cypher(query_hash)
+
+      result = _query(cypher, query_hash[:params])
+      if result.respond_to?(:error?) && result.error?
+        raise Neo4j::Session::CypherError.new(result.error_msg, result.error_code, result.error_status)
+      end
+
+      map_return_procs = @query_builder.to_map_return_procs(query_hash)
+      ResultWrapper.new(result, map_return_procs, cypher)
+    end
+
+    def find_all_nodes(label)
+      EmbeddedLabel.new(self, label).find_nodes
+    end
+
+    def find_nodes(label, key, value)
+      EmbeddedLabel.new(self, label).find_nodes(key,value)
+    end
+
+    # Performs a cypher query with given string.
+    # Remember that you should close the resource iterator.
+    # @param [String] q the cypher query as a String
+    # @return (see #query)
+    def _query(q, params={})
+      engine = Java::OrgNeo4jCypherJavacompat::ExecutionEngine.new(@graph_db)
+      engine.execute(q, Neo4j::Core::HashWithIndifferentAccess.new(params))
+    rescue Exception => e
+        raise Neo4j::Session::CypherError.new(e.message, e.class, 'cypher error')
+    end
+
+    def query_default_return(as)
+      " RETURN #{as}"
+    end
+
+    def _query_or_fail(q)
+      engine = Java::OrgNeo4jCypherJavacompat::ExecutionEngine.new(@graph_db)
+      engine.execute(q)
+    end
+
+    def search_result_to_enumerable(result)
+      result.map {|column| column['n'].wrapper}
+    end
+
+    def create_node(properties = nil, labels=[])
+      if labels.empty?
+        _java_node = graph_db.create_node
+      else
+        labels = EmbeddedLabel.as_java(labels)
+        _java_node = graph_db.create_node(labels)
+      end
+      properties.each_pair { |k, v| _java_node[k]=v } if properties
+      _java_node
+    end
+    tx_methods :create_node
+
+  end
+
+
+
+end