lexster 0.0.1

data/lib/lexster/search_session.rb

@@ -0,0 +1,28 @@
+module Lexster
+  class SearchSession
+    def initialize(response, *models)
+      @response = response || []
+      @models = models
+    end
+    
+    def hits
+      @response.map { |x| Neography::Node.new(x) }
+    end
+
+    def ids
+      @response.collect { |x| x['data']['ar_id'] }
+    end
+    
+    def results
+      models_by_name = @models.inject({}) { |all, curr| all[curr.name] = curr; all }
+
+      ids_by_klass = @response.inject({}) do |all, curr|
+        klass_name = curr['data']['ar_type']
+        (all[models_by_name[klass_name]] ||= []) << curr['data']['ar_id']
+        all
+      end
+
+      ids_by_klass.map { |klass, ids| klass.where(id: ids) }.flatten
+    end
+  end
+end

data/lib/lexster/version.rb

@@ -0,0 +1,3 @@
+module Lexster
+  VERSION = "0.0.1"
+end

data/spec/lexster/batch_spec.rb

@@ -0,0 +1,170 @@
+require 'spec_helper'
+
+describe Lexster::ModelAdditions do
+  context "promises" do
+    it "should run scripts in a batch and return results" do
+      Lexster.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
+      Lexster.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
+      Lexster.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 = Lexster.db.create_node
+      node_2 = Lexster.db.create_node
+      rel = Lexster.db.create_relationship(:related, node_1, node_2)
+
+      Lexster.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 = []
+
+      Lexster.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 = Lexster.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 = Lexster.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 = Lexster.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
+
+    #     Lexster.db.get_node(u1_node_id).should_not be_nil
+    #     Lexster.db.get_node(u2_node_id).should_not be_nil
+    #   end
+
+    #   res.length.should == 2
+
+    #   Lexster.db.get_node(u1_node_id).should be_nil
+    #   Lexster.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 = Lexster.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 = Lexster.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/lexster/config_spec.rb

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

data/spec/lexster/model_config_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+require 'fileutils'
+
+
+describe Lexster::ModelConfig do
+  context "config on a model" do
+    it "should store search fields" do
+      Article.lexster_config.search_options.should_not be_nil
+      Article.lexster_config.search_options.index_fields.keys.should =~ [ :title, :body, :year ]
+    end
+
+    it "should store stored fields" do
+      Article.lexster_config.stored_fields.should_not be_nil
+      Article.lexster_config.stored_fields.keys.should =~ [ :title, :year, :title_length ]
+      Article.lexster_config.stored_fields[:title_length].should be_a(Proc)
+    end
+
+    it "should store stored fields based on blocks" do
+      article = Article.create! title: "Hello", year: 2012
+      
+      article.neo_node.title_length.should == article.title.length
+    end
+  end
+end

data/spec/lexster/node_spec.rb

