neography 0.0.5 → 0.0.6

data/Gemfile.lock

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

data/README.rdoc

@@ -157,10 +157,32 @@ The Neo4j ID is available by using node.neo_id .
   new_rel = Neography::Relationship.create(:family, n1, n2)            # Create a relationship from my_node to node2
   new_rel.start_node                                                   # Get the start/from node of a relationship
   new_rel.end_node                                                     # Get the end/to node of a relationship
+  new_rel.other_node(n2)                                               # Get the other node of a relationship
+
   existing_rel = Neography::Relationship.load(12)                      # Get an existing relationship by id
   existing_rel.del                                                     # Delete a relationship
 
   Neography::Relationship.create(:friends, n1, n2)
+  n1.outgoing(:friends) << n2                                          # Create outgoing relationship
+  n1.incoming(:friends) << n2                                          # Create incoming relationship
+  n1.both(:friends) << n2                                              # Create both relationships
+
+  n1.outgoing                                                          # Get nodes related by outgoing relationships
+  n1.incoming                                                          # Get nodes related by incoming relationships
+  n1.both                                                              # Get nodes related by any relationships
+
+  n1.outgoing(:friends)                                                # Get nodes related by outgoing friends relationship
+  n1.incoming(:friends)                                                # Get nodes related by incoming friends relationship
+  n1.both(:friends)                                                    # Get nodes related by friends relationship
+
+  n1.outgoing(:friends).incoming(:enemies)                             # Get nodes related by one of multiple relationships
+  n1.outgoing(:friends).depth(2)                                       # Get nodes related by friends and friends of friends
+  n1.outgoing(:friends).depth(:all)                                    # Get nodes related by friends until the end of the graph
+  n1.outgoing(:friends).depth(2).include_start_node                    # Get n1 and nodes related by friends and friends of friends
+
+  n1.outgoing(:friends).prune("position.endNode().getProperty('name') == 'Tom';")
+  n1.outgoing(:friends).filter("position.length() == 2;")
+
   n1.rel?(:friends)                                                    # Has a friends relationship
   n1.rel?(:outgoing, :friends)                                         # Has outgoing friends relationship
   n1.rel?(:friends, :outgoing)                                         # same, just the other way
@@ -169,6 +191,12 @@ The Neo4j ID is available by using node.neo_id .
   n1.rel?(:all)                                                        # same as above
   n1.rel?                                                              # same as above
 
