neo4j-core 0.0.5-java → 0.0.6-java

data/lib/neo4j/algo.rb

@@ -0,0 +1,300 @@
+module Neo4j
+
+
+  # A wrapper for the Neo4j Algo <tt>org.neo4j.graphalgo.GraphAlgoFactory</tt> class.
+  #
+  # @example the length of the first path found between two nodes
+  #   Neo4j::Algo.all_paths(a,b).outgoing(:friends).depth(1).first.length
+  #
+  # @example the nodes in the shortest path between two nodes
+  #   Neo4j::Algo.shortest_path(a,b).outgoing(:friends).outgoing(:knows).to_a #=> [node1, node2, node3 ...]
+  #
+  # @example the relationships in the shortest path between two nodes
+  #   Neo4j::Algo.shortest_path(a,b).outgoing(:friends).outgoing(:knows).rels.to_a #=> [rel1, rel2, rel3 ...]
+  #
+  # @example The Dijkstra algorithm using a cost evaluator
+  #   Neo4j::Algo.dijkstra_path(a,b).cost_evaluator{|rel,direction| rel[:weight]}
+  class Algo
+    include Enumerable
+    include Neo4j::Core::ToJava
+
+    class EstimateEvaluator #:nodoc
+      include org.neo4j.graphalgo.EstimateEvaluator
+      include Neo4j::Core::ToJava
+
+      def initialize(&evaluator)
+        @evaluator = evaluator
+      end
+
+      # Implements T getCost(Node node, Node goal)
+      # Estimate the weight of the remaining path from one node to another.
+      def get_cost(node, goal)
+        @evaluator.call(node, goal)
+      end
+    end
+
+    class CostEvaluator #:nodoc
+      include org.neo4j.graphalgo.CostEvaluator
+      include Neo4j::Core::ToJava
+
+      def initialize(&evaluator)
+        @evaluator = evaluator
+      end
+
+      # Implements the Java Method:   T getCost(Relationship relationship, Direction direction)
+      # From the JavaDoc: <pre>
+      # This is the general method for looking up costs for relationships.
+      # This can do anything, like looking up a property or running some small calculation.
+      # Parameters:
+      # relationship -
+      # direction - The direction in which the relationship is being evaluated, either Direction.INCOMING or Direction.OUTGOING.
+      # Returns:
+      # The cost for this edge/relationship
+      # </pre>
+      def get_cost(relationship, direction)
+        @evaluator.call(relationship, dir_from_java(direction))
+      end
+    end
+
+    def initialize(from, to, &factory_proc) #:nodoc:
+      @from          = from
+      @to            = to
+      @factory_proc  = factory_proc
+      @type_and_dirs = []
+
+    end
+
+    def _depth #:nodoc:
+      @depth || java.lang.Integer::MAX_VALUE
+    end
+
+    def _expander #:nodoc:
+      expander = @expander
+      expander ||= @type_and_dirs.empty? ? org.neo4j.kernel.Traversal.expanderForAllTypes() : org.neo4j.kernel.Traversal.expanderForTypes(*@type_and_dirs)
+      expander
+    end
+
+    def _cost_evaluator #:nodoc:
+      raise "Algorithm requeries a cost evalulator, use the cost_evaluator to provide one" unless @cost_evaluator
+      @cost_evaluator
+    end
+
+    def _estimate_evaluator #:nodoc:
+      raise "Algorithm requeries a estimate evaluator, use the estimate_evaluator to provide one" unless @estimate_evaluator
+      @estimate_evaluator
+    end
+
+    # Specifies which outgoing relationship should be traversed for the graph algorithm
+    #
+    # @param [String, Symbol] rel the relationship type
+    # @return self
+    def outgoing(rel)
+      @type_and_dirs << type_to_java(rel)
+      @type_and_dirs << dir_to_java(:outgoing)
+      self
+    end
+
+    # Specifies which incoming relationship should be traversed for the graph algorithm
+    #
+    # @param [String, Symbol] rel the relationship type
+    # @return self
+    def incoming(rel)
+      @type_and_dirs << type_to_java(rel)
+      @type_and_dirs << dir_to_java(:incoming)
+      self
+    end
+
+    # Specifies which relationship should be traversed for the graph algorithm
+    #
+    # @example
+    #  Neo4j::Algo.shortest_path(@x,@y).expand{|node| node._rels(:outgoing, :friends)}
+    #
+    # @example the above is same as:
+    #  Neo4j::Algo.shortest_path(@x,@y).outgoing(:friends)
+    #
+    # @param [Proc] expander_proc a proc relationship type (symbol)
+    # @return self
+    def expand(&expander_proc)
+      @expander = (Neo4j::Core::Traversal::RelExpander.create_pair(&expander_proc))
+      self
+    end
+
+    # If only a single path should be returned,
+    # default for some algorithms, like shortest_path
+    def single
+      @single = true
+      self
+    end
+
+    # See #single
+    # Not sure if this method is useful
+    def many
+      @single = false
+    end
+
+    # The depth of the traversal
+    # Notice not all algorithm uses this argument (aStar and dijkstra)
+    def depth(depth)
+      @depth = depth
+      self
+    end
+
+    # Specifies a cost evaluator for the algorithm.
+    # Only available for the aStar and dijkstra algorithms.
+    #
+    # @example
+    #  Neo4j::Algo.dijkstra(@x,@y).cost_evaluator{|rel,*| rel[:weight]}
+    #
+    def cost_evaluator(&cost_evaluator_proc)
+      @cost_evaluator = CostEvaluator.new(&cost_evaluator_proc)
+      self
+    end
+
+    # Specifies an evaluator that returns an (optimistic) estimation of the cost to get from the current node (in the traversal) to the end node.
+    # Only available for the aStar algorithm.
+    #
+    # The provided proc estimate the weight of the remaining path from one node to another.
+    # The proc takes two parameters:
+    # * node :: the node to estimate the weight from.
+    # * goal :: the node to estimate the weight to.
+    #
+    # The proc should return an estimation of the weight of the path from the first node to the second.
+    #
+    # @example
+    #  Neo4j::Algo.a_star(@x,@y).cost_evaluator{...}.estimate_evaluator{|node,goal| some calculation returning a Float}
+    #
+    def estimate_evaluator(&estimate_evaluator_proc)
+      @estimate_evaluator = EstimateEvaluator.new(&estimate_evaluator_proc)
+      self
+    end
+
+    # Specifies that nodes should be returned from as result
+    # @see #rels
+    def nodes
+      @path_finder_method = :nodes
+      self
+    end
+
+    # Specifies that relationships should be returned from as result
+    # @see #nodes
+    def rels
+      @path_finder_method = :relationships
+      self
+    end
+
+
+    # So that one can call directly method on the PathFinder result from an executed algorithm.
+    def method_missing(m, *args, &block)
+      execute_algo.send(m, *args)
+    end
+
+    def each(&block) #:nodoc:
+      if @single && @path_finder_method
+        execute_algo.send(@path_finder_method).each &block
+      else
+        traversal = execute_algo
+        traversal.each &block if traversal
+      end
+    end
+
+    def execute_algo #:nodoc:
+      instance = self.instance_eval(&@factory_proc)
+      if @single
+        instance.find_single_path(@from._java_node, @to._java_node)
+      else
+        instance.find_all_paths(@from._java_node, @to._java_node)
+      end
+    end
+
+    # Returns an instance of Neo4j::Algo which can find all available paths between two nodes.
+    # These returned paths can contain loops (i.e. a node can occur more than once in any returned path).
+    def self.all_paths(from, to)
+      Algo.new(from, to) { org.neo4j.graphalgo.GraphAlgoFactory.all_paths(_expander, _depth) }
+    end
+
+    # See #all_paths, returns the first path found
+    def self.all_path(from, to)
+      Algo.new(from, to) { org.neo4j.graphalgo.GraphAlgoFactory.all_paths(_expander, _depth) }.single
+    end
+
+    # Returns an instance of Neo4j::Algo which can find all simple paths between two nodes.
+    # These returned paths cannot contain loops (i.e. a node cannot occur more than once in any returned path).
+    def self.all_simple_paths(from, to)
+      Algo.new(from, to) { org.neo4j.graphalgo.GraphAlgoFactory.all_simple_paths(_expander, _depth) }
+    end
+
+    # See #all_simple_paths, returns the first path found
+    def self.all_simple_path(from, to)
+      Algo.new(from, to) { org.neo4j.graphalgo.GraphAlgoFactory.all_simple_paths(_expander, _depth) }.single
+    end
+
+    # Returns an instance of Neo4j::Algo which can find all shortest paths (that is paths with as short Path.length() as possible) between two nodes.
+    # These returned paths cannot contain loops (i.e. a node cannot occur more than once in any returned path).
+    def self.shortest_paths(from, to)
+      Algo.new(from, to) { org.neo4j.graphalgo.GraphAlgoFactory.shortest_path(_expander, _depth) }
+    end
+
+    # See #shortest_paths, returns the first path found
+    def self.shortest_path(from, to)
+      Algo.new(from, to) { org.neo4j.graphalgo.GraphAlgoFactory.shortest_path(_expander, _depth) }.single
+    end
+
+    # Returns an instance of Neo4j::Algo which uses the Dijkstra algorithm to find the cheapest path between two nodes.
+    # The definition of "cheap" is the lowest possible cost to get from the start node to the end node, where the cost is returned from costEvaluator.
+    # These returned paths cannot contain loops (i.e. a node cannot occur more than once in any returned path).
+    # See http://en.wikipedia.org/wiki/Dijkstra%27s_algorithm for more information.
+    #
+    # Example
+    #
+    #   Neo4j::Algo.dijkstra_path(node_a,node_b).cost_evaluator{|rel,*| rel[:weight]}.rels
+    #
+    def self.dijkstra_paths(from, to)
+      Algo.new(from, to) { org.neo4j.graphalgo.GraphAlgoFactory.dijkstra(_expander, _cost_evaluator) }
+    end
+
+    # See #dijkstra_paths, returns the first path found
+    #
+    def self.dijkstra_path(from, to)
+      Algo.new(from, to) { org.neo4j.graphalgo.GraphAlgoFactory.dijkstra(_expander, _cost_evaluator) }.single
+    end
+
+    # Returns an instance of Neo4j::Algo which uses the A* algorithm to find the cheapest path between two nodes.
+    # The definition of "cheap" is the lowest possible cost to get from the start node to the end node, where the cost is returned from lengthEvaluator and estimateEvaluator. These returned paths cannot contain loops (i.e. a node cannot occur more than once in any returned path).
+    # See http://en.wikipedia.org/wiki/A*_search_algorithm for more information.
+    #
+    # Expacts an cost evaluator and estimate evaluator, see Algo#cost_evaluator and Algo#estimate_evaluator
+    #
+    # Example:
+    #
+    #  Neo4j::Algo.a_star_path(@x,@y).cost_evaluator{|rel,*| rel[:weight]}.estimate_evaluator{|node,goal| returns a float value}
+    #
+    def self.a_star_paths(from, to)
+      Algo.new(from, to) { org.neo4j.graphalgo.GraphAlgoFactory.a_star(_expander, _cost_evaluator, _estimate_evaluator) }
+    end
+
+    # See #a_star_paths, returns the first path found
+    #
+    def self.a_star_path(from, to)
+      Algo.new(from, to) { org.neo4j.graphalgo.GraphAlgoFactory.a_star(_expander, _cost_evaluator, _estimate_evaluator) }.single
+    end
+
+    # Returns an instance of Neo4j::Algo can find all paths of a certain length(depth) between two nodes.
+    # These returned paths cannot contain loops (i.e. a node cannot occur more than once in any returned path).
+    # Expects setting the depth parameter (the lenghto of the path) by the Algo#depth method.
+    #
+    # Example:
+    #
+    #   Neo4j::Algo.with_length_paths(node_a,node_b).depth(2).each {|x| puts "Node #{x}"}
+    #
+    def self.with_length_paths(from,to)
+      Algo.new(from, to) { org.neo4j.graphalgo.GraphAlgoFactory.paths_with_length(_expander, _depth) }
+    end
+
+    # See #with_length_paths, returns the first path found
+    #
+    def self.with_length_path(from,to)
+      Algo.new(from, to) { org.neo4j.graphalgo.GraphAlgoFactory.paths_with_length(_expander, _depth) }.single
+    end
+
+  end
+end

