neoid 0.0.51 → 0.1

data/lib/neoid/relationship.rb

@@ -1,59 +1,100 @@
 module Neoid
   module Relationship
+    # this is a proxy that delays loading of start_node and end_node from Neo4j until accessed.
+    # the original Neography Relatioship loaded them on initialization
+    class RelationshipLazyProxy < ::Neography::Relationship
+      def start_node
+        @start_node_from_db ||= @start_node = Neography::Node.load(@start_node, Neoid.db)
+      end
+
+      def end_node
+        @end_node_from_db ||= @end_node = Neography::Node.load(@end_node, Neoid.db)
+      end
+    end
+
+    def self.from_hash(hash)
+      relationship = RelationshipLazyProxy.new(hash)
+
+      relationship
+    end
+
+
+    module ClassMethods
+      def delete_command
+        :delete_relationship
+      end
+    end
+
     module InstanceMethods
       def neo_find_by_id
-        Neoid.db.get_relationship_index(self.class.neo_index_name, :ar_id, self.id)
-      rescue Neography::NotFoundException
-        nil
+        results = Neoid.db.get_relationship_auto_index(Neoid::UNIQUE_ID_KEY, self.neo_unique_id)
+        relationship = results.present? ? Neoid::Relationship.from_hash(results[0]) : nil
+        relationship
       end
       
-      def neo_create
+      def _neo_save
         return unless Neoid.enabled?
-        @_neo_destroyed = false
         
         options = self.class.neoid_config.relationship_options
         
-        start_node = self.send(options[:start_node])
-        end_node = self.send(options[:end_node])
+        start_item = self.send(options[:start_node])
+        end_item = self.send(options[:end_node])
         
-        return unless start_node && end_node
+        return unless start_item && end_item
+
+        # initialize nodes
+        start_item.neo_node
+        end_item.neo_node
 
-        data = self.to_neo.merge(ar_type: self.class.name, ar_id: self.id)
+        data = self.to_neo.merge(ar_type: self.class.name, ar_id: self.id, Neoid::UNIQUE_ID_KEY => self.neo_unique_id)
         data.reject! { |k, v| v.nil? }
-        
-        relationship = Neography::Relationship.create(
-          options[:type].is_a?(Proc) ? options[:type].call(self) : options[:type],
-          start_node.neo_node,
-          end_node.neo_node,
-          data
-        )
-        
-        Neoid.db.add_relationship_to_index(self.class.neo_index_name, :ar_id, self.id, relationship)
 
-        Neoid::logger.info "Relationship#neo_create #{self.class.name} #{self.id}, index = #{self.class.neo_index_name}"
+        rel_type = options[:type].is_a?(Proc) ? options[:type].call(self) : options[:type]
+
+        gremlin_query = <<-GREMLIN
+          idx = g.idx('relationship_auto_index');
+          q = null;
+          if (idx) q = idx.get(unique_id_key, unique_id);
+
+          relationship = null;
+          if (q && q.hasNext()) {
+            relationship = q.next();
+            relationship_data.each {
+              if (relationship.getProperty(it.key) != it.value) {
+                relationship.setProperty(it.key, it.value);
+              }
+            }
+          } else {
+            node_index = g.idx('node_auto_index');
+            start_node = node_index.get(unique_id_key, start_node_unique_id).next();
+            end_node = node_index.get(unique_id_key, end_node_unique_id).next();
+
+            relationship = g.addEdge(start_node, end_node, rel_type, relationship_data);
+          }
+
+          relationship
+        GREMLIN
+
+         script_vars = {
+          unique_id_key: Neoid::UNIQUE_ID_KEY,
+          relationship_data: data,
+          unique_id: self.neo_unique_id,
+          start_node_unique_id: start_item.neo_unique_id,
+          end_node_unique_id: end_item.neo_unique_id,
+          rel_type: rel_type
+        }
+
+        Neoid::logger.info "Relationship#neo_save #{self.class.name} #{self.id}"
         
