neography 0.0.2 → 0.0.3

data/CONTRIBUTORS

@@ -0,0 +1,5 @@
+Maintainer:
+  Max De Marzi <maxdemarzi at gmail dot com>
+
+Contributors:
+* Peter Neubauer

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    neography (0.0.1)
+    neography (0.0.2)
       httparty (~> 0.6.1)
       json
 

data/README.rdoc

@@ -9,8 +9,13 @@ If you want to the full power of Neo4j, you will want to use JRuby and the excel
 === Installation
 
   gem install 'neography'
+
+After that, in your ruby script, do
+
+  require 'rubygems'
   require 'neography'
 
+in order to access the functionality.
 === Dependencies
 
   for use:
@@ -41,46 +46,46 @@ To Use:
 
   @neo = Neography::Rest.new 
 
-  @neo.get_root                                     # Get the root node
-  @neo.create_node                                  # Create an empty node
-  @neo.create_node("age" => 31, "name" => "Max")    # Create a node with some properties
-  @neo.get_node(id)                                 # Get a node and its properties
-  @neo.delete_node(id)                              # Delete an unrelated node
-  @neo.delete_node!(id)                             # Delete a node and all its relationships
-
-  @neo.reset_node_properties(id, {"age" => 31})     # Reset a node's properties
-  @neo.set_node_properties(id, {"weight" => 200})   # Set a node's properties
-  @neo.get_node_properties(id)                      # Get just the node properties
-  @neo.get_node_properties(id, ["weight","age"])    # Get some of the node properties
-  @neo.remove_node_properties(id)                   # Remove all properties of a node
-  @neo.remove_node_properties(id, "weight")         # Remove one property of a node
-  @neo.remove_node_properties(id, ["weight","age"]) # Remove multiple properties of a node
-
-  @neo.create_relationship("friends", node1, node2)        # Create a relationship between node1 and node2
-  @neo.get_node_relationships(id)                          # Get all relationships
-  @neo.get_node_relationships(id, "in")                    # Get only incoming relationships
-  @neo.get_node_relationships(id, "all", "enemies")        # Get all relationships of type enemies
-  @neo.get_node_relationships(id, "in", "enemies")         # Get only incoming relationships of type enemies
-  @neo.delete_relationship(id)                             # Delete a relationship
-
-  @neo.reset_relationship_properties(id, {"age" => 31})    # Reset a relationship's properties
-  @neo.set_relationship_properties(id, {"weight" => 200})  # Set a relationship's properties
-  @neo.get_relationship_properties(id)                     # Get just the relationship properties
-  @neo.get_relationship_properties(id, ["since","met"])    # Get some of the relationship properties
-  @neo.remove_relationship_properties(id)                  # Remove all properties of a relationship
-  @neo.remove_relationship_properties(id, "since")         # Remove one property of a relationship
-  @neo.remove_relationship_properties(id, ["since","met"]) # Remove multiple properties of a relationship
-
-  @neo.list_indexes                        # doesn't really seam to do what the api says it does
-  @neo.add_to_index(key, value, id)        # adds a node to an index with the given key/value pair
-  @neo.remove_from_index(key, value, id)   # removes a node to an index with the given key/value pair
-  @neo.get_index(key, value)               # gets an index with the given key/value pair
-
-  @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"
+  @neo.get_root                                              # Get the root node
+  node1 = @neo.create_node                                   # Create an empty node
+  node2 = @neo.create_node("age" => 31, "name" => "Max")     # Create a node with some properties
+  @neo.get_node(node2)                                       # Get a node and its properties
+  @neo.delete_node(node2)                                    # Delete an unrelated node
+  @neo.delete_node!(node2)                                   # Delete a node and all its relationships
+
+  @neo.reset_node_properties(node1, {"age" => 31})           # Reset a node's properties
+  @neo.set_node_properties(node1, {"weight" => 200})         # Set a node's properties
+  @neo.get_node_properties(node1)                            # Get just the node properties
+  @neo.get_node_properties(node1, ["weight","age"])          # Get some of the node properties
+  @neo.remove_node_properties(node1)                         # Remove all properties of a node
+  @neo.remove_node_properties(node1, "weight")               # Remove one property of a node
+  @neo.remove_node_properties(node1, ["weight","age"])       # Remove multiple properties of a node
+
+  rel1 = @neo.create_relationship("friends", node1, node2)   # Create a relationship between node1 and node2
+  @neo.get_node_relationships(node1)                         # Get all relationships
+  @neo.get_node_relationships(node1, "in")                   # Get only incoming relationships
+  @neo.get_node_relationships(node1, "all", "enemies")       # Get all relationships of type enemies
+  @neo.get_node_relationships(node1, "in", "enemies")        # Get only incoming relationships of type enemies
+  @neo.delete_relationship(rel1)                             # Delete a relationship
+
+  @neo.reset_relationship_properties(rel1, {"age" => 31})    # Reset a relationship's properties
+  @neo.set_relationship_properties(rel1, {"weight" => 200})  # Set a relationship's properties
+  @neo.get_relationship_properties(rel1)                     # Get just the relationship properties
+  @neo.get_relationship_properties(rel1, ["since","met"])    # Get some of the relationship properties
+  @neo.remove_relationship_properties(rel1)                  # Remove all properties of a relationship
+  @neo.remove_relationship_properties(rel1, "since")         # Remove one property of a relationship
+  @neo.remove_relationship_properties(rel1, ["since","met"]) # Remove multiple properties of a relationship
+
+  @neo.list_indexes                                          # doesn't really seam to do what the api says it does
+  @neo.add_to_index(key, value, node1)                       # adds a node to an index with the given key/value pair
+  @neo.remove_from_index(key, value, node1)                  # removes a node to an index with the given key/value pair
+  @neo.get_index(key, value)                                 # gets an index with the given key/value pair
+
+  @neo.get_path(node1, node2, relationships, depth=4, algorithm="shortestPath") # finds the shortest path between two nodes 
+  @neo.get_paths(node1, node2, relationships, depth=3, algorithm="allPaths")    # finds all paths between two nodes
+
+  nodes = @neo.traverse(node1,                                              # the node where the traversal starts
+                        "nodes",                                            # return_type "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
@@ -88,7 +93,7 @@ To Use:
                                              {"type"=> "friends",           # 
                                               "direction" => "out"}],       # 
                          "prune evaluator" => {"language" => "javascript",  # A prune evaluator (when to stop traversing)
-                                               "body" => "position.endNode().getProperty('age') < 21;"
+                                               "body" => "position.endNode().getProperty('age') < 21;"},
                          "return filter" => {"language" => "builtin",       # "all" or "all but start node"
                                              "name" => "all"},
                          "depth" => 4})  

