neo4j-core 0.0.1-java

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

@@ -0,0 +1,99 @@
+module Neo4j
+  module Core
+    module Rels
+
+      # Traverse relationships of depth one from one node.
+      # This object is returned from the Neo4j::Node#rels method.
+      # @see Neo4j::Core::Node#rels
+      class Traverser
+        include Enumerable
+        include Neo4j::Core::ToJava
+
+        attr_reader :node
+        attr_reader :dir
+        attr_reader :types
+
+        # Called from Neo4j::Core::Node#rels
+        def initialize(node, types, dir = :both)
+          @node = node
+          @types = types
+          @dir = dir
+        end
+
+        def to_s
+          "#{self.class} [types: #{@types.join(',')} dir:#{@dir}]"
+        end
+
+        # Implements the Ruby Enumerable mixin
+        def each
+          iter = iterator
+          while (iter.has_next())
+            rel = iter.next
+            yield rel.wrapper if match_to_other?(rel)
+          end
+        end
+
+        # @return [true,false] if there are no relationships of specified dir and type(s)
+        def empty?
+          first == nil
+        end
+
+        # @return The Java Iterator
+        def iterator
+          @node._rels(@dir, *@types)
+        end
+
+        # @return [true,false] true if it match the specified other node
+        # @see #to_other
+        def match_to_other?(rel)
+          if @to_other.nil?
+            true
+          elsif @dir == :outgoing
+            rel._end_node == @to_other
+          elsif @dir == :incoming
+            rel._start_node == @to_other
+          else
+            rel._start_node == @to_other || rel._end_node == @to_other
+          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
+        # @return self
+        def to_other(to_other)
+          @to_other = to_other
+          self
+        end
+
+        # Deletes all the relationships
+        def del
+          each { |rel| rel.del }
+        end
+
+
+        # Specifies that we want both incoming and outgoing direction
+        # @return self
+        def both
+          @dir = :both
+          self
+        end
+
+        # Specifies that we only want incoming relationships
+        # @return self
+        def incoming
+          @dir = :incoming
+          self
+        end
+
+        # Specifies that only outgoing relationships is wanted.
+        # @return self
+        def outgoing
+          @dir = :outgoing
+          self
+        end
+
+      end
+
+    end
+  end
+end

data/lib/neo4j-core/to_java.rb

@@ -0,0 +1,51 @@
+module Neo4j
+  module Core
+    # 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
+end

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