-        relationship
-      end
-      
-      def neo_load(relationship)
-        Neography::Relationship.load(relationship)
-      end
-      
-      def neo_destroy
-        return if @_neo_destroyed
-        @_neo_destroyed = true
-        return unless neo_relationship
-        Neoid.db.remove_relationship_from_index(self.class.neo_index_name, neo_relationship)
-        neo_relationship.del
-        _reset_neo_representation
-
-        Neoid::logger.info "Relationship#neo_destroy #{self.class.name} #{self.id}, index = #{self.class.neo_index_name}"
+        relationship = Neoid.execute_script_or_add_to_batch gremlin_query, script_vars do |value|
+          Neoid::Relationship.from_hash(value)
+        end
 
-        true
+        relationship
       end
       
-      def neo_update
-        Neoid.db.set_relationship_properties(neo_relationship, self.to_neo) if neo_relationship
+      def neo_load(hash)
+        Neoid::Relationship.from_hash(hash)
       end
 
       def neo_relationship
@@ -64,16 +105,15 @@ module Neoid
     def self.included(receiver)
       receiver.send :include, Neoid::ModelAdditions
       receiver.send :include, InstanceMethods
+      receiver.extend         ClassMethods
       
-      receiver.after_create :neo_create
-      receiver.after_destroy :neo_destroy
-      receiver.after_update :neo_update
-
-      if Neoid.env_loaded
-        initialize_relationship receiver
-      else
-        Neoid.relationship_models << receiver
-      end
+      initialize_relationship receiver if Neoid.env_loaded
+
+      Neoid.relationship_models << receiver
+    end
+
+    def self.meta_data
+      @meta_data ||= {}
     end
 
     def self.initialize_relationship(rel_model)
@@ -90,7 +130,6 @@ module Neoid
         # e.g. User has_many :likes, after_remove: ...
         full_callback_name = "after_remove_for_#{this_has_many.name}"
         belongs_to.klass.send(full_callback_name) << :neo_after_relationship_remove if belongs_to.klass.method_defined?(full_callback_name)
-        # belongs_to.klass.send(:has_many, this_has_many.name, this_has_many.options.merge(after_remove: :neo_after_relationship_remove))
 
         # has_many (with through) on the side of the relationship that removes a relationship. e.g. User has_many :movies, through :likes
         many_to_many = all_has_many.find { |o| o.options[:through] == this_has_many.name }
@@ -104,24 +143,20 @@ module Neoid
         # movie_id
         foreign_key_of_record = many_to_many.source_reflection.foreign_key
 
-        (Neoid.config[:relationship_meta_data] ||= {}).tap do |data|
+        (Neoid::Relationship.meta_data ||= {}).tap do |data|
           (data[belongs_to.klass.name.to_s] ||= {}).tap do |model_data|
             model_data[many_to_many.klass.name.to_s] = [rel_model.name.to_s, foreign_key_of_owner, foreign_key_of_record]
           end
         end
 
-        # puts Neoid.config[:relationship_meta_data].inspect
-
         # e.g. User has_many :movies, through: :likes, before_remove: ...
         full_callback_name = "before_remove_for_#{many_to_many.name}"
         belongs_to.klass.send(full_callback_name) << :neo_before_relationship_through_remove if belongs_to.klass.method_defined?(full_callback_name)
-        # belongs_to.klass.send(:has_many, many_to_many.name, many_to_many.options.merge(before_remove: :neo_after_relationship_remove))
 
 
         # e.g. User has_many :movies, through: :likes, after_remove: ...
         full_callback_name = "after_remove_for_#{many_to_many.name}"
         belongs_to.klass.send(full_callback_name) << :neo_after_relationship_through_remove if belongs_to.klass.method_defined?(full_callback_name)
-        # belongs_to.klass.send(:has_many, many_to_many.name, many_to_many.options.merge(after_remove: :neo_after_relationship_remove))
       end
     end
   end

data/lib/neoid/version.rb

@@ -1,3 +1,3 @@
 module Neoid
-  VERSION = "0.0.51"
+  VERSION = "0.1"
 end

data/spec/neoid/batch_spec.rb

