neo4j-core 2.0.0.alpha.1-java → 2.0.0-java

data/lib/neo4j-core/property/property.rb

@@ -5,9 +5,7 @@ module Neo4j
       # @return [Hash] all properties plus the id of the node with the key <tt>_neo_id</tt>
       def props
         ret = {"_neo_id" => neo_id}
-        iter = get_property_keys.iterator
-        while (iter.hasNext) do
-          key = iter.next
+        property_keys.each do |key|
           ret[key] = get_property(key)
         end
         ret

data/lib/neo4j-core/relationship/relationship.rb

@@ -3,16 +3,19 @@ module Neo4j
     module Relationship
 
       # Same as Java::OrgNeo4jGraphdb::Relationship#getEndNode
+      # @see http://api.neo4j.org/1.6.1/org/neo4j/graphdb/Relationship.html#getEndNode()
       def _end_node
         get_end_node
       end
 
       # Same as Java::OrgNeo4jGraphdb::Relationship#getStartNode
+      # @see http://api.neo4j.org/1.6.1/org/neo4j/graphdb/Relationship.html#getStartNode()
       def _start_node
         get_start_node
       end
 
       # Same as Java::OrgNeo4jGraphdb::Relationship#getOtherNode
+      # @see http://api.neo4j.org/1.6.1/org/neo4j/graphdb/Relationship.html#getOtherNode()
       def _other_node(node)
         get_other_node(node)
       end
@@ -49,6 +52,7 @@ module Neo4j
       #
       # @param [Neo4j::Node] node the node that we don't want to return
       # @return [Neo4j::Node] the other node wrapper
+      # @see #_other_node
       def other_node(node)
         _other_node(node._java_node).wrapper
       end
@@ -56,7 +60,7 @@ module Neo4j
 
       # same as #_java_rel
       # Used so that we have same method for both relationship and nodes
-      def wrapped_entity
+      def _java_entity
         self
       end
 
@@ -70,21 +74,15 @@ module Neo4j
         Neo4j::Relationship.exist?(self)
       end
 
-      # Loads the wrapper using the #wrapper class method if it exists, otherwise return self.
-      def wrapper
-        self.class.respond_to?(:wrapper) ? self.class.wrapper(node) : self
-      end
-
-
       # Returns the relationship name
       #
       # @example
       #   a = Neo4j::Node.new
       #   a.outgoing(:friends) << Neo4j::Node.new
-      #   a.rels.first.rel_type # => 'friends'
-      # @return [String] the type of the relationship
+      #   a.rels.first.rel_type # => :friends
+      # @return [Symbol] the type of the relationship
       def rel_type
-        getType().name()
+        getType().name().to_sym
       end
 
       def class

data/lib/neo4j-core/rels/rels.rb

@@ -2,6 +2,8 @@ module Neo4j
   module Core
     # Contains methods for traversing relationship object of depth one from one node.
     module Rels
+
+
       # 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.
@@ -76,7 +78,9 @@ module Neo4j
       #
       # @see Neo4j::Core::Node#wrapper #wrapper - The method used wrap to the node in a Ruby object if the node was found
       # @see Neo4j::Relationship#rel_type
-      def rels(dir, *types)
+      # @raise an exception if the first parameter is not <tt>:both</tt>, <tt>;outgoing</tt> or <tt>:incoming</tt>
+      def rels(dir=:both, *types)
+        raise "Illegal argument, first argument must be :both, :incoming or :outgoing, got #{dir.inspect}" unless [:incoming, :outgoing, :both].include?(dir)
         Neo4j::Core::Rels::Traverser.new(self, types, dir)
       end
 
@@ -114,14 +118,15 @@ module Neo4j
       # @return [Enumerable] of Neo4j::Relationship objects
       def _rels(dir=:both, *types)
         if types.size > 1
-          get_relationships(ToJava.dir_to_java(dir), ToJava.types_to_java(types))
+          get_relationships(ToJava.dir_to_java(dir), ToJava.types_to_java(types)).iterator
         elsif types.size == 1
-          get_relationships(ToJava.type_to_java(types[0]), ToJava.dir_to_java(dir))
+          get_relationships(ToJava.type_to_java(types[0]), ToJava.dir_to_java(dir)).iterator
         else
