neography 0.0.4 → 0.0.5

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    neography (0.0.3)
+    neography (0.0.4)
       httparty (~> 0.6.1)
       json
 
@@ -13,6 +13,7 @@ GEM
     fakeweb (1.3.0)
     httparty (0.6.1)
       crack (= 0.1.8)
+    json (1.4.6)
     json (1.4.6-java)
     net-http-spy (0.2.1)
     rspec (2.0.1)
@@ -28,6 +29,7 @@ GEM
 
 PLATFORMS
   java
+  ruby
 
 DEPENDENCIES
   fakeweb (~> 1.3.0)

data/README.rdoc

@@ -35,12 +35,12 @@ Just add gem 'neography' to your Gemfile and run bundle install
 
 A thin ruby wrapper Neography::Rest which tries to mirror the Neo4j Rest API and returns JSON or Nil:
 
-  #                            protocol,  server,        port,  log_file,           log_enabled
-  @neo = Neography::Rest.new ('http://', '192.168.10.1', 7479, 'log/neography.log', true)
+  #                            protocol,  server,        port,  log_file,           log_enabled, max_threads
+  @neo = Neography::Rest.new ('http://', '192.168.10.1', 7479, 'log/neography.log', true,        50)
 
 Default Parameters are:   
 
-  @neo = Neography::Rest.new ('http://', 'localhost', 7474, '/neography.log', false)
+  @neo = Neography::Rest.new ('http://', 'localhost', 7474, '/neography.log', false, 20)
 
 To Use:
 
@@ -104,6 +104,72 @@ To Use:
 
 Please see the specs for more examples.
 
