neo4j-core 2.0.0.alpha.1-java → 2.0.0-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/config.rb

@@ -37,7 +37,7 @@ module Neo4j
       # @return [Hash] the default file loaded by yaml
       def defaults
         require 'yaml'
-        @defaults ||= YAML.load_file(default_file)
+        @defaults ||= Neo4j::Core::HashWithIndifferentAccess.new(YAML.load_file(default_file))
       end
 
       # @return [String] the expanded path of the Config[:storage_path] property
@@ -56,7 +56,7 @@ module Neo4j
       # @yield config
       # @yieldparam [Neo4j::Config] config - this configuration class
       def use
-        @configuration ||= {}
+        @configuration ||= Neo4j::Core::HashWithIndifferentAccess.new
         yield @configuration
         nil
       end
@@ -123,16 +123,13 @@ module Neo4j
         map
       end
 
-      private
-
       # @return The a new configuration using default values as a hash.
       def setup()
-        @configuration = {}
+        @configuration = Neo4j::Core::HashWithIndifferentAccess.new
         @configuration.merge!(defaults)
         @configuration
       end
 
-
     end
   end
 

data/lib/neo4j/cypher.rb

@@ -0,0 +1,180 @@
+module Neo4j
+
+  # Generates a Cypher string from a Ruby DSL.
+  # This class is used by the {Ņeo4j#query} method.
+  # Methods on in this class returns object from the {Neo4j::Core::Cypher} module (e.g. {Neo4j::Cypher#node} can return a #{Neo4j::Core::Cypher::StartNode}).
+  #
+  # @example usage
+  #   Neo4j::Cypher.new { node }
+  #
+  class Cypher
+    # @private
+    attr_reader :expressions
+
+    include Neo4j::Core::Cypher
+    include Neo4j::Core::Cypher::MathFunctions
+
+    # Creates a Cypher DSL query.
+    # To create a new cypher query you must initialize it either an String or a Block.
+    #
+    # @example <tt>START n0=node(3) MATCH (n0)--(x) RETURN x</tt> same as
+    #   Cypher.new { start n = node(3); match n <=> :x; ret :x }.to_s
+    #
+    # @example <tt>START n0=node(3) MATCH (n0)-[r]->(x) RETURN r</tt> same as
+    #   node(3) > :r > :x; :r
+    #
+    # @example <tt>START n0=node(3) MATCH (n0)-->(x) RETURN x</tt> same as
+    #   node(3) >> :x; :x
+    #
+    # @param args the argument for the dsl_block
+    # @yield the block which will be evaluated in the context of this object in order to create an Cypher Query string
+    # @yieldreturn [Return, Object] If the return is not an instance of Return it will be converted it to a Return object (if possible).
+    # @see Neo4j::Core::Cypher
+    def initialize(*args, &dsl_block)
+      @expressions = []
+      @variables = []
+      to_dsl_args = args.map do |a|
+        case
+          when a.is_a?(Array) && a.first.respond_to?(:_java_node)
+            StartNode.new(a, @expressions)
+          when a.is_a?(Array) && a.first.respond_to?(:_java_rel)
+            StartRel.new(a, @expressions)
+          when a.respond_to?(:_java_node)
+            StartNode.new([a], @expressions)
+          when a.respond_to?(:_java_rel)
+            StartRel.new([a], @expressions)
+          else
+            a
+        end
+      end
+      res = self.instance_exec(*to_dsl_args, &dsl_block)
+      unless res.kind_of?(Return)
+        res.respond_to?(:to_a) ? ret(*res) : ret(res)
+      end
+    end
+
+    # Does nothing, just for making the DSL easier to read (maybe).
+    # @return self
+    def match(*)
+      self
+    end
+
+    # Does nothing, just for making the DSL easier to read (maybe)
+    # @return self
+    def start(*)
+      self
+    end
+
+    def where(w=nil)
+      Where.new(@expressions, w) if w.is_a?(String)
+      self
+    end
+
+    # Specifies a start node by performing a lucene query.
+    # @param [Class] index_class a class responsible for an index
+    # @param [String] q the lucene query
+    # @param [Symbol] index_type the type of index
+    # @return [NodeQuery]
+    def query(index_class, q, index_type = :exact)
+      NodeQuery.new(index_class, q, index_type, @expressions)
+    end
+
+    # Specifies a start node by performing a lucene query.
+    # @param [Class] index_class a class responsible for an index
+    # @param [String, Symbol] key the key we ask for
+    # @param [String, Symbol] value the value of the key we ask for
+    # @return [NodeLookup]
+    def lookup(index_class, key, value)
+      NodeLookup.new(index_class, key, value, @expressions)
+    end
+
+    # Creates a node variable.
+    # It will create different variables depending on the type of the first element in the nodes argument.
+    # * Fixnum - it will be be used as neo_id  for start node(s) (StartNode)
+    # * Symbol - it will create an unbound node variable with the same name as the symbol (NodeVar#as)
+    # * empty array - it will create an unbound node variable (NodeVar)
+    #
+    # @param [Fixnum,Symbol,String] nodes the id of the nodes we want to start from
+    # @return [StartNode, NodeVar]
+    def node(*nodes)
+      if nodes.first.is_a?(Symbol)
+        NodeVar.new(@expressions, @variables).as(nodes.first)
+      elsif !nodes.empty?
+        StartNode.new(nodes, @expressions)
+      else
+        NodeVar.new(@expressions, @variables)
+      end
+    end
+
+    # Similar to #node
+    # @return [StartRel, RelVar]
+    def rel(*rels)
+      if rels.first.is_a?(Fixnum) || rels.first.respond_to?(:neo_id)
+        StartRel.new(rels, @expressions)
+      elsif rels.first.is_a?(Symbol)
+        RelVar.new(@expressions, @variables, ":`#{rels.first}`").as(rels.first)
+      elsif rels.first.is_a?(String)
+        RelVar.new(@expressions, @variables, rels.first)
+      else
+        raise "Unknown arg #{rels.inspect}"
+      end
+    end
+
+    # Specifies a return statement.
+    # Notice that this is not needed, since the last value of the DSL block will be converted into one or more
+    # return statements.
+    # @param [Symbol, #var_name] returns a list of variables we want to return
+    # @return [Return]
+    def ret(*returns)
+      options = returns.last.is_a?(Hash) ? returns.pop : {}
+      @expressions -= @expressions.find_all { |r| r.clause == :return && returns.include?(r) }
+      returns.each { |ret| Return.new(ret, @expressions, options) unless ret.respond_to?(:clause) && [:order_by, :skip, :limit].include?(ret.clause)}
+      @expressions.last
+    end
+
+    def shortest_path(&block)
+      match = instance_eval(&block)
+      match.algorithm = 'shortestPath'
+      match.find_match_start
+    end
+
+    def shortest_paths(&block)
+      match = instance_eval(&block)
+      match.algorithm = 'allShortestPaths'
+      match.find_match_start
+    end
+
+    # @param [Symbol,nil] variable the entity we want to count or wildcard (*)
+    # @return [Return] a counter return clause
+    def count(variable='*')
+      Return.new("count(#{variable.to_s})", @expressions)
+    end
+
+    def coalesce(*args)
+      s = args.map { |x| x.var_name }.join(", ")
+      Return.new("coalesce(#{s})", @expressions)
+    end
+
+    def nodes(*args)
+      s = args.map { |x| x.referenced!; x.var_name }.join(", ")
+      Return.new("nodes(#{s})", @expressions)
+    end
+
+    def rels(*args)
+      s = args.map { |x| x.referenced!; x.var_name }.join(", ")
+      Return.new("relationships(#{s})", @expressions)
+    end
+
+    # Converts the DSL query to a cypher String which can be executed by cypher query engine.
+    def to_s
+      clause = nil
+      @expressions.map do |expr|
+        next unless expr.valid?
+        expr_to_s = expr.clause != clause ? "#{expr.prefix} #{expr.to_s}" : "#{expr.separator}#{expr.to_s}"
+        clause = expr.clause
+        expr_to_s
+      end.join
+    end
+
+  end
+end