+  n1.rels                                                              # Get node relationships
+  n1.rels(:friends)                                                    # Get friends relationships
+  n1.rels(:friends).outgoing                                           # Get outgoing friends relationships
+  n1.rels(:friends).incoming                                           # Get incoming friends relationships
+  n1.rels(:friends,:work)                                              # Get friends and work relationships
+  n1.rels(:friends,:work).outgoing                                     # Get outgoing friends and work relationships          
 
 See Neo4j API for:
 * {Order}[http://components.neo4j.org/neo4j-examples/1.2.M04/apidocs/org/neo4j/graphdb/Traverser.Order.html]
@@ -185,12 +213,11 @@ A couple of examples borrowed from Matthew Deiters's Neo4jr-social
 
 === To Do
 
-* More tests
-* More examples
-* batch import with typhoeus ?
-* create proper objects for Node and Relationship
+* More Tests
+* More Examples
+* Mixins ?
 
-=== License
+=== Licenses
 
 * 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

data/lib/neography.rb

@@ -17,7 +17,6 @@ end
 
 DIRECTIONS = ["incoming", "in", "outgoing", "out", "all", "both"]
 
-
 require 'httparty'
 require 'json'
 require 'logger'

data/lib/neography/node_relationship.rb

@@ -2,27 +2,15 @@ module Neography
   module NodeRelationship
 
     def outgoing(types=nil)
-      if types
-        NodeTraverser.new(self).outgoing(types)
-      else
-        NodeTraverser.new(self).outgoing
-      end
+      NodeTraverser.new(self).outgoing(types)
     end
 
     def incoming(types=nil)
-      if types
-        NodeTraverser.new(self).incoming(types)
-      else
-        NodeTraverser.new(self).incoming
-      end
+      NodeTraverser.new(self).incoming(types)
     end
 
     def both(types=nil)
-      if types
-        NodeTraverser.new(self).both(types)
-      else
-        NodeTraverser.new(self) # default is both
-      end
+      NodeTraverser.new(self).both(types)
     end
 
     def rels(*types)
@@ -30,7 +18,9 @@ module Neography
     end
 
     def rel(dir, type)
-      Neography::RelationshipTraverser.new(self, type, dir).first
+      rel = Neography::RelationshipTraverser.new(self, type, dir)
+      rel = rel.first unless rel.nil?
+      rel
     end
 
     def rel?(dir=nil, type=nil)

data/lib/neography/node_traverser.rb

@@ -2,19 +2,128 @@ module Neography
   class NodeTraverser
     include Enumerable
 
-    attr_accessor :order, :uniqueness, :depth, :prune, :filter
+    attr_accessor :order, :uniqueness, :depth, :prune, :filter, :relationships
 
-    def initialize(from, types = nil, dir=nil)
+    def initialize(from, types = nil, dir = "all" )
       @from  = from
-      @depth = 1
       @order = "depth first"
       @uniqueness = "none"
-      if types.nil? || dir.nil?
-#        @td    = org.neo4j.kernel.impl.traversal.TraversalDescriptionImpl.new.breadth_first()
+      @relationships = Array.new
+      types.each do |type|
+        @relationships << {"type" => type.to_s, "direction" => dir.to_s }
+      end unless types.nil?
+    end
+
+    def <<(other_node)
+      create(other_node)
+      self
+    end
+
+    def create(other_node)
+      case @relationships.first["direction"]
+        when "outgoing", "out"
+          rel = Neography::Relationship.new(@from.neo_server.create_relationship(@relationships.first["type"], @from, other_node))
+        when "incoming", "in"
+          rel = Neography::Relationship.new(@from.neo_server.create_relationship(@relationships.first["type"], other_node, @from))
+        else
+          rel = Array.new
+          rel << Neography::Relationship.new(@from.neo_server.create_relationship(@relationships.first["type"], @from, other_node))
+          rel << Neography::Relationship.new(@from.neo_server.create_relationship(@relationships.first["type"], other_node, @from))
+      end
+      rel       
+    end
+
+    def both(type)
+      @relationships << {"type" => type.to_s, "direction" => "all"}
+      self
+    end
+
+    def outgoing(type)
+      @relationships << {"type" => type.to_s, "direction" => "out"}
+      self
+    end
+
+    def incoming(type)
+      @relationships << {"type" => type.to_s, "direction" => "in"}
+      self
+    end
+
+    def filter(body)
+      @filter = Hash.new
+      @filter["language"] = "javascript"
+      @filter["body"] = body
+      self
+    end
+
+    def prune(body)
+      @prune = Hash.new
+      @prune["language"] = "javascript"
+      @prune["body"] = body
+      self
+    end
+
+    def depth(d)
+      d = 2147483647 if d == :all
+      @depth = d
+      self
+    end
+
+    def include_start_node
+      @filter = Hash.new
+      @filter["language"] = "builtin"
+      @filter["name"] = "all"
+      self
+    end
+
+    def size
+      [*self].size
+    end
+
+    alias_method :length, :size
+
+    def [](index)
+      each_with_index {|node,i| break node if index == i}
+    end
+
+    def empty?
+      first == nil
+    end
+
+    def each
+      iterator.each do |i| 
+        node = Neography::Node.new(i)
+        node.neo_server = @from.neo_server
+        yield node
+      end
+    end
+
+    def iterator
+      options = Hash.new
+      options["order"] = @order
+      options["uniqueness"] = @uniqueness
+      options["relationships"] = @relationships
+      options["prune evaluator"] = @prune unless @prune.nil?
+      options["return filter"] = @filter unless @filter.nil?
+      options["depth"] = @depth unless @depth.nil?
+
+      if @relationships[0]["type"].blank?
+        rels = @from.neo_server.get_node_relationships(@from, @relationships[0]["direction"])
+        case @relationships[0]["direction"]
+          when "in"
+            rels.collect { |r| @from.neo_server.get_node(r["start"]) } #.uniq
+          when "out"
+            rels.collect { |r| @from.neo_server.get_node(r["end"]) } #.uniq
+          else
+            rels.collect { |r| 
+            if @from.neo_id == r["start"].split('/').last
+              @from.neo_server.get_node(r["end"]) 
+            else
+              @from.neo_server.get_node(r["start"]) 
+            end
+            } #.uniq
+        end
       else
-#        @types  = type_to_java(type)
-#        @dir   = dir_to_java(dir)
-#        @td    = org.neo4j.kernel.impl.traversal.TraversalDescriptionImpl.new.breadth_first().relationships(@type, @dir)
+        @from.neo_server.traverse(@from, "nodes", options)
       end
     end
 

data/lib/neography/relationship.rb

@@ -42,8 +42,12 @@ module Neography
       self.start_node.neo_server.delete_relationship(self.neo_id)
     end
 
+    def exist?
+      !self.start_node.neo_server.get_relationship(self.neo_id).nil?
+    end
+
     def other_node(node)
-      if node = @start_node
+      if node == @start_node
         @end_node
       else
         @start_node

data/lib/neography/relationship_traverser.rb

@@ -19,15 +19,38 @@ module Neography
     end
 
     def each
-      iterator.each { |i| yield Neography::Relationship.new(i, @node.neo_server) }
+      iterator.each do |i| 
+        rel = Neography::Relationship.new(i, @node.neo_server)
+        rel.start_node = Neography::Node.load(rel.start_node)
+        rel.end_node = Neography::Node.load(rel.end_node)
+
+        yield rel if match_to_other?(rel)
+      end
     end
 
     def empty?
       first == nil
     end
-    
+
     def iterator
-      @node.neo_server.get_node_relationships(@node, @direction, @types)
+      Array(@node.neo_server.get_node_relationships(@node, @direction, @types))
+    end
+
+    def match_to_other?(rel)
+      if @to_other.nil?
+        true
+      elsif @direction == :outgoing
+        rel.end_node == @to_other
+      elsif @direction == :incoming
+        rel.start_node == @to_other
+      else
+        rel.start_node == @to_other || rel.end_node == @to_other
+      end
+    end
+
+    def to_other(to_other)
+      @to_other = to_other
+      self
     end
 
     def del
@@ -44,13 +67,11 @@ module Neography
     end
 
     def incoming
-      raise "Not allowed calling incoming when finding several relationships types" if @types
       @direction = :incoming
       self
     end
 
     def outgoing
-      raise "Not allowed calling outgoing when finding several relationships types" if @types
       @direction = :outgoing
       self
     end

data/lib/neography/version.rb

@@ -1,3 +1,3 @@
 module Neography
-  VERSION = "0.0.5"
+  VERSION = "0.0.6"
 end

data/spec/integration/node_relationship_spec.rb

@@ -0,0 +1,374 @@
+require File.join(File.dirname(__FILE__), '..', 'spec_helper')
+
+describe Neography::NodeRelationship do
+
+    def create_nodes
+      #
+      #                f
+      #                ^
+      #              friends
+      #                |
+      #  a --friends-> b  --friends--> c
+      #                |              ^
+      #                |              |
+      #                +--- work  -----+
+      #                |
+      #                +--- work  ---> d  --- work --> e
+      a = Neography::Node.create :name => 'a'
+      b = Neography::Node.create :name => 'b'
+      c = Neography::Node.create :name => 'c'
+      d = Neography::Node.create :name => 'd'
+      e = Neography::Node.create :name => 'e'
+      f = Neography::Node.create :name => 'f'
+      a.outgoing(:friends) << b
+      b.outgoing(:friends) << c
+      b.outgoing(:work) << c
+      b.outgoing(:work) << d
+      d.outgoing(:work) << e
+      b.outgoing(:friends) << f
+      [a,b,c,d,e,f]
+    end
+
+  describe "outgoing" do
+    it "#outgoing(:friends) << other_node creates an outgoing relationship of type :friends" do
+      a = Neography::Node.create
+      other_node = Neography::Node.create
+
+      # when
+      a.outgoing(:friends) << other_node
+
+      # then
+      a.outgoing(:friends).first.should == other_node
+    end
+
+    it "#outgoing(:friends) << b << c creates an outgoing relationship of type :friends" do
+      a = Neography::Node.create
+      b = Neography::Node.create
+      c = Neography::Node.create
+
+      # when
+      a.outgoing(:friends) << b << c
+
+      # then
+      a.outgoing(:friends).should include(b,c)
+    end
+
+    it "#outgoing returns all incoming nodes of any type" do
+      a,b,c,d,e,f = create_nodes
+
+      b.outgoing.should include(c,f,d)
+      [*b.outgoing].size.should == 4 #c is related by both work and friends
+    end
+
+    it "#outgoing(type) should only return outgoing nodes of the given type of depth one" do
+      a,b,c,d = create_nodes
+      b.outgoing(:work).should include(c,d)
+      [*b.outgoing(:work)].size.should == 2
+    end
+
+    it "#outgoing(type1).outgoing(type2) should return outgoing nodes of the given types" do
+      a,b,c,d,e,f = create_nodes
+      nodes = b.outgoing(:work).outgoing(:friends)
+     
+      nodes.should include(c,d,f)
+      nodes.size.should == 4 #c is related by both work and friends
+    end
+
+    it "#outgoing(type).depth(4) should only return outgoing nodes of the given type and depth" do
+      a,b,c,d,e = create_nodes
+      [*b.outgoing(:work).depth(4)].size.should == 3
+      b.outgoing(:work).depth(4).should include(c,d,e)
+    end
+
+    it "#outgoing(type).depth(4).include_start_node should also include the start node" do
+      a,b,c,d,e = create_nodes
+      [*b.outgoing(:work).depth(4).include_start_node].size.should == 4
+      b.outgoing(:work).depth(4).include_start_node.should include(b,c,d,e)
+    end
+
+    it "#outgoing(type).depth(:all) should traverse at any depth" do
+      a,b,c,d,e = create_nodes
+      [*b.outgoing(:work).depth(:all)].size.should == 3
+      b.outgoing(:work).depth(:all).should include(c,d,e)
+    end
+  end
+
+  describe "incoming" do
+    it "#incoming(:friends) << other_node should add an incoming relationship" do
+      a = Neography::Node.create
+      other_node = Neography::Node.create
+
+      # when
+      a.incoming(:friends) << other_node
+
+      # then
+      a.incoming(:friends).first.should == other_node
+    end
+
+    it "#incoming(:friends) << b << c creates an incoming relationship of type :friends" do
+      a = Neography::Node.create
+      b = Neography::Node.create
+      c = Neography::Node.create
+
+      # when
+      a.incoming(:friends) << b << c
+
+      # then
+      a.incoming(:friends).should include(b,c)
+    end
+
+    it "#incoming returns all incoming nodes of any type" do
+      a,b,c,d,e,f = create_nodes
+
+      b.incoming.should include(a)
+      [*b.incoming].size.should == 1
+    end
+
+    it "#incoming(type).depth(2) should only return outgoing nodes of the given type and depth" do
+      a,b,c,d,e = create_nodes
+      [*e.incoming(:work).depth(2)].size.should == 2
+      e.incoming(:work).depth(2).should include(b,d)
+    end
+
+    it "#incoming(type) should only return incoming nodes of the given type of depth one" do
+      a,b,c,d = create_nodes
+      c.incoming(:work).should include(b)
+      [*c.incoming(:work)].size.should == 1
+    end
+  end
+
+  describe "both" do
+    it "#both(:friends) << other_node should raise an exception" do
+      a = Neography::Node.create
+      other_node = Neography::Node.create
+
+      # when
+      a.both(:friends) << other_node
+      a.incoming(:friends).first.should == other_node
+      a.outgoing(:friends).first.should == other_node
+    end
+
+    it "#both returns all incoming and outgoing nodes of any type" do
+      a,b,c,d,e,f = create_nodes
+
+      b.both.should include(a,c,d,f)
+      [*b.both].size.should == 5 #c is related by both work and friends
+      b.incoming.should include(a)
+      b.outgoing.should include(c)
+    end
+
+    it "#both(type) should return both incoming and outgoing nodes of the given type of depth one" do
+      a,b,c,d,e,f = create_nodes
+
+      b.both(:friends).should include(a,c,f)
+      [*b.both(:friends)].size.should == 3
+    end
+
+    it "#outgoing and #incoming can be combined to traverse several relationship types" do
+      a,b,c,d,e = create_nodes
+      nodes = [*b.incoming(:friends).outgoing(:work)]
+
+      nodes.should include(a,c,d)
+      nodes.should_not include(b,e)
+    end
+  end
+
+
+  describe "prune" do
+    it "#prune, if it returns true the traversal will be stop for that path" do
+      a, b, c, d, e = create_nodes
+      [*b.outgoing(:work).depth(4)].size.should == 3
+      b.outgoing(:work).depth(4).should include(c,d,e)
+
+      [*b.outgoing(:work).prune("position.endNode().getProperty('name') == 'd';")].size.should == 2
+      b.outgoing(:work).prune("position.endNode().getProperty('name') == 'd';").should include(c,d)
+    end
+  end
+
+  describe "filter" do
+    it "#filter, if it returns true the node will be included in the return results" do
+      a, b, c, d, e = create_nodes
+      [*b.outgoing(:work).depth(4)].size.should == 3
+      b.outgoing(:work).depth(4).should include(c,d,e)
+
+      [*b.outgoing(:work).depth(4).filter("position.length() == 2;")].size.should == 1
+      b.outgoing(:work).depth(4).filter("position.length() == 2;").should include(e)
+    end
+  end
+
+  describe "rels" do
+    it "#rels returns a RelationshipTraverser which can filter which relationship it should return by specifying #to_other" do
+      a = Neography::Node.create      
+      b = Neography::Node.create
+      c = Neography::Node.create
+      r1 = Neography::Relationship.create(:friend, a, b)
+      Neography::Relationship.create(:friend, a, c)
+
+      a.rels.to_other(b).size.should == 1
+      a.rels.to_other(b).should include(r1)
+    end
+
+    it "#rels returns an RelationshipTraverser which provides a method for deleting all the relationships" do
+      a = Neography::Node.create
+      b = Neography::Node.create
+      c = Neography::Node.create
+      r1 = Neography::Relationship.create(:friend, a, b)
+      r2 = Neography::Relationship.create(:friend, a, c)
+
+      a.rel?(:friend).should be_true
+      a.rels.del
+      a.rel?(:friend).should be_false
+      r1.exist?.should be_false
+      r2.exist?.should be_false
+    end
+
+    it "#rels returns an RelationshipTraverser with methods #del and #to_other which can be combined to only delete a subset of the relationships" do
+      a = Neography::Node.create
+      b = Neography::Node.create
+      c = Neography::Node.create
+      r1 = Neography::Relationship.create(:friend, a, b)
+      r2 = Neography::Relationship.create(:friend, a, c)
+      r1.exist?.should be_true
+      r2.exist?.should be_true
+      a.rels.to_other(c).del
+      r1.exist?.should be_true
+      r2.exist?.should be_false
+    end
+
+ it "#rels should return both incoming and outgoing relationship of any type of depth one" do
+      a,b,c,d,e,f = create_nodes
+      b.rels.size.should == 5
+      nodes = b.rels.collect{|r| r.other_node(b)}
+      nodes.should include(a,c,d,f)
+      nodes.should_not include(e)
+    end
+
+    it "#rels(:friends) should return both incoming and outgoing relationships of given type of depth one" do
+      # given
+      a,b,c,d,e,f = create_nodes
+
+      # when
+      rels = [*b.rels(:friends)]
+
+      # then
+      rels.size.should == 3
+      nodes = rels.collect{|r| r.end_node}
+      nodes.should include(b,c,f)
+      nodes.should_not include(a,d,e)
+    end
+
+    it "#rels(:friends).outgoing should return only outgoing relationships of given type of depth one" do
+      # given
+      a,b,c,d,e,f = create_nodes
+
+      # when
+      rels = [*b.rels(:friends).outgoing]
+
+      # then
+      rels.size.should == 2
+      nodes = rels.collect{|r| r.end_node}
+      nodes.should include(c,f)
+      nodes.should_not include(a,b,d,e)
+    end
+
+
+    it "#rels(:friends).incoming should return only outgoing relationships of given type of depth one" do
+      # given
+      a,b,c,d,e = create_nodes
+
+      # when
+      rels = [*b.rels(:friends).incoming]
+
+      # then
+      rels.size.should == 1
+      nodes = rels.collect{|r| r.start_node}
+      nodes.should include(a)
+      nodes.should_not include(b,c,d,e)
+    end
+
+    it "#rels(:friends,:work) should return both incoming and outgoing relationships of given types of depth one" do
+      # given
+      a,b,c,d,e,f = create_nodes
+
+      # when
+      rels = [*b.rels(:friends,:work)]
+
+      # then
+      rels.size.should == 5
+      nodes = rels.collect{|r| r.other_node(b)}
+      nodes.should include(a,c,d,f)
+      nodes.should_not include(b,e)
+    end
+
+    it "#rels(:friends,:work).outgoing should return outgoing relationships of given types of depth one" do
+      # given
+      a,b,c,d,e,f = create_nodes
+
+      # when
+      rels = [*b.rels(:friends,:work).outgoing]
+
+      # then
+      rels.size.should == 4
+      nodes = rels.collect{|r| r.other_node(b)}
+      nodes.should include(c,d,f)
+      nodes.should_not include(a,b,e)
+    end
+  end
+
+  describe "rel" do
+    it "#rel returns a single relationship if there is only one relationship" do
+      a = Neography::Node.create
+      b = Neography::Node.create
+      rel = Neography::Relationship.create(:friend, a, b)
+      a.rel(:outgoing, :friend).should == rel
+    end
+
+    it "#rel returns nil if there is no relationship" do
+      a = Neography::Node.create
+      b = Neography::Node.create
+      a.rel(:outgoing, :friend).should be_nil
+    end
+
+    it "#rel should only return one relationship even if there are more" do
+      a = Neography::Node.create
+      b = Neography::Node.create
+      c = Neography::Node.create
+      Neography::Relationship.create(:friend, a, b)
+      Neography::Relationship.create(:friend, a, c)
+      [*a.rel(:outgoing, :friend)].size == 1
+    end
+  end
+
+  describe "rel?" do
+    it "#rel? returns true if there are any relationships" do
+      n1 = Neography::Node.create
+      n1.rel?.should be_false
+      n1.outgoing(:foo) << Neography::Node.create
+
+      n1.rel?.should be_true
+      n1.rel?(:bar).should be_false
+      n1.rel?(:foo).should be_true
+      n1.rel?(:incoming, :foo).should be_false
+      n1.rel?(:outgoing, :foo).should be_true
+      n1.rel?(:foo, :incoming).should be_false
+      n1.rel?(:foo, :outgoing).should be_true
+      n1.rel?(:incoming).should be_false
+      n1.rel?(:outgoing).should be_true
+      n1.rel?(:both).should be_true
+      n1.rel?(:all).should be_true
+      n1.rel?.should be_true
+    end
+  end
+
+
+  describe "delete relationship" do
+    it "can delete an existing relationship" do
+      p1 = Neography::Node.create
+      p2 = Neography::Node.create
+      new_rel = Neography::Relationship.create(:family, p1, p2)
+      new_rel.del
+      Neography::Relationship.load(new_rel).should be_nil
+    end
+  end
+
+end

data/spec/integration/relationship_spec.rb

@@ -6,21 +6,16 @@ describe Neography::Relationship do
       p1 = Neography::Node.create
       p2 = Neography::Node.create
 
-      new_rel = Neography::Relationship.create(:family, p1, p2)
-      puts new_rel.inspect
-      new_rel.start_node.should == p1
-      new_rel.end_node.should == p2
-
-
-#      p1.outgoing(:family).should include(p2)
-#      p2.incoming(:family).should include(p1)
+      Neography::Relationship.create(:family, p1, p2)
+      p1.outgoing(:family).should include(p2)
+      p2.incoming(:family).should include(p1)
     end
 
     it "#new(:family, p1, p2, :since => '1998', :colour => 'blue') creates relationship and sets its properties" do
       p1 = Neography::Node.create
       p2 = Neography::Node.create
- 
       rel = Neography::Relationship.create(:family, p1, p2, :since => 1998, :colour => 'blue')
+
       rel[:since].should == 1998
       rel[:colour].should == 'blue'
       rel.since.should == 1998
@@ -30,42 +25,13 @@ describe Neography::Relationship do
     it "#outgoing(:friends).create(other) creates a new relationship between self and other node" do
       p1 = Neography::Node.create
       p2 = Neography::Node.create
-
       rel = p1.outgoing(:foo).create(p2)
-      p1.outgoing(:foo).first.should == p2
-      rel.should be_kind_of(Neography::Relationship)
-    end
-  end
 
-  describe "rel?" do
-    it "#rel? returns true if there are any relationships" do
-      n1 = Neography::Node.create
-      n2 = Neography::Node.create
-      new_rel = Neography::Relationship.create(:foo, n1, n2)
-      n1.rel?.should be_true
-      n1.rel?(:bar).should be_false
-      n1.rel?(:foo).should be_true
-      n1.rel?(:incoming, :foo).should be_false
-      n1.rel?(:outgoing, :foo).should be_true
-      n1.rel?(:foo, :incoming).should be_false
-      n1.rel?(:foo, :outgoing).should be_true
-
-      n1.rel?(:incoming).should be_false
-      n1.rel?(:outgoing).should be_true
-      n1.rel?(:both).should be_true
-      n1.rel?(:all).should be_true
-      n1.rel?.should be_true
+      rel.should be_kind_of(Neography::Relationship)
+      p1.outgoing(:foo).first.should == p2
+      p1.outgoing(:foo).should include(p2)
+      p2.incoming(:foo).should include(p1)
     end
   end
 
-
-  describe "delete relationship" do
-    it "can delete an existing relationship" do
-      p1 = Neography::Node.create
-      p2 = Neography::Node.create
-      new_rel = Neography::Relationship.create(:family, p1, p2)
-      new_rel.del
-      Neography::Relationship.load(new_rel).should be_nil
-    end
-  end
 end

metadata

@@ -3,95 +3,95 @@ name: neography
 version: !ruby/object:Gem::Version 
   prerelease: false
   segments: 
-    - 0
-    - 0
-    - 5
-  version: 0.0.5
+  - 0
+  - 0
+  - 6
+  version: 0.0.6
 platform: ruby
 authors: 
-  - Max De Marzi
+- Max De Marzi
 autorequire: 
 bindir: bin
 cert_chain: []
 
-date: 2010-12-08 00:00:00 -08:00
+date: 2010-12-10 00:00:00 -08:00
 default_executable: 
 dependencies: 
-  - !ruby/object:Gem::Dependency 
-    name: rspec
-    prerelease: false
-    requirement: &id001 !ruby/object:Gem::Requirement 
-      none: false
-      requirements: 
-        - - ~>
-          - !ruby/object:Gem::Version 
-            segments: 
-              - 2
-              - 0
-              - 0
-              - beta
-              - 22
-            version: 2.0.0.beta.22
-    type: :development
-    version_requirements: *id001
-  - !ruby/object:Gem::Dependency 
-    name: net-http-spy
-    prerelease: false
-    requirement: &id002 !ruby/object:Gem::Requirement 
-      none: false
-      requirements: 
-        - - ~>
-          - !ruby/object:Gem::Version 
-            segments: 
-              - 0
-              - 2
-              - 1
-            version: 0.2.1
-    type: :development
-    version_requirements: *id002
-  - !ruby/object:Gem::Dependency 
-    name: fakeweb
-    prerelease: false
-    requirement: &id003 !ruby/object:Gem::Requirement 
-      none: false
-      requirements: 
-        - - ~>
-          - !ruby/object:Gem::Version 
-            segments: 
-              - 1
-              - 3
-              - 0
-            version: 1.3.0
-    type: :development
-    version_requirements: *id003
-  - !ruby/object:Gem::Dependency 
-    name: httparty
-    prerelease: false
-    requirement: &id004 !ruby/object:Gem::Requirement 
-      none: false
-      requirements: 
-        - - ~>
-          - !ruby/object:Gem::Version 
-            segments: 
-              - 0
-              - 6
-              - 1
-            version: 0.6.1
-    type: :runtime
-    version_requirements: *id004
-  - !ruby/object:Gem::Dependency 
-    name: json
-    prerelease: false
-    requirement: &id005 !ruby/object:Gem::Requirement 
-      none: false
-      requirements: 
-        - - ">="
-          - !ruby/object:Gem::Version 
-            segments: 
-              - 0
-            version: "0"
-    type: :runtime
-    version_requirements: *id005
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 2
+        - 0
+        - 0
+        - beta
+        - 22
+        version: 2.0.0.beta.22
+  type: :development
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: net-http-spy
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 2
+        - 1
+        version: 0.2.1
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: fakeweb
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 1
+        - 3
+        - 0
+        version: 1.3.0
+  type: :development
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: httparty
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 6
+        - 1
+        version: 0.6.1
+  type: :runtime
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: json
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id005
 description: A Ruby wrapper to the Neo4j Rest API see http://components.neo4j.org/neo4j-rest/ for more details.
 email: maxdemarzi@gmail.com
 executables: []
@@ -101,42 +101,43 @@ extensions: []
 extra_rdoc_files: []
 
 files: 
-  - .gitignore
-  - CONTRIBUTORS
-  - Gemfile
-  - Gemfile.lock
-  - LICENSE
-  - README.rdoc
-  - Rakefile
-  - examples/facebook.rb
-  - examples/linkedin.rb
-  - examples/traversal_example1.rb
-  - lib/neography.rb
-  - lib/neography/config.rb
-  - lib/neography/equal.rb
-  - lib/neography/neography.rb
-  - lib/neography/node.rb
-  - lib/neography/node_relationship.rb
-  - lib/neography/node_traverser.rb
-  - lib/neography/property.rb
-  - lib/neography/property_container.rb
-  - lib/neography/relationship.rb
-  - lib/neography/relationship_traverser.rb
-  - lib/neography/rest.rb
-  - lib/neography/version.rb
-  - neography.gemspec
-  - spec/integration/neography_spec.rb
-  - spec/integration/node_spec.rb
-  - spec/integration/relationship_spec.rb
-  - spec/integration/rest_bulk_spec.rb
-  - spec/integration/rest_experimental_spec.rb
-  - spec/integration/rest_index_spec.rb
-  - 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
+- .gitignore
+- CONTRIBUTORS
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- README.rdoc
+- Rakefile
+- examples/facebook.rb
+- examples/linkedin.rb
+- examples/traversal_example1.rb
+- lib/neography.rb
+- lib/neography/config.rb
+- lib/neography/equal.rb
+- lib/neography/neography.rb
+- lib/neography/node.rb
+- lib/neography/node_relationship.rb
+- lib/neography/node_traverser.rb
+- lib/neography/property.rb
+- lib/neography/property_container.rb
+- lib/neography/relationship.rb
+- lib/neography/relationship_traverser.rb
+- lib/neography/rest.rb
+- lib/neography/version.rb
+- neography.gemspec
+- spec/integration/neography_spec.rb
+- spec/integration/node_relationship_spec.rb
+- spec/integration/node_spec.rb
+- spec/integration/relationship_spec.rb
+- spec/integration/rest_bulk_spec.rb
+- spec/integration/rest_experimental_spec.rb
+- spec/integration/rest_index_spec.rb
+- 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
 homepage: http://rubygems.org/gems/neography
 licenses: []
@@ -145,23 +146,23 @@ post_install_message:
 rdoc_options: []
 
 require_paths: 
-  - lib
+- lib
 required_ruby_version: !ruby/object:Gem::Requirement 
   none: false
   requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        segments: 
-          - 0
-        version: "0"
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
 required_rubygems_version: !ruby/object:Gem::Requirement 
   none: false
   requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        segments: 
-          - 0
-        version: "0"
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
 requirements: []
 
 rubyforge_project: neography