+Experimental:
+
+  nodes = @neo.create_nodes(5)                                              # Create 5 empty nodes
+  nodes = @neo.create_nodes_threaded(5)                                     # Create 5 empty nodes using threads
+  nodes = @neo.create_node_nodes([{"age" => 31, "name" => "Max"},
+                                  {"age" => 24, "name" => "Alex"})          # Create two nodes with properties
+  nodes = @neo.create_node_nodes_threaded([{"age" => 31, "name" => "Max"},
+                                           {"age" => 24, "name" => "Alex"}) # Create two nodes with properties threaded
+  nodes = @neo.get_nodes([17,86,397,33])                                    # Get four nodes by their id
+
+  one_set_nodes = @neo.create_nodes(3) 
+  another_node = @neo.create_node("age" => 31, "name" => "Max")
+  nodes = @neo.get_nodes([one_set_nodes, another_node])                     # Get four nodes
+
+=== Phase 2 (work in progress):
+
+Trying to mimic the Neo4j.rb API.
+
+Now we are returning full objects.  The properties of the node or relationship can be accessed directly (node.name).
+The Neo4j ID is available by using node.neo_id .
+
+  @neo2 = Neography::Rest.new ('http://', '192.168.10.1')
+
+  Neography::Node.create                                               # Create an empty node
+  Neography::Node.create("age" => 31, "name" => "Max")                 # Create a node with some properties
+  Neography::Node.create(@neo2, {"age" => 31, "name" => "Max"})        # Create a node on the server defined in @neo2
+  Neography::Node.create({"age" => 31, "name" => "Max"}, @neo2)        # Same as above, but different order
+
+  Neography::Node.load(5)                                              # Get a node and its properties by id
+  Neography::Node.load(existing_node)                                  # Get a node and its properties by Node
+  Neography::Node.load("http://localhost:7474/db/data/node/2")         # Get a node and its properties by String
+
+  Neography::Node.load(@neo2, 5)                                       # Get a node on the server defined in @neo2
+  Neography::Node.load(5, @neo2)                                       # Same as above, but different order
+
+  n1 = Node.create
+  n1.del                                                               # Deletes the node
+  n1.exist?                                                            # returns true/false if node exists in Neo4j
+
+  n1 = Node.create("age" => 31, "name" => "Max")
+  n1[:age] #returns 31                                                 # Get a node property using [:key]
+  n1.name  #returns "Max"                                              # Get a node property as a method
+  n1[:age] = 24                                                        # Set a node property using [:key] =
+  n1.name = "Alex"                                                     # Set a node property as a method
+  n1[:hair] = "black"                                                  # Add a node property using [:key] =
+  n1.weight = 190                                                      # Add a node property as a method
+  n1[:name] = nil                                                      # Delete a node property using [:key] = nil
+  n1.name = nil                                                        # Delete a node property by setting it to nil
+ 
+  n2 = Neography::Node.create
+  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
+  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.rel?(:friends)                                                    # Has a friends relationship
+  n1.rel?(:outgoing, :friends)                                         # Has outgoing friends relationship
+  n1.rel?(:friends, :outgoing)                                         # same, just the other way
+  n1.rel?(:outgoing)                                                   # Has any outgoing relationships
+  n1.rel?(:both)                                                       # Has any relationships
+  n1.rel?(:all)                                                        # same as above
+  n1.rel?                                                              # same as above
+
+
 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]

data/lib/neography/config.rb

@@ -0,0 +1,14 @@
+module Neography
+  class Config 
+    class << self; attr_accessor :protocol, :server, :port, :log_file, :log_enabled, :logger, :max_threads end
+
+    @protocol = 'http://'
+    @server = 'localhost'
+    @port = 7474 
+    @log_file = 'neography.log'
+    @log_enabled = false
+    @logger = Logger.new(@log_file) if @log_enabled
+    @max_threads = 20
+
+  end
+end

data/lib/neography/equal.rb

@@ -0,0 +1,21 @@
+module Neography
+
+  # == This mixin is used for both nodes and relationships to decide if two entities are equal or not.
+  #
+  module Equal
+    def equal?(o)
+      eql?(o)
+    end
+
+    def eql?(o)
+      return false unless o.respond_to?(:neo_id)
+      o.neo_id == neo_id
+    end
+
+    def ==(o)
+      eql?(o)
+    end
+
+  end
+
+end

data/lib/neography/neography.rb

@@ -0,0 +1,10 @@
+module Neography
+
+  class << self
+
+    def ref_node(this_db = Neography::Rest.new)
+      this_db.get_root
+    end
+
+  end
+end

data/lib/neography/node.rb

@@ -0,0 +1,43 @@
+module Neography
+  class Node < PropertyContainer
+    include Neography::NodeRelationship
+    include Neography::Equal
+    include Neography::Property
+
+    attr_accessor :neo_server
+
+    class << self
+      def create(*args)
+        # the arguments can be an hash of properties to set or a rest instance
+        props = (args[0].respond_to?(:each_pair) && args[0]) || args[1]
+        db = (args[0].is_a?(Neography::Rest) && args[0]) || args[1] || Neography::Rest.new
+        node = Neography::Node.new(db.create_node(props))
+        node.neo_server = db
+        node
+      end
+
+      def load(*args)
+        # the first argument can be an hash of properties to set
+        node = !args[0].is_a?(Neography::Rest) && args[0] || args[1]
+
+        # a db instance can be given, it is the first argument or the second
+        db = (args[0].is_a?(Neography::Rest) && args[0]) || args[1] || Neography::Rest.new
+        node = db.get_node(node)
+        node = Neography::Node.new(node) unless node.nil?
+        node.neo_server = db unless node.nil?
+        node
+      end
+
+      #alias_method :new, :create
+    end
+
+    def del
+      self.neo_server.delete_node!(self.neo_id)
+    end
+
+    def exist?
+      !self.neo_server.get_node(self.neo_id).nil?
+    end
+
+  end
+end

data/lib/neography/node_relationship.rb

@@ -0,0 +1,45 @@
+module Neography
+  module NodeRelationship
+
+    def outgoing(types=nil)
+      if types
+        NodeTraverser.new(self).outgoing(types)
+      else
+        NodeTraverser.new(self).outgoing
+      end
+    end
+
+    def incoming(types=nil)
+      if types
+        NodeTraverser.new(self).incoming(types)
+      else
+        NodeTraverser.new(self).incoming
+      end
+    end
+
+    def both(types=nil)
+      if types
+        NodeTraverser.new(self).both(types)
+      else
+        NodeTraverser.new(self) # default is both
+      end
+    end
+
+    def rels(*types)
+      Neography::RelationshipTraverser.new(self, types, :both)
+    end
+
+    def rel(dir, type)
+      Neography::RelationshipTraverser.new(self, type, dir).first
+    end
+
+    def rel?(dir=nil, type=nil)
+      if DIRECTIONS.include?(dir.to_s)
+        !self.neo_server.get_node_relationships(self, dir, type).nil? 
+      else
+        !self.neo_server.get_node_relationships(self, type, dir).nil? 
+      end
+    end
+
+  end
+end

data/lib/neography/node_traverser.rb

@@ -0,0 +1,23 @@
+module Neography
+  class NodeTraverser
+    include Enumerable
+
+    attr_accessor :order, :uniqueness, :depth, :prune, :filter
+
+    def initialize(from, types = nil, dir=nil)
+      @from  = from
+      @depth = 1
+      @order = "depth first"
+      @uniqueness = "none"
+      if types.nil? || dir.nil?
+#        @td    = org.neo4j.kernel.impl.traversal.TraversalDescriptionImpl.new.breadth_first()
+      else
+#        @types  = type_to_java(type)
+#        @dir   = dir_to_java(dir)
+#        @td    = org.neo4j.kernel.impl.traversal.TraversalDescriptionImpl.new.breadth_first().relationships(@type, @dir)
+      end
+    end
+
+  end
+
+end

data/lib/neography/property.rb

@@ -0,0 +1,55 @@
+module Neography
+  module Property
+
+
+    def [](key)
+      return unless respond_to?(key)
+      @table[key]
+    end
+
+    def []=(key, value)
+      k = key.to_s
+      if value.nil?
+        if self.is_a? Neography::Node
+          neo_server.remove_node_properties(self.neo_id, [key])
+          @table[key] = nil
+        else
+          neo_server.remove_relationship_properties(self.neo_id, [key])
+          @table[key] = nil
+        end
+      else
+        if self.is_a? Neography::Node
+          neo_server.set_node_properties(self.neo_id, {k => value})
+        else
+          neo_server.set_relationship_properties(self.neo_id, {k => value})
+        end
+       
+        new_ostruct_member(k) unless self.respond_to?(key)
+
+      end
+    end
+
+
+  def new_ostruct_member(name)
+    name = name.to_sym
+    unless self.respond_to?(name)
+      meta = class << self; self; end
+      meta.send(:define_method, name) { @table[name] }
+      meta.send(:define_method, "#{name}=") do |x| 
+        @table[name] = x 
+        self[name.to_sym] = x        
+      end
+    end
+  end
+
+
+  def self.method_missing(method_sym, *arguments, &block)
+    if (method_sym.to_s =~ /$=/) != nil
+      new_ostruct_member(method_sym.to_s.chomp("="))
+    else
+      super
+    end
+  end
+
+  end
+end

data/lib/neography/property_container.rb

@@ -0,0 +1,17 @@
+module Neography
+  class PropertyContainer < OpenStruct
+    attr_reader :neo_id
+
+    def initialize(hash=nil)
+      @table = {}
+      if hash
+        @neo_id = hash["self"].split('/').last
+        for k,v in hash["data"]
+          @table[k.to_sym] = v
+          new_ostruct_member(k)
+        end
+      end
+    end
+
+  end
+end

data/lib/neography/relationship.rb

@@ -0,0 +1,54 @@
+module Neography
+  class Relationship < PropertyContainer
+    include Neography::Equal
+    include Neography::Property
+
+    attr_accessor :start_node, :end_node, :rel_type
+
+    class << self
+
+      def create(type, from_node, to_node, props=nil)
+        rel = Neography::Relationship.new(from_node.neo_server.create_relationship(type, from_node, to_node, props))
+        rel.start_node = from_node
+        rel.end_node = to_node
+        rel.rel_type = type
+        rel
+      end
+
+      def load(*args)
+        # the first argument can be an hash of properties to set
+        rel = !args[0].is_a?(Neography::Rest) && args[0] || args[1]
+
+        # a db instance can be given, it is the first argument or the second
+        db = (args[0].is_a?(Neography::Rest) && args[0]) || args[1] || Neography::Rest.new
+        rel = db.get_relationship(rel)
+        unless rel.nil?
+          rel = Neography::Relationship.new(rel) 
+          rel.start_node = Neography::Node.load(rel.start_node) 
+          rel.end_node = Neography::Node.load(rel.end_node) 
+        end
+        rel
+      end
+    end
+
+    def initialize(hash=nil, neo_server=nil)
+      super(hash)
+      @start_node = hash["start"].split('/').last
+      @end_node = hash["end"].split('/').last
+      @rel_type = hash["type"]
+    end
+
+    def del
+      self.start_node.neo_server.delete_relationship(self.neo_id)
+    end
+
+    def other_node(node)
+      if node = @start_node
+        @end_node
+      else
+        @start_node
+      end
+    end
+
+  end
+end

data/lib/neography/relationship_traverser.rb

@@ -0,0 +1,59 @@
+module Neography
+  class RelationshipTraverser
+    include Enumerable
+
+    def initialize(node, types, direction)
+      @node      = node
+      @types     = [types]
+      @direction = direction
+    end
+
+    def to_s
+      if @types.size == 1 && !@types.empty?
+        "#{self.class} [type: #{@type} dir:#{@direction}]"
+      elsif !@types.empty?
+        "#{self.class} [types: #{@types.join(',')} dir:#{@direction}]"
+      else
+        "#{self.class} [types: ANY dir:#{@direction}]"
+      end
+    end
+
+    def each
+      iterator.each { |i| yield Neography::Relationship.new(i, @node.neo_server) }
+    end
+
+    def empty?
+      first == nil
+    end
+    
+    def iterator
+      @node.neo_server.get_node_relationships(@node, @direction, @types)
+    end
+
+    def del
+      each { |rel| @node.neo_server.delete_relationship(rel) }
+    end
+
+    def size
+      [*self].size
+    end
+
+    def both
+      @direction = :both
+      self
+    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
+
+  end
+end

data/lib/neography/rest.rb

@@ -1,15 +1,21 @@
 module Neography
   class Rest
     include HTTParty
-    attr_accessor :protocol, :server, :port, :log_file, :log_enabled, :logger
-
-      def initialize(protocol='http://', server='localhost', port=7474, log_file='neography.log', log_enabled=false)
+    attr_accessor :protocol, :server, :port, :log_file, :log_enabled, :logger, :max_threads
+
+      def initialize(protocol=Neography::Config.protocol, 
+                     server=Neography::Config.server, 
+                     port=Neography::Config.port, 
+                     log_file=Neography::Config.log_file, 
+                     log_enabled=Neography::Config.log_enabled, 
+                     max_threads=Neography::Config.max_threads)
         @protocol = protocol
         @server = server
         @port = port 
         @log_file = log_file
         @log_enabled = log_enabled
         @logger = Logger.new(@log_file) if @log_enabled
+        @max_threads = max_threads
       end
 
       def configure(protocol, server, port)
@@ -35,10 +41,67 @@ module Neography
         end
       end
 
+      def create_nodes(nodes)
+        nodes = Array.new(nodes) if nodes.kind_of? Fixnum
+        created_nodes = Array.new
+        nodes.each do |node|
+            created_nodes <<  create_node(node)
+        end
+        created_nodes
+      end
+
+      def create_nodes_threaded(nodes)
+        nodes = Array.new(nodes) if nodes.kind_of? Fixnum
+
+        node_queue = Queue.new
+        thread_pool = []
+        responses = Queue.new
+
+        nodes.each do |node|
+          node_queue.push node
+        end
+
+        [nodes.size, @max_threads].min.times do
+          thread_pool << Thread.new do
+            until node_queue.empty? do
+              node = node_queue.pop
+              if node.respond_to?(:each_pair) 
+                responses.push( post("/node", { :body => node.to_json, :headers => {'Content-Type' => 'application/json'} } ) )
+              else
+                responses.push( post("/node") )
+              end
+            end 
+            self.join
+          end
+        end
+
+        created_nodes = Array.new
+
+        while created_nodes.size < nodes.size 
+          created_nodes << responses.pop
+        end
+        created_nodes
+      end
+
+#  This is not yet implemented in the REST API
+#
+#      def get_all_node
+#        puts "get all nodes"
+#        get("/nodes/")
+#      end
+
       def get_node(id)
         get("/node/#{get_id(id)}")
       end
 
+      def get_nodes(*nodes)
+        gotten_nodes = Array.new
+        Array(nodes).flatten.each do |node|
+            gotten_nodes <<  get_node(node)
+        end
+        gotten_nodes
+      end
+
       def reset_node_properties(id, properties)
         options = { :body => properties.to_json, :headers => {'Content-Type' => 'application/json'} } 
         put("/node/#{get_id(id)}/properties", options)
@@ -49,7 +112,7 @@ module Neography
           get("/node/#{get_id(id)}/properties")
         else
           node_properties = Hash.new 
-          properties.to_a.each do |property| 
+          Array(properties).each do |property| 
             value = get("/node/#{get_id(id)}/properties/#{property}")
             node_properties[property] = value unless value.nil?
           end
@@ -62,7 +125,7 @@ module Neography
         if properties.nil?
           delete("/node/#{get_id(id)}/properties")
         else 
-          properties.to_a.each do |property| 
+          Array(properties).each do |property| 
             delete("/node/#{get_id(id)}/properties/#{property}") 
           end
         end
@@ -98,7 +161,7 @@ module Neography
           get("/relationship/#{get_id(id)}/properties")
         else
           relationship_properties = Hash.new 
-          properties.to_a.each do |property| 
+          Array(properties).each do |property| 
             value = get("/relationship/#{get_id(id)}/properties/#{property}")
             relationship_properties[property] = value unless value.nil?
           end
@@ -111,7 +174,7 @@ module Neography
         if properties.nil?
           delete("/relationship/#{get_id(id)}/properties")
         else 
-          properties.to_a.each do |property| 
+          Array(properties).each do |property| 
             delete("/relationship/#{get_id(id)}/properties/#{property}")
           end
         end
@@ -134,7 +197,7 @@ module Neography
         if types.nil?
           node_relationships = get("/node/#{get_id(id)}/relationships/#{dir}") || Array.new
         else
-          node_relationships = get("/node/#{get_id(id)}/relationships/#{dir}/#{types.to_a.join('&')}") || Array.new
+          node_relationships = get("/node/#{get_id(id)}/relationships/#{dir}/#{Array(types).join('&')}") || Array.new
         end
         return nil if node_relationships.empty?
         node_relationships
@@ -235,6 +298,8 @@ module Neography
             id["self"].split('/').last
           when String
             id.split('/').last
+          when Neography::Node, Neography::Relationship
+            id.neo_id
           else
             id
           end 

data/lib/neography/version.rb

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

data/lib/neography.rb

@@ -15,12 +15,28 @@ def find_and_require_user_defined_code
   end
 end
 
+DIRECTIONS = ["incoming", "in", "outgoing", "out", "all", "both"]
+
 
 require 'httparty'
 require 'json'
 require 'logger'
+require 'ostruct'
 
+require 'neography/config'
 require 'neography/rest'
+require 'neography/neography'
+
+require 'neography/property_container'
+require 'neography/property'
+require 'neography/node_relationship'
+require 'neography/relationship_traverser'
+require 'neography/node_traverser'
+require 'neography/equal'
+
+
+require 'neography/node'
+require 'neography/relationship'
 
 find_and_require_user_defined_code
 

data/spec/integration/neography_spec.rb

@@ -0,0 +1,10 @@
+require File.join(File.dirname(__FILE__), '..', 'spec_helper')
+
+describe Neography do
+  describe "ref_node" do
+    it "can get the reference node" do
+      root_node = Neography.ref_node
+      root_node.should have_key("reference_node")
+    end
+  end
+end

data/spec/integration/node_spec.rb

@@ -0,0 +1,198 @@
+require File.join(File.dirname(__FILE__), '..', 'spec_helper')
+
+describe Neography::Node do
+
+  describe "create and new" do
+    it "can create an empty node" do
+      new_node = Neography::Node.create
+      new_node.should_not be_nil
+    end
+
+    it "can create a node with one property" do
+      new_node = Neography::Node.create("name" => "Max")
+      new_node.name.should == "Max"
+    end
+
+    it "can create a node with more than one property" do
+      new_node = Neography::Node.create("age" => 31, "name" => "Max")
+      new_node.name.should == "Max"
+      new_node.age.should == 31
+    end
+
+    it "can create a node with more than one property not on the default rest server" do
+      @neo = Neography::Rest.new
+      new_node = Neography::Node.create({"age" => 31, "name" => "Max"}, @neo)
+      new_node.name.should == "Max"
+      new_node.age.should == 31
+    end
+
+    it "can create a node with more than one property not on the default rest server the other way" do
+      @neo = Neography::Rest.new
+      new_node = Neography::Node.create(@neo, {"age" => 31, "name" => "Max"})
+      new_node.name.should == "Max"
+      new_node.age.should == 31
+    end
+  end
+
+
+  describe "load" do
+    it "can get a node that exists" do
+      new_node = Neography::Node.create
+      existing_node = Neography::Node.load(new_node)
+      existing_node.should_not be_nil
+      existing_node.neo_id.should_not be_nil
+      existing_node.neo_id.should == new_node.neo_id
+    end
+
+    it "returns nil if it tries to load a node that does not exist" do
+      new_node = Neography::Node.create
+      fake_node = new_node.neo_id.to_i + 1000
+      existing_node = Neography::Node.load(fake_node)
+      existing_node.should be_nil
+    end
+
+    it "can load a node that exists not on the default rest server" do
+      @neo = Neography::Rest.new
+      new_node = Neography::Node.create(@neo)
+      existing_node = Neography::Node.load(new_node, @neo)
+      existing_node.should_not be_nil
+      existing_node.neo_id.should_not be_nil
+      existing_node.neo_id.should == new_node.neo_id
+    end
+
+    it "can load a node that exists not on the default rest server the other way" do
+      @neo = Neography::Rest.new
+      new_node = Neography::Node.create(@neo)
+      existing_node = Neography::Node.load(@neo, new_node)
+      existing_node.should_not be_nil
+      existing_node.neo_id.should_not be_nil
+      existing_node.neo_id.should == new_node.neo_id
+    end
+  end
+
+  describe "del" do
+    it "can delete itself" do
+      new_node = Neography::Node.create
+      node_id = new_node.neo_id
+      new_node.del
+      deleted_node = Neography::Node.load(node_id)
+      deleted_node.should be_nil
+    end
+  end
+
+  describe "exists?" do
+    it "can tell if it exists" do
+      new_node = Neography::Node.create
+      new_node.exist?.should be_true 
+    end
+
+    it "can tell if does not exists" do
+      new_node = Neography::Node.create
+      new_node.del
+      new_node.exist?.should be_false
+    end
+  end
+
+  describe "equality" do
+    it "can tell two nodes are the same with equal?" do
+      new_node = Neography::Node.create
+      another_node = Neography::Node.load(new_node)
+      new_node.equal?(another_node).should be_true 
+    end
+
+    it "can tell two nodes are the same with eql?" do
+      new_node = Neography::Node.create
+      another_node = Neography::Node.load(new_node)
+      new_node.eql?(another_node).should be_true 
+    end
+
+    it "can tell two nodes are the same with ==" do
+      new_node = Neography::Node.create
+      another_node = Neography::Node.load(new_node)
+      (new_node == another_node).should be_true 
+    end
+  end
+
+  describe "set properties" do
+    it "can change a node's properties that already exist using []=" do
+      new_node = Neography::Node.create("weight" => 150, "eyes" => "green")
+
+      new_node[:weight] = 200
+      new_node[:eyes] = "brown"
+
+      existing_node = Neography::Node.load(new_node)
+      existing_node.weight.should == 200
+      existing_node.eyes.should == "brown"
+    end
+
+    it "can change a node's properties that already exist" do
+      new_node = Neography::Node.create("weight" => 150, "eyes" => "green")
+
+      new_node.weight = 200
+      new_node.eyes = "brown"
+
+      existing_node = Neography::Node.load(new_node)
+      existing_node.weight.should == 200
+      existing_node.eyes.should == "brown"
+    end
+
+    it "can change a node's properties that does not already exist" do
+      new_node = Neography::Node.create("weight" => 150, "eyes" => "green")
+
+      new_node.weight = 200
+      new_node.eyes = "brown"
+      new_node[:hair] = "black"
+
+      existing_node = Neography::Node.load(new_node)
+      existing_node.weight.should == 200
+      existing_node.eyes.should == "brown"
+      existing_node.hair.should == "black"
+    end
+  end
+
+  describe "get node properties" do
+    it "can get node properties using []" do
+      new_node = Neography::Node.create("weight" => 150, "eyes" => "green")
+      new_node[:weight].should == 150
+      new_node[:eyes].should == "green"
+    end
+
+    it "can get node properties" do
+      new_node = Neography::Node.create("weight" => 150, "eyes" => "green")
+      new_node.weight.should == 150
+      new_node.eyes.should == "green"
+    end
+  end
+
+  describe "delete node properties" do
+    it "can delete node properties using []" do
+      new_node = Neography::Node.create("weight" => 150, "eyes" => "green")
+
+      new_node[:weight] = nil
+      new_node[:eyes] = nil
+
+      new_node[:weight].should be_nil
+      new_node[:eyes].should be_nil
+
+      existing_node = Neography::Node.load(new_node)
+      existing_node.weight.should be_nil
+      existing_node.eyes.should be_nil
+    end
+
+    it "can delete node properties" do
+      new_node = Neography::Node.create("weight" => 150, "eyes" => "green")
+
+      new_node.weight = nil
+      new_node.eyes = nil
+
+      new_node.weight.should be_nil
+      new_node.eyes.should be_nil
+
+      existing_node = Neography::Node.load(new_node)
+      existing_node.weight.should be_nil
+      existing_node.eyes.should be_nil
+    end
+  end
+
+
+end

data/spec/integration/relationship_spec.rb

@@ -0,0 +1,71 @@
+require File.join(File.dirname(__FILE__), '..', 'spec_helper')
+
+describe Neography::Relationship do
+  describe "create relationship" do
+    it "#new(:family, p1, p2) creates a new relationship between to nodes of given type" 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)
+    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
+      rel.colourshould == 'blue'
+    end
+
+    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
+    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/rest_bulk_spec.rb