data/lib/neography/rest.rb

@@ -36,21 +36,21 @@ module Neography
       end
 
       def get_node(id)
-        get("/node/#{id}")
+        get("/node/#{get_id(id)}")
       end
 
       def reset_node_properties(id, properties)
         options = { :body => properties.to_json, :headers => {'Content-Type' => 'application/json'} } 
-        put("/node/#{id}/properties", options)
+        put("/node/#{get_id(id)}/properties", options)
       end
 
       def get_node_properties(id, properties = nil)
         if properties.nil?
-          get("/node/#{id}/properties")
+          get("/node/#{get_id(id)}/properties")
         else
           node_properties = Hash.new 
           properties.to_a.each do |property| 
-            value = get("/node/#{id}/properties/#{property}")
+            value = get("/node/#{get_id(id)}/properties/#{property}")
             node_properties[property] = value unless value.nil?
           end
           return nil if node_properties.empty?
@@ -60,10 +60,10 @@ module Neography
 
       def remove_node_properties(id, properties = nil)
         if properties.nil?
-          delete("/node/#{id}/properties")
+          delete("/node/#{get_id(id)}/properties")
         else 
           properties.to_a.each do |property| 
-            delete("/node/#{id}/properties/#{property}") 
+            delete("/node/#{get_id(id)}/properties/#{property}") 
           end
         end
       end
