neography 0.0.1 → 0.0.2

data/README.rdoc

@@ -1,9 +1,10 @@
 == Welcome to Neography
 
-Neography is a thin ruby wrapper to the Neo4j Rest API, for more information:
+Neography is a thin Ruby wrapper to the Neo4j Rest API, for more information:
 * {Getting Started with Neo4j Server}[http://wiki.neo4j.org/content/Getting_Started_with_Neo4j_Server]
 * {Neo4j Rest API Reference}[http://components.neo4j.org/neo4j-rest/]
 
+If you want to the full power of Neo4j, you will want to use JRuby and the excellent Neo4j.rb gem at https://github.com/andreasronge/neo4j
 
 === Installation
 
@@ -78,17 +79,42 @@ To Use:
   @neo.get_path(from, to, relationships, depth=4, algorithm="shortestPath") # finds the shortest path between two nodes 
   @neo.get_paths(from, to, relationships, depth=3, algorithm="allPaths")    # finds all paths between two nodes
 
+  nodes = @neo.traverse(id,                                                 # the id of the node where the traversal starts
+                        "nodes",                                            # return_type (can be "nodes", "relationships" or "paths"
+                        {"order" => "breadth first",                        # "breadth first" or "depth first" traversal order
+                         "uniqueness" => "node global",                     # See Uniqueness in API documentation for options.
+                         "relationships" => [{"type"=> "roommates",         # A hash containg a description of the traversal
+                                              "direction" => "all"},        # two relationships. 
+                                             {"type"=> "friends",           # 
+                                              "direction" => "out"}],       # 
+                         "prune evaluator" => {"language" => "javascript",  # A prune evaluator (when to stop traversing)
+                                               "body" => "position.endNode().getProperty('age') < 21;"
+                         "return filter" => {"language" => "builtin",       # "all" or "all but start node"
+                                             "name" => "all"},
+                         "depth" => 4})  
+
+  # "depth" is a short-hand way of specifying a prune evaluator which prunes after a certain depth. 
+  # If not specified a depth of 1 is used and if a "prune evaluator" is specified instead of a depth, no depth limit is set.
+
+Please see the specs for more examples.
+
+See Neo4j API for:
+* {Order}[http://components.neo4j.org/neo4j-examples/1.2.M04/apidocs/org/neo4j/graphdb/Traverser.Order.html]
+* {Uniqueness}[http://components.neo4j.org/neo4j-examples/1.2.M04/apidocs/org/neo4j/kernel/Uniqueness.html]
+* {Prune Evaluator}[http://components.neo4j.org/neo4j-examples/1.2.M04/apidocs/org/neo4j/graphdb/StopEvaluator.html]
+* {Return Filter}[http://components.neo4j.org/neo4j-examples/1.2.M04/apidocs/org/neo4j/graphdb/ReturnableEvaluator.html]
+
 === To Do
 
-Path tests
-Traverse tests
-@neo.traverse()
-examples
+* More tests
+* examples
+* batch import with typhoeus ?
+* create proper objects for Node and Relationship
 
 === License
 
 * Neography - MIT, see the LICENSE file http://github.com/maxdemarzi/neography/tree/master/LICENSE.
 * Lucene -  Apache, see http://lucene.apache.org/java/docs/features.html
-* Neo4j - Dual free software/commercial license, see http://neo4j.org/
+* Neo4j - Dual free software/commercial license, see http://neo4j.org
 
 

data/lib/neography/rest.rb

@@ -161,6 +161,16 @@ module Neography
         index
       end
 
+      def traverse(id, return_type, description)
+        options = { :body => {"order" => get_order(description["order"]), 
+                              "uniqueness" => get_uniqueness(description["uniqueness"]), 
+                              "relationships" => description["relationships"], 
+                              "prune evaluator" => description["prune evaluator"], 
+                              "return filter" => description["return filter"], 
+                              "max depth" => get_depth(description["depth"]), }.to_json, :headers => {'Content-Type' => 'application/json'} } 
+        traversal = post("/node/#{id}/traverse/#{get_type(return_type)}", options) || Array.new
+      end
+
       def get_path(from, to, relationships, depth=1, algorithm="shortestPath")
         options = { :body => {"to" => self.configuration + "/node/#{to}", "relationships" => relationships, "max depth" => depth, "algorithm" => get_algorithm(algorithm) }.to_json, :headers => {'Content-Type' => 'application/json'} } 
         path = post("/node/#{from}/path", options) || Hash.new
@@ -237,5 +247,49 @@ module Neography
         end
       end
 
+      def get_order(order)
+        case order
+          when :breadth, "breadth", "breadth first", "breadthFirst", :wide, "wide"
+            "breadth first"
+          else
+            "depth first"
+        end
+      end
+
+      def get_type(type)
+        case type
+          when :node, "nodes", :nodes, "nodes"
+            "node"
+          when :relationship, "relationship", :relationships, "relationships"
+            "relationship"
+          else
+            "path"
+        end
+      end
+
+      def get_uniqueness(uniqueness)
+        case uniqueness
+          when :nodeglobal, "node global", "nodeglobal", "node_global"
+            "node global"
+          when :nodepath, "node path", "nodepath", "node_path"
+            "node path"
+          when :noderecent, "node recent", "noderecent", "node_recent"
+            "node recent"
+          when :relationshipglobal, "relationship global", "relationshipglobal", "relationship_global"
+            "relationship global"
+          when :relationshippath, "relationship path", "relationshippath", "relationship_path"
+            "relationship path"
+          when :relationshiprecent, "relationship recent", "relationshiprecent", "relationship_recent"
+            "relationship recent"
+          else
+            "none"
+        end
+      end
+
+      def get_depth(depth)
+        return 1 if depth.to_i == 0
+        depth.to_i
+      end
+
   end
 end

data/lib/neography/version.rb

@@ -1,3 +1,3 @@
 module Neography
-  VERSION = "0.0.1"
+  VERSION = "0.0.2"
 end

data/spec/integration/rest_path_spec.rb

@@ -19,41 +19,235 @@ describe Neography::Rest do
     end
 
     it "can get the shortest path between two nodes" do
-      pending
+      new_node1 = @neo.create_node
+      new_node1[:id] = new_node1["self"].split('/').last
+      new_node2 = @neo.create_node
+      new_node2[:id] = new_node2["self"].split('/').last
+      new_node3 = @neo.create_node
+      new_node3[:id] = new_node3["self"].split('/').last
+      new_node4 = @neo.create_node
+      new_node4[:id] = new_node4["self"].split('/').last
+      new_node5 = @neo.create_node
+      new_node5[:id] = new_node5["self"].split('/').last
+      @neo.create_relationship("friends", new_node1[:id], new_node2[:id])
+      @neo.create_relationship("friends", new_node2[:id], new_node3[:id])
+      @neo.create_relationship("friends", new_node3[:id], new_node4[:id])
+      @neo.create_relationship("friends", new_node4[:id], new_node5[:id])
+      @neo.create_relationship("friends", new_node3[:id], new_node5[:id])
+      path = @neo.get_path(new_node1[:id], new_node5[:id], {"type"=> "friends", "direction" => "out"}, depth=3, algorithm="shortestPath")
+      path["start"].should == new_node1["self"]
+      path["end"].should == new_node5["self"]
+      path["nodes"].should == [new_node1["self"], new_node2["self"], new_node3["self"], new_node5["self"]]
     end
 
     it "can get a simple path between two nodes" do
-      pending
+      new_node1 = @neo.create_node
+      new_node1[:id] = new_node1["self"].split('/').last
+      new_node2 = @neo.create_node
+      new_node2[:id] = new_node2["self"].split('/').last
+      new_node3 = @neo.create_node
+      new_node3[:id] = new_node3["self"].split('/').last
+      new_node4 = @neo.create_node
+      new_node4[:id] = new_node4["self"].split('/').last
+      new_node5 = @neo.create_node
+      new_node5[:id] = new_node5["self"].split('/').last
+      @neo.create_relationship("friends", new_node1[:id], new_node2[:id])
+      @neo.create_relationship("friends", new_node2[:id], new_node3[:id])
+      @neo.create_relationship("friends", new_node3[:id], new_node4[:id])
+      @neo.create_relationship("friends", new_node4[:id], new_node5[:id])
+      @neo.create_relationship("friends", new_node3[:id], new_node5[:id])
+      path = @neo.get_path(new_node1[:id], new_node5[:id], {"type"=> "friends", "direction" => "out"}, depth=3, algorithm="simplePaths")
+      path["start"].should == new_node1["self"]
+      path["end"].should == new_node5["self"]
+      path["nodes"].should == [new_node1["self"], new_node2["self"], new_node3["self"], new_node5["self"]]
     end
 
-    it "can get a path between two nodes of max depth 3" do
-      pending
+    it "fails to get a path between two nodes 3 nodes apart when using max depth of 2" do
+      new_node1 = @neo.create_node
+      new_node1[:id] = new_node1["self"].split('/').last
+      new_node2 = @neo.create_node
+      new_node2[:id] = new_node2["self"].split('/').last
+      new_node3 = @neo.create_node
+      new_node3[:id] = new_node3["self"].split('/').last
+      new_node4 = @neo.create_node
+      new_node4[:id] = new_node4["self"].split('/').last
+      new_node5 = @neo.create_node
+      new_node5[:id] = new_node5["self"].split('/').last
+      @neo.create_relationship("friends", new_node1[:id], new_node2[:id])
+      @neo.create_relationship("friends", new_node2[:id], new_node3[:id])
+      @neo.create_relationship("friends", new_node3[:id], new_node4[:id])
+      @neo.create_relationship("friends", new_node4[:id], new_node5[:id])
+      @neo.create_relationship("friends", new_node3[:id], new_node5[:id])
+      path = @neo.get_path(new_node1[:id], new_node5[:id], {"type"=> "friends", "direction" => "out"}, depth=2, algorithm="shortestPath")
+      path["start"].should be_nil
+      path["end"].should be_nil
     end
 
     it "can get a path between two nodes of a specific relationship" do
-      pending
+      new_node1 = @neo.create_node
+      new_node1[:id] = new_node1["self"].split('/').last
+      new_node2 = @neo.create_node
+      new_node2[:id] = new_node2["self"].split('/').last
+      new_node3 = @neo.create_node
+      new_node3[:id] = new_node3["self"].split('/').last
+      new_node4 = @neo.create_node
+      new_node4[:id] = new_node4["self"].split('/').last
+      new_node5 = @neo.create_node
+      new_node5[:id] = new_node5["self"].split('/').last
+      @neo.create_relationship("classmates", new_node1[:id], new_node2[:id])
+      @neo.create_relationship("classmates", new_node2[:id], new_node5[:id])
+      @neo.create_relationship("friends", new_node1[:id], new_node2[:id])
+      @neo.create_relationship("friends", new_node2[:id], new_node3[:id])
+      @neo.create_relationship("friends", new_node3[:id], new_node4[:id])
+      @neo.create_relationship("friends", new_node4[:id], new_node5[:id])
+      path = @neo.get_path(new_node1[:id], new_node5[:id], {"type"=> "friends", "direction" => "out"}, depth=4, algorithm="shortestPath")
+      path["start"].should == new_node1["self"]
+      path["end"].should == new_node5["self"]
+      path["nodes"].should == [new_node1["self"], new_node2["self"], new_node3["self"], new_node4["self"], new_node5["self"]]
     end
   end
 
   describe "get paths" do
     it "can get the shortest paths between two nodes" do
-      pending
+      new_node1 = @neo.create_node
+      new_node1[:id] = new_node1["self"].split('/').last
+      new_node2 = @neo.create_node
+      new_node2[:id] = new_node2["self"].split('/').last
+      new_node3 = @neo.create_node
+      new_node3[:id] = new_node3["self"].split('/').last
+      new_node4 = @neo.create_node
+      new_node4[:id] = new_node4["self"].split('/').last
+      new_node5 = @neo.create_node
+      new_node5[:id] = new_node5["self"].split('/').last
+      @neo.create_relationship("friends", new_node1[:id], new_node2[:id])
+      @neo.create_relationship("friends", new_node2[:id], new_node5[:id])
+      @neo.create_relationship("friends", new_node1[:id], new_node3[:id])
+      @neo.create_relationship("friends", new_node3[:id], new_node4[:id])
+      @neo.create_relationship("friends", new_node4[:id], new_node5[:id])
+      @neo.create_relationship("friends", new_node3[:id], new_node5[:id])
+      paths = @neo.get_paths(new_node1[:id], new_node5[:id], {"type"=> "friends", "direction" => "out"}, depth=4, algorithm="shortestPath")
+      paths.length.should == 2
+      paths[0]["length"].should == 2
+      paths[0]["start"].should == new_node1["self"]
+      paths[0]["end"].should == new_node5["self"]
+      paths[1]["length"].should == 2
+      paths[1]["start"].should == new_node1["self"]
+      paths[1]["end"].should == new_node5["self"]
     end
 
     it "can get all paths between two nodes" do
-      pending
+      new_node1 = @neo.create_node
+      new_node1[:id] = new_node1["self"].split('/').last
+      new_node2 = @neo.create_node
+      new_node2[:id] = new_node2["self"].split('/').last
+      new_node3 = @neo.create_node
+      new_node3[:id] = new_node3["self"].split('/').last
+      new_node4 = @neo.create_node
+      new_node4[:id] = new_node4["self"].split('/').last
+      new_node5 = @neo.create_node
+      new_node5[:id] = new_node5["self"].split('/').last
+      @neo.create_relationship("friends", new_node1[:id], new_node2[:id])
+      @neo.create_relationship("friends", new_node2[:id], new_node5[:id])
+      @neo.create_relationship("friends", new_node1[:id], new_node3[:id])
+      @neo.create_relationship("friends", new_node3[:id], new_node4[:id])
+      @neo.create_relationship("friends", new_node4[:id], new_node5[:id])
+      @neo.create_relationship("friends", new_node3[:id], new_node5[:id])
+      paths = @neo.get_paths(new_node1[:id], new_node5[:id], {"type"=> "friends", "direction" => "out"}, depth=4, algorithm="allPaths")
+      paths.length.should == 3
+      paths[0]["length"].should == 2
+      paths[0]["start"].should == new_node1["self"]
+      paths[0]["end"].should == new_node5["self"]
+      paths[1]["length"].should == 3
+      paths[1]["start"].should == new_node1["self"]
+      paths[1]["end"].should == new_node5["self"]
+      paths[2]["length"].should == 2
+      paths[2]["start"].should == new_node1["self"]
+      paths[2]["end"].should == new_node5["self"]
     end
 
     it "can get all simple paths between two nodes" do
-      pending
+      new_node1 = @neo.create_node
+      new_node1[:id] = new_node1["self"].split('/').last
+      new_node2 = @neo.create_node
+      new_node2[:id] = new_node2["self"].split('/').last
+      new_node3 = @neo.create_node
+      new_node3[:id] = new_node3["self"].split('/').last
+      new_node4 = @neo.create_node
+      new_node4[:id] = new_node4["self"].split('/').last
+      new_node5 = @neo.create_node
+      new_node5[:id] = new_node5["self"].split('/').last
+      @neo.create_relationship("friends", new_node1[:id], new_node2[:id])
+      @neo.create_relationship("friends", new_node2[:id], new_node1[:id])
+      @neo.create_relationship("friends", new_node2[:id], new_node5[:id])
+      @neo.create_relationship("friends", new_node1[:id], new_node3[:id])
+      @neo.create_relationship("friends", new_node3[:id], new_node4[:id])
+      @neo.create_relationship("friends", new_node4[:id], new_node5[:id])
+      @neo.create_relationship("friends", new_node3[:id], new_node5[:id])
+      paths = @neo.get_paths(new_node1[:id], new_node5[:id], {"type"=> "friends", "direction" => "out"}, depth=4, algorithm="allSimplePaths")
+      paths.length.should == 3
+      paths[0]["length"].should == 2
+      paths[0]["start"].should == new_node1["self"]
+      paths[0]["end"].should == new_node5["self"]
+      paths[1]["length"].should == 3
+      paths[1]["start"].should == new_node1["self"]
+      paths[1]["end"].should == new_node5["self"]
+      paths[2]["length"].should == 2
+      paths[2]["start"].should == new_node1["self"]
+      paths[2]["end"].should == new_node5["self"]
     end
 
-    it "can get paths between two nodes of max depth 3" do
-      pending
-    end
+    it "can get paths between two nodes of max depth 2" do
+      new_node1 = @neo.create_node
+      new_node1[:id] = new_node1["self"].split('/').last
+      new_node2 = @neo.create_node
+      new_node2[:id] = new_node2["self"].split('/').last
+      new_node3 = @neo.create_node
+      new_node3[:id] = new_node3["self"].split('/').last
+      new_node4 = @neo.create_node
+      new_node4[:id] = new_node4["self"].split('/').last
+      new_node5 = @neo.create_node
+      new_node5[:id] = new_node5["self"].split('/').last
+      @neo.create_relationship("friends", new_node1[:id], new_node2[:id])
+      @neo.create_relationship("friends", new_node2[:id], new_node5[:id])
+      @neo.create_relationship("friends", new_node1[:id], new_node3[:id])
+      @neo.create_relationship("friends", new_node3[:id], new_node4[:id])
+      @neo.create_relationship("friends", new_node4[:id], new_node5[:id])
+      @neo.create_relationship("friends", new_node3[:id], new_node5[:id])
+      paths = @neo.get_paths(new_node1[:id], new_node5[:id], {"type"=> "friends", "direction" => "out"}, depth=2, algorithm="allPaths")
+      paths.length.should == 2
+      paths[0]["length"].should == 2
+      paths[0]["start"].should == new_node1["self"]
+      paths[0]["end"].should == new_node5["self"]
+      paths[1]["length"].should == 2
+      paths[1]["start"].should == new_node1["self"]
+      paths[1]["end"].should == new_node5["self"]    end
 
     it "can get paths between two nodes of a specific relationship" do
-      pending
+      new_node1 = @neo.create_node
+      new_node1[:id] = new_node1["self"].split('/').last
+      new_node2 = @neo.create_node
+      new_node2[:id] = new_node2["self"].split('/').last
+      new_node3 = @neo.create_node
+      new_node3[:id] = new_node3["self"].split('/').last
+      new_node4 = @neo.create_node
+      new_node4[:id] = new_node4["self"].split('/').last
+      new_node5 = @neo.create_node
+      new_node5[:id] = new_node5["self"].split('/').last
+      @neo.create_relationship("classmates", new_node1[:id], new_node2[:id])
+      @neo.create_relationship("classmates", new_node2[:id], new_node5[:id])
+      @neo.create_relationship("friends", new_node1[:id], new_node2[:id])
+      @neo.create_relationship("friends", new_node2[:id], new_node3[:id])
+      @neo.create_relationship("friends", new_node3[:id], new_node4[:id])
+      @neo.create_relationship("friends", new_node4[:id], new_node5[:id])
+      @neo.create_relationship("classmates", new_node1[:id], new_node3[:id])
+      @neo.create_relationship("classmates", new_node3[:id], new_node5[:id])
+      paths = @neo.get_paths(new_node1[:id], new_node5[:id], {"type"=> "classmates", "direction" => "out"}, depth=4, algorithm="allPaths")
+      paths[0]["length"].should == 2
+      paths[0]["start"].should == new_node1["self"]
+      paths[0]["end"].should == new_node5["self"]
+      paths[1]["length"].should == 2
+      paths[1]["start"].should == new_node1["self"]
+      paths[1]["end"].should == new_node5["self"]    
     end
 
   end

data/spec/integration/rest_traverse_spec.rb

@@ -0,0 +1,230 @@
+require File.join(File.dirname(__FILE__), '..', 'spec_helper')
+
+describe Neography::Rest do
+  before(:each) do
+    @neo = Neography::Rest.new
+  end
+
+  describe "traverse" do
+    it "can traverse the graph and return nodes" do
+      new_node1 = @neo.create_node
+      new_node1[:id] = new_node1["self"].split('/').last
+      new_node2 = @neo.create_node
+      new_node2[:id] = new_node2["self"].split('/').last
+      new_node3 = @neo.create_node
+      new_node3[:id] = new_node3["self"].split('/').last
+      new_node4 = @neo.create_node
+      new_node4[:id] = new_node4["self"].split('/').last
+      new_node5 = @neo.create_node
+      new_node5[:id] = new_node5["self"].split('/').last
+      @neo.create_relationship("friends", new_node1[:id], new_node2[:id])
+      @neo.create_relationship("friends", new_node2[:id], new_node3[:id])
+      @neo.create_relationship("friends", new_node3[:id], new_node4[:id])
+      @neo.create_relationship("friends", new_node4[:id], new_node5[:id])
+      @neo.create_relationship("friends", new_node3[:id], new_node5[:id])
+      nodes = @neo.traverse(new_node1[:id], "nodes", {"relationships" => {"type"=> "friends", "direction" => "out"}, "depth" => 4} )
+      nodes.should_not be_nil
+      nodes[0]["self"].should == new_node2["self"]
+      nodes[1]["self"].should == new_node3["self"]
+      nodes[2]["self"].should == new_node4["self"]
+      nodes[3]["self"].should == new_node5["self"]
+    end
+
+    it "can traverse the graph and return relationships" do
+      new_node1 = @neo.create_node
+      new_node1[:id] = new_node1["self"].split('/').last
+      new_node2 = @neo.create_node
+      new_node2[:id] = new_node2["self"].split('/').last
+      new_node3 = @neo.create_node
+      new_node3[:id] = new_node3["self"].split('/').last
+      new_node4 = @neo.create_node
+      new_node4[:id] = new_node4["self"].split('/').last
+      new_node5 = @neo.create_node
+      new_node5[:id] = new_node5["self"].split('/').last
+
+      new_relationship1= @neo.create_relationship("friends", new_node1[:id], new_node2[:id])
+      new_relationship2= @neo.create_relationship("friends", new_node2[:id], new_node3[:id])
+      new_relationship3= @neo.create_relationship("friends", new_node3[:id], new_node4[:id])
+      new_relationship4= @neo.create_relationship("friends", new_node4[:id], new_node5[:id])
+      new_relationship5= @neo.create_relationship("friends", new_node3[:id], new_node5[:id])
+
+      relationships = @neo.traverse(new_node1[:id], "relationships", {"relationships" => {"type"=> "friends", "direction" => "out"}, "depth" => 4} )
+      relationships.should_not be_nil
+
+      relationships[0]["self"].should == new_relationship1["self"]
+      relationships[1]["self"].should == new_relationship2["self"]
+      relationships[2]["self"].should == new_relationship3["self"]
+      relationships[3]["self"].should == new_relationship4["self"]
+    end
+
+    it "can traverse the graph and return paths" do
+      new_node1 = @neo.create_node
+      new_node1[:id] = new_node1["self"].split('/').last
+      new_node2 = @neo.create_node
+      new_node2[:id] = new_node2["self"].split('/').last
+      new_node3 = @neo.create_node
+      new_node3[:id] = new_node3["self"].split('/').last
+      new_node4 = @neo.create_node
+      new_node4[:id] = new_node4["self"].split('/').last
+      new_node5 = @neo.create_node
+      new_node5[:id] = new_node5["self"].split('/').last
+
+      new_relationship1= @neo.create_relationship("friends", new_node1[:id], new_node2[:id])
+      new_relationship2= @neo.create_relationship("friends", new_node2[:id], new_node3[:id])
+      new_relationship3= @neo.create_relationship("friends", new_node3[:id], new_node4[:id])
+      new_relationship4= @neo.create_relationship("friends", new_node4[:id], new_node5[:id])
+      new_relationship5= @neo.create_relationship("friends", new_node3[:id], new_node5[:id])
+
+      paths = @neo.traverse(new_node1[:id], "paths", {"relationships" => {"type"=> "friends", "direction" => "out"}, "depth" => 4} )
+      paths.should_not be_nil
+  
+      paths[0]["nodes"].should == [new_node1["self"], new_node2["self"]]
+      paths[1]["nodes"].should == [new_node1["self"], new_node2["self"], new_node3["self"]]
+      paths[2]["nodes"].should == [new_node1["self"], new_node2["self"], new_node3["self"], new_node4["self"]]
+      paths[3]["nodes"].should == [new_node1["self"], new_node2["self"], new_node3["self"], new_node4["self"], new_node5["self"]]
+    end
+
+    it "can traverse the graph up to a certain depth" do
+      new_node1 = @neo.create_node
+      new_node1[:id] = new_node1["self"].split('/').last
+      new_node2 = @neo.create_node
+      new_node2[:id] = new_node2["self"].split('/').last
+      new_node3 = @neo.create_node
+      new_node3[:id] = new_node3["self"].split('/').last
+      new_node4 = @neo.create_node
+      new_node4[:id] = new_node4["self"].split('/').last
+      new_node5 = @neo.create_node
+      new_node5[:id] = new_node5["self"].split('/').last
+
+      new_relationship1= @neo.create_relationship("friends", new_node1[:id], new_node2[:id])
+      new_relationship2= @neo.create_relationship("friends", new_node2[:id], new_node3[:id])
+      new_relationship3= @neo.create_relationship("friends", new_node3[:id], new_node4[:id])
+      new_relationship4= @neo.create_relationship("friends", new_node4[:id], new_node5[:id])
+      new_relationship5= @neo.create_relationship("friends", new_node3[:id], new_node5[:id])
+
+      paths = @neo.traverse(new_node1[:id], "paths", {"relationships" => {"type"=> "friends", "direction" => "out"}, "depth" => 3} )
+      paths.should_not be_nil
+
+      paths[0]["nodes"].should == [new_node1["self"], new_node2["self"]]
+      paths[1]["nodes"].should == [new_node1["self"], new_node2["self"], new_node3["self"]]
+      paths[2]["nodes"].should == [new_node1["self"], new_node2["self"], new_node3["self"], new_node4["self"]]
+      paths[3]["nodes"].should == [new_node1["self"], new_node2["self"], new_node3["self"], new_node5["self"]]
+    end
+
+    it "can traverse the graph in a certain order" do
+      new_node1 = @neo.create_node
+      new_node1[:id] = new_node1["self"].split('/').last
+      new_node2 = @neo.create_node
+      new_node2[:id] = new_node2["self"].split('/').last
+      new_node3 = @neo.create_node
+      new_node3[:id] = new_node3["self"].split('/').last
+      new_node4 = @neo.create_node
+      new_node4[:id] = new_node4["self"].split('/').last
+      new_node5 = @neo.create_node
+      new_node5[:id] = new_node5["self"].split('/').last
+
+      new_relationship1= @neo.create_relationship("friends", new_node1[:id], new_node2[:id])
+      new_relationship2= @neo.create_relationship("friends", new_node2[:id], new_node3[:id])
+      new_relationship3= @neo.create_relationship("friends", new_node3[:id], new_node4[:id])
+      new_relationship4= @neo.create_relationship("friends", new_node4[:id], new_node5[:id])
+      new_relationship5= @neo.create_relationship("friends", new_node3[:id], new_node5[:id])
+
+      paths = @neo.traverse(new_node1[:id], "paths", {"order" => "breadth first", "relationships" => {"type"=> "friends", "direction" => "out"}, "depth" => 4} )
+      paths.should_not be_nil
+    
+      paths[0]["nodes"].should == [new_node1["self"], new_node2["self"]]
+      paths[1]["nodes"].should == [new_node1["self"], new_node2["self"], new_node3["self"]]
+      paths[2]["nodes"].should == [new_node1["self"], new_node2["self"], new_node3["self"], new_node4["self"]]
+      paths[3]["nodes"].should == [new_node1["self"], new_node2["self"], new_node3["self"], new_node5["self"]]
+    end
+
+    it "can traverse the graph with a specific uniqueness" do
+      new_node1 = @neo.create_node
+      new_node1[:id] = new_node1["self"].split('/').last
+      new_node2 = @neo.create_node
+      new_node2[:id] = new_node2["self"].split('/').last
+      new_node3 = @neo.create_node
+      new_node3[:id] = new_node3["self"].split('/').last
+      new_node4 = @neo.create_node
+      new_node4[:id] = new_node4["self"].split('/').last
+      new_node5 = @neo.create_node
+      new_node5[:id] = new_node5["self"].split('/').last
+
+      new_relationship1= @neo.create_relationship("roommates", new_node1[:id], new_node2[:id])
+      new_relationship2= @neo.create_relationship("roommates", new_node2[:id], new_node3[:id])
+      new_relationship1= @neo.create_relationship("friends", new_node3[:id], new_node2[:id])
+      new_relationship2= @neo.create_relationship("friends", new_node2[:id], new_node5[:id])
+      new_relationship3= @neo.create_relationship("friends", new_node3[:id], new_node4[:id])
+      new_relationship4= @neo.create_relationship("friends", new_node4[:id], new_node5[:id])
+      new_relationship5= @neo.create_relationship("friends", new_node3[:id], new_node5[:id])
+
+      paths = @neo.traverse(new_node1[:id], "paths", {"order" => "breadth first", "uniqueness" => "node global", "relationships" => [{"type"=> "roommates", "direction" => "all"},{"type"=> "friends", "direction" => "out"}], "depth" => 4} )
+      paths.should_not be_nil
+    
+      paths[0]["nodes"].should == [new_node1["self"], new_node2["self"]]
+      paths[1]["nodes"].should == [new_node1["self"], new_node2["self"], new_node3["self"]]
+      paths[2]["nodes"].should == [new_node1["self"], new_node2["self"], new_node5["self"]]
+      paths[3]["nodes"].should == [new_node1["self"], new_node2["self"], new_node3["self"], new_node4["self"]]
+    end
+
+    it "can traverse the graph with a prune evaluator" do
+      new_node1 = @neo.create_node("age" => 31, "name" => "Max")
+      new_node1[:id] = new_node1["self"].split('/').last
+      new_node2 = @neo.create_node("age" => 30, "name" => "Helene")
+      new_node2[:id] = new_node2["self"].split('/').last
+      new_node3 = @neo.create_node("age" => 17, "name" => "Alex")
+      new_node3[:id] = new_node3["self"].split('/').last
+      new_node4 = @neo.create_node("age" => 24, "name" => "Eric")
+      new_node4[:id] = new_node4["self"].split('/').last
+      new_node5 = @neo.create_node("age" => 32, "name" => "Leslie")
+      new_node5[:id] = new_node5["self"].split('/').last
+
+      new_relationship1= @neo.create_relationship("friends", new_node1[:id], new_node2[:id])
+      new_relationship2= @neo.create_relationship("friends", new_node2[:id], new_node3[:id])
+      new_relationship3= @neo.create_relationship("friends", new_node3[:id], new_node4[:id])
+      new_relationship4= @neo.create_relationship("friends", new_node4[:id], new_node5[:id])
+      new_relationship5= @neo.create_relationship("friends", new_node3[:id], new_node5[:id])
+
+      paths = @neo.traverse(new_node1[:id],
+                            "paths",
+                            {"relationships" => {"type"=> "friends", "direction" => "out"}, 
+                             "depth" => 3,
+                             "prune evaluator" => {"language" => "javascript",  "body" => "position.endNode().getProperty('age') < 21;"
+                              }} )
+      paths.should_not be_nil
+      paths[0]["nodes"].should == [new_node1["self"], new_node2["self"]]
+      paths[1]["nodes"].should == [new_node1["self"], new_node2["self"], new_node3["self"]]
+      paths[2].should be_nil
+    end
+
+    it "can traverse the graph with a return filter" do
+      new_node1 = @neo.create_node
+      new_node1[:id] = new_node1["self"].split('/').last
+      new_node2 = @neo.create_node
+      new_node2[:id] = new_node2["self"].split('/').last
+      new_node3 = @neo.create_node
+      new_node3[:id] = new_node3["self"].split('/').last
+      new_node4 = @neo.create_node
+      new_node4[:id] = new_node4["self"].split('/').last
+      new_node5 = @neo.create_node
+      new_node5[:id] = new_node5["self"].split('/').last
+      @neo.create_relationship("friends", new_node1[:id], new_node2[:id])
+      @neo.create_relationship("friends", new_node2[:id], new_node3[:id])
+      @neo.create_relationship("friends", new_node3[:id], new_node4[:id])
+      @neo.create_relationship("friends", new_node4[:id], new_node5[:id])
+      @neo.create_relationship("friends", new_node3[:id], new_node5[:id])
+      nodes = @neo.traverse(new_node1[:id], "nodes", {"relationships" => {"type"=> "friends", "direction" => "out"}, 
+                                                      "return filter" => {"language" => "builtin", "name" => "all"},
+                                                      "depth" => 4} )
+      nodes.should_not be_nil
+      nodes[0]["self"].should == new_node1["self"]
+      nodes[1]["self"].should == new_node2["self"]
+      nodes[2]["self"].should == new_node3["self"]
+      nodes[3]["self"].should == new_node4["self"]
+      nodes[4]["self"].should == new_node5["self"]
+    end
+
+
+  end
+
+end

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
     - 0
     - 0
-    - 1
-  version: 0.0.1
+    - 2
+  version: 0.0.2
 platform: ruby
 authors: 
   - Max De Marzi
@@ -108,7 +108,6 @@ files:
   - README.rdoc
   - Rakefile
   - lib/neography.rb
-  - lib/neography/config.rb
   - lib/neography/rest.rb
   - lib/neography/version.rb
   - neography.gemspec
@@ -116,6 +115,7 @@ files:
   - spec/integration/rest_node_spec.rb
   - spec/integration/rest_path_spec.rb
   - spec/integration/rest_relationship_spec.rb
+  - spec/integration/rest_traverse_spec.rb
   - spec/spec_helper.rb
   - spec/support/fake_root_spec.rb
 has_rdoc: true

data/lib/neography/config.rb

@@ -1,152 +0,0 @@
-module Neography
-
-  # == Keeps configuration for neography
-  #
-  # The most important configuration options are <tt>Neograophy::Config[:server]</tt> and <tt>Neograophy::Config[:port]</tt> which are
-  # used to locate where the neo4j database and is stored on the network.
-  # If these options are not supplied then the default of localhost:9999 will be used.
-  #
-  # ==== Default Configurations
-  # <tt>:protocol</tt>:: default <tt>http://</tt> protocol to use (can be https://)
-  # <tt>:server</tt>::   default <tt>localhost</tt> where the database is stored on the network
-  # <tt>:port</tt>::     default <tt>7474</tt> what port is listening
-  #
-  class Config
-    # This code is copied from merb-core/config.rb.
-    class << self
-      # Returns the hash of default config values for neography
-      #
-      # ==== Returns
-      # Hash:: The defaults for the config.
-      def defaults
-        @defaults ||= {
-          :protocol => 'http://',
-          :server => 'localhost',
-          :port => '7474'
-        }
-      end
-
-     
-      # Yields the configuration.
-      #
-      # ==== Block parameters
-      # c :: The configuration parameters, a hash.
-      #
-      # ==== Examples
-      # Neography::Config.use do |config|
-      #   config[:server] = '192.168.1.13'
-      # end
-      #
-      # ==== Returns
-      # nil
-      def use
-        @configuration ||= {}
-        yield @configuration
-        nil
-      end
-      
-      
-      # Set the value of a config entry.
-      #
-      # ==== Parameters
-      # key :: The key to set the parameter for.
-      # val :: The value of the parameter.
-      #
-      def []=(key, val)
-        (@configuration ||= setup)[key] = val
-      end
-
-
-      # Gets the the value of a config entry
-      #
-      # ==== Parameters
-      # key:: The key of the config entry value we want
-      #
-      def [](key)
-        (@configuration ||= setup)[key]
-      end
-
-
-      # Remove the value of a config entry.
-      #
-      # ==== Parameters
-      # key<Object>:: The key of the parameter to delete.
-      #
-      # ==== Returns
-      # The value of the removed entry.
-      #
-      def delete(key)
-        @configuration.delete(key)
-      end
-
-
-      # Remove all configuration. This can be useful for testing purpose.
-      #
-      #
-      # ==== Returns
-      # nil
-      #
-      def delete_all
-        @configuration = nil
-      end
-
-
-      # Retrieve the value of a config entry, returning the provided default if the key is not present
-      #
-      # ==== Parameters
-      # key:: The key to retrieve the parameter for.
-      # default::The default value to return if the parameter is not set.
-      #
-      # ==== Returns
-      # The value of the configuration parameter or the default.
-      #
-      def fetch(key, default)
-        @configuration.fetch(key, default)
-      end
-
-      # Sets up the configuration
-      #
-      # ==== Returns
-      # The configuration as a hash.
-      #
-      def setup()
-        @configuration = {}
-        @configuration.merge!(defaults)
-        @configuration
-      end
-
-
-      # Returns the configuration as a hash.
-      #
-      # ==== Returns
-      # The config as a hash.
-      #
-      def to_hash
-        @configuration
-      end
-
-      # Returns the config as YAML.
-      #
-      # ==== Returns
-      # The config as YAML.
-      #
-      def to_yaml
-        require "yaml"
-        @configuration.to_yaml
-      end
-
-      # Returns the configuration as a string.
-      #
-      # ==== Returns
-      # The config as a string.
-      #
-      def to_s
-        setup
-        @configuration[:protocol] + @configuration[:server].to_s + ':' + @configuration[:port].to_s
-      end
-
-
-    end
-  end
-
-end