neo4j 2.0.0.alpha.5-java → 2.0.0.alpha.6-java

data/lib/neo4j/to_java.rb

@@ -1,31 +0,0 @@
-module Neo4j
-  module ToJava
-
-    def type_to_java(type)
-      org.neo4j.graphdb.DynamicRelationshipType.withName(type.to_s)
-    end
-
-    def dir_from_java(dir)
-      case dir
-        when org.neo4j.graphdb.Direction::OUTGOING then :outgoing
-        when org.neo4j.graphdb.Direction::BOTH     then :both
-        when org.neo4j.graphdb.Direction::INCOMING then :incoming
-        else raise "unknown direction '#{dir} / #{dir.class}'"
-      end
-    end
-
-    def dir_to_java(dir)
-      case dir
-        when :outgoing then org.neo4j.graphdb.Direction::OUTGOING
-        when :both     then org.neo4j.graphdb.Direction::BOTH
-        when :incoming then org.neo4j.graphdb.Direction::INCOMING
-        else raise "unknown direction '#{dir}', expects :outgoing, :incoming or :both"
-      end
-    end
-
-    def ensure_valid_props(hash)
-      hash ||= {}
-      Hash[ hash.each_pair.map{|k,v| [k.to_s, v]} ]
-    end
-  end
-end

data/lib/neo4j/transaction.rb

@@ -1,73 +0,0 @@
-module Neo4j
-  #
-  # All modifying operations that work with the node space must be wrapped in a transaction. Transactions are thread confined.
-  # Neo4j does not implement true nested transaction, instead it uses flat nested transactions
-  # see http://wiki.neo4j.org/content/Flat_nested_transactions
-  #
-  class Transaction
-
-    # Starts a new Neo4j Transaction
-    # Returns a Java Neo4j Transaction object
-    # See http://api.neo4j.org/current/org/neo4j/graphdb/Transaction.html
-    #
-    # Example:
-    #  tx = Neo4j::Transaction.new
-    #  # modify something
-    #  tx.success
-    #  tx.finish
-    def self.new(instance = Neo4j.started_db)
-      instance.begin_tx
-    end
-
-    # Runs a block in a Neo4j transaction
-    #
-    # Many operations on neo requires an transaction. You will get much better performance if
-    # one transaction is wrapped around several neo operation instead of running one transaction per
-    # neo operation.
-    # If one transaction is already running then a 'placebo' transaction will be created.
-    # Performing a finish on a placebo transaction will not finish the 'real' transaction.
-    #
-    # ==== Params
-    # ::yield:: the block to be performed in one transaction
-    #
-    # ==== Examples
-    #  include 'neo4j'
-    #
-    #  Neo4j::Transaction.run {
-    #    node = PersonNode.new
-    #  }
-    #
-    # You have also access to transaction object
-    #
-    #   Neo4j::Transaction.run { |t|
-    #     # something failed
-    #     t.failure # will cause a rollback
-    #   }
-
-    # If an exception occurs inside the block the transaction will rollback automatically
-    #
-    # ==== Returns
-    # The value of the evaluated provided block
-    #
-    def self.run # :yield: block that will be executed in a transaction
-      raise ArgumentError.new("Expected a block to run in Transaction.run") unless block_given?
-
-      begin
-        tx = Neo4j::Transaction.new
-        ret = yield tx
-        tx.success
-      rescue Exception => e
-        if Neo4j::Config[:debug_java] && e.respond_to?(:cause)
-          puts "Java Exception in a transaction, cause: #{e.cause}"
-          e.cause.print_stack_trace
-        end
-
-        tx.failure unless tx.nil?
-        raise
-      ensure
-        tx.finish unless tx.nil?
-      end
-      ret
-    end
-  end
-end

data/lib/neo4j/traversal/filter_predicate.rb

@@ -1,25 +0,0 @@
-module Neo4j
-  module Traversal
-    class FilterPredicate # :nodoc:
-      include org.neo4j.helpers.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

data/lib/neo4j/traversal/prune_evaluator.rb

@@ -1,14 +0,0 @@
-module Neo4j
-  module Traversal
-    class PruneEvaluator  # :nodoc:
-      include org.neo4j.graphdb.traversal.PruneEvaluator
-      def initialize(proc)
-        @proc = proc
-      end
-
-      def prune_after(path)
-        @proc.call(path)
-      end
-    end
-  end
-end

