lifesaver 0.0.1 → 0.1.0

data/lib/lifesaver/notification/model_additions.rb

@@ -0,0 +1,104 @@
+module Lifesaver
+  module Notification
+    module ModelAdditions
+      module ClassMethods
+        def notifies_for_indexing(*args)
+          self.notifiable_associations = NotifiableAssociations.new
+          options = args.last.is_a?(Hash) ? args.pop : {}
+          notifiable_associations.populate(args, options)
+          notification_callbacks
+        end
+
+        def load_with_notifiable_associations(ids)
+          includes(notifiable_associations.on_notify).where(id: ids)
+        end
+
+        private
+
+        def notification_callbacks
+          after_save do
+            send :update_associations, :update
+          end
+          before_destroy do
+            send :update_associations, :destroy
+          end
+        end
+      end
+
+      def self.included(base)
+        base.class_attribute :notifiable_associations
+        base.notifiable_associations = NotifiableAssociations.new
+        base.extend(ClassMethods)
+      end
+
+      def associations_to_notify
+        models = []
+        self.class.notifiable_associations.on_notify.each do |association|
+          models |= models_for_association(association)
+        end
+        models
+      end
+
+      def needs_to_notify?
+        self.class.notifiable_associations.any_to_notify?
+      end
+
+      def models_for_association(assoc)
+        models = []
+        association = send(assoc)
+        unless association.nil?
+          if association.respond_to?(:each)
+            association.each do |m|
+              models << m
+            end
+          else
+            models << association
+          end
+        end
+        models
+      end
+
+      private
+
+      def update_associations(operation)  models = []
+        to_skip = operation == :destroy ? dependent_associations : []
+        to_load = associations_to_load(:on_change, to_skip)
+
+        models = []
+        to_load.each { |key| models |= models_for_association(key) }
+        serialized_models = serialize_models(models)
+        enqueue_worker(serialized_models)
+      end
+
+      def associations_to_load(key, skip_associations)
+        associations = self.class.notifiable_associations.public_send(key)
+        skip_associations_map = {}
+        skip_associations.each { |assoc| skip_associations_map[assoc] = true }
+        associations.reject { |assoc| skip_associations_map[assoc] }
+      end
+
+      def dependent_associations
+        dependent_associations = []
+        self.class.reflect_on_all_associations.each do |association|
+          if association.options[:dependent].present?
+            dependent_associations << association.name.to_sym
+          end
+        end
+        dependent_associations
+      end
+
+      def serialize_models(models)
+        serialized_models = []
+        models.each do |m|
+          serialized_models << Lifesaver::SerializedModel.new(m.class.name, m.id)
+        end
+        serialized_models
+      end
+
+      def enqueue_worker(serialized_models)
+        Lifesaver::Notification::Enqueuer.new(serialized_models).enqueue
+      end
+
+    end
+  end
+end

data/lib/lifesaver/notification/notifiable_associations.rb

@@ -0,0 +1,49 @@
+module Lifesaver
+  module Notification
+    class NotifiableAssociations
+      class AssociationKeys < Struct.new(:on_change, :on_notify); end
+
+      def initialize
+        @association_keys = AssociationKeys.new([], [])
+      end
+
+      def populate(associations, options = nil)
+        options ||= {}
+        add_associations(:on_change, associations)
+        add_associations(:on_notify, associations)
+
+        if options[:only_on_change]
+          add_associations(:on_change, options[:only_on_change])
+        end
+
+        if options[:only_on_notify]
+          add_associations(:on_notify, options[:only_on_notify])
+        end
+      end
+
+      def on_notify
+        association_keys.on_notify
+      end
+
+      def on_change
+        association_keys.on_change
+      end
+
+      def any_to_notify?
+        !on_notify.empty?
+      end
+
+      private
+
+      attr_accessor :association_keys
+
+      def add_associations(key, associations)
+        if associations.is_a?(Array)
+          association_keys[key] |= associations
+        else
+          association_keys[key] << associations
+        end
+      end
+    end
+  end
+end

data/lib/lifesaver/notification/traversal_queue.rb