-          get_relationships(ToJava.dir_to_java(dir))
+          get_relationships(ToJava.dir_to_java(dir)).iterator
         end
       end
 
+
       # Check if the given relationship exists
       # Returns true if there are one or more relationships from this node to other nodes
       # with the given relationship.

data/lib/neo4j-core/rels/traverser.rb

@@ -26,10 +26,8 @@ module Neo4j
 
         # Implements the Ruby Enumerable mixin
         def each
-          iter = iterator
-          while (iter.has_next())
-            rel = iter.next
-            yield rel.wrapper if match_to_other?(rel)
+          iterator.each do |rel|
+            yield rel.wrapper if match_between?(rel)
           end
         end
 
@@ -43,42 +41,30 @@ module Neo4j
           @node._rels(@dir, *@types)
         end
 
-        # @return [Fixnum] the size of all matched relationship, also check if it #to_other node
-        # @see #to_other
-        def size
-          c = 0
-          iter = iterator
-          while (iter.has_next())
-            rel = iter.next
-            next unless match_to_other?(rel)
-            c += 1
-          end
-          c
-        end
-
-
         # @return [true,false] true if it match the specified other node
-        # @see #to_other
-        def match_to_other?(rel)
-          if @to_other.nil?
+        # @see #between
+        def match_between?(rel)
+          if @between.nil?
             true
           elsif @dir == :outgoing
-            rel._end_node == @to_other
+            rel._end_node == @between
           elsif @dir == :incoming
-            rel._start_node == @to_other
+            rel._start_node == @between
           else
-            rel._start_node == @to_other || rel._end_node == @to_other
+            rel._start_node == @between || rel._end_node == @between
           end
         end
 
         # Specifies that we only want relationship to the given node
-        # @param [Neo4j::Node] to_other a node or an object that implements the Neo4j::Core::Equal mixin
+        # @param [Neo4j::Node] between a node or an object that implements the Neo4j::Core::Equal mixin
         # @return self
-        def to_other(to_other)
-          @to_other = to_other
+        def between(between)
+          @between = between
           self
         end
 
+        alias_method :to_other, :between
+        
         # Deletes all the relationships
         def del
           each { |rel| rel.del }

data/lib/neo4j-core/traversal/prune_evaluator.rb

@@ -1,9 +1,9 @@
 module Neo4j
   module Core
 
-    # Implements the Neo4j PruneEvaluator Java interface, only used internally.
-    # @private
     module Traversal
+      # Implements the Neo4j PruneEvaluator Java interface, only used internally.
+      # @private
       class PruneEvaluator
         include Java::OrgNeo4jGraphdbTraversal::PruneEvaluator
 

data/lib/neo4j-core/traversal/traverser.rb

@@ -2,6 +2,54 @@ module Neo4j
   module Core
     module Traversal
 
+      class CypherQuery
+        include Enumerable
+        attr_accessor :query, :return_variable
+
+        def initialize(start_id, dir, types, query_hash=nil, &block)
+          this = self
+
+          rel_type = ":#{types.map{|x| "`#{x}`"}.join('|')}"
+
+          @query = Neo4j::Cypher.new do
+            default_ret = node(:default_ret)
+            n = node(start_id)
+            case dir
+              when :outgoing then
+                n > rel_type > default_ret
+              when :incoming then
+                n < rel_type < default_ret
+              when :both then
+                n - rel_type - default_ret
+            end
+
+            # where statement
+            ret_maybe = block && self.instance_exec(default_ret, &block)
+            ret = ret_maybe.respond_to?(:var_name) ? ret_maybe : default_ret
+            if query_hash
+              expr = []
+              query_hash.each{|pair|  expr << (ret[pair[0]] == pair[1])}.to_a
+              expr.each_with_index do |obj, i|
+                Neo4j::Core::Cypher::ExprOp.new(obj, expr[i+1], "and") if i < expr.size - 1
+              end
+            end
+
+            this.return_variable = ret.var_name.to_sym
+            ret
+          end.to_s
+        end
+
+        def to_s
+          @query
+        end
+
+        def each
+          Neo4j._query(query).each do |r|
+            yield r[return_variable]
+          end
+        end
+      end
+
       # By using this class you can both specify traversals and create new relationships.
       # This object is return from the Neo4j::Core::Traversal methods.
       # @see Neo4j::Core::Traversal#outgoing
