neography 1.5.0 → 1.5.1

data/Guardfile

@@ -0,0 +1,14 @@
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+guard :rspec do
+  # Just rerun the whole suite until the file names are matching
+  # in lib/ and spec/
+  #
+  # watch(%r{^lib/(.+)\.rb$})     { |m| "spec/lib/#{m[1]}_spec.rb" }
+  # watch(%r{^lib/(.+)\.rb$})     { |m| "spec/unit/lib/#{m[1]}_spec.rb" }
+  watch(%r{^lib/(.+)\.rb$})     { "spec" }
+
+  watch(%r{^spec/.+_spec\.rb$})
+  watch('spec/spec_helper.rb')  { "spec" }
+end

data/README.md

@@ -61,20 +61,22 @@ Configure Neography as follows:
 ```ruby
 # these are the default values:
 Neography.configure do |config|
-  config.protocol           = "http://"
-  config.server             = "localhost"
-  config.port               = 7474
-  config.directory          = ""  # prefix this path with '/'
-  config.cypher_path        = "/cypher"
-  config.gremlin_path       = "/ext/GremlinPlugin/graphdb/execute_script"
-  config.log_file           = "neography.log"
-  config.log_enabled        = false
-  config.slow_log_threshold = 0    # time in ms for query logging
-  config.max_threads        = 20
-  config.authentication     = nil  # 'basic' or 'digest'
-  config.username           = nil
-  config.password           = nil
-  config.parser             = MultiJsonParser
+  config.protocol             = "http://"
+  config.server               = "localhost"
+  config.port                 = 7474
+  config.directory            = ""  # prefix this path with '/'
+  config.cypher_path          = "/cypher"
+  config.gremlin_path         = "/ext/GremlinPlugin/graphdb/execute_script"
+  config.log_file             = "neography.log"
+  config.log_enabled          = false
+  config.slow_log_threshold   = 0    # time in ms for query logging
+  config.max_threads          = 20
+  config.authentication       = nil  # 'basic' or 'digest'
+  config.username             = nil
+  config.password             = nil
+  config.parser               = MultiJsonParser
+  config.http_send_timeout    = 1200
+  config.http_receive_timeout = 1200
   end
   ```
 

data/lib/neography/connection.rb

@@ -234,6 +234,7 @@ module Neography
         when /NodeNotFoundException/         ; NodeNotFoundException
         when /NoSuchPropertyException/       ; NoSuchPropertyException
         when /RelationshipNotFoundException/ ; RelationshipNotFoundException
+        when /ParameterNotFoundException/    ; ParameterNotFoundException
         when /NotFoundException/             ; NotFoundException
         when /UniquePathNotUniqueException/  ; UniquePathNotUniqueException
         when /DeadlockDetectedException/     ; DeadlockDetectedException

data/lib/neography/errors.rb

@@ -54,4 +54,7 @@ module Neography
   # Unknown batch option exception detected
   class UnknownBatchOptionException < NeographyError; end
 
+  # A Cypher query is using a parameter that is not supplied
+  class ParameterNotFoundException < NeographyError; end
+
 end

data/lib/neography/node.rb

@@ -8,36 +8,32 @@ module Neography
 
     attr_accessor :neo_server
 
-    class << self
-      def create(props = nil, db = Neography::Rest.new)
-        raise ArgumentError.new("syntax deprecated") if props.is_a?(Neography::Rest)
+    def self.create(props = nil, db = Neography::Rest.new)
+      raise ArgumentError.new("syntax deprecated") if props.is_a?(Neography::Rest)
 
-        node = self.new(db.create_node(props))
-        node.neo_server = db
-        node
-      end
+      node = self.new(db.create_node(props))
+      node.neo_server = db
+      node
+    end
 
-      def create_unique(index, key, value, props = nil, db = Neography::Rest.new)
-        raise ArgumentError.new("syntax deprecated") if props.is_a?(Neography::Rest)
+    def self.create_unique(index, key, value, props = nil, db = Neography::Rest.new)
+      raise ArgumentError.new("syntax deprecated") if props.is_a?(Neography::Rest)
 
