lifesaver 0.0.1

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.travis.yml

@@ -0,0 +1,7 @@
+language: ruby
+rvm:
+  - 1.9.3
+  - 2.0.0
+services:
+  - redis-server
+  - elasticsearch

data/CHANGELOG.md

@@ -0,0 +1,3 @@
+## v0.0.1
+
+* initial release

data/Gemfile

@@ -0,0 +1,8 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in lifesaver.gemspec
+gemspec
+
+group :test do
+  gem 'coveralls', require: false
+end

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Paul Sorensen
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,93 @@
+# Lifesaver
+
+[![Build Status](https://travis-ci.org/paulnsorensen/lifesaver.png?branch=master)](https://travis-ci.org/paulnsorensen/lifesaver)
+[![Dependency Status](https://gemnasium.com/paulnsorensen/lifesaver.png)](https://gemnasium.com/paulnsorensen/lifesaver)
+[![Coverage Status](https://coveralls.io/repos/paulnsorensen/lifesaver/badge.png)](https://coveralls.io/r/paulnsorensen/lifesaver)
+[![Code Climate](https://codeclimate.com/github/paulnsorensen/lifesaver.png)](https://codeclimate.com/github/paulnsorensen/lifesaver)
+
+Indexes your ActiveRecord models in [elasticsearch](https://github.com/elasticsearch/elasticsearch) asynchronously by making use of [tire](https://github.com/karmi/tire) and [resque](https://github.com/resque/resque) (hence the name: resque + tire = lifesaver). Using lifesaver, you can easily control when or if to reindex your model depending on your context. Lifesaver also provides the ability to traverse ActiveRecord associations to trigger the index updates of related models.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'lifesaver', git: "git://github.com/paulnsorensen/lifesaver.git"
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install lifesaver
+
+## Usage
+
+Replaces the tire callbacks in your models
+
+```ruby
+    class Article < ActiveRecord::Base
+      include Tire::Model::Search
+      # Replace the following include with Lifesaver
+      # include Tire::Model::Callbacks
+      enqueues_indexing
+    end
+```
+
+#### Configurable Behavior
+You can decided when or if the index gets updated at all based on your current situation. Lifesaver exposes two methods (`supress_indexing`, `unsuppress_indexing`) that set a model's indexing behavior until that model is saved.
+
+```ruby
+    class ArticlesController < ApplicationController
+      def suppressed_update
+        @article = Article.find(params[:id])
+        @article.attributes = params[:article]
+
+        # No reindexing will occur at all
+        @article.suppress_indexing
+
+        @article.save!
+        
+        # Not neccessary but if saved
+        # after this following call,
+        # this article would reindex
+        @article.unsuppress_indexing
+      end
+    end
+```
+
+#### ActiveRecord Association Traversal
+Lifesaver can trigger other models to reindex if you have nested models in your indexes that you would like to update. Use the `notifies_for_indexing` method to indicate which related models should be marked for indexing. Any associations passed will be both updated when a model is changed (`save` or `destroy`) and when another model notifies it. Any associations passed in the options will only notify when the model is changed or notified when specified in the `only_on_change` or `only_on_notify` keys, respectively.
+
+```ruby
+    class Article < ActiveRecord::Base
+      belongs_to :author
+      belongs_to :category
+      has_many :watchers
+      has_one :moderator
+      
+      notifies_for_indexing :author, 
+        only_on_change: :category,
+        only_on_notify: [:watchers, :moderator]
+    end
+```
+
+## Integration with Resque
+You will see two new queues: `lifesaver_indexing` and `lifesaver_notification`
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request
+
+## TODO
++ specify which fields will trigger indexing changes
++ configuration options
++ bulk indexing
++ resque-scheduler to provide `delay_indexing` and `enqueues_indexing after: 30.minutes, on: :save`
++ unsuppress indexing after save
++ sidekiq support
++ prepare for new elasticsearch library

data/Rakefile

@@ -0,0 +1,5 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+task default: :spec

data/lib/lifesaver.rb

@@ -0,0 +1,24 @@
+require 'resque-loner'
+require "lifesaver/version"
+require "lifesaver/marshal"
+require "lifesaver/index_graph"
+require "lifesaver/model_additions"
+require "lifesaver/index_worker"
+require "lifesaver/visitor_worker"
+require "lifesaver/railtie" if defined? Rails
+
+module Lifesaver
+  @@suppress_indexing = false
+
+  def self.suppress_indexing
+    @@suppress_indexing = true
+  end
+
+  def self.unsuppress_indexing
+    @@suppress_indexing = false
+  end
+
+  def self.indexing_suppressed?
+    @@suppress_indexing
+  end
+end

data/lib/lifesaver/index_graph.rb

@@ -0,0 +1,53 @@
+module Lifesaver
+  class IndexGraph
+    def self.generate(marshalled_models)
+      models_to_index = []
+      visited_models = {}
+      graph = []
+      marshalled_models.each do |m|
+        mdl, opts = Lifesaver::Marshal.load(m)
+        if mdl
+          if opts[:status] == :notified
+            graph << mdl
+          elsif opts[:status] == :changed
+            visited_models[self.visited_model_key(mdl)] = true
+            graph |= self.notified_models(mdl, true)
+          end
+        end
+      end
+      graph.each {|m| visited_models[self.visited_model_key(m)] = true }
+      while !graph.empty?
+        mdl = graph.shift
+        models_to_index << mdl if mdl.has_index?
+        self.notified_models(mdl).each do |m|
+          unless visited_models[self.visited_model_key(m)]
+            visited_models[self.visited_model_key(m)] = true
+            graph << m
+          end
+        end
+      end
+      models_to_index
+     end
+
+     def self.visited_model_key(mdl)
+       if mdl.is_a?(Hash)
+         klass = mdl[:class].to_s.classify
+         "#{klass}_#{mdl[:id]}"
+       elsif mdl.try(:id)
+         "#{mdl.class.name}_#{mdl.id}"
+       end
+     end
+
+     def self.notified_models(mdl, on_change = false)
+       if Lifesaver::Marshal.is_serialized?(mdl)
+         mdl, opts = Lifesaver::Marshal.load(mdl)
+       end
+       models = []
+       key = on_change ? :on_change : :on_notify
+       mdl.class.notifiable_associations[key].each do |assoc|
+         models |= mdl.association_models(assoc)
+       end
+       models
+     end
+  end
+end

data/lib/lifesaver/index_worker.rb

@@ -0,0 +1,13 @@
+class Lifesaver::IndexWorker
+  include ::Resque::Plugins::UniqueJob
+  @queue = :lifesaver_indexing
+  def self.perform(class_name, id, action)
+    klass = class_name.to_s.classify.constantize
+    case action.to_sym
+    when :update
+      klass.find(id).update_index if klass.exists?(id)
+    when :destroy
+      klass.index.remove({type: klass.document_type, id: id})
+    end
+  end
+end

data/lib/lifesaver/marshal.rb

@@ -0,0 +1,43 @@
+module Lifesaver
+  class Marshal
+    def self.dump(obj, opts={})
+      raise unless opts.is_a?(Hash)
+      opts[:class] = obj.class.name.underscore.to_sym
+      opts[:id] = obj.id
+      opts
+    end
+
+    def self.load(obj)
+      raise unless self.is_serialized?(obj)
+      obj = self.sanitize(obj)
+      klass = obj[:class].to_s.classify.constantize
+      if klass.exists?(obj[:id])
+        mdl = klass.find(obj[:id])
+        obj.delete(:id)
+        obj.delete(:class)
+        return mdl, obj
+      else
+        nil
+      end
+    end
+
+    def self.sanitize(obj)
+      raise unless obj.is_a?(Hash)
+      obj = obj.symbolize_keys
+      obj[:id] = obj[:id].to_i if obj[:id]
+      obj[:class] = obj[:class].to_sym if obj[:class]
+      obj[:status] = obj[:status].to_sym if obj[:status]
+      obj
+    end
+
+    def self.is_serialized?(obj)
+      if obj.is_a?(Hash)
+        obj = self.sanitize(obj)
+        if obj.key?(:class) && obj.key?(:id)
+          return true
+        end
+      end
+      false
+    end
+  end
+end

data/lib/lifesaver/model_additions.rb

@@ -0,0 +1,133 @@
+module Lifesaver
+  module ModelAdditions
+    module ClassMethods
+
+      def notifies_for_indexing(*args)
+        self.notifiable_associations = { on_change: [], on_notify: [] }
+        opts = args.pop if args.last.is_a?(Hash)
+        args.each do |a|
+          self.notifiable_associations[:on_change] << a
+          self.notifiable_associations[:on_notify] << a
+        end
+        %w(on_change on_notify).each do |k|
+          opt = opts[("only_" + k).to_sym] if opts
+          key = k.to_sym
+          if opt
+            if opt.is_a?(Array)
+              self.notifiable_associations[key] |= opt
+            else
+              self.notifiable_associations[key] << opt
+            end
+          end
+        end
+        notification_callbacks
+      end
+
+      def enqueues_indexing(options = {})
+        indexing_callbacks
+      end
+
+      private
+
+      def notification_callbacks(options={})
+        after_save do
+          send :update_associations, options.merge(operation: :update)
+        end
+        before_destroy do
+          send :update_associations, options.merge(operation: :destroy)
+        end
+      end
+
+      def indexing_callbacks(options={})
+        after_save do
+          send :enqueue_indexing, options.merge(operation: :update)
+        end
+        after_destroy do
+          send :enqueue_indexing, options.merge(operation: :destroy)
+        end
+      end
+    end
+
+    def self.included(base)
+      base.class_attribute :notifiable_associations
+      base.notifiable_associations = { on_change: [], on_notify: [] }
+      base.extend(ClassMethods)
+    end
+
+    def association_models(assoc)
+       models = []
+       association = send(assoc.to_sym)
+       unless association.nil?
+         if association.respond_to?(:each)
+           association.each do |m|
+             models << m
+           end
+         else
+           models << association
+         end
+       end
+       models
+     end
+
+     def has_index?
+       self.respond_to?(:tire)
+     end
+
+     def suppress_indexing
+       @indexing_suppressed = true
+     end
+
+     def unsuppress_indexing
+       @indexing_suppressed = false
+     end
+
+    private
+
+    def enqueue_indexing(opts)
+      if has_index? && !suppress_indexing?
+        ::Resque.enqueue(
+          Lifesaver::IndexWorker,
+          self.class.name.underscore.to_sym,
+          self.id,
+          opts[:operation]
+        )
+      end
+    end
+
+    def dependent_association_map
+      dependent = {}
+      self.class.reflect_on_all_associations.each do |assoc|
+        dependent[assoc.name.to_sym] = true if assoc.options[:dependent].present?
+      end
+      dependent
+    end
+
+    def update_associations(opts)
+      models = []
+      if opts[:operation] == :destroy
+        dependent = dependent_association_map
+        assoc_models = []
+        self.class.notifiable_associations[:on_change].each do |assoc|
+          assoc_models |= association_models(assoc) unless dependent[assoc]
+        end
+        assoc_models.each do |m|
+          models << Lifesaver::Marshal.dump(m, {status: :notified})
+        end
+      elsif opts[:operation] == :update
+        models << Lifesaver::Marshal.dump(self, {status: :changed})
+      end
+
+      ::Resque.enqueue(Lifesaver::VisitorWorker, models) unless models.empty?
+    end
+
+    def validate_options(options)
+      # on: should only have active model callback verbs (create, update, destroy?)
+      # after: (next versions after you use resque scheduler) time to schedule
+      # only: specifies fields that trigger changes
+    end
+
+    def suppress_indexing?
+      Lifesaver.indexing_suppressed? || @indexing_suppressed || false
+    end
+  end
+end

data/lib/lifesaver/railtie.rb

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

data/lib/lifesaver/version.rb

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

data/lib/lifesaver/visitor_worker.rb

@@ -0,0 +1,9 @@
+class Lifesaver::VisitorWorker
+  include Resque::Plugins::UniqueJob
+  @queue = :lifesaver_notification
+  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?
+    end
+  end
+end

data/lifesaver.gemspec

@@ -0,0 +1,31 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'lifesaver/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "lifesaver"
+  spec.version       = Lifesaver::VERSION
+  spec.authors       = ["Paul Sorensen"]
+  spec.email         = ["paulnsorensen@gmail.com"]
+  spec.description   = %q{Indexes your ActiveRecord models in elasticsearch asynchronously by making use of tire and resque}
+  spec.summary       = %q{Indexes your ActiveRecord models in elasticsearch asynchronously by making use of tire and resque}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.required_ruby_version = '>= 1.9'
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "activerecord"
+  spec.add_development_dependency "sqlite3"
+  spec.add_runtime_dependency 'activerecord', '>= 3'
+  spec.add_runtime_dependency 'tire', '~> 0.6.0'
+  spec.add_runtime_dependency 'resque', '~> 1.25.0'
+  spec.add_runtime_dependency 'resque-loner', '~> 1.2.1'
+end

data/spec/lifesaver/index_graph_spec.rb

@@ -0,0 +1,64 @@
+require 'spec_helper'
+
+describe Lifesaver::IndexGraph do
+  Lifesaver.suppress_indexing
+
+  describe ".visited_model_key" do
+    it "should return a key when passed an ActiveRecord model" do
+      post = Post.create(title: "Some post")
+      expect(Lifesaver::IndexGraph.visited_model_key(post)).to eql("Post_1")
+    end
+
+    it "should return a key when passed a Hash" do
+      post = {class: "post", id: "1", status: "notified"}
+      expect(Lifesaver::IndexGraph.visited_model_key(post)).to eql("Post_1")
+    end
+  end
+
+  describe ".notified_models" do
+    after(:all) do
+      Post.destroy_all
+      Author.destroy_all
+      Authorship.destroy_all
+    end
+    context "when passed model has changed" do
+      before(:each) do
+        @post = Post.create(title: "Some post")
+        @author = Author.create(name: "Some guy")
+        Authorship.create(post: @post, author: @author)
+      end
+      
+      it "should return notified models when passed an ActiveRecord model" do
+        models = Lifesaver::IndexGraph.notified_models(@post, true)
+        expect(models.size).to eql(1)
+      end
+
+      it "should return notified models when passed a Hash" do
+        post = {class: "post", id: "1", status: "changed"}
+        models = Lifesaver::IndexGraph.notified_models(post, true)
+        expect(models.size).to eql(1)
+      end
+    end
+
+    context "when passed model has not changed" do
+      before(:each) do
+        @post = Post.create(title: "Some post")
+        @author = Author.create(name: "Some guy")
+        Authorship.create(post: @post, author: @author)
+      end
+
+      it "should return notified models when passed an ActiveRecord model" do
+        models = Lifesaver::IndexGraph.notified_models(@author)
+        expect(models.size).to eql(1)
+      end
+      
+      it "should return notified models when passed a Hash" do
+        author = {class: "author", id: "1", status: "notified"}
+        models = Lifesaver::IndexGraph.notified_models(author)
+        expect(models.size).to eql(1)
+      end
+    end
+  end
+
+  Lifesaver.unsuppress_indexing
+end

data/spec/lifesaver/marshal_spec.rb

@@ -0,0 +1,80 @@
+require 'spec_helper'
+
+describe Lifesaver::Marshal do
+  describe ".is_serialized?" do
+    it "returns true if Hash has :id and :class" do
+      obj = { class: :post, id: 1 }
+      expect(Lifesaver::Marshal.is_serialized?(obj)).to eql(true)
+    end
+
+    it "returns true if Hash has 'id' and 'class'" do
+      obj = { "class" => "post", "id" => "1" }
+      expect(Lifesaver::Marshal.is_serialized?(obj)).to eql(true)
+    end
+
+    it "returns false if Hash does not have id and class keys" do
+      obj = { some_key: 1, id: 4 }
+      expect(Lifesaver::Marshal.is_serialized?(obj)).to eql(false)
+    end
+
+    it "returns false if passed an non-Hash object" do
+      obj = Post.new
+      expect(Lifesaver::Marshal.is_serialized?(obj)).to eql(false)
+    end
+  end
+
+  describe ".sanitize" do
+    it "returns symbolized version of the Hash'" do
+      obj = { "class" => "post", "id" => "1", "status" => "updated" }
+      out = { class: :post, id: 1, status: :updated }
+      expect(Lifesaver::Marshal.sanitize(obj)).to eql(out)
+    end
+
+    it "rejects non-Hashes" do
+      obj = Post.new
+      expect { Lifesaver::Marshal.sanitize(obj) }.to raise_error
+    end
+  end
+
+  describe ".load" do
+    before(:all) do
+      Post.create(title: "Test Post")
+    end
+
+    it "loads a serialized object from ActiveRecord" do
+      obj = { class: :post, id: 1 }
+      expect(Lifesaver::Marshal.load(obj)).to eql([Post.find(1), {}])
+    end
+
+    it "returns nil if model not found" do
+      obj = { class: :post, id: 12 }
+      expect(Lifesaver::Marshal.load(obj)).to eql(nil)
+    end
+
+    it "returns options if they were passed" do
+      obj = { class: :post, id: 1, status: :notified }
+      m = Lifesaver::Marshal.load(obj)
+      expect(m).to eql([Post.find(1), {status: :notified}])
+    end
+
+
+    it "rejects bad input" do
+      obj = Post.new
+      expect { Lifesaver::Marshal.load(obj) }.to raise_error
+    end
+  end
+
+  describe ".dump" do
+    it "decomposes an object to a Hash" do
+      obj = Post.create(title: "Test Post")
+      out = { class: :post, id: 2 }
+      expect(Lifesaver::Marshal.dump(obj)).to eql(out)
+    end
+
+    it "adds additional key, value pairs if passed" do
+      obj = Post.create(title: "Test Post")
+      out = { status: :updated, class: :post, id: 2 }
+      expect(Lifesaver::Marshal.dump(obj, {status: :updated})).to eql(out)
+    end
+  end
+end

data/spec/lifesaver/model_additions_spec.rb

@@ -0,0 +1,91 @@
+require 'spec_helper'
+
+describe Lifesaver::ModelAdditions do
+  Lifesaver.suppress_indexing
+
+  describe ".notifies_for_indexing" do
+    after(:each) do 
+      Post.send(:notifies_for_indexing, only_on_change: :authorships)
+    end
+    it "should return a Hash of models for notification on save and notify" do
+      Post.send(:notifies_for_indexing, :comments, 
+        only_on_change: :authorships,
+        only_on_notify: :authors
+      )
+      exp_hash = { on_change: [], on_notify: [] }
+      exp_hash[:on_change] << :comments
+      exp_hash[:on_change] << :authorships
+      exp_hash[:on_notify] << :comments
+      exp_hash[:on_notify] << :authors
+      expect(Post.notifiable_associations).to eql(exp_hash)
+    end
+  end
+
+  describe "#association_models" do
+    before(:each) do
+      @post = Post.create(title: "Some post")
+      affiliate = Affiliate.create(name: "Some place")
+      @author = Author.create(name: "Some guy", affiliate_id: affiliate.id)
+      Authorship.create(post: @post, author: @author)
+    end
+    after(:all) do
+      Post.destroy_all
+      Author.destroy_all
+      Authorship.destroy_all
+      Affiliate.destroy_all
+    end
+
+    it "should return an array of models for multiple association" do
+      association = @post.association_models(:authorships)
+      expect(association[0]).to be_a_kind_of(Authorship)
+    end
+
+    it "should return an array of one model for a singular association" do
+      association = @author.association_models(:affiliate)
+      expect(association[0]).to be_a_kind_of(Affiliate)
+    end
+  end
+  
+  Lifesaver.unsuppress_indexing
+
+  describe "#indexing_suppressed?" do
+    let(:post) { Post.new(title: "Test Post") }
+
+    it "should be false by default" do
+      expect(post.send(:suppress_indexing?)).to eql(false)
+    end
+
+    it "should be true if overridden locally" do
+      Lifesaver.suppress_indexing
+      expect(post.send(:suppress_indexing?)).to eql(true)
+    end
+
+    it "should be false if override is cancelled" do
+      Lifesaver.unsuppress_indexing
+      expect(post.send(:suppress_indexing?)).to eql(false)
+    end
+
+    it "should be true if set individually" do
+      post.suppress_indexing
+      expect(post.send(:suppress_indexing?)).to eql(true)
+    end
+
+    it "should be false if unset individually" do
+      post.unsuppress_indexing
+      expect(post.send(:suppress_indexing?)).to eql(false)
+    end
+  end
+
+  describe "#dependent_association_map" do
+    it "returns an empty Hash when there are no dependent associations" do
+      expect(Comment.new.send(:dependent_association_map)).to eql({})
+    end
+
+    it "returns a Hash with the keys of dependent_association" do
+      dependent_map = Author.new.send(:dependent_association_map)
+      expect(dependent_map).to eql({authorships: true})
+    end
+
+  end
+
+end

data/spec/lifesaver_spec.rb

@@ -0,0 +1,111 @@
+require 'spec_helper'
+
+describe Lifesaver do
+  before(:all) do
+    Lifesaver.suppress_indexing
+    Post.destroy_all
+    Author.destroy_all
+    Authorship.destroy_all
+    Affiliate.destroy_all
+    Comment.destroy_all
+    Lifesaver.unsuppress_indexing
+  end
+  before(:each) do
+    [Author, Post].each do |klass|
+      klass.tire.index.delete
+      klass.tire.create_elasticsearch_index
+    end
+
+    Lifesaver.suppress_indexing
+    
+    @posts = []
+    @posts << Post.create(
+      title: "Lifesavers are my favorite candy", 
+      content: "Lorem ipsum",
+      tags: %w(candy stuff opinions)
+      )
+    @posts << Post.create(
+      title: "Birds are the best animal", 
+      content: "Lorem ipsum",
+      tags: %w(animals stuff facts)
+    )
+    @posts << Post.create(
+      title: "Chicago Cubs have a winning season", 
+      content: "Lorem ipsum",
+      tags: %w(sports stuff jokes)
+    )
+    @comments = []
+    @comments << Comment.create(
+      post: @posts.last,
+      text: "We love this!"
+    )
+    @comments << Comment.create(
+      post: @posts.last,
+      text: "We lied. Didn't realize it was a joke."
+    )
+    @authors = []
+    @authors << Author.create(name: "Paul Sorensen")
+    @authors << Author.create(name: "Paul Sorensen's Ghost Writer")
+    @authors << Author.create(name: "Theo Epstein")
+    @affiliates = []
+    @affiliates << Affiliate.create(name: "Prosper Forebearer")
+    @affiliates << Affiliate.create(name: "Chicago Cubs")
+    @authors[0].affiliate_id = @affiliates.first.id
+    @authors[1].affiliate_id = @affiliates.first.id
+    @authors[2].affiliate_id = @affiliates.last.id
+    @authors.each { |a| a.save! }
+    Authorship.create(post: @posts[0], author: @authors[0])
+    Authorship.create(post: @posts[1], author: @authors[0])
+    Authorship.create(post: @posts[1], author: @authors[1])
+    Authorship.create(post: @posts[2], author: @authors[2])
+
+    Lifesaver.unsuppress_indexing
+
+    [Author, Post].each do |klass|
+      klass.all.each { |k| k.tire.update_index }
+      klass.tire.index.refresh
+    end
+  end
+
+  after(:each) do
+    Post.destroy_all
+    Author.destroy_all
+    Authorship.destroy_all
+    Affiliate.destroy_all
+    Comment.destroy_all
+  end
+
+  it "should traverse the provided graph" do
+    models = Lifesaver::IndexGraph.generate([{"class"=>"author", "id"=>1, "status"=>"changed"}])
+    expect(models.size).to eql(2)
+  end
+
+  it "should reindex on destroy" do
+    @authors[2].destroy
+    sleep(1.seconds)
+    expect(Author.search(query: "Theo Epstein").to_a.size).to eql(0)
+  end
+
+  it "should reindex on update" do
+    @authors[2].name = "Harry Carry"
+    @authors[2].save!
+    sleep(1.seconds) # need to wait for elasticsearch to update
+    expect(Author.search(query: "Harry Carry").to_a.size).to eql(1)
+  end
+
+  it "should update distant related indexes" do
+    @posts[0].tags << 'werd'
+    @posts[0].save!
+    sleep(1.seconds)
+    expect(Author.search(query: "werd").to_a.size).to eql(1)
+  end
+
+  it "should update related indexes if saved model doesn't have index" do
+    @comments[0].text = "We hate this!"
+    @comments[0].save!
+    sleep(1.seconds)
+    result = Post.search(query: "Chicago").to_a.first
+    comment_text = result.comments.first.text
+    expect(comment_text).to eql("We hate this!")
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,27 @@
+require 'coveralls'
+Coveralls.wear!
+
+require 'lifesaver'
+
+require 'support/active_record'
+require 'support/test_models'
+ActiveSupport.on_load :active_record do
+  include Lifesaver::ModelAdditions
+end
+
+Resque.inline = true
+Tire::Model::Search.index_prefix "lifesaver_test"
+
+
+RSpec.configure do |config|
+  # config.expect_with :rspec do |c|
+  #   c.syntax = :expect
+  # end
+
+  config.around do |example|
+    ActiveRecord::Base.transaction do
+      example.run
+      raise ActiveRecord::Rollback
+    end
+  end
+end

data/spec/support/active_record.rb

@@ -0,0 +1,53 @@
+require 'active_record'
+ActiveRecord::Base.establish_connection adapter: "sqlite3", database: ":memory:"
+
+module ActiveModel::Validations
+  # Extension to enhance `should have` on AR Model instances.  Calls
+  # model.valid? in order to prepare the object's errors object.
+  #
+  # You can also use this to specify the content of the error messages.
+  #
+  # @example
+  #
+  #     model.should have(:no).errors_on(:attribute)
+  #     model.should have(1).error_on(:attribute)
+  #     model.should have(n).errors_on(:attribute)
+  #
+  #     model.errors_on(:attribute).should include("can't be blank")
+  def errors_on(attribute)
+    self.valid?
+    [self.errors[attribute]].flatten.compact
+  end
+  alias :error_on :errors_on
+end
+
+# test models we'll use in each spec
+ActiveRecord::Migration.create_table :comments do |t|
+  t.string :text
+  t.integer :post_id
+  t.timestamps
+end
+
+ActiveRecord::Migration.create_table :posts do |t|
+  t.string :title
+  t.text :content
+  t.text :tags
+  t.timestamps
+end
+
+ActiveRecord::Migration.create_table :authors do |t|
+  t.string :name
+  t.integer :affiliate_id
+  t.timestamps
+end
+
+ActiveRecord::Migration.create_table :authorships do |t|
+  t.integer :post_id
+  t.integer :author_id
+  t.timestamps
+end
+
+ActiveRecord::Migration.create_table :affiliates do |t|
+  t.string :name
+  t.timestamps
+end

data/spec/support/test_models.rb

@@ -0,0 +1,90 @@
+require 'tire'
+
+ActiveSupport.on_load :active_record do
+  include Lifesaver::ModelAdditions
+end
+
+
+class Author < ActiveRecord::Base
+  has_many :authorships, dependent: :destroy
+  has_many :posts, through: :authorships
+  belongs_to :affiliate
+  enqueues_indexing
+  include ::Tire::Model::Search
+  notifies_for_indexing :authorships
+  def post_tags
+    tags = Set.new
+    posts.select(:tags).each do |p|
+      tags |= Set.new(p.tags)
+    end
+    tags.to_a
+  end
+  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'}
+    }
+    indexes :post_tags, analyzer: 'keyword'
+  end
+  def self.search(params)
+    tire.search do
+      size 100
+      query { string params[:query] } if params[:query].present?
+      sort do
+        by 'name.untouched', :asc
+      end
+      filter :term, affiliate_id: params[:afilliate_id] if params[:affiliate_id].present?
+    end
+  end
+  def to_indexed_json
+    to_json(include: :affiliate, methods: :post_tags)
+  end
+end
+
+class Authorship < ActiveRecord::Base
+  belongs_to :author
+  belongs_to :post
+  notifies_for_indexing only_on_notify: [:author, :post]
+end
+
+class Comment < ActiveRecord::Base
+  belongs_to :post
+  notifies_for_indexing :post
+end
+
+class Post < ActiveRecord::Base
+  has_many :comments
+  has_many :authorships, dependent: :destroy
+  has_many :authors, through: :authorships
+  serialize :tags, Array
+  enqueues_indexing
+  notifies_for_indexing only_on_change: :authorships
+  include ::Tire::Model::Search
+  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'}
+    }
+  end
+
+  def self.search(params)
+    tire.search do
+      size 100
+      query { string params[:query] } if params[:query].present?
+      sort do
+        by 'title.untouched', :asc
+      end
+    end
+  end
+
+  def to_indexed_json
+    to_json(include: :comments, authors: { include: :affiliate })
+  end
+end
+
+class Affiliate < ActiveRecord::Base
+  has_many :authors
+  notifies_for_indexing :authors
+end

metadata

@@ -0,0 +1,223 @@
+--- !ruby/object:Gem::Specification
+name: lifesaver
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Paul Sorensen
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-10-09 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '3'
+- !ruby/object:Gem::Dependency
+  name: tire
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.6.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.6.0
+- !ruby/object:Gem::Dependency
+  name: resque
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.25.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.25.0
+- !ruby/object:Gem::Dependency
+  name: resque-loner
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.2.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.2.1
+description: Indexes your ActiveRecord models in elasticsearch asynchronously by making
+  use of tire and resque
+email:
+- paulnsorensen@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .coveralls.yml
+- .gitignore
+- .travis.yml
+- CHANGELOG.md
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/lifesaver.rb
+- lib/lifesaver/index_graph.rb
+- lib/lifesaver/index_worker.rb
+- lib/lifesaver/marshal.rb
+- lib/lifesaver/model_additions.rb
+- lib/lifesaver/railtie.rb
+- lib/lifesaver/version.rb
+- lib/lifesaver/visitor_worker.rb
+- lifesaver.gemspec
+- spec/lifesaver/index_graph_spec.rb
+- spec/lifesaver/marshal_spec.rb
+- spec/lifesaver/model_additions_spec.rb
+- spec/lifesaver_spec.rb
+- spec/spec_helper.rb
+- spec/support/active_record.rb
+- spec/support/test_models.rb
+homepage: ''
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '1.9'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: Indexes your ActiveRecord models in elasticsearch asynchronously by making
+  use of tire and resque
+test_files:
+- spec/lifesaver/index_graph_spec.rb
+- spec/lifesaver/marshal_spec.rb
+- spec/lifesaver/model_additions_spec.rb
+- spec/lifesaver_spec.rb
+- spec/spec_helper.rb
+- spec/support/active_record.rb
+- spec/support/test_models.rb