@@ -0,0 +1,131 @@
+require 'spec_helper'
+
+describe Lexster::Node do
+  context "create graph nodes" do
+    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 node for user" do
+      user = User.create!(name: "Elad Ossadon", slug: "elado")
+
+      user.neo_node.should_not be_nil
+      
+      user.neo_node.ar_id.should == user.id
+      user.neo_node.name.should == user.name
+      user.neo_node.slug.should == user.slug
+    end
+
+    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
+      movie.neo_node.name.should == movie.name
+      movie.neo_node.year.should == movie.year
+    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 connect subrefs to reference node" do
+      old, Lexster.config.enable_subrefs = Lexster.config.enable_subrefs, true
+
+      Lexster.send(:initialize_subrefs)
+      
+      begin
+        Lexster.ref_node.rel(:outgoing, :users_subref).should_not be_nil
+      ensure
+        Lexster.config.enable_subrefs = old
+      end
+    end
+
+    it "should create a relationship with a subref node" do
+      old, Lexster.config.enable_subrefs = Lexster.config.enable_subrefs, true
+
+      Lexster.send(:initialize_subrefs)
+      
+      begin
+        user = User.create!(name: "Elad")
+        user.neo_node.rel(:incoming, :users).should_not be_nil
+      ensure
+        Lexster.config.enable_subrefs = old
+      end
+    end
+
+    it "should not create a relationship with a subref node if disabled" do
+      old, Lexster.config.enable_subrefs = Lexster.config.enable_subrefs, false
+
+      begin
+        user = User.create!(name: "Elad")
+        user.neo_node.rel(:incoming, :users_subref).should be_nil
+      ensure
+        Lexster.config.enable_subrefs = old
+      end
+    end
+  end
+
+  context "per_model_indexes" do
+    it "should create a relationship with a subref node" do
+      old, Lexster.config.enable_per_model_indexes = Lexster.config.enable_per_model_indexes, true
+
+      Lexster.send(:initialize_per_model_indexes)
+
+      begin
+        user = User.create!(name: "Elad")
+        Lexster.db.get_node_index(User.neo_model_index_name, 'ar_id', user.id).should_not be_nil
+      ensure
+        Lexster.config.enable_per_model_indexes = old
+      end
+    end
+
+    it "should not create a relationship with a subref node if disabled" do
+      old, Lexster.config.enable_per_model_indexes = Lexster.config.enable_per_model_indexes, false
+
+      begin
+        user = User.create!(name: "Elad")
+        expect { Lexster.db.get_node_index(User.neo_model_index_name, 'ar_id', user.id) }.to raise_error(Neography::NotFoundException)
+      ensure
+        Lexster.config.enable_per_model_indexes = old
+      end
+    end
+  end
+end

data/spec/lexster/relationship_spec.rb

@@ -0,0 +1,102 @@
+require 'spec_helper'
+
+describe Lexster::Relationship do
+  let(:user) { User.create!(name: "Elad Ossadon", slug: "elado") }
+  let(:movie) { Movie.create!(name: "Memento", slug: "memento-1999", year: 1999) }
+  
+  it "should call neo_save after relationship model creation" do
+    Like.any_instance.should_receive(:neo_save)
+    user.like! movie
+  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
+    like.neo_relationship.end_node.should == movie.neo_node
+    like.neo_relationship.rel_type.should == 'likes'
+  end
+  
+  it "should delete a relationship on deleting a record" do
+    user.like! movie
+    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
+    
+    expect { Neography::Relationship.load(relationship_neo_id) }.to raise_error(Neography::RelationshipNotFoundException)
+  end
+
+  it "should update neo4j on manual set of a collection" do
+    movies = [
+      Movie.create(name: "Memento"),
+      Movie.create(name: "The Prestige"),
+      Movie.create(name: "The Dark Knight"),
+      Movie.create(name: "Spiderman")
+    ]
+
+    user.neo_node.outgoing(:likes).length.should == 0
+
+    expect {
+      user.movies = movies
+    }.to change{ user.neo_node.outgoing(:likes).length }.to(movies.length)
+
+    expect { expect {
+      user.movies -= movies[0..1]
+    }.to change{ user.movies.count }.by(-2)
+    }.to change{ user.neo_node.outgoing(:likes).length }.by(-2)
+
+    expect {
+      user.movies = []
+    }.to change{ user.neo_node.outgoing(:likes).length }.to(0)
+
+    expect {
+      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
+
+  context "polymorphic relationship" do
+    let(:user) { User.create(name: "Elad Ossadon", slug: "elado") }
+
+    it "should create relationships with polymorphic items" do
+      followed = [
+        User.create(name: "Some One", slug: "someone"),
+        Movie.create(name: "The Prestige"),
+        Movie.create(name: "The Dark Knight")
+      ]
+
+      expect {
+        followed.each do |item|
+          user.user_follows.create!(item: item)
+        end
+      }.to change{ user.neo_node.outgoing(:follows).length }.to(followed.length)
+
+      expect {
+        user.user_follows = user.user_follows[0...1]
+      }.to change{ user.neo_node.outgoing(:follows).length }.to(1)
+
+      expect {
+        user.user_follows = []
+      }.to change{ user.neo_node.outgoing(:follows).length }.to(0)
+    end
+  end
+end