-        node = self.new(db.create_unique_node(index, key, value, props))
-        node.neo_server = db
-        node
-      end
+      node = self.new(db.create_unique_node(index, key, value, props))
+      node.neo_server = db
+      node
+    end
 
-      def load(node, db = Neography::Rest.new)
-        raise ArgumentError.new("syntax deprecated") if node.is_a?(Neography::Rest)
-        node = node.first if node.kind_of?(Array)
-        node = db.get_node(node) if (node.to_s.match(/^\d+$/) or node.to_s.split("/").last.match(/^\d+$/))
-        if node
-          node = self.new(node)
-          node.neo_server = db
-        end
-        node
+    def self.load(node, db = Neography::Rest.new)
+      raise ArgumentError.new("syntax deprecated") if node.is_a?(Neography::Rest)
+      node = node.first if node.kind_of?(Array)
+      node = db.get_node(node) if (node.to_s.match(/^\d+$/) or node.to_s.split("/").last.match(/^\d+$/))
+      if node
+        node = self.new(node)
+        node.neo_server = db
       end
-
-      #alias_method :new, :create
-    end    
+      node
+    end
 
     def find(*args)
       node = self.new

data/lib/neography/property.rb

@@ -2,9 +2,7 @@ module Neography
   module Property
 
     def [](key)
-      key = key.to_sym
-      return unless respond_to?(key)
-      @table[key]
+      @table[key.to_sym]
     end
 
     def []=(key, value)
@@ -12,38 +10,75 @@ module Neography
       k_str = key.to_s
       if value.nil?
         unless @table[key].nil?
-          if self.is_a? Neography::Node
+          if node?
             neo_server.remove_node_properties(self.neo_id, [k_str])
           else
             neo_server.remove_relationship_properties(self.neo_id, [k_str])
           end
         end
+        remove_ostruct_member(key)
       else
-        if self.is_a? Neography::Node
+        if node?
           neo_server.set_node_properties(self.neo_id, {k_str => value})
         else
           neo_server.set_relationship_properties(self.neo_id, {k_str => value})
         end
-        new_ostruct_member(key) unless self.respond_to?(key)
+        new_ostruct_member(key, value)
+      end
+    end
+
+    # Set many properties at once and only issue one http
+    # request and update the node/relationship instance on the fly.
+    #
+    # To remove a property, set its value to nil.
+    def set_properties(hash)
+      hash.each do |key, value|
+        add_or_remove_ostruct_member(key, value)
+      end
+      rest_reset_properties
+    end
+
+    # As #set_properties, but this one hard resets the node's/relationship's
+    # properties to exactly what's given in the hash.
+    def reset_properties(hash)
+      @table.keys.each{|key| remove_ostruct_member(key)}
+      hash.each{|key,value| new_ostruct_member(key,value)}
+      rest_reset_properties
+    end
+
+    def add_or_remove_ostruct_member(name, value)
+      if value.nil?
+        remove_ostruct_member(name)
+      else
+        new_ostruct_member(name, value)
       end
-      @table[key] = value
     end
 
-    def new_ostruct_member(name)
+    def new_ostruct_member(name, value)
       name = name.to_sym
+      @table[name] = value
       unless self.respond_to?(name)
         meta = class << self; self; end
         meta.send(:define_method, name) { @table[name] }
-        meta.send(:define_method, "#{name}=") do |value|
-          self[name.to_sym] = value
+        meta.send(:define_method, "#{name}=") do |new_value|
+          self[name.to_sym] = new_value
         end
       end
       name
     end
 
+    def remove_ostruct_member(name)
+      @table.delete(name.to_sym)
+      meta = class << self; self; end
+      names = [name, "#{name}="].map(&:to_sym)
+      names.each do |n|
+        meta.send(:remove_method, n) if self.respond_to?(n)
+      end
+    end
+
     def method_missing(method_sym, *arguments, &block)
       if (method_sym.to_s =~ /=$/) != nil
