neo4j 1.0.0.beta.9 → 1.0.0.beta.10

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

@@ -1,129 +0,0 @@
-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

@@ -1,138 +0,0 @@
-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

@@ -1,149 +0,0 @@
-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

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

@@ -1,50 +0,0 @@
-module Neo4j
-  module Relationships
-
-    # Wrapper for org.neo4j.graphdb.TraversalPosition
-    # See Javadoc for org.neo4j.graphdb.TraversalPosition
-    # It can be used as a parameter in traversals filter functions.
-    #
-    # :api: public
-    class TraversalPosition
-      def initialize(traversal_position, raw = false)
-        @traversal_position = traversal_position
-        @raw = raw
-      end
-
-      # Return the current node.
-      def current_node
-        Neo4j.load_node(@traversal_position.currentNode.getId, @raw)
-      end
-
-      # Returns the previous node, may be nil.
-      def previous_node
-        return nil if @traversal_position.previousNode.nil?
-        Neo4j.load_node(@traversal_position.previousNode.getId, @raw)
-      end
-
-      # Return the last relationship traversed, may be nil.
-      def last_relationship_traversed
-        relationship = @traversal_position.lastRelationshipTraversed()
-        return nil if relationship.nil?
-        return relationship.wrapper unless @raw
-        relationship
-      end
-
-      # Returns the current traversal depth.
-      def depth
-        @traversal_position.depth
-      end
-
-      # Returns true if the current position is the start node, false otherwise.
-      def start_node?
-        @traversal_position.isStartNode
-      end
-
-      # Returns the number of nodes returned by traverser so far.
-      def returned_nodes_count
-        @traversal_position.returnedNodesCount
-      end
-    end
-  end
-end

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

@@ -1,51 +0,0 @@
-module Neo4j
-  module Relationships
-
-    # Wrapper for org.neo4j.graphdb.ReturnableEvaluator
-    #
-    # :api: private
-    class ReturnableEvaluator #:nodoc:
-      include org.neo4j.graphdb.ReturnableEvaluator
-
-      def initialize(proc, raw = false)
-        @proc = proc
-        @raw = raw
-      end
-
-      def isReturnableNode( traversal_position )
-        # if the Proc takes one argument that we give it the traversal_position
-        result = if @proc.arity == 1
-          # wrap the traversal_position in the Neo4j.rb TraversalPostion object
-          @proc.call TraversalPosition.new(traversal_position, @raw)
-        else # otherwise we eval the proc in the context of the current node
-          # do not include the start node
-          return false if traversal_position.isStartNode()
-          eval_context = Neo4j::load_node(traversal_position.currentNode.getId, @raw)
-          eval_context.instance_eval(&@proc)
-        end
-
-        # java does not treat nil as false so we need to do it instead
-        (result)? true : false
-      end
-    end
-
-    
-    # Wrapper for the neo4j org.neo4j.graphdb.StopEvalutor interface.
-    # Used in the Neo4j Traversers.
-    #
-    # :api: private
-    class DepthStopEvaluator #:nodoc:
-      include org.neo4j.graphdb.StopEvaluator
-
-      def initialize(depth)
-        @depth = depth
-      end
-
-      def isStopNode(pos)
-        pos.depth >= @depth
-      end
-    end
-
-  end
-  
-end

data/lib/neo4j.old/search_result.rb

@@ -1,72 +0,0 @@
-module Neo4j
-
-  # 
-  # Holds the search result and performs the query.
-  # The query is not performed until a search result item is requested.
-  # It is possible that one node is deleted,updated,created after the search is performed.
-  #
-  class SearchResult
-    include Enumerable
-
-    def initialize(index, query, query_for_nodes = true, &block)
-      @query = query
-      @query_for_nodes = query_for_nodes # if we are searching for nodes or relationships
-      @block = block
-      @index = index
-      @sort_by_fields = []
-    end
-
-    def hits
-      @hits ||= @index.find(query_params, &@block)
-    end
-
-    def query_params
-      unless @sort_by_fields.empty?
-        return case @query
-          when Hash
-            @query.merge({:sort_by => @sort_by_fields})
-          when String
-            [@query, { :sort_by => @sort_by_fields}]
-        end
-      end
-      return @query
-    end
-
-
-    # Returns the first item in the search result
-    #
-    # :api: public
-    def first
-      return nil if empty?
-      self[0]
-    end
-
-    def empty?
-      size == 0
-    end
-
-    def each
-      hits.each do |doc|
-
-        node_or_rel =  @query_for_nodes ? Neo4j.load_node(doc[:id]) : Neo4j.load_rel(doc[:id])
-        # can happen that another thread has deleted it
-        raise "lucene found node/rel #{id} but it does not exist in neo" if node_or_rel.nil?
-        yield node_or_rel
-      end
-    end
-
-    def [](n)
-      doc = hits[n]
-      Neo4j.load_node(doc[:id])
-    end
-
-    def sort_by(*fields)
-      @sort_by_fields += fields
-      self
-    end
-
-    def size
-      hits.size
-    end
-  end
-end