@@ -0,0 +1,170 @@
+require 'spec_helper'
+
+describe Neoid::ModelAdditions do
+  context "promises" do
+    it "should run scripts in a batch and return results" do
+      Neoid.batch do |batch|
+        batch << [:execute_script, "1"]
+        batch << [:execute_script, "2"]
+      end.then do |results|
+        results.should == [1, 2]
+      end
+    end
+
+    it "should run scripts in a batch with batch_size and flush batch when it's full" do
+      Neoid.batch(batch_size: 3) do |batch|
+        (0...9).each do |i|
+          batch.count.should == i % 3
+          batch << [:execute_script, i.to_s]
+          if i % 3 == 0
+            batch.results.count.should == i
+          end
+        end
+      end
+    end
+
+    it "should run scripts in a batch with batch_size and return all results" do
+      Neoid.batch(batch_size: 2) do |batch|
+        (1..6).each do |i|
+          batch << [:execute_script, i.to_s]
+        end
+      end.then do |results|
+        results.should == [1, 2, 3, 4, 5, 6]
+      end
+    end
+
+    it "should return results then process them" do
+      node_1 = Neoid.db.create_node
+      node_2 = Neoid.db.create_node
+      rel = Neoid.db.create_relationship(:related, node_1, node_2)
+
+      Neoid.batch do |batch|
+        batch << [:execute_script, "g.v(neo_id)", neo_id: node_1['self'].split('/').last.to_i]
+        batch << [:execute_script, "g.v(neo_id)", neo_id: node_2['self'].split('/').last]
+        batch << [:execute_script, "g.e(neo_id)", neo_id: rel['self'].split('/').last]
+      end.then do |results|
+        results[0].should be_a(Neography::Node)
+        results[1].should be_a(Neography::Node)
+        results[2].should be_a(Neography::Relationship)
+      end
+    end
+
+    it "should remember what to do after each script has executed, and perform it when batch is flushed" do
+      then_results = []
+
+      Neoid.batch do |batch|
+        (batch << [:execute_script, "1"]).then { |res| then_results << res }
+        (batch << [:execute_script, "2"]).then { |res| then_results << res }
+        batch << [:execute_script, "3"]
+        (batch << [:execute_script, "4"]).then { |res| then_results << res }
+      end.then do |results|
+        results.should == [1, 2, 3, 4]
+        then_results.should == [1, 2, 4]
+      end
+    end
+  end
+
+  context "nodes" do
+    it "should not execute until batch is done" do
+      u1 = u2 = nil
+
+      res = Neoid.batch do
+        u1 = User.create!(name: "U1")
+        u2 = User.create!(name: "U2")
+
+        u1.neo_find_by_id.should be_nil
+        u2.neo_find_by_id.should be_nil
+      end
+
+      res.length.should == 2
+
+      u1.neo_find_by_id.should_not be_nil
+      u2.neo_find_by_id.should_not be_nil
+    end
+
+    it "should update nodes in batch" do
+      u1 = User.create!(name: "U1")
+      u2 = User.create!(name: "U2")
+
+      res = Neoid.batch do
+        u1.name = "U1 update"
+        u2.name = "U2 update"
+
+        u1.save!
+        u2.save!
+
+        u1.neo_find_by_id.name.should == "U1"
+        u2.neo_find_by_id.name.should == "U2"
+      end
+
+      res.length.should == 2
+
+      u1.neo_find_by_id.name.should == "U1 update"
+      u2.neo_find_by_id.name.should == "U2 update"
+    end
+
+
+    # Not working yet because Neography can't delete a node and all of its realtionships in a batch, and deleting a node with relationships results an error
+    # it "should delete nodes in batch" do
+    #   u1 = User.create!(name: "U1")
+    #   u2 = User.create!(name: "U2")
+
+    #   res = Neoid.batch do
+    #     u1_node_id = u1.neo_find_by_id.neo_id
+    #     u2_node_id = u2.neo_find_by_id.neo_id
+
+    #     u1.destroy
+    #     u2.destroy
+
+    #     Neoid.db.get_node(u1_node_id).should_not be_nil
+    #     Neoid.db.get_node(u2_node_id).should_not be_nil
+    #   end
+
+    #   res.length.should == 2
+
+    #   Neoid.db.get_node(u1_node_id).should be_nil
+    #   Neoid.db.get_node(u2_node_id).should be_nil
+    # end
+  end
+
+  context "relationships" do
+    let(:user) { User.create(name: "Elad Ossadon", slug: "elado") }
+    let(:movie) { Movie.create(name: "Memento", slug: "memento-1999", year: 1999) }
+
+    it "should not execute until batch is done" do
+      # ensure user and movie nodes are inserted
+      user
+      movie
+
+      res = Neoid.batch do |batch|
+        user.like! movie
+
+        user.likes.last.neo_find_by_id.should be_nil
+      end
+
+      res.length.should == 1
+
+      user.likes.last.neo_find_by_id.should_not be_nil
+    end
+
+    it "should not execute until batch is done" do
+      # ensure user and movie nodes are inserted
+      user
+      movie
+
+      # then destroy the nodes, allow the relationship do that in the batch
+      user.neo_destroy
+      movie.neo_destroy
+
+      res = Neoid.batch do |batch|
+        user.like! movie
+
+        user.likes.last.neo_find_by_id.should be_nil
+      end
+
+      res.length.should == 3
+
+      user.likes.last.neo_find_by_id.should_not be_nil
+    end
+  end
+end