@@ -71,31 +71,31 @@ module Neography
       def set_node_properties(id, properties)
           properties.each do |key, value| 
             options = { :body => value.to_json, :headers => {'Content-Type' => 'application/json'} } 
-            put("/node/#{id}/properties/#{key}", options) 
+            put("/node/#{get_id(id)}/properties/#{key}", options) 
           end
       end
 
       def delete_node(id)
-        delete("/node/#{id}")
+        delete("/node/#{get_id(id)}")
       end
 
       def create_relationship(type, from, to, props = nil)
-         options = { :body => {:to => self.configuration + "/node/#{to}", :data => props, :type => type }.to_json, :headers => {'Content-Type' => 'application/json'} } 
-         post("/node/#{from}/relationships", options)
+         options = { :body => {:to => self.configuration + "/node/#{get_id(to)}", :data => props, :type => type }.to_json, :headers => {'Content-Type' => 'application/json'} } 
+         post("/node/#{get_id(from)}/relationships", options)
       end
 
       def reset_relationship_properties(id, properties)
         options = { :body => properties.to_json, :headers => {'Content-Type' => 'application/json'} } 
-        put("/relationship/#{id}/properties", options)
+        put("/relationship/#{get_id(id)}/properties", options)
       end
 
       def get_relationship_properties(id, properties = nil)
         if properties.nil?
-          get("/relationship/#{id}/properties")
+          get("/relationship/#{get_id(id)}/properties")
         else
           relationship_properties = Hash.new 
           properties.to_a.each do |property| 
-            value = get("/relationship/#{id}/properties/#{property}")
+            value = get("/relationship/#{get_id(id)}/properties/#{property}")
             relationship_properties[property] = value unless value.nil?
           end
           return nil if relationship_properties.empty?
@@ -105,10 +105,10 @@ module Neography
 
       def remove_relationship_properties(id, properties = nil)
         if properties.nil?
-          delete("/relationship/#{id}/properties")
+          delete("/relationship/#{get_id(id)}/properties")
         else 
           properties.to_a.each do |property| 
-            delete("/relationship/#{id}/properties/#{property}")
+            delete("/relationship/#{get_id(id)}/properties/#{property}")
           end
         end
       end
@@ -116,30 +116,30 @@ module Neography
       def set_relationship_properties(id, properties)
           properties.each do |key, value| 
             options = { :body => value.to_json, :headers => {'Content-Type' => 'application/json'} } 
-            put("/relationship/#{id}/properties/#{key}", options)
+            put("/relationship/#{get_id(id)}/properties/#{key}", options)
           end
       end
 
       def delete_relationship(id)
-        delete("/relationship/#{id}")
+        delete("/relationship/#{get_id(id)}")
       end
 
       def get_node_relationships(id, dir=nil, types=nil)
         dir = get_dir(dir)
 
         if types.nil?
-          node_relationships = get("/node/#{id}/relationships/#{dir}") || Array.new
+          node_relationships = get("/node/#{get_id(id)}/relationships/#{dir}") || Array.new
         else
-          node_relationships = get("/node/#{id}/relationships/#{dir}/#{types.to_a.join('&')}") || Array.new
+          node_relationships = get("/node/#{get_id(id)}/relationships/#{dir}/#{types.to_a.join('&')}") || Array.new
         end
         return nil if node_relationships.empty?
         node_relationships
       end
 
       def delete_node!(id)
-        relationships = get_node_relationships(id)
+        relationships = get_node_relationships(get_id(id))
         relationships.each { |r| delete_relationship(r["self"].split('/').last) } unless relationships.nil?
-        delete("/node/#{id}")
+        delete("/node/#{get_id(id)}")
       end
 
       def list_indexes
@@ -147,12 +147,12 @@ module Neography
       end
 
       def add_to_index(key, value, id)
-        options = { :body => (self.configuration + "/node/#{id}").to_json, :headers => {'Content-Type' => 'application/json'} } 
+        options = { :body => (self.configuration + "/node/#{get_id(id)}").to_json, :headers => {'Content-Type' => 'application/json'} } 
         post("/index/node/#{key}/#{value}", options)
       end
 
       def remove_from_index(key, value, id)