@@ -0,0 +1,36 @@
+module Neo4j
+  module Core
+    module Traversal
+
+      # Implements the Neo4j Evaluator Java interface, only used internally.
+      # @private
+      class Evaluator
+        include Java::OrgNeo4jGraphdbTraversal::Evaluator
+
+        def initialize(&eval_block)
+          @eval_block = eval_block
+        end
+
+        # Implements the Java Interface:
+        #  evaluate(Path path)
+        #  Evaluates a Path and returns an Evaluation containing information about whether or not to include it in the traversal result, i.e return it from the Traverser.
+        def evaluate(path)
+          ret = @eval_block.call(path)
+          case ret
+            when :exclude_and_continue then
+              Java::OrgNeo4jGraphdbTraversal::Evaluation::EXCLUDE_AND_CONTINUE
+            when :exclude_and_prune then
+              Java::OrgNeo4jGraphdbTraversal::Evaluation::EXCLUDE_AND_PRUNE
+            when :include_and_continue then
+              Java::OrgNeo4jGraphdbTraversal::Evaluation::INCLUDE_AND_CONTINUE
+            when :include_and_prune then
+              Java::OrgNeo4jGraphdbTraversal::Evaluation::INCLUDE_AND_PRUNE
+            else
+              raise "Got #{ret}, only accept :exclude_and_continue,:exclude_and_prune,:include_and_continue and :include_and_prune"
+          end
+        end
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+module Neo4j
+  module Core
+    module Traversal
+      # Implements the Neo4j Predicate Java interface, only used internally.
+      # @private
+      class FilterPredicate
+        include Java::OrgNeo4jHelpers::Predicate
+
+        def initialize
+          @procs = []
+        end
+
+        def add(proc)
+          @procs << proc
+        end
+
+        def include_start_node
+          @include_start_node = true
+        end
+
+        def accept(path)
+          return false if @include_start_node && path.length == 0
+          # find the first filter which returns false
+          # if not found then we will accept this path
+          @procs.find { |p| !p.call(path) }.nil?
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+module Neo4j
+  module Core
+
+    # Implements the Neo4j PruneEvaluator Java interface, only used internally.
+    # @private
+    module Traversal
+      class PruneEvaluator
+        include Java::OrgNeo4jGraphdbTraversal::PruneEvaluator
+
+        def initialize(proc)
+          @proc = proc
+        end
+
+        def prune_after(path)
+          @proc.call(path)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+module Neo4j
+  module Core
+    module Traversal
+      # Implements the Neo4j RelationshipExpander Java interface, only used internally.
+      # @private
+      class RelExpander
+        include Java::OrgNeo4jGraphdb::RelationshipExpander
+
+        attr_accessor :reversed
+
+        def initialize(&block)
+          @block = block
+          @reverse = false
+        end
+
+        def self.create_pair(&block)
+          normal = RelExpander.new(&block)
+          reversed = RelExpander.new(&block)
+          normal.reversed = reversed
+          reversed.reversed = normal
+          reversed.reverse!
+          normal
+        end
+
+        def expand(node)
+          @block.arity == 1 ? @block.call(node) : @block.call(node, @reverse)
+        end
+
+        def reverse!
+          @reverse = true
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,130 @@
+require 'neo4j-core/traversal/filter_predicate'
+require 'neo4j-core/traversal/prune_evaluator'
+require 'neo4j-core/traversal/rel_expander'
+require 'neo4j-core/traversal/traverser'
+
+module Neo4j
+
+  module Core
+    # Contains methods that are mixin for Neo4j::Node
+    # The builder pattern is used to construct traversals (all methods returns Neo4j::Traversal::Traverser)
+    # @see http://github.com/andreasronge/neo4j/wiki/traverser
+    # @see http://docs.neo4j.org/chunked/stable/tutorial-traversal-java-api.html
+    module Traversal
+      include ToJava
+
+      # A more powerful alternative of #outgoing, #incoming and #both method.
+      # You can use this method for example to only traverse nodes based on properties on the relationships
+      #
+      # @example traverse all relationships with a property of age > 5
+      #   some_node.expand { |n| n._rels.find_all { |r| r[:age] > 5 } }.depth(:all).to_a
+      #
+      # @yield [node] Used to find out which relationship should be included in the traversal
+      # @yieldparam [Neo4j::Node] node the current node from which we can decide which relationship should be traversed
+      # @yieldreturn [Enumerable<Neo4j::Relationship>] which relationships should be traversed
+      # @return [Neo4j::Core::Traversal::Traverser] a traverser object which can be used to further describe the traversal
+      def expand(&expander)
+        Traverser.new(self).expander(&expander)
+      end
+
+
+      # Returns the outgoing nodes for this node.
+      #
+      # @example Find all my friends (nodes of depth 1 of type <tt>friends</tt>)
+      #   me.outgoing(:friends).each {|friend| puts friend.name}
+      #
+      # @example A possible faster way, avoid loading wrapper Ruby classes, instead use raw java neo4j node objects
+      #   me.outgoing(:friends).raw.each {|friend| puts friend[:name]}
+      #
+      # @example Find all my friends and their friends (nodes of depth 1 of type <tt>friends</tt>)
+      #   me.outgoing(:friends).depth(2).each {|friend| puts friend[:name]}
+      #
+      # @example Find all my friends and include my self in the result
+      #   me.outgoing(:friends).depth(4).include_start_node.each {...}
+      #
+      # @example Find all my friends friends friends, etc. at any depth
+      #   me.outgoing(:friends).depth(:all).each {...}
+      #
+      # @example Find all my friends friends but do not include my friends (only depth == 2)
+      #   me.outgoing(:friends).depth(2).filter{|path| path.length == 2}
+      #
+      # @example Find all my friends but 'cut off' some parts of the traversal path
+      #   me.outgoing(:friends).depth(42).prune(|path| an_expression_using_path_returning_true_false }
+      #
+      # @example Find all my friends and work colleges
+      #   me.outgoing(:friends).outgoing(:work).each {...}
+      #
+      # Of course all the methods <tt>outgoing</tt>, <tt>incoming</tt>, <tt>both</tt>, <tt>depth</tt>, <tt>include_start_node</tt>, <tt>filter</tt>, and <tt>prune</tt>, <tt>eval_paths</tt>, <tt>unique</tt> can be combined.
+      #
+      # @see http://github.com/andreasronge/neo4j/wiki/traverser
+      # @param [String, Symbol] type the relationship type
+      # @return (see #expand)
+      def outgoing(type)
+        Traverser.new(self, :outgoing, type)
+      end
+
+
+      # Returns the incoming nodes of given type(s).
+      #
+      # @param [String, Symbol] type the relationship type
+      # @see #outgoing
+      # @see http://github.com/andreasronge/neo4j/wiki/traverser
+      # @return (see #expand)
+      def incoming(type)
+        Traverser.new(self, :incoming, type)
+      end
+
+      # Returns both incoming and outgoing nodes of given types(s)
+      #
+      # If a type is not given then it will return all types of relationships.
+      #
+      # @see #outgoing
+      # @return (see #expand)
+      def both(type=nil)
+        Traverser.new(self, :both, type)
+      end
+
+
+      # Traverse using a block. The block is expected to return one of the following values:
+      # * <tt>:exclude_and_continue</tt>
+      # * <tt>:exclude_and_prune</tt>
+      # * <tt>:include_and_continue</tt>
+      # * <tt>:include_and_prune</tt>
+      # This value decides if it should continue to traverse and if it should include the node in the traversal result.
+      # The block will receive a path argument.
+      #
+      # @example
+      #   @pet0.eval_paths {|path| path.end_node ==  @principal1 ? :include_and_prune : :exclude_and_continue }.unique(:node_path).depth(:all)
+      #
+      # ==== See also
+      #
+      # * How to use - http://neo4j.rubyforge.org/guides/traverser.html
+      # * the path parameter - http://api.neo4j.org/1.4/org/neo4j/graphdb/Path.html
+      # * the #unique method - if paths should be visit more the once, etc...
+      #
+      # @return (see #expand)
+      def eval_paths(&eval_block)
+        Traverser.new(self).eval_paths(&eval_block)
+      end
+
+      # Sets uniqueness of nodes or relationships to visit during a traversals.
+      #
+      # Allowed values
+      # * <tt>:node_global</tt>  A node cannot be traversed more than once (default)
+      # * <tt>:node_path</tt>  For each returned node there 's a unique path from the start node to it.
+      # * <tt>:node_recent</tt>  This is like :node_global, but only guarantees uniqueness among the most recent visited nodes, with a configurable count.
+      # * <tt>:none</tt>  No restriction (the user will have to manage it).
+      # * <tt>:rel_global</tt>  A relationship cannot be traversed more than once, whereas nodes can.
+      # * <tt>:rel_path</tt>  No restriction (the user will have to manage it).
+      # * <tt>:rel_recent</tt>  Same as for :node_recent, but for relationships.
+      #
+      # @param (see Neo4j::Core::Traversal::Traverser#unique)
+      # @see example in #eval_paths
+      # @see http://docs.neo4j.org/chunked/stable/tutorial-traversal-java-api.html#_uniqueness
+      # @return (see #expand)
+      def unique(u)
+        Traverser.new(self).unique(u)
+      end
+    end
+  end
+end