neo4j 1.0.0.beta.1

data/lib/neo4j.old/relationships/has_list.rb

@@ -0,0 +1,101 @@
+module Neo4j
+
+  module Relationships
+
+    # Provides appending and traversing nodes that are linked together in a list with
+    # relationships to the next list item.
+    #
+    class HasList 
+      include Enumerable
+      attr_reader :relationship_type
+
+      def initialize(node, dsl, &filter)
+        @node = node
+        @relationship_type = "_list_#{dsl.to_type}_#{node.neo_id}"
+        if (dsl.counter?)
+          @counter_id = "_#{dsl.to_type}_size".to_sym
+        end
+        @cascade_delete = dsl.cascade_delete_prop_name
+      end
+
+      def size
+        @node[@counter_id] || 0
+      end
+
+      # called by the event handler
+      def self.on_node_deleted(node) #:nodoc:
+        # check if node is member of one or more lists
+        node.lists{|list_item| list_item.prev.next = list_item.next if list_item.prev; list_item.size -= 1}
+      end
+
+      # Appends one node to the end of the list
+      #
+      # :api: public
+      def <<(other)
+        # does node have a relationship ?
+        new_rel = []
+        if (@node.rel?(@relationship_type))
+          # get that relationship
+          first = @node.rels.outgoing(@relationship_type).first
+
+          # delete this relationship
+          first.del
+          old_first = first.other_node(@node)
+          new_rel << @node.add_rel(@relationship_type, other)
+          new_rel << other.add_rel(@relationship_type, old_first)
+        else
+          # the first node will be set
+          new_rel << @node.add_rel(@relationship_type, other)
+        end
+
+        if @cascade_delete
+          # the @node.neo_id is only used for cascade_delete_incoming since that node will be deleted when all the list items has been deleted.
+          # if cascade_delete_outgoing all nodes will be deleted when the root node is deleted
+          # if cascade_delete_incoming then the root node will be deleted when all root nodes' outgoing nodes are deleted
+          new_rel.each {|rel| rel[@cascade_delete] = @node.neo_id}
+        end
+        if @counter_id
+          @node[@counter_id] ||= 0
+          @node[@counter_id] += 1
+        end
+
+        self
+      end
+
+      # Returns true if the list is empty                                                                        s
+      #
+      # :api: public
+      def empty?
+        !iterator.hasNext
+      end
+
+      def first
+        return nil unless @node.rel?(@relationship_type, :outgoing)
+        @node.rel(@relationship_type, :outgoing).end_node
+      end
+
+      def each
+        iter = iterator
+        while (iter.hasNext) do
+          n = iter.next
+          yield Neo4j.load_node(n.get_id)
+        end
+      end
+
+      def iterator
+        stop_evaluator = org.neo4j.graphdb.StopEvaluator::END_OF_GRAPH
+        traverser_order = org.neo4j.graphdb.Traverser::Order::BREADTH_FIRST
+        returnable_evaluator = org.neo4j.graphdb.ReturnableEvaluator::ALL_BUT_START_NODE
+        types_and_dirs = []
+        types_and_dirs << org.neo4j.graphdb.DynamicRelationshipType.withName(@relationship_type.to_s)
+        types_and_dirs << org.neo4j.graphdb.Direction::OUTGOING
+        @node._java_node.traverse(traverser_order, stop_evaluator,  returnable_evaluator, types_and_dirs.to_java(:object)).iterator
+      end
+
+    end
+
+
+  end
+
+
+end

data/lib/neo4j.old/relationships/has_n.rb