@@ -17,14 +65,27 @@ module Neo4j
           if type.nil?
             raise "Traversing all relationship in direction #{dir.inspect} not supported, only :both supported" unless dir == :both
             @td = Java::OrgNeo4jKernelImplTraversal::TraversalDescriptionImpl.new.breadth_first()
+          elsif (dir == :both)
+            both(type)
+          elsif (dir == :incoming)
+            incoming(type)
+          elsif (dir == :outgoing)
+            outgoing(type)
           else
-            @type = type_to_java(type)
-            @dir = dir_to_java(dir)
-            @td = Java::OrgNeo4jKernelImplTraversal::TraversalDescriptionImpl.new.breadth_first().relationships(@type, @dir)
+            raise "Illegal direction #{dir.inspect}, expected :outgoing, :incoming or :both"
           end
         end
 
 
+        def query(query_hash = nil, &block)
+          # only one direction is supported
+          rel_types = [@outgoing_rel_types, @incoming_rel_types, @both_rel_types].find_all { |x| !x.nil? }
+          raise "Only one direction is allowed, outgoing:#{@outgoing_rel_types}, incoming:#{@incoming_rel_types}, @both:#{@both_rel_types}" if rel_types.count != 1
+          start_id = @from.neo_id
+          dir = (@outgoing_rel_types && :outgoing) || (@incoming_rel_types && :incoming) || (@both_rel_types && :both)
+          CypherQuery.new(start_id, dir, rel_types.first, query_hash, &block)
+        end
+
         # Sets traversing depth first.
         #
         # The <tt>pre_or_post</tt> parameter parameter can have two values: :pre or :post
@@ -112,11 +173,19 @@ module Neo4j
         end
 
         def to_s
-          "NodeTraverser [from: #{@from.neo_id} depth: #{@depth} type: #{@type} dir:#{@dir}"
+          "NodeTraverser [from: #{@from.neo_id} depth: #{@depth}"
         end
 
 
         # Creates a new relationship between given node and self
+        # It can create more then one relationship
+        #
+        # @example One outgoing relationships
+        #   node.outgoing(:foo) << other_node
+        #
+        # @example Two outgoing relationships
+        #   node.outgoing(:foo).outgoing(:bar) << other_node
+        #
         # @param [Neo4j::Node] other_node the node to which we want to create a relationship
         # @return (see #new)
         def <<(other_node)
@@ -130,25 +199,49 @@ module Neo4j
         end
 
         # Creates a new relationship between self and given node.
+        # It can create more then one relationship
+        # This method is used by the <tt><<</tt> operator.
+        #
+        # @example create one relationship
+        #   node.outgoing(:bar).new(other_node, rel_props)
+        #
+        # @example two relationships
+        #   node.outgoing(:bar).outgoing(:foo).new(other_node, rel_props)
+        #
+        # @example both incoming and outgoing - two relationships
+        #   node.both(:bar).new(other_node, rel_props)
+        #
+        # @see #<<
         # @param [Hash] props properties of new relationship
         # @return [Neo4j::Relationship] the created relationship
         def new(other_node, props = {})
-          case @dir
-            when Java::OrgNeo4jGraphdb::Direction::OUTGOING
-              @from.create_relationship_to(other_node, @type).update(props)
-            when Java::OrgNeo4jGraphdb::Direction::INCOMING
-              other_node.create_relationship_to(@from, @type).update(props)
-            else
-              raise "Only allowed to create outgoing or incoming relationships (not #@dir)"
-          end
+          @outgoing_rel_types && @outgoing_rel_types.each { |type| _new_out(other_node, type, props) }
+          @incoming_rel_types && @incoming_rel_types.each { |type| _new_in(other_node, type, props) }
+          @both_rel_types && @both_rel_types.each { |type| _new_both(other_node, type, props) }
+        end
+
+        # @private
+        def _new_out(other_node, type, props)
+          @from.create_relationship_to(other_node, type_to_java(type)).update(props)
+        end
+
+        # @private
+        def _new_in(other_node, type, props)
+          other_node.create_relationship_to(@from, type_to_java(type)).update(props)
+        end
+
+        # @private
+        def _new_both(other_node, type, props)
+          _new_out(other_node, type, props)
+          _new_in(other_node, type, props)
         end
 
         # @param (see Neo4j::Core::Traversal#both)
         # @see Neo4j::Core::Traversal#both
         def both(type)