-        new_ostruct_member(method_sym.to_s.chomp("="))
+        new_ostruct_member(method_sym.to_s.chomp("="), *arguments)
 
         # We just defined the getter/setter above, but we haven't actually
         # applied them yet.
@@ -57,5 +92,19 @@ module Neography
       @table.keys
     end
 
+    def node?
+      self.is_a?(Neography::Node)
+    end
+
+    private
+
+    def rest_reset_properties
+      if node?
+        neo_server.reset_node_properties(self.neo_id, @table)
+      else
+        neo_server.reset_relationship_properties(self.neo_id, @table)
+      end
+    end
+
   end
 end

data/lib/neography/property_container.rb

@@ -4,7 +4,7 @@ module Neography
 
     def initialize(hash=nil)
       @table = {}
-      if hash
+      unless hash.nil?
         if hash["self"] # coming from REST API
           @neo_id = hash["self"].split('/').last
           data = hash["data"]
@@ -12,16 +12,15 @@ module Neography
           @neo_id = hash.neo_id
           data = Hash[*hash.attributes.collect{|x| [x.to_sym, hash.send(x)]}.flatten]
         elsif hash["data"] # coming from CYPHER
-          @neo_id = hash["data"].first.first["self"].split('/').last  
+          @neo_id = hash["data"].first.first["self"].split('/').last
           data = hash["data"].first.first["data"]
         end
       else
         data = []
-      end      
-      
+      end
+
       for k,v in data
-        @table[k.to_sym] = v
-        new_ostruct_member(k)
+        new_ostruct_member(k.to_sym, v)
       end
     end
 

data/lib/neography/rest/batch.rb

@@ -83,6 +83,16 @@ module Neography
           }
         end
       end
+      
+      def batch_create_or_fail_unique_node(index, key, value, properties = {})
+        post "/index/node/%{index}?uniqueness=%{function}" %  {:index => index, :function => 'create_or_fail'} do
+          {
+            :key        => key,
+            :value      => value,
+            :properties => properties
+          }
+        end
+      end
 
       def batch_add_node_to_index(index, key, value, id, unique = false)
         path = unique ? "/index/node/%{index}?unique" % {:index => index} : "/index/node/%{index}" % {:index => index}

data/lib/neography/rest/node_properties.rb

@@ -1,7 +1,7 @@
 module Neography
   class Rest
     module NodeProperties
-    
+
       def set_node_properties(id, properties)
         properties.each do |property, value|
           options = { :body => value.to_json, :headers => json_content_type }

data/lib/neography/version.rb

@@ -1,3 +1,3 @@
 module Neography
-  VERSION = "1.5.0"
+  VERSION = "1.5.1"
 end

data/neography.gemspec

@@ -12,7 +12,7 @@ Gem::Specification.new do |s|
   s.summary     = "ruby wrapper to Neo4j Rest API"
   s.description = "A Ruby wrapper to the Neo4j Rest API see http://docs.neo4j.org/chunked/stable/rest-api.html for more details."
   s.license     = 'MIT'
-  
+
   s.rubyforge_project = "neography"
 
   s.files         = `git ls-files`.split("\n")
@@ -23,12 +23,14 @@ Gem::Specification.new do |s|
   s.add_development_dependency "rspec", ">= 2.11"
   s.add_development_dependency "net-http-spy", "0.2.1"
   s.add_development_dependency "coveralls"
+  s.add_development_dependency "debugger"
+  s.add_development_dependency "guard-rspec"
   s.add_dependency "excon", "~> 0.33.0"
   s.add_dependency "json", ">= 1.7.7"
   s.add_dependency "os", ">= 0.9.6"
   s.add_dependency "rubyzip", ">= 1.0.0"
   s.add_dependency "multi_json", ">= 1.3.2"
-  
+
   if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
     s.add_runtime_dependency 'rake', '>= 0.8.7'
   else

data/spec/integration/authorization_spec.rb