@@ -0,0 +1,48 @@
+module Lifesaver
+  module Notification
+    class TraversalQueue
+      def initialize
+        @visited_models = {}
+        @queue = []
+      end
+
+      def size
+        queue.size
+      end
+
+      def push(model)
+        return if model_visited?(model)
+        visit_model(model)
+        queue << model
+      end
+
+      def <<(model)
+        push(model)
+      end
+
+      def pop
+        queue.shift
+      end
+
+      def empty?
+        queue.empty?
+      end
+
+      private
+
+      attr_accessor :queue, :visited_models
+
+      def visit_model(model)
+        visited_models[model_key(model)] = true
+      end
+
+      def model_visited?(model)
+        visited_models[model_key(model)] || false
+      end
+
+      def model_key(model)
+        "#{model.class.name}_#{model.id}"
+      end
+    end
+  end
+end

data/lib/lifesaver/railtie.rb

@@ -1,9 +1,10 @@
 module Lifesaver
   class Railtie < Rails::Railtie
-    initializer 'lifesaver.model_additions' do
+    initializer 'lifesaver.model' do
       ActiveSupport.on_load :active_record do
-        include ModelAdditions
+        include Indexing::ModelAdditions
+        include Notification::ModelAdditions
       end
     end
   end
-end
+end

data/lib/lifesaver/serialized_model.rb

@@ -0,0 +1,3 @@
+module Lifesaver
+  class SerializedModel < Struct.new(:class_name, :id); end
+end

data/lib/lifesaver/version.rb

@@ -1,3 +1,3 @@
 module Lifesaver
-  VERSION = "0.0.1"
+  VERSION = '0.1.0'
 end

data/lib/lifesaver/visitor_worker.rb

@@ -1,9 +1,13 @@
 class Lifesaver::VisitorWorker
   include Resque::Plugins::UniqueJob
-  @queue = :lifesaver_notification
+
+  def self.queue; Lifesaver.config.notification_queue end
+
   def self.perform(models)
-    Lifesaver::IndexGraph.generate(models).each do |m|
-      Resque.enqueue(Lifesaver::IndexWorker, m.class.name.underscore.to_sym, m.id, :update) if m.has_index?
+    indexing_graph = Lifesaver::Notification::IndexingGraph.new
+    indexing_graph.initialize_models(models)
+    indexing_graph.generate.each do |m|
+      Lifesaver::Indexing::Enqueuer.new(model: m, operation: :update).enqueue
     end
   end
-end
+end

data/spec/integration/lifesaver_spec.rb

@@ -0,0 +1,78 @@
+require 'spec_helper'
+
+describe Lifesaver do
+  before do
+    Lifesaver.suppress_indexing
+  end
+  let(:affiliate) { Affiliate.create(name: 'Prosper Forebearer') }
+  let(:author) do
+    Author.create(name: 'Theo Epstein', affiliate_id: affiliate.id)
+  end
+  let(:post) do
+  Post.create(
+              title: 'Lifesavers are my favorite candy',
+              content: 'Lorem ipsum',
+              tags: %w(candy stuff opinions)
+             )
+  end
+  let(:comment) do
+    Comment.create(
+                   post: post,
+                   text: 'We love this!'
+                  )
+  end
+  before do
+    Authorship.create(post: post, author: author)
+    author.reload
+    post.reload
+
+    setup_indexes([author, post])
+
+    Lifesaver.unsuppress_indexing
+  end
+
+  it 'should traverse the provided graph' do
+    input = [{ 'class_name' => 'Author', 'id' => 1 }]
+    output = [author, post]
+    indexing_graph = Lifesaver::Notification::IndexingGraph.new
+    indexing_graph.initialize_models(input)
+
+    models = indexing_graph.generate
+
+    expect(models).to eql(output)
+  end
+
+  it 'should reindex on destroy' do
+    author.destroy
+    sleep(1.seconds)
+
+    expect(Author.search(query: 'Theo Epstein').count).to eql(0)
+  end
+
+  it 'should reindex on update' do
+    author.name = 'Harry Carry'
+    author.save!
+    sleep(1.seconds)
+
+    expect(Author.search(query: 'Harry Carry').count).to eql(1)
+  end
+
+  it 'should update distant related indexes' do
+    post.tags << 'werd'
+    post.save!
+    sleep(1.seconds)
+
+    expect(Author.search(query: 'werd').count).to eql(1)
+  end
+
+  it "should update related indexes if saved model doesn't have index" do
+    comment.text = 'We hate this!'
+    comment.save!
+    sleep(1.seconds)
+
+    result = Post.search(query: 'Lifesavers').to_a.first
+    comment_text = result.comments.first.text
+
+    expect(comment_text).to eql('We hate this!')
+  end
+end

data/spec/spec_helper.rb

@@ -1,27 +1,29 @@
+require 'pry'
 require 'coveralls'