@@ -0,0 +1,129 @@
+module Neo4j
+  module Relationships
+
+    # Enables creating and traversal of nodes.
+    # Includes the Enumerable Mixin.
+    #
+    class HasN
+      include Enumerable
+
+      def initialize(node, dsl, &filter) # :nodoc:
+        @node = node
+        @traverser = NodeTraverser.new(node._java_node)
+        @outgoing = dsl.outgoing?
+        # returns the other DSL if it exists otherwise use this DSL for specifing incoming relationships
+        if @outgoing
+          @dsl = dsl
+        else
+          # which class specifies the incoming DSL ?
+          clazz = dsl.to_class || node.class
+          @dsl = clazz.decl_relationships[dsl.to_type]
+          raise "Unspecified outgoing relationship '#{dsl.to_type}' for incoming relationship '#{dsl.rel_id}' on class #{clazz}" if @dsl.nil?
+        end
+
+        if  @outgoing
+          @traverser.outgoing(@dsl.namespace_type)
+        else
+          @traverser.incoming(@dsl.namespace_type)
+        end
+
+        @traverser.filter(&filter) unless filter.nil?
+      end
+
+
+      # Returns the relationships instead of the nodes.
+      #
+      # ==== Example
+      # # return the relationship objects between the folder and file nodes:
+      # folder.files.rels.each {|x| ...}
+      #
+      def rels
+        Neo4j::Relationships::RelationshipDSL.new(@node._java_node, (@outgoing)? :outgoing : :incoming, @dsl.namespace_type)
+      end
+
+      # Sets the depth of the traversal.
+      # Default is 1 if not specified.
+      #
+      # ==== Example
+      #  morpheus.friends.depth(:all).each { ... }
+      #  morpheus.friends.depth(3).each { ... }
+      #  
+      # ==== Arguments
+      # d<Fixnum,Symbol>:: the depth or :all if traversing to the end of the network.
+      # ==== Return
+      # self
+      # 
+      # :api: public
+      def depth(d)
+        @traverser.depth(d)
+        self
+      end
+
+      # Required by the Enumerable mixin.
+      def each(&block)
+        @traverser.each(&block)
+      end
+
+
+      # Returns true if there are no node in this type of relationship
+      def empty?
+        @traverser.empty?
+      end
+
+      # Return the first relationship or nil
+      def first
+        @traverser.first
+      end
+
+      # Creates a relationship instance between this and the other node.
+      def new(other)
+        create_rel(@node, other)
+      end
+
+
+      # Creates a relationship between this and the other node.
+      #
+      # ==== Example
+      # 
+      #   n1 = Node.new # Node has declared having a friend type of relationship
+      #   n2 = Node.new
+      #   n3 = Node.new
+      #
+      #   n1 << n2 << n3
+      #
+      # This is the same as:
+      #
+      #   n1.add_rel(:friends, n2)
+      #   n1.add_rel(:friends, n3)
+      #
+      # ==== Returns
+      # self
+      #
+      # :api: public
+      def <<(other)
+        create_rel(@node, other)
+        self
+      end
+
+
+      def create_rel(node, other) # :nodoc:
+        # If the are creating an incoming relationship we need to swap incoming and outgoing nodes
+        if @outgoing
+          from, to = node, other
+        else
+          from, to = other, node
+        end
+
+        rel = from.add_rel(@dsl.namespace_type, to, @dsl.relationship_class)
+
+        # the from.neo_id is only used for cascade_delete_incoming since that node will be deleted when all the list items has been deleted.
+        # if cascade_delete_outgoing all nodes will be deleted when the root node is deleted
+        # if cascade_delete_incoming then the root node will be deleted when all root nodes' outgoing nodes are deleted
+        rel[@dsl.cascade_delete_prop_name] = node.neo_id if @dsl.cascade_delete?
+        rel
+      end
+
+    end
+
+  end
+end

data/lib/neo4j.old/relationships/node_traverser.rb

@@ -0,0 +1,138 @@
+module Neo4j
+  module Relationships
+
+    class IllegalTraversalArguments < StandardError;
+    end
+
+    # Enables traversing nodes
+    # Contains state about one specific traversal to be performed.
+    class NodeTraverser
+      include Enumerable
+
+      attr_accessor :raw
+      attr_reader :_java_node
+
+      def initialize(_java_node, raw = false)
+        @_java_node = _java_node
+        @raw = raw
+        @stop_evaluator = DepthStopEvaluator.new(1)
+        @types_and_dirs = [] # what types of relationships and which directions should be traversed
+        @traverser_order = org.neo4j.graphdb.Traverser::Order::BREADTH_FIRST
+        @returnable_evaluator = org.neo4j.graphdb.ReturnableEvaluator::ALL_BUT_START_NODE
+      end
+
+      # if raw == true then it will return raw Java object instead of wrapped JRuby object which can improve performance.
+      def raw(raw = true)
+        @raw = raw
+        self
+      end
+
+      # Sets the depth of the traversal.
+      # Default is 1 if not specified.
+      #
+      # ==== Example
+      #  morpheus.outgoing(:friends).depth(:all).each { ... }
+      #  morpheus.outgoing(:friends).depth(3).each { ... }
+      #
+      # ==== Arguments
+      # d<Fixnum,Symbol>:: the depth or :all if traversing to the end of the network.
+      # ==== Return
+      # self
+      #
+      # :api: public
+      def depth(d)
+        if d == :all
+          @stop_evaluator = org.neo4j.graphdb.StopEvaluator::END_OF_GRAPH
+        else
+          @stop_evaluator = DepthStopEvaluator.new(d)
+        end
+        self
+      end
+
+      def filter(&proc)
+        @returnable_evaluator = ReturnableEvaluator.new(proc, @raw)
+        self
+      end
+
+      def outgoing(*types)
+        types.each do |type|
+          @types_and_dirs << org.neo4j.graphdb.DynamicRelationshipType.withName(type.to_s)
+          @types_and_dirs << org.neo4j.graphdb.Direction::OUTGOING
+        end
+        self
+      end
+
+      def incoming(*types)
+        types.each do |type|
+          @types_and_dirs << org.neo4j.graphdb.DynamicRelationshipType.withName(type.to_s)
+          @types_and_dirs << org.neo4j.graphdb.Direction::INCOMING
+        end
+        self
+      end
+
+      def both(*types)
+        types.each do |type|
+          @types_and_dirs << org.neo4j.graphdb.DynamicRelationshipType.withName(type.to_s)
+          @types_and_dirs << org.neo4j.graphdb.Direction::BOTH
+        end
+        self
+      end
+
+      def empty?
+        !iterator.hasNext
+      end
+
+      def first
+        find {true}
+      end
+
+      def each
+        iter = iterator
+        if @raw
+          while (iter.hasNext) do
+            yield iter.next
+          end
+        else
+          while (iter.hasNext) do
+            yield iter.next.wrapper
+          end
+        end
+      end
+
+      # Same as #each method but includes the TraversalPosition argument as a yield argument.
+      #
+      #
+      def each_with_position(&block)
+        traverser = create_traverser
+        iter = traverser.iterator
+        while (iter.hasNext) do
+          n = iter.next
+          tp = TraversalPosition.new(traverser.currentPosition(), @raw)
+          block.call Neo4j.load_node(n.get_id), tp
+        end
+      end
+
+
+      def create_traverser
+        # check that we know which type of relationship should be traversed
+        if @types_and_dirs.empty?
+          raise IllegalTraversalArguments.new "Unknown type of relationship. Needs to know which type(s) of relationship in order to traverse. Please use the outgoing, incoming or both method."
+        end
+
+        @_java_node.traverse(@traverser_order, @stop_evaluator,
+                                @returnable_evaluator, @types_and_dirs.to_java(:object))
+      end
+
+      def iterator
+        create_traverser.iterator
+      end
+
+      def to_s
+        "NodeTraverser [direction=#{@direction}, type=#{@type}]"
+      end
+
+    end
+
+
+  end
+end