data/lib/neo4j/traversal/rel_expander.rb

@@ -1,31 +0,0 @@
-module Neo4j
-  module Traversal
-    class RelExpander
-      include org.neo4j.graphdb.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

data/lib/neo4j/traversal/traversal.rb

@@ -1,141 +0,0 @@
-require 'neo4j/traversal/filter_predicate'
-require 'neo4j/traversal/prune_evaluator'
-require 'neo4j/traversal/rel_expander'
-require 'neo4j/traversal/traverser'
-
-module Neo4j
-
-  # Contains methods that are mixin for Neo4j::Node
-  # They all return Neo4j::Traversal::Traverser
-  # See the {Neo4j.rb Guide: Traversing Relationships and Nodes}[http://neo4j.rubyforge.org/guides/traverser.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
-    #
-    #   some_node.expand { |n| n._rels.find_all { |r| r[:age] > 5 } }.depth(:all).to_a
-    #
-    # The above traverse all relationships with a property of age > 5
-    #
-    # See http://neo4j.rubyforge.org/guides/traverser.html
-    #
-    def expand(&expander)
-      Traverser.new(self).expander(&expander)
-    end
-
-
-    # Returns the outgoing nodes for this node.
-    #
-    # ==== Returns
-    # a Neo4j::NodeTraverser which can be used to further specify which nodes should be included
-    # in traversal by using the <tt>depth</tt>, <tt>filter</tt> and <tt>prune</tt> methods.
-    #
-    # ==== Examples
-    #   # Find all my friends (nodes of depth 1 of type <tt>friends</tt>)
-    #   me.outgoing(:friends).each {|friend| puts friend.name}
-    #
-    #   # 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]}
-    #
-    #   # 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]}
-    #
-    #   # Find all my friends and include my self in the result
-    #   me.outgoing(:friends).depth(4).include_start_node.each {...}
-    #
-    #   # Find all my friends friends friends, etc. at any depth
-    #   me.outgoing(:friends).depth(:all).each {...}
-    #
-    #   # Find all my friends friends but do not include my friends (only depth == 2)
-    #   me.outgoing(:friends).depth(2).filter{|path| path.length == 2}
-    #
-    #   # 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 }
-    #
-    #   # 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 the {Neo4j.rb Guides}[http://neo4j.rubyforge.org/guides/traverser.html]
-    #
-    def outgoing(type)
-      if type
-        Traverser.new(self).outgoing(type)
-      else
-        raise "Not implemented getting all types of outgoing relationship. Specify a relationship type"
-      end
-    end
-
-
-    # Returns the incoming nodes of given type(s).
-    #
-    # See #outgoing and http://neo4j.rubyforge.org/guides/traverser.html
-    #
-    def incoming(type)
-      if type
-        Traverser.new(self).incoming(type)
-      else
-        raise "Not implemented getting all types of incoming relationship. Specify a relationship type"
-      end
-    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 and http://neo4j.rubyforge.org/guides/traverser.html
-    #
-    def both(type=nil)
-      if type
-        Traverser.new(self).both(type)
-      else
-        Traverser.new(self) # default is both
-      end
-    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...
-    #
-    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.
-    #
-    # See example in #eval_paths
-    # See http://api.neo4j.org/1.4/org/neo4j/kernel/Uniqueness.html and http://neo4j.rubyforge.org/guides/traverser.html
-    def unique(u)
-      Traverser.new(self).unique(u)
-    end
-  end
-end

data/lib/neo4j/traversal/traverser.rb