-Coveralls.wear!
+Coveralls.wear! if ENV['RUN_COVERALLS']
 
 require 'lifesaver'
 
 require 'support/active_record'
 require 'support/test_models'
-ActiveSupport.on_load :active_record do
-  include Lifesaver::ModelAdditions
-end
+require 'support/tire_helper'
 
 Resque.inline = true
-Tire::Model::Search.index_prefix "lifesaver_test"
+Tire::Model::Search.index_prefix 'lifesaver_test'
 
+Model = Struct.new(:id)
 
 RSpec.configure do |config|
-  # config.expect_with :rspec do |c|
-  #   c.syntax = :expect
-  # end
+  config.include TireHelper
+
+  config.expect_with :rspec do |c|
+    c.syntax = :expect
+  end
 
   config.around do |example|
     ActiveRecord::Base.transaction do
       example.run
-      raise ActiveRecord::Rollback
+      fail ActiveRecord::Rollback
     end
   end
-end
+end

data/spec/support/active_record.rb

@@ -1,5 +1,5 @@
 require 'active_record'
-ActiveRecord::Base.establish_connection adapter: "sqlite3", database: ":memory:"
+ActiveRecord::Base.establish_connection adapter: 'sqlite3', database: ':memory:'
 
 module ActiveModel::Validations
   # Extension to enhance `should have` on AR Model instances.  Calls
@@ -16,7 +16,7 @@ module ActiveModel::Validations
   #     model.errors_on(:attribute).should include("can't be blank")
   def errors_on(attribute)
     self.valid?
-    [self.errors[attribute]].flatten.compact
+    [errors[attribute]].flatten.compact
   end
   alias :error_on :errors_on
 end
@@ -50,4 +50,4 @@ end
 ActiveRecord::Migration.create_table :affiliates do |t|
   t.string :name
   t.timestamps
-end
+end

data/spec/support/test_models.rb

@@ -1,7 +1,8 @@
 require 'tire'
 
 ActiveSupport.on_load :active_record do
-  include Lifesaver::ModelAdditions
+  include Lifesaver::Indexing::ModelAdditions
+  include Lifesaver::Notification::ModelAdditions
 end
 
 
@@ -11,6 +12,7 @@ class Author < ActiveRecord::Base
   belongs_to :affiliate
   enqueues_indexing
   include ::Tire::Model::Search
+
   notifies_for_indexing :authorships
   def post_tags
     tags = Set.new
@@ -22,8 +24,8 @@ class Author < ActiveRecord::Base
   mapping do
     indexes :id, type: 'integer', index: 'not_analyzed'
     indexes :name, type: 'multi_field', fields: {
-      name: {type: 'string', analyzer: 'snowball'},
-      untouched: {type: 'string', index: 'not_analyzed'}
+      name: { type: 'string', analyzer: 'snowball' },
+      untouched: { type: 'string', index: 'not_analyzed' }
     }
     indexes :post_tags, analyzer: 'keyword'
   end
@@ -64,8 +66,8 @@ class Post < ActiveRecord::Base
   mapping do
     indexes :id, type: 'integer', index: 'not_analyzed'
     indexes :title, type: 'multi_field', fields: {
-      title: {type: 'string', analyzer: 'snowball'},
-      untouched: {type: 'string', index: 'not_analyzed'}
+      title: { type: 'string', analyzer: 'snowball' },
+      untouched: { type: 'string', index: 'not_analyzed' }
     }
   end
 
@@ -87,4 +89,4 @@ end
 class Affiliate < ActiveRecord::Base
   has_many :authors
   notifies_for_indexing :authors
-end
+end

data/spec/support/tire_helper.rb

@@ -0,0 +1,37 @@
+module TireHelper
+  def setup_indexes(models)
+    @class_buckets = {}
+    bucketize_models(models)
+    refresh_indexes
+  end
+
+  private
+
+  attr_accessor :class_buckets
+
+  def bucketize_models(models)
+    models.each do |model|
+      add_model_to_bucket(model)
+    end
+  end
+
+  def add_model_to_bucket(model)
+    key = model.class.name
+    class_buckets[key] ||= []
+    class_buckets[key] << model
+  end
+
+  def refresh_indexes
+    class_buckets.each do |class_name, models|
+      refresh_index(class_name, models)
+    end
+  end
+
+  def refresh_index(class_name, models)
+    klass = class_name.constantize
+    klass.tire.index.delete
+    klass.tire.create_elasticsearch_index
+    models.each { |model| model.tire.update_index }
+    klass.tire.index.refresh
+  end
+end