data/lib/neo4j/cypher.rb

@@ -116,7 +116,7 @@ module Neo4j
 
     def shortest_paths(&block)
       match = instance_eval(&block)
-      match.algorithm = 'shortestPaths'
+      match.algorithm = 'allShortestPaths'
       match.find_match_start
     end
 

data/lib/neo4j-core/index/index_config.rb

@@ -79,7 +79,6 @@ module Neo4j
           @_index_names = hash
         end
 
-
         def rm_index_config
           @_index_type = {}
           @_field_types = {}

data/lib/neo4j-core/index/indexer.rb

@@ -94,7 +94,7 @@ module Neo4j
         # (by Rack).
         #
         # @example with a block
-        #   Person.find('name: kalle') {|query| puts "#{[*query].join(', )"}
+        #   Person.find('name: kalle') {|query| puts "First item #{query.first}"}
         #
         # @example using an exact lucene index
         #   query = Person.find('name: kalle')
@@ -109,6 +109,14 @@ module Neo4j
         # @example Sorting, descending by one property
         #    Person.find({:name => 'kalle'}, :sort => {:name => :desc})
         #
+        # @example Sorting using the builder pattern
+        #    Person.find(:name => 'kalle').asc(:name)
+        #
+        # @example Compound queries and Range queries
+        #    Person.find('name: pelle').and(:age).between(2, 5)
+        #    Person.find(:name => 'kalle', :age => (2..5))
+        #    Person.find("name: 'asd'").and(:wheels => 8)
+        #
         # @example Using the lucene java object
         #   # using the Neo4j query method directly
         #   # see, http://api.neo4j.org/1.6.1/org/neo4j/graphdb/index/ReadableIndex.html#query(java.lang.Object)

data/lib/neo4j-core/version.rb

@@ -1,5 +1,5 @@
 module Neo4j
   module Core
-    VERSION = "0.0.5"
+    VERSION = "0.0.6"
   end
 end

data/lib/neo4j-core.rb

@@ -61,6 +61,7 @@ require 'neo4j-core/traversal/traverser'
 require 'neo4j-core/cypher/cypher'
 require 'neo4j-core/cypher/result_wrapper'
 
+require 'neo4j/algo'
 require 'neo4j/cypher'
 require 'neo4j/node'
 require 'neo4j/relationship'

metadata

@@ -2,7 +2,7 @@
 name: neo4j-core
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 0.0.5
+  version: 0.0.6
 platform: java
 authors: 
   - Andreas Ronge
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-04-01 00:00:00 Z
+date: 2012-04-03 00:00:00 Z
 dependencies: 
   - !ruby/object:Gem::Dependency 
     name: neo4j-community
@@ -39,6 +39,7 @@ extra_rdoc_files:
 files: 
   - lib/neo4j-core.rb
   - lib/neo4j/config.rb
+  - lib/neo4j/algo.rb
   - lib/neo4j/cypher.rb
   - lib/neo4j/transaction.rb
   - lib/neo4j/neo4j.rb