@@ -6,7 +6,7 @@ describe Neography::Rest, :slow => true do
       it "can get the root node"do
         @neo = Neography::Rest.new({:authentication => 'digest', :username => "username", :password => "password"})
         root_node = @neo.get_root
-        root_node.should have_key("reference_node")
+        expect(root_node).to have_key("reference_node")
       end
     end    
     
@@ -14,7 +14,7 @@ describe Neography::Rest, :slow => true do
       it "can create an empty node" do
         @neo = Neography::Rest.new({:authentication => 'basic', :username => "username", :password => "password"})
         new_node = @neo.create_node
-        new_node.should_not be_nil
+        expect(new_node).not_to be_nil
       end
     end
 
@@ -22,7 +22,7 @@ describe Neography::Rest, :slow => true do
       it "can create an empty node" do
         @neo = Neography::Rest.new("http://username:password@localhost:7474")
         new_node = @neo.create_node
-        new_node.should_not be_nil
+        expect(new_node).not_to be_nil
       end
     end
   end
@@ -32,7 +32,7 @@ describe Neography::Rest, :slow => true do
       it "can create an empty node" do
         @neo = Neography::Rest.new({:authentication => 'digest', :username => "username", :password => "password"})
         new_node = @neo.create_node
-        new_node.should_not be_nil
+        expect(new_node).not_to be_nil
       end
     end
   end

data/spec/integration/broken_spatial_spec.rb

@@ -17,12 +17,12 @@ describe Neography::Rest do
       # getting "The transaction is marked for rollback only." errors
       # possibly related to a Cypher Transaction Bug.
       puts batch_result.inspect
-      batch_result[0].first["data"]["layer"].should == "restaurantsbatch"
-      batch_result[1].first["data"]["lat"].should == properties[:lat]
-      batch_result[1].first["data"]["lon"].should == properties[:lon]
-      batch_result[2].first["data"]["layer"].should == "restaurantsbatch"
-      batch_result[3].first["data"].should_not be_empty
-      batch_result[4].first["data"].should_not be_empty
+      expect(batch_result[0].first["data"]["layer"]).to eq("restaurantsbatch")
+      expect(batch_result[1].first["data"]["lat"]).to eq(properties[:lat])
+      expect(batch_result[1].first["data"]["lon"]).to eq(properties[:lon])
+      expect(batch_result[2].first["data"]["layer"]).to eq("restaurantsbatch")
+      expect(batch_result[3].first["data"]).not_to be_empty
+      expect(batch_result[4].first["data"]).not_to be_empty
     end
   end
 end

data/spec/integration/index_spec.rb

@@ -30,7 +30,7 @@ describe Neography::Index do
     new_node = Neography::Node.create("name" => value)
     new_node.add_to_index("node_test_index", "name", value)
     existing_node = Neography::Node.find("node_test_index", "name", value)
-    existing_node.name.should == value
+    expect(existing_node.name).to eq(value)
   end
 
   it "can find a node in an index with brackets" do
@@ -39,7 +39,7 @@ describe Neography::Index do
     new_node = Neography::Node.create("name" => value)
     new_node.add_to_index(key, "name", value)
     existing_node = Neography::Node.find(key, "name", value)
-    existing_node.name.should == value
+    expect(existing_node.name).to eq(value)
   end
 
   it "can find a relationship in an index" do
@@ -49,7 +49,7 @@ describe Neography::Index do
     r = Neography::Relationship.create(:friends, node1, node2, {"name" => value})
     r.add_to_index("relationship_test_index", "name", value)
     existing_r = Neography::Relationship.find("relationship_test_index", "name", value)
-    existing_r.name.should == value
+    expect(existing_r.name).to eq(value)
   end
 
   it "can find multiple nodes in an index" do
@@ -62,9 +62,9 @@ describe Neography::Index do
     node2.add_to_index("node_test_index", "first_name", value1)
 
     existing_nodes = Neography::Node.find("node_test_index", "first_name", value1)