-          @type = type_to_java(type) if type
-          @dir = dir_to_java(:both)
-          @td = @td.relationships(type_to_java(type), @dir)
+          @both_rel_types ||= []
+          @both_rel_types << type
+          _add_rel(:both, type)
           self
         end
 
@@ -165,9 +258,9 @@ module Neo4j
         # @return self
         # @see Neo4j::Core::Traversal#outgoing
         def outgoing(type)
-          @type = type_to_java(type) if type
-          @dir = dir_to_java(:outgoing)
-          @td = @td.relationships(type_to_java(type), @dir)
+          @outgoing_rel_types ||= []
+          @outgoing_rel_types << type
+          _add_rel(:outgoing, type)
           self
         end
 
@@ -176,12 +269,19 @@ module Neo4j
         # @return self
         # @see Neo4j::Core::Traversal#incoming
         def incoming(type)
-          @type = type_to_java(type) if type
-          @dir = dir_to_java(:incoming)
-          @td = @td.relationships(type_to_java(type), @dir)
+          @incoming_rel_types ||= []
+          @incoming_rel_types << type
+          _add_rel(:incoming, type)
           self
         end
 
+        # @private
+        def _add_rel(dir, type)
+          t = type_to_java(type)
+          d = dir_to_java(dir)
+          @td = @td ? @td.relationships(t, d) : Java::OrgNeo4jKernelImplTraversal::TraversalDescriptionImpl.new.breadth_first().relationships(t, d)
+        end
+
         # Cuts of of parts of the traversal.
         # @yield [path]
         # @yieldparam [Java::OrgNeo4jGraphdb::Path] path the path which can be used to filter nodes
@@ -228,12 +328,6 @@ module Neo4j
           self
         end
 
-        #def size
-        #  s = 0
-        #  iterator.each { |_| s += 1 }
-        #  s
-        #end
-
         # @param [Fixnum] index the n'th node that will be return from the traversal
         def [](index)
           each_with_index { |node, i| break node if index == i }
@@ -295,6 +389,7 @@ module Neo4j
           end
 
         end
+
       end
     end
   end

data/lib/neo4j-core/version.rb

@@ -1,5 +1,5 @@
 module Neo4j
   module Core
-    VERSION = "2.0.0.alpha.1"
+    VERSION = "2.0.0"
   end
 end

data/lib/neo4j-core/wrapper/class_methods.rb

@@ -0,0 +1,22 @@
+module Neo4j
+  module Core
+    module Wrapper
+      module ClassMethods
+
+        # Tries to load a wrapper for this node if possible
+        # @see #wrapper_proc=
+        def wrapper(entity)
+          @_wrapper_proc ? @_wrapper_proc.call(entity) : entity
+        end
+
+        # Sets the procs to be used to load wrappers
+        # @see #wrapper
+        def wrapper_proc=(proc)
+          @_wrapper_proc = proc
+        end
+
+
+      end
+    end
+  end
+end

data/lib/neo4j-core/wrapper/wrapper.rb

@@ -0,0 +1,20 @@
+module Neo4j
+  module Core
+    # Can be used to define your own wrapper class around nodes and relationships
+    module Wrapper
+
+      # @return [self, Object] return self or a wrapper Ruby object
+      # @see  Neo4j::Node::ClassMethods#wrapper
+      def wrapper
+        self.class.wrapper(self)
+      end
+
+      # This can be implemented by a wrapper to returned the underlying java node or relationship.
+      # You can override this method in your own wrapper class.
+      # @return self
+      def _java_entity
+        self
+      end
+    end
+  end
+end