data/spec/neoid/config_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+describe Neoid::Config do
+  context "config" do
+    it "should store and read config" do
+      Neoid.configure do |config|
+        config.enable_subrefs = false
+      end
+
+      Neoid.config.enable_subrefs.should == false
+    end
+  end
+end

data/spec/neoid/model_additions_spec.rb

@@ -1,16 +1,15 @@
 require 'spec_helper'
-require 'fileutils'
 
 describe Neoid::ModelAdditions do
   context "nodes" do
     context "create graph nodes" do
-      it "should call neo_create on a neo_node for user" do
-        User.any_instance.should_receive(:neo_create)
-
-        User.create!(name: "Elad Ossadon")
+      it "should call neo_save after model creation" do
+        user = User.new(name: "Elad Ossadon")
+        user.should_receive(:neo_save)
+        user.save!
       end
   
-      it "should create a neo_node for user" do
+      it "should create a node for user" do
         user = User.create!(name: "Elad Ossadon", slug: "elado")
 
         user.neo_node.should_not be_nil
@@ -22,7 +21,7 @@ describe Neoid::ModelAdditions do
 
       it "should create a neo_node for movie" do
         movie = Movie.create!(name: "Memento", slug: "memento-1999", year: 1999)
-      
+
         movie.neo_node.should_not be_nil
         
         movie.neo_node.ar_id.should == movie.id
@@ -31,26 +30,110 @@ describe Neoid::ModelAdditions do
       end
     end
   
+    context "update graph nodes" do
+      it "should call neo_save after model update" do
+        user = User.create!(name: "Elad Ossadon")
+        user.should_receive(:neo_save)
+        user.name = "John Doe"
+        user.save!
+      end
+
+      it "should update a node after model update" do
+        user = User.create!(name: "Elad Ossadon")
+        user.neo_node.name.should == "Elad Ossadon"
+
+        user.name = "John Doe"
+        user.save!
+
+        user.neo_node.name.should == "John Doe"
+      end
+    end
+
     context "find by id" do
       it "should find a neo_node for user" do
         user = User.create!(name: "Elad Ossadon", slug: "elado")
-      
+        
         user.neo_node.should_not be_nil
         user.neo_find_by_id.should_not be_nil
       end
     end