-    existing_nodes.size.should == 2
-    existing_nodes.first.last_name.should == value2
-    existing_nodes.last.last_name.should == value3
+    expect(existing_nodes.size).to eq(2)
+    expect(existing_nodes.first.last_name).to eq(value2)
+    expect(existing_nodes.last.last_name).to eq(value3)
   end
 
 

data/spec/integration/neography_spec.rb

@@ -4,7 +4,7 @@ describe Neography do
   describe "ref_node", :reference => true do
     it "can get the reference node" do
       root_node = Neography.ref_node
-      root_node.should have_key("self")
+      expect(root_node).to have_key("self")
     end
   end
 end

data/spec/integration/node_encoding_spec.rb

@@ -7,13 +7,13 @@ describe Neography::Node do
 
     it "can create a node with UTF-8 encoded properties" do
       new_node = Neography::Node.create("name" => "美都池水")
-      new_node.name.should == "美都池水"
+      expect(new_node.name).to eq("美都池水")
     end
 
     it "can create a node with more than one UTF-8 encoded properties" do
       new_node = Neography::Node.create("first_name" => "美都", "last_name" => "池水")
-      new_node.first_name.should == "美都"
-      new_node.last_name.should == "池水"
+      expect(new_node.first_name).to eq("美都")
+      expect(new_node.last_name).to eq("池水")
     end
 
   end
@@ -22,11 +22,11 @@ describe Neography::Node do
     it "can get a node with UTF-8 encoded properties that exists" do
       new_node = Neography::Node.create("first_name" => "美都", "last_name" => "池水")
       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
-      existing_node.first_name.should == "美都"
-      existing_node.last_name.should == "池水"
+      expect(existing_node).not_to be_nil
+      expect(existing_node.neo_id).not_to be_nil
+      expect(existing_node.neo_id).to eq(new_node.neo_id)
+      expect(existing_node.first_name).to eq("美都")
+      expect(existing_node.last_name).to eq("池水")
     end
 
     it "can get a node with UTF-8 encoded properties from an index" do
@@ -37,11 +37,11 @@ describe Neography::Node do
       @neo.add_node_to_index("test_node_index", key, value, new_node)
       node_from_index = @neo.get_node_index("test_node_index", key, value)
       existing_node = Neography::Node.load(node_from_index)
-      existing_node.should_not be_nil
-      existing_node.neo_id.should_not be_nil
-      existing_node.neo_id.should == new_node.neo_id
-      existing_node.first_name.should == "美都"
-      existing_node.last_name.should == "池水"
+      expect(existing_node).not_to be_nil
+      expect(existing_node.neo_id).not_to be_nil
+      expect(existing_node.neo_id).to eq(new_node.neo_id)
+      expect(existing_node.first_name).to eq("美都")
+      expect(existing_node.last_name).to eq("池水")
     end
 
     it "can get a node with UTF-8 encoded properties that exists via cypher" do
@@ -50,11 +50,11 @@ describe Neography::Node do
       @neo = Neography::Rest.new
       results = @neo.execute_query(cypher, {:id => new_node.neo_id.to_i})
       existing_node = Neography::Node.load(results)
-      existing_node.should_not be_nil
-      existing_node.neo_id.should_not be_nil
-      existing_node.neo_id.should == new_node.neo_id
-      existing_node.first_name.should == "美都"
-      existing_node.last_name.should == "池水"
+      expect(existing_node).not_to be_nil
+      expect(existing_node.neo_id).not_to be_nil
+      expect(existing_node.neo_id).to eq(new_node.neo_id)
+      expect(existing_node.first_name).to eq("美都")
+      expect(existing_node.last_name).to eq("池水")
     end
 
     it "can get columns of data from a node with UTF-8 encoded properties that exists via cypher" do
@@ -63,7 +63,7 @@ describe Neography::Node do
                     RETURN me.first_name, me.last_name"
       @neo = Neography::Rest.new
       results = @neo.execute_query(cypher, {:id => new_node.neo_id.to_i})
-      results['data'][0].should == ["美都","池水"]
+      expect(results['data'][0]).to eq(["美都","池水"])
     end
 
   end