data/lib/neo4j.old/relationships/relationship_dsl.rb

@@ -0,0 +1,149 @@
+module Neo4j
+  module Relationships
+
+    # Enables finding relationships for one node
+    #
+    class RelationshipDSL
+      include Enumerable
+      attr_reader :node
+
+      def initialize(node, direction = :outgoing, type = nil)
+        @raw  = false
+        @type = type
+        @node = node
+
+        case direction
+          when :outgoing
+            outgoing(type)
+          when :incoming
+            incoming(type)
+          when :both
+            both(type)
+        end
+      end
+
+      # if raw == true then it will return raw Java object instead of wrapped JRuby object which can improve performance.
+      def raw(raw = true)
+        @raw = raw
+        self
+      end
+      
+      def outgoing(type = nil)
+        @type = type
+        @direction = org.neo4j.graphdb.Direction::OUTGOING
+        self
+      end
+
+      def incoming(type = nil)
+        @type = type
+        @direction = org.neo4j.graphdb.Direction::INCOMING
+        self
+      end
+
+      def filter(&filter_proc)
+        @filter_proc = filter_proc
+        self
+      end
+
+      def both(type = nil)
+        @type = type
+        @direction = org.neo4j.graphdb.Direction::BOTH
+        self
+      end
+
+
+      # Creates a not declared relationship between this node and the given other_node with the given relationship type
+      # Use this method if you do not want to declare the relationship with the class methods has_one or has_n.
+      # Can be used at any time on any node.
+      #
+      # Only supports outgoing relationships.
+      #
+      # ==== Example
+      #
+      #  node1 = Neo4j::Node.new
+      #  node2 = Neo4j::Node.new
+      #  node1.rels.outgoing(:some_relationship_type) << node2  << node3
+      #
+      # ==== Returns
+      # self - so that the << can be chained
+      #
+      # :api: public
+      def <<(other_node)
+        source, target = @node, other_node
+        source, target = target, source if @direction == org.neo4j.graphdb.Direction::INCOMING
+        source.add_rel(@type, target)
+        self
+      end
+
+      def empty?
+        !iterator.hasNext
+      end
+
+      # Return the first relationship or nil
+      def first
+        find {true}
+      end
+
+      #
+      # Returns the relationship object to the other node.
+      #
+      def [](other_node)
+        find {|r| r.end_node.neo_id == other_node.neo_id}
+      end
+
+
+      def each
+        iter = iterator
+        while (iter.hasNext) do
+          rel = @raw ? iter.next : iter.next.wrapper
+          next if @filter_proc && !rel.instance_eval(&@filter_proc)
+          yield rel
+        end
+      end
+
+      def nodes
+        RelationshipsEnumeration.new(self, @raw)
+      end
+
+      def iterator
+        # if type is nil then we traverse all relationship types of depth one
+        return @node.getRelationships(@direction).iterator if @type.nil?
+        return @node.getRelationships(org.neo4j.graphdb.DynamicRelationshipType.withName(@type.to_s), @direction).iterator unless @type.nil?
+      end
+
+      def to_s
+        "RelationshipDSL [direction=#{@direction}, type=#{@type}]"
+      end
+
+      # Used from RelationshipDSL when traversing nodes instead of relationships.
+      #
+      class RelationshipsEnumeration #:nodoc:
+        include Enumerable
+
+        def initialize(relationships, raw)
+          @relationships = relationships
+          @raw = raw
+        end
+
+        def first
+          find {true}
+        end
+
+        def empty?
+          first.nil?
+        end
+
+        def each
+          if @raw
+            @relationships.each { |relationship| yield relationship.other_node(@relationships.node) }
+          else
+            @relationships.each { |relationship| yield relationship.other_node(@relationships.node).wrapper }
+          end
+        end
+
+
+      end
+    end
+
+  end
+end