@@ -0,0 +1,106 @@
+require File.join(File.dirname(__FILE__), '..', 'spec_helper')
+
+describe Neography::Rest do
+  before(:each) do
+    @neo = Neography::Rest.new
+  end
+
+  describe "can create many nodes threaded" do
+    it "can create empty nodes threaded" do
+      new_nodes = @neo.create_nodes_threaded(2)
+      new_nodes.should_not be_nil
+      new_nodes.size.should == 2
+    end
+
+    it "is faster than non-threaded?" do
+      Benchmark.bm do |x|
+        x.report("create 500 nodes         ") { @not_threaded = @neo.create_nodes(500) }
+        x.report("create 500 nodes threaded") { @threaded     = @neo.create_nodes_threaded(500) }
+        x.report("create 1000 nodes threaded") { @threaded2c   = @neo.create_nodes_threaded(1000) }
+      end
+
+      @not_threaded[99].should_not be_nil
+      @threaded[99].should_not be_nil
+      @threaded2c[199].should_not be_nil
+    end
+
+  end
+
+  describe "can create many nodes" do
+    it "can create empty nodes" do
+      new_nodes = @neo.create_nodes(2)
+      new_nodes.should_not be_nil
+      new_nodes.size.should == 2
+    end
+
+    it "can create nodes with one property" do
+      new_nodes = @neo.create_nodes([{"name" => "Max"}, {"name" => "Alex"}])
+      new_nodes[0]["data"]["name"].should == "Max"
+      new_nodes[1]["data"]["name"].should == "Alex"
+    end
+
+    it "can create nodes with one property that are different" do
+      new_nodes = @neo.create_nodes([{"name" => "Max"}, {"age" => 24}])
+      new_nodes[0]["data"]["name"].should == "Max"
+      new_nodes[1]["data"]["age"].should == 24
+    end
+
+    it "can create nodes with more than one property" do
+      new_nodes = @neo.create_nodes([{"age" => 31, "name" => "Max"}, {"age" => 24, "name" => "Alex"}])
+      new_nodes[0]["data"]["name"].should == "Max"
+      new_nodes[0]["data"]["age"].should == 31
+      new_nodes[1]["data"]["name"].should == "Alex"
+      new_nodes[1]["data"]["age"].should == 24
+    end
+
+    it "can create nodes with more than one property that are different" do
+      new_nodes = @neo.create_nodes([{"age" => 31, "name" => "Max"}, {"height" => "5-11", "weight" => 215}])
+      new_nodes[0]["data"]["name"].should == "Max"
+      new_nodes[0]["data"]["age"].should == 31
+      new_nodes[1]["data"]["height"].should == "5-11"
+      new_nodes[1]["data"]["weight"].should == 215
+    end
+
+    it "is not super slow?" do
+      Benchmark.bm do |x|
+        x.report(  "create 1 node" ) { @neo.create_nodes(  1) }
+        x.report( "create 10 nodes") { @neo.create_nodes( 10) }
+        x.report("create 100 nodes") { @neo.create_nodes(100) }
+      end
+    end
+  end
+
+  describe "can get many nodes" do
+    it "can get 2 nodes passed in as an array" do
+      new_nodes = @neo.create_nodes(2)
+      existing_nodes = @neo.get_nodes(new_nodes)
+      existing_nodes.should_not be_nil
+      existing_nodes.size.should == 2
+    end
+
+    it "can get 2 nodes passed in by commas" do
+      new_nodes = @neo.create_nodes(2)
+      new_node1 = new_nodes[0]["self"].split('/').last
+      new_node2 = new_nodes[1]["self"].split('/').last
+      existing_nodes = @neo.get_nodes(new_node1, new_node2)
+      existing_nodes.should_not be_nil
+      existing_nodes.size.should == 2
+      existing_nodes[0]["self"] == new_node1["self"]
+      existing_nodes[1]["self"] == new_node2["self"]
+    end
+
+    it "is not super slow?" do
+               one_node  = @neo.create_nodes(  1)
+              ten_nodes =  @neo.create_nodes( 10)
+      one_hundred_nodes =  @neo.create_nodes(100)
+
+      Benchmark.bm do |x|
+        x.report(  "get 1 node ") { @neo.get_nodes(one_node) }
+        x.report( "get 10 nodes") { @neo.get_nodes(ten_nodes) }
+        x.report("get 100 nodes") { @neo.get_nodes(one_hundred_nodes) }
+      end
+    end
+
+  end
+
+end