-        delete("/index/node/#{key}/#{value}/#{id}")
+        delete("/index/node/#{key}/#{value}/#{get_id(id)}")
       end
 
       def get_index(key, value)
@@ -168,17 +168,17 @@ module Neography
                               "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
+        traversal = post("/node/#{get_id(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
+        options = { :body => {"to" => self.configuration + "/node/#{get_id(to)}", "relationships" => relationships, "max depth" => depth, "algorithm" => get_algorithm(algorithm) }.to_json, :headers => {'Content-Type' => 'application/json'} } 
+        path = post("/node/#{get_id(from)}/path", options) || Hash.new
       end
 
       def get_paths(from, to, relationships, depth=1, algorithm="allPaths")
-        options = { :body => {"to" => self.configuration + "/node/#{to}", "relationships" => relationships, "max depth" => depth, "algorithm" => get_algorithm(algorithm) }.to_json, :headers => {'Content-Type' => 'application/json'} } 
-        paths = post("/node/#{from}/paths", options) || Array.new
+        options = { :body => {"to" => self.configuration + "/node/#{get_id(to)}", "relationships" => relationships, "max depth" => depth, "algorithm" => get_algorithm(algorithm) }.to_json, :headers => {'Content-Type' => 'application/json'} } 
+        paths = post("/node/#{get_id(from)}/paths", options) || Array.new
       end
 
       private
@@ -190,10 +190,10 @@ module Neography
         case code 
           when 200 
             @logger.debug "OK" if @log_enabled
-            response
+            response.parsed_response
           when 201
             @logger.debug "OK, created #{body}" if @log_enabled
-            response
+            response.parsed_response
           when 204  
             @logger.debug "OK, no content returned" if @log_enabled
             nil
@@ -225,6 +225,17 @@ module Neography
           evaluate_response(HTTParty.delete(configuration + path, options))
        end
 
+      def get_id(id)
+        case id
+          when Hash
+            id["self"].split('/').last
+          when String
+            id.split('/').last
+          else
+            id
+          end 
+      end
+
       def get_dir(dir)
         case dir
           when :incoming, "incoming", :in, "in"

data/lib/neography/version.rb

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

data/spec/integration/rest_index_spec.rb

@@ -14,26 +14,24 @@ describe Neography::Rest do
   describe "add to index" do
     it "can add a node to an index" do
       new_node = @neo.create_node
-      new_node[:id] = new_node["self"].split('/').last
       key = generate_text(6)
       value = generate_text
-      @neo.add_to_index(key, value, new_node[:id]) 
+      @neo.add_to_index(key, value, new_node) 
       new_index = @neo.get_index(key, value) 
       new_index.should_not be_nil
-      @neo.remove_from_index(key, value, new_node[:id]) 
+      @neo.remove_from_index(key, value, new_node) 
     end
   end
 
   describe "remove from index" do
     it "can remove a node from an index" do
       new_node = @neo.create_node
-      new_node[:id] = new_node["self"].split('/').last
       key = generate_text(6)
       value = generate_text
-      @neo.add_to_index(key, value, new_node[:id]) 
+      @neo.add_to_index(key, value, new_node) 
       new_index = @neo.get_index(key, value) 
       new_index.should_not be_nil
-      @neo.remove_from_index(key, value, new_node[:id]) 
+      @neo.remove_from_index(key, value, new_node) 
       new_index = @neo.get_index(key, value) 
       new_index.should be_nil
     end
@@ -42,13 +40,12 @@ describe Neography::Rest do
   describe "get index" do
     it "can get an index" do
       new_node = @neo.create_node
-      new_node[:id] = new_node["self"].split('/').last
       key = generate_text(6)
       value = generate_text
-      @neo.add_to_index(key, value, new_node[:id]) 
+      @neo.add_to_index(key, value, new_node) 
       new_index = @neo.get_index(key, value) 
       new_index.should_not be_nil
-      @neo.remove_from_index(key, value, new_node[:id]) 
+      @neo.remove_from_index(key, value, new_node) 
     end
   end
 

data/spec/integration/rest_node_spec.rb

@@ -34,7 +34,7 @@ describe Neography::Rest do
     it "can get a node that exists" do
       new_node = @neo.create_node
       new_node[:id] = new_node["self"].split('/').last
-      existing_node = @neo.get_node(new_node[:id])
+      existing_node = @neo.get_node(new_node)
       existing_node.should_not be_nil
       existing_node.should have_key("self")
       existing_node["self"].split('/').last.should == new_node[:id]
@@ -42,8 +42,8 @@ describe Neography::Rest do
 
     it "returns nil if it tries to get a node that does not exist" do
       new_node = @neo.create_node
-      new_node[:id] = new_node["self"].split('/').last
-      existing_node = @neo.get_node(new_node[:id].to_i + 1000)
+      fake_node = new_node["self"].split('/').last.to_i + 1000
+      existing_node = @neo.get_node(fake_node)
       existing_node.should be_nil
     end
   end
@@ -51,18 +51,17 @@ describe Neography::Rest do
   describe "set_node_properties" do
     it "can set a node's properties" do
       new_node = @neo.create_node
-      new_node[:id] = new_node["self"].split('/').last
-      @neo.set_node_properties(new_node[:id], {"weight" => 200, "eyes" => "brown"})
-      existing_node = @neo.get_node(new_node[:id])
+      @neo.set_node_properties(new_node, {"weight" => 200, "eyes" => "brown"})
+      existing_node = @neo.get_node(new_node)
       existing_node["data"]["weight"].should == 200
       existing_node["data"]["eyes"].should == "brown"
     end
 
     it "it fails to set properties on a node that does not exist" do
       new_node = @neo.create_node
-      new_node[:id] = new_node["self"].split('/').last
-      @neo.set_node_properties(new_node[:id].to_i + 1000, {"weight" => 150, "hair" => "blonde"})
-      node_properties = @neo.get_node_properties(new_node[:id].to_i + 1000)
+      fake_node = new_node["self"].split('/').last.to_i + 1000
+      @neo.set_node_properties(fake_node, {"weight" => 150, "hair" => "blonde"})
+      node_properties = @neo.get_node_properties(fake_node)
       node_properties.should be_nil
     end
   end
@@ -70,10 +69,9 @@ describe Neography::Rest do
   describe "reset_node_properties" do
     it "can reset a node's properties" do
       new_node = @neo.create_node
-      new_node[:id] = new_node["self"].split('/').last
-      @neo.set_node_properties(new_node[:id], {"weight" => 200, "eyes" => "brown", "hair" => "black"})
-      @neo.reset_node_properties(new_node[:id], {"weight" => 190, "eyes" => "blue"})
-      existing_node = @neo.get_node(new_node[:id])
+      @neo.set_node_properties(new_node, {"weight" => 200, "eyes" => "brown", "hair" => "black"})
+      @neo.reset_node_properties(new_node, {"weight" => 190, "eyes" => "blue"})
+      existing_node = @neo.get_node(new_node)
       existing_node["data"]["weight"].should == 190
       existing_node["data"]["eyes"].should == "blue"
       existing_node["data"]["hair"].should be_nil
@@ -81,9 +79,9 @@ describe Neography::Rest do
 
     it "it fails to reset properties on a node that does not exist" do
       new_node = @neo.create_node
-      new_node[:id] = new_node["self"].split('/').last
-      @neo.reset_node_properties(new_node[:id].to_i + 1000, {"weight" => 170, "eyes" => "green"})
-      node_properties = @neo.get_node_properties(new_node[:id].to_i + 1000)
+      fake_node = new_node["self"].split('/').last.to_i + 1000
+      @neo.reset_node_properties(fake_node, {"weight" => 170, "eyes" => "green"})
+      node_properties = @neo.get_node_properties(fake_node)
       node_properties.should be_nil
     end
   end
@@ -91,16 +89,14 @@ describe Neography::Rest do
   describe "get_node_properties" do
     it "can get all of a node's properties" do
       new_node = @neo.create_node("weight" => 200, "eyes" => "brown")
-      new_node[:id] = new_node["self"].split('/').last
-      node_properties = @neo.get_node_properties(new_node[:id])
+      node_properties = @neo.get_node_properties(new_node)
       node_properties["weight"].should == 200
       node_properties["eyes"].should == "brown"
     end
 
     it "can get some of a node's properties" do
       new_node = @neo.create_node("weight" => 200, "eyes" => "brown", "height" => "2m")
-      new_node[:id] = new_node["self"].split('/').last
-      node_properties = @neo.get_node_properties(new_node[:id], ["weight", "height"])
+      node_properties = @neo.get_node_properties(new_node, ["weight", "height"])
       node_properties["weight"].should == 200
       node_properties["height"].should == "2m"
       node_properties["eyes"].should be_nil
@@ -108,51 +104,46 @@ describe Neography::Rest do
 
     it "returns nil if it gets the properties on a node that does not have any" do
       new_node = @neo.create_node
-      new_node[:id] = new_node["self"].split('/').last
-      @neo.get_node_properties(new_node[:id]).should be_nil
+      @neo.get_node_properties(new_node).should be_nil
     end
 
     it "returns nil if it tries to get some of the properties on a node that does not have any" do
       new_node = @neo.create_node
-      new_node[:id] = new_node["self"].split('/').last
-      @neo.get_node_properties(new_node[:id], ["weight", "height"]).should be_nil
+      @neo.get_node_properties(new_node, ["weight", "height"]).should be_nil
     end
 
     it "returns nil if it fails to get properties on a node that does not exist" do
       new_node = @neo.create_node
-      new_node[:id] = new_node["self"].split('/').last
-      @neo.get_node_properties(new_node[:id].to_i + 10000).should be_nil
+      fake_node = new_node["self"].split('/').last.to_i + 1000
+      @neo.get_node_properties(fake_node).should be_nil
     end
   end
 
   describe "remove_node_properties" do
     it "can remove a node's properties" do
       new_node = @neo.create_node("weight" => 200, "eyes" => "brown")
-      new_node[:id] = new_node["self"].split('/').last
-      @neo.remove_node_properties(new_node[:id])
-      @neo.get_node_properties(new_node[:id]).should be_nil
+      @neo.remove_node_properties(new_node)
+      @neo.get_node_properties(new_node).should be_nil
     end
 
     it "returns nil if it fails to remove the properties of a node that does not exist" do
       new_node = @neo.create_node
-      new_node[:id] = new_node["self"].split('/').last
-      @neo.remove_node_properties(new_node[:id].to_i + 10000).should be_nil
+      fake_node = new_node["self"].split('/').last.to_i + 1000
+      @neo.remove_node_properties(fake_node).should be_nil
     end
 
     it "can remove a specific node property" do
       new_node = @neo.create_node("weight" => 200, "eyes" => "brown")
-      new_node[:id] = new_node["self"].split('/').last
-      @neo.remove_node_properties(new_node[:id], "weight")
-      node_properties = @neo.get_node_properties(new_node[:id])
+      @neo.remove_node_properties(new_node, "weight")
+      node_properties = @neo.get_node_properties(new_node)
       node_properties["weight"].should be_nil
       node_properties["eyes"].should == "brown"
     end
 
     it "can remove more than one property" do
       new_node = @neo.create_node("weight" => 200, "eyes" => "brown", "height" => "2m")
-      new_node[:id] = new_node["self"].split('/').last
-      @neo.remove_node_properties(new_node[:id], ["weight", "eyes"])
-      node_properties = @neo.get_node_properties(new_node[:id])
+      @neo.remove_node_properties(new_node, ["weight", "eyes"])
+      node_properties = @neo.get_node_properties(new_node)
       node_properties["weight"].should be_nil
       node_properties["eyes"].should be_nil
     end
@@ -161,39 +152,35 @@ describe Neography::Rest do
   describe "delete_node" do
     it "can delete an unrelated node" do
       new_node = @neo.create_node
-      new_node[:id] = new_node["self"].split('/').last
-      @neo.delete_node(new_node[:id]).should be_nil
-      existing_node = @neo.get_node(new_node[:id])
+      @neo.delete_node(new_node).should be_nil
+      existing_node = @neo.get_node(new_node)
       existing_node.should be_nil
     end
 
     it "cannot delete a node that has 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
-      @neo.create_relationship("friends", new_node1[:id], new_node2[:id])
-      @neo.delete_node(new_node1[:id]).should be_nil
-      existing_node = @neo.get_node(new_node1[:id])
+      @neo.create_relationship("friends", new_node1, new_node2)
+      @neo.delete_node(new_node1).should be_nil
+      existing_node = @neo.get_node(new_node1)
       existing_node.should_not be_nil
     end
 
     it "returns nil if it tries to delete a node that does not exist" do
       new_node = @neo.create_node
-      new_node[:id] = new_node["self"].split('/').last
-      @neo.delete_node(new_node[:id].to_i + 1000).should be_nil
-      existing_node = @neo.get_node(new_node[:id].to_i + 1000)
+      fake_node = new_node["self"].split('/').last.to_i + 1000
+      @neo.delete_node(fake_node).should be_nil
+      existing_node = @neo.get_node(fake_node)
       existing_node.should be_nil
     end
 
     it "returns nil if it tries to delete a node that has already been deleted" do
       new_node = @neo.create_node
-      new_node[:id] = new_node["self"].split('/').last
-      @neo.delete_node(new_node[:id]).should be_nil
-      existing_node = @neo.get_node(new_node[:id])
+      @neo.delete_node(new_node).should be_nil
+      existing_node = @neo.get_node(new_node)
       existing_node.should be_nil
-      @neo.delete_node(new_node[:id]).should be_nil
-      existing_node = @neo.get_node(new_node[:id])
+      @neo.delete_node(new_node).should be_nil
+      existing_node = @neo.get_node(new_node)
       existing_node.should be_nil
     end
   end
@@ -201,39 +188,35 @@ describe Neography::Rest do
   describe "delete_node!" do
     it "can delete an unrelated node" do
       new_node = @neo.create_node
-      new_node[:id] = new_node["self"].split('/').last
-      @neo.delete_node!(new_node[:id]).should be_nil
-      existing_node = @neo.get_node(new_node[:id])
+      @neo.delete_node!(new_node).should be_nil
+      existing_node = @neo.get_node(new_node)
       existing_node.should be_nil
     end
 
     it "can delete a node that has 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
-      @neo.create_relationship("friends", new_node1[:id], new_node2[:id])
-      @neo.delete_node!(new_node1[:id]).should be_nil
-      existing_node = @neo.get_node(new_node1[:id])
+      @neo.create_relationship("friends", new_node1, new_node2)
+      @neo.delete_node!(new_node1).should be_nil
+      existing_node = @neo.get_node(new_node1)
       existing_node.should be_nil
     end
 
     it "returns nil if it tries to delete a node that does not exist" do
       new_node = @neo.create_node
-      new_node[:id] = new_node["self"].split('/').last
-      @neo.delete_node!(new_node[:id].to_i + 1000).should be_nil
-      existing_node = @neo.get_node(new_node[:id].to_i + 1000)
+      fake_node = new_node["self"].split('/').last.to_i + 1000
+      @neo.delete_node!(fake_node).should be_nil
+      existing_node = @neo.get_node(fake_node)
       existing_node.should be_nil
     end
 
     it "returns nil if it tries to delete a node that has already been deleted" do
       new_node = @neo.create_node
-      new_node[:id] = new_node["self"].split('/').last
-      @neo.delete_node!(new_node[:id]).should be_nil
-      existing_node = @neo.get_node(new_node[:id])
+      @neo.delete_node!(new_node).should be_nil
+      existing_node = @neo.get_node(new_node)
       existing_node.should be_nil
-      @neo.delete_node!(new_node[:id]).should be_nil
-      existing_node = @neo.get_node(new_node[:id])
+      @neo.delete_node!(new_node).should be_nil
+      existing_node = @neo.get_node(new_node)
       existing_node.should be_nil
     end
   end