+
+    context "no auto_index" do
+      it "should not index a node if option :auto_index is set to false" do
+        model = NoAutoIndexNode.new(name: "Hello")
+        model.should_not_receive(:neo_save)
+        model.save!
+      end
+    end
+
+    context "subrefs" do
+      it "should create a relationship with a subref node" do
+        old, Neoid.config.enable_subrefs = Neoid.config.enable_subrefs, true
+
+        Neoid.send(:initialize_subrefs)
+        
+        begin
+          user = User.create!(name: "Elad")
+          user.neo_node.rel(:incoming, :users_subref).should_not be_nil
+        ensure
+          Neoid.config.enable_subrefs = old
+        end
+      end
+
+      it "should not create a relationship with a subref node if disabled" do
+        old, Neoid.config.enable_subrefs = Neoid.config.enable_subrefs, false
+
+        begin
+          user = User.create!(name: "Elad")
+          user.neo_node.rel(:incoming, :users_subref).should be_nil
+        ensure
+          Neoid.config.enable_subrefs = old
+        end
+      end
+    end
+
+    context "per_model_indexes" do
+      it "should create a relationship with a subref node" do
+        old, Neoid.config.enable_per_model_indexes = Neoid.config.enable_per_model_indexes, true
+
+        Neoid.send(:initialize_per_model_indexes)
+
+        begin
+          user = User.create!(name: "Elad")
+          Neoid.db.get_node_index(User.neo_model_index_name, 'ar_id', user.id).should_not be_nil
+        ensure
+          Neoid.config.enable_per_model_indexes = old
+        end
+      end
+
+      it "should not create a relationship with a subref node if disabled" do
+        old, Neoid.config.enable_per_model_indexes = Neoid.config.enable_per_model_indexes, false
+
+        begin
+          user = User.create!(name: "Elad")
+          expect { Neoid.db.get_node_index(User.neo_model_index_name, 'ar_id', user.id) }.to raise_error(Neography::NotFoundException)
+        ensure
+          Neoid.config.enable_per_model_indexes = old
+        end
+      end
+    end
   end
   
   context "relationships" do
-    let(:user) { User.create(name: "Elad Ossadon", slug: "elado") }
-    let(:movie) { Movie.create(name: "Memento", slug: "memento-1999", year: 1999) }
+    let(:user) { User.create!(name: "Elad Ossadon", slug: "elado") }
+    let(:movie) { Movie.create!(name: "Memento", slug: "memento-1999", year: 1999) }
     
-    it "should create a relationship on neo4j" do
+    it "should call neo_save after relationship model creation" do
+      Like.any_instance.should_receive(:neo_save)
       user.like! movie
-      like = user.likes.first
-      
+    end
+
+    it "should create a neo_relationship for like" do
+      like = user.like! movie
+      like = user.likes.last
+
       like.neo_find_by_id.should_not be_nil
-    
+
       like.neo_relationship.should_not be_nil
       
       like.neo_relationship.start_node.should == user.neo_node
@@ -63,7 +146,7 @@ describe Neoid::ModelAdditions do
       like = user.likes.last
       
       relationship_neo_id = like.neo_relationship.neo_id
-      
+
       Neography::Relationship.load(relationship_neo_id).should_not be_nil
       
       user.unlike! movie
@@ -98,12 +181,23 @@ describe Neoid::ModelAdditions do
         user.movie_ids = movies[0...2].collect(&:id)
       }.to change{ user.neo_node.outgoing(:likes).length }.to(2)
     end
+
+    it "should update a relationship after relationship model update" do
+      like = user.like! movie
+
+      like.neo_relationship.rate.should be_nil
+
+      like.rate = 10
+      like.save!
+
+      like.neo_relationship.rate.should == 10
+    end
   end
 
   context "polymorphic relationship" do
     let(:user) { User.create(name: "Elad Ossadon", slug: "elado") }
 
-    it "description" do
+    it "should create relationships with polymorphic items" do
       followed = [
         User.create(name: "Some One", slug: "someone"),
         Movie.create(name: "The Prestige"),
@@ -112,7 +206,7 @@ describe Neoid::ModelAdditions do
 
       expect {
         followed.each do |item|
-          user.user_follows.create(item: item)
+          user.user_follows.create!(item: item)
         end
       }.to change{ user.neo_node.outgoing(:follows).length }.to(followed.length)