@@ -1,284 +0,0 @@
-module Neo4j
-
-  module Traversal
-
-    class Evaluator  #:nodoc:
-      include org.neo4j.graphdb.traversal.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
-            org.neo4j.graphdb.traversal.Evaluation::EXCLUDE_AND_CONTINUE
-          when :exclude_and_prune then
-            org.neo4j.graphdb.traversal.Evaluation::EXCLUDE_AND_PRUNE
-          when :include_and_continue then
-            org.neo4j.graphdb.traversal.Evaluation::INCLUDE_AND_CONTINUE
-          when :include_and_prune then
-            org.neo4j.graphdb.traversal.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
-
-    class Traverser
-      include Enumerable
-      include ToJava
-
-
-      def initialize(from, type = nil, dir=nil)
-        @from = from
-        @depth = 1
-        if type.nil? || dir.nil?
-          @td = org.neo4j.kernel.impl.traversal.TraversalDescriptionImpl.new.breadth_first()
-        else
-          @type = type_to_java(type)
-          @dir = dir_to_java(dir)
-          @td = org.neo4j.kernel.impl.traversal.TraversalDescriptionImpl.new.breadth_first().relationships(@type, @dir)
-        end
-      end
-
-
-      # Sets traversing depth first.
-      #
-      # The <tt>pre_or_post</tt> parameter parameter can have two values: :pre or :post
-      # * :pre - Traversing depth first, visiting each node before visiting its child nodes (default)
-      # * :post -  Traversing depth first, visiting each node after visiting its child nodes.
-      #
-      def depth_first(pre_or_post = :pre)
-        case pre_or_post
-          when :pre then @td = @td.order(org.neo4j.kernel.Traversal.preorderDepthFirst())
-          when :post then @td = @td.order(org.neo4j.kernel.Traversal.postorderDepthFirst())
-          else raise "Unknown type #{pre_or_post}, should be :pre or :post"
-        end
-        self
-      end
-
-
-      # Sets traversing breadth first (default).
-      #
-      # This is the default ordering if none is defined.
-      # The <tt>pre_or_post</tt> parameter parameter can have two values: :pre or :post
-      # * :pre - Traversing breadth first, visiting each node before visiting its child nodes (default)
-      # * :post - Traversing breadth first, visiting each node after visiting its child nodes.
-      #
-      #	==== Note
-      # Please note that breadth first traversals have a higher memory overhead than depth first traversals.
-      # BranchSelectors carries state and hence needs to be uniquely instantiated for each traversal. Therefore it is supplied to the TraversalDescription through a BranchOrderingPolicy interface, which is a factory of BranchSelector instances.
-      #
-      def breadth_first(pre_or_post = :pre)
-        case pre_or_post
-          when :pre then @td = @td.order(org.neo4j.kernel.Traversal.preorderBreadthFirst())
-          when :post then @td = @td.order(org.neo4j.kernel.Traversal.postorderBreadthFirst())
-          else raise "Unknown type #{pre_or_post}, should be :pre or :post"
-        end
-        self
-      end
-
-
-      def eval_paths(&eval_path_block)
-        @td = @td.evaluator(Evaluator.new(&eval_path_block))
-        self
-      end
-
-      def unique(u = :node_global)
-        case u
-          when :node_global then
-            # A node cannot be traversed more than once.
-            @td = @td.uniqueness(org.neo4j.kernel.Uniqueness::NODE_GLOBAL)
-          when :node_path then
-            # For each returned node there 's a unique path from the start node to it.
-            @td = @td.uniqueness(org.neo4j.kernel.Uniqueness::NODE_PATH)
-          when :node_recent then
-            # This is like NODE_GLOBAL, but only guarantees uniqueness among the most recent visited nodes, with a configurable count.
-            @td = @td.uniqueness(org.neo4j.kernel.Uniqueness::NODE_RECENT)
-          when :none then
-            # No restriction (the user will have to manage it).
-            @td = @td.uniqueness(org.neo4j.kernel.Uniqueness::NONE)
-          when :rel_global then
-            # A relationship cannot be traversed more than once, whereas nodes can.
-            @td = @td.uniqueness(org.neo4j.kernel.Uniqueness::RELATIONSHIP_GLOBAL)
-          when :rel_path then
-            # No restriction (the user will have to manage it).
-            @td = @td.uniqueness(org.neo4j.kernel.Uniqueness::RELATIONSHIP_PATH)
-          when :rel_recent then
-            # Same as for NODE_RECENT, but for relationships.
-            @td = @td.uniqueness(org.neo4j.kernel.Uniqueness::RELATIONSHIP_RECENT)
-          else
-            raise "Got option for unique '#{u}' allowed: :node_global, :node_path, :node_recent, :none, :rel_global, :rel_path, :rel_recent"
-        end
-        self
-      end
-
-      def to_s
-        "NodeTraverser [from: #{@from.neo_id} depth: #{@depth} type: #{@type} dir:#{@dir}"
-      end
-
-
-      def <<(other_node)
-        new(other_node)
-        self
-      end
-
-      # Returns an real ruby array.
-      def to_ary
-        self.to_a
-      end
-
-      def new(other_node)
-        case @dir
-          when org.neo4j.graphdb.Direction::OUTGOING
-            @from.create_relationship_to(other_node, @type)
-          when org.neo4j.graphdb.Direction::INCOMING
-            other_node.create_relationship_to(@from, @type)
-          else
-            raise "Only allowed to create outgoing or incoming relationships (not #@dir)"
-        end
-      end
-
-      def both(type)
-        @type = type_to_java(type) if type
-        @dir = dir_to_java(:both)
-        @td = @td.relationships(type_to_java(type), @dir)
-        self
-      end
-
-      def expander(&expander)
-        @td = @td.expand(RelExpander.create_pair(&expander))
-        self
-      end
-
-      def outgoing(type)
-        @type = type_to_java(type) if type
-        @dir = dir_to_java(:outgoing)
-        @td = @td.relationships(type_to_java(type), @dir)
-        self
-      end
-
-      def incoming(type)
-        @type = type_to_java(type) if type
-        @dir = dir_to_java(:incoming)
-        @td = @td.relationships(type_to_java(type), @dir)
-        self
-      end
-
-      def filter_method(name, &proc)
-        # add method name
-        singelton = class << self;
-          self;
-        end
-        singelton.send(:define_method, name) { filter &proc }
-        self
-      end
-
-      def functions_method(func, rule_node, rule_name)
-        singelton = class << self;
-          self;
-        end
-        singelton.send(:define_method, func.class.function_name) do |*args|
-          function_id = args.empty? ? "_classname" : args[0]
-          function = rule_node.find_function(rule_name, func.class.function_name, function_id)
-          function.value(rule_node.rule_node, rule_name)
-        end
-        self
-      end
-
-      def prune(&block)
-        @td = @td.prune(PruneEvaluator.new(block))
-        self
-      end
-
-      def filter(&block)
-        # we keep a reference to filter predicate since only one filter is allowed and we might want to modify it
-        @filter_predicate ||= FilterPredicate.new
-        @filter_predicate.add(block)
-        @td = @td.filter(@filter_predicate)
-        self
-      end
-
-      # Sets depth, if :all then it will traverse any depth
-      def depth(d)
-        @depth = d
-        self
-      end
-
-      def include_start_node
-        @include_start_node = true
-        self
-      end
-
-      def size
-        s = 0
-        iterator.each { |_| s += 1 }
-        s
-      end
-
-      alias_method :length, :size
-
-      def [](index)
-        each_with_index { |node, i| break node if index == i }
-      end
-
-      def empty?
-        first == nil
-      end
-
-      def each
-        @raw ? iterator.each { |i| yield i } : iterator.each { |i| yield i.wrapper }
-      end
-
-      # Same as #each but does not wrap each node in a Ruby class, yields the Java Neo4j Node instance instead.
-      def each_raw
-        iterator.each { |i| yield i }
-      end
-
-      # Returns an enumerable of relationships instead of nodes
-      #
-      def rels
-        @traversal_result = :rels
-        self
-      end
-
-      # If this is called then it will not wrap the nodes but instead return the raw Java Neo4j::Node objects when traversing
-      #
-      def raw
-        @raw = true
-        self
-      end
-
-      # Returns an enumerable of paths instead of nodes
-      #
-      def paths
-        @traversal_result = :paths
-        @raw = true
-        self
-      end
-
-      def iterator
-        unless @include_start_node
-          if @filter_predicate
-            @filter_predicate.include_start_node
-          else
-            @td = @td.filter(org.neo4j.kernel.Traversal.return_all_but_start_node)
-          end
-        end
-        @td = @td.prune(org.neo4j.kernel.Traversal.pruneAfterDepth(@depth)) unless @depth == :all
-        if @traversal_result == :rels
-          @td.traverse(@from._java_node).relationships
-        elsif @traversal_result == :paths
-          @td.traverse(@from._java_node).iterator
-        else
-          @td.traverse(@from._java_node).nodes
-        end
-
-      end
-    end
-  end
-end