data/spec/integration/rest_experimental_spec.rb

@@ -0,0 +1,23 @@
+require File.join(File.dirname(__FILE__), '..', 'spec_helper')
+
+describe Neography::Rest do
+  before(:each) do
+    @neo = Neography::Rest.new
+  end
+
+
+  describe "get_nodes" do
+    it "can get nodes that exists" do
+      existing_nodes = @neo.get_nodes
+      existing_nodes.should_not be_nil
+      puts existing_nodes.inspect
+    end
+
+    it "can get all nodes that exists the ugly way" do
+      new_node = @neo.create_node
+      last_node_id = new_node["self"].split('/').last.to_i
+      existing_nodes = @neo.get_nodes((1..last_node_id).to_a)
+      existing_nodes.should_not be_nil
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -1,5 +1,6 @@
 require 'neography'
 require 'fakeweb'
+require 'benchmark'
 
 Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each {|f| require f}
 

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
     - 0
     - 0
-    - 4
-  version: 0.0.4
+    - 5
+  version: 0.0.5
 platform: ruby
 authors: 
   - Max De Marzi
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-11-21 00:00:00 -08:00
+date: 2010-12-08 00:00:00 -08:00
 default_executable: 
 dependencies: 
   - !ruby/object:Gem::Dependency 
@@ -112,9 +112,24 @@ files:
   - 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