sunspot_submodel_index 0.0.2

data/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in sunspot_submodel_index.gemspec
+gemspec

data/MIT_LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2011 Finetooth Enterprises, Inc.
+
+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.rdoc

@@ -0,0 +1,68 @@
+= Sunspot Submodel Index
+
+This gem ties into the Rails model lifecycle to add support for calling Sunspot index on another model when data it relies on for its index is from an associated model.
+
+== Example
+Lets say you have two ActiveRecord models.  A Person model and a Company model.  As part of your Sunspot indexing for a Person you include the Company name associated with that Person.  When the Company name changes you need to be able to automatically reindex the Person model.  Or if the Company is destroyed you need to be able to reindex the Person with a blank Company name.  This can be easily done with the sunspot_submodel_index declaration in Company to tell it to notify the Person model.
+
+  class Person < ActiveRecord::Base
+    belongs_to :company
+
+    searchable  do
+      textgen :contact_name, :using => :name, :stored => true
+      textgen(:contact_company_name, :stored => true) { self.company_id ? company.name : '' }
+    end
+  end
+  
+  class Company < ActiveRecord::Base
+    has_many :people
+    sunspot_submodel_index :parent => :people, :included_attributes => [:name]
+  end
+  
+Notice that in this example people is a has_many association.  That means all people associated with the company will be reindexed.  
+
+== Usage
+
+This gem ties into the Rails ActiveRecord lifecycle and ties into save and destroy events.  You add the sunspot_submodel_index declaration to the model that needs to notify another model when it is saved or destroyed.  The simplest declaration is:
+
+  sunspot_submodel_index :parent => :some_parent
+  
+In this example the class instance must respond to some_parent.  The parent object will then need to respond to solr_index.
+
+=== Enumerable parents
+
+If the parent is an Enumerable type then it will be iterated over and each member will be reindexed.  
+
+=== Included and Ignored Attributes
+
+You often will only need to notify the parent model if some subset of the attributes on the object have changed.  You can declare attributes to include or ignore.  For included attributes if any attribute in the include set has changed on the object the parent will get indexed.  For ignored attributes the parent will only get indexed if attributes other then those in the ignore set were changed.  If you declare both included and ignored attribute options only the included option is used.
+
+Examples
+
+  sunspot_submodel_index :parent => :people, :included_attributes => [:name]
+  
+  sunspot_submodel_index :parent => :people, :ignore_attributes => [:industry, :address]
+
+=== If Option
+
+There is also the option to call a Proc before parent is indexed.  The Proc is passed the instance of the object.  If the Proc returns false the parent is not indexed.  
+
+Example
+
+  sunspot_submodel_index :parent => :people, :if => Proc.new {|obj| !obj.subsidiary? }
+
+=== Force association reload
+
+Sometimes you will want to force a reload on the association of the parent model before you call it to reindex.  You can set this option with force_association_reload.  If this option is set parent will be called with the parameter true before solr_index is called.
+
+Example
+
+  sunspot_submodel_index :parent => :people, :force_association_reload => true
+
+== Dependencies
+1. Sunspot
+2. ActiveRecord 2+
+
+== License
+
+Sunspot Submodel Index is distributed under the MIT License, copyright (c) 2011 Finetooth Enterprises, Inc.

data/Rakefile

@@ -0,0 +1,9 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+#Test tasks
+require 'rspec'
+require 'rspec/core/rake_task'
+desc 'Run the unit tests'
+RSpec::Core::RakeTask.new(:test)
+#End test tasks

data/lib/sunspot_submodel_index/submodel_index.rb

@@ -0,0 +1,110 @@
+module Sunspot
+  module SubmodelIndex
+    
+    def self.included(klass)
+      klass.class_eval do
+        
+        # Solr Index a parent model when this model is saved or destroyed.
+        #
+        # ==== Options (+options+)
+        # 
+        # :parent<Symbol>::
+        #   Method to call to access the parent to Solr index.
+        # :if<Proc>::
+        #   A Proc that is called before the parent index and is passed an instance of the object.
+        #   Will block Solr index of the parent if false is returned.
+        # :force_association_reload<Boolean>::
+        #   Force a reload on the parent association for Solr index is called on the parent.
+        # :include_attributes<Array>::
+        #   Define only those attributes whose change should trigger a reindex of the parent.
+        # :ignore_attributes<Array>::
+        #   Define attributes, that should not trigger a reindex of the parent.
+        #
+        # ==== Example
+        #
+        #   class Company < ActiveRecord::Base
+        #     has_many :people
+        #     sunspot_submodel_index :parent => :people, :included_attributes => [:name]
+        #   end
+        #
+        def self.sunspot_submodel_index(options = {})
+          include Sunspot::SubmodelIndex::InstanceMethods
+          extend Sunspot::SubmodelIndex::ClassMethods
+          class_inheritable_hash :_sunspot_submodel_options
+          
+          options[:parent] = options[:parent].to_sym
+          options[:included_attributes] =  false if options[:included_attributes].blank? #set to false if empty sent
+          options[:ignored_attributes] =  false if options[:ignored_attributes].blank? #set to false if empty sent
+          options[:force_association_reload] =  false if options[:force_association_reload].blank? #set to false if empty sent
+          
+          self._sunspot_submodel_options = options
+          
+          #add call backs
+          before_save :mark_for_parent_solr_index
+          after_save :parent_solr_index
+          after_destroy :parent_solr_index_on_destroy
+          
+        end
+        
+      end
+    end
+
+    module InstanceMethods
+      
+      def call_parent_solr_index
+        if self.respond_to?(self._sunspot_submodel_options[:parent]) && !self.send(self._sunspot_submodel_options[:parent]).nil?
+          self.send(self._sunspot_submodel_options[:parent],true) if self._sunspot_submodel_options[:force_association_reload]
+          if self.send(self._sunspot_submodel_options[:parent]).is_a?(Enumerable)
+            self.send(self._sunspot_submodel_options[:parent]).each {|item| item.solr_index }
+          else
+            self.send(self._sunspot_submodel_options[:parent]).solr_index 
+          end
+        end
+      end
+      
+      def check_parent_solr_if_statement
+        if self._sunspot_submodel_options[:if] && self._sunspot_submodel_options[:if].instance_of?(Proc)
+          self._sunspot_submodel_options[:if].call(self)
+        else
+          true
+        end
+      end
+      
+      #to run before a save to see if this is a new record, or if fields I care about changed.
+      def mark_for_parent_solr_index
+        #only mark for index if the record is new, or if fields changed that I care about
+        #check the if proc first
+        return unless check_parent_solr_if_statement
+        if self._sunspot_submodel_options[:included_attributes]
+          fields_changed = !(self.changed.map {|k| k.to_sym} & self._sunspot_submodel_options[:included_attributes]).empty?
+        elsif self._sunspot_submodel_options[:ignored_attributes]
+          fields_changed = !(self.changed.map {|k| k.to_sym} - self._sunspot_submodel_options[:ignored_attributes]).empty?
+        else
+          fields_changed = true
+        end
+        if new_record? || fields_changed
+          @marked_for_parent_solr_indexing = true
+        end
+      end
+      
+      #call reindex if I need too
+      def parent_solr_index
+        if @marked_for_parent_solr_indexing
+          call_parent_solr_index
+          remove_instance_variable(:@marked_for_parent_solr_indexing)
+        end
+      end
+      
+      #always call reindex on destroy
+      def parent_solr_index_on_destroy
+        call_parent_solr_index
+      end
+
+    end
+
+    module ClassMethods
+     
+    end
+    
+  end
+end

data/lib/sunspot_submodel_index/version.rb

@@ -0,0 +1,3 @@
+module SunspotSubmodelIndex
+  VERSION = "0.0.2"
+end

data/lib/sunspot_submodel_index.rb

@@ -0,0 +1,9 @@
+require 'sunspot_submodel_index/submodel_index'
+
+if ActiveRecord::VERSION::MAJOR > 2
+  ActiveSupport.on_load(:active_record) do
+    include(Sunspot::SubmodelIndex)
+  end
+else
+  ActiveRecord::Base.send(:include, Sunspot::SubmodelIndex)
+end

data/spec/lib/sunspot_submodel_test_model.rb

@@ -0,0 +1,21 @@
+class SunspotSubmodelTestModel < ActiveRecord::Base
+  
+  sunspot_submodel_index :parent => :parent_model
+  
+  def self.create_table
+    connection.create_table :sunspot_submodel_test_models do |t|
+      t.integer :parent_id
+    end
+  end
+
+  def title
+    "Fake AR"
+  end
+  
+  def parent_model
+    return nil
+  end
+  
+  private
+  
+end

data/spec/spec_helper.rb

@@ -0,0 +1,15 @@
+require 'rubygems'
+
+# require 'uri'
+# require 'fileutils'
+# require 'net/http'
+require 'active_record'
+
+require File.expand_path('../../lib/sunspot_submodel_index', __FILE__)
+
+#include the submodel to test
+require File.expand_path('../lib/sunspot_submodel_test_model', __FILE__)
+
+RSpec.configure do |config|
+  config.mock_with :mocha
+end

data/spec/submodel_index_spec.rb

@@ -0,0 +1,210 @@
+require File.expand_path('../spec_helper', __FILE__)
+
+def stub_object_no_index(new_record = false)
+  obj = SunspotSubmodelTestModel.new
+  obj.class._sunspot_submodel_options[:included_attributes] = false
+  obj.class._sunspot_submodel_options[:ignored_attributes] = false
+  obj.stubs(:new_record?).returns(new_record)
+  parent_mock = mock()
+  parent_mock.expects(:solr_index).never
+  obj.stubs(:parent_model).returns(parent_mock)
+  obj
+end
+
+def stub_object_array_parents(number_of_parents = 2, new_record = false, should_index = true)
+  obj = SunspotSubmodelTestModel.new
+  obj.class._sunspot_submodel_options[:included_attributes] = false
+  obj.class._sunspot_submodel_options[:ignored_attributes] = false
+  obj.stubs(:new_record?).returns(new_record)
+  parents = []
+  number_of_parents.times do |i|
+    parent_mock = mock()
+    should_index ? parent_mock.expects(:solr_index) : parent_mock.expects(:solr_index).never
+    parents << parent_mock
+  end
+  obj.stubs(:parent_model).returns(parents)
+  obj
+end
+
+def stub_object_will_index(new_record = false)
+  obj = SunspotSubmodelTestModel.new
+  obj.class._sunspot_submodel_options[:included_attributes] = false
+  obj.class._sunspot_submodel_options[:ignored_attributes] = false
+  obj.stubs(:new_record?).returns(new_record)
+  parent_mock = mock()
+  parent_mock.expects(:solr_index)
+  obj.stubs(:parent_model).returns(parent_mock)
+  obj
+end
+
+describe Sunspot::SubmodelIndex do 
+  
+  before :all do
+    ActiveRecord::Base.establish_connection("adapter" => "sqlite3", "database" => ":memory:")
+    SunspotSubmodelTestModel.create_table
+  end
+  
+  after :all do
+    ActiveRecord::Base.connection.disconnect!
+  end
+  
+  context "new record" do
+     it "should call solr_index on parent_model on save" do
+       obj = stub_object_will_index(true)
+       obj.save
+     end
+   end
+   
+   
+   context "for existing records" do
+     it "should reindex if no attributes options are set on save if no attributes are included or excluded" do
+       obj = stub_object_will_index
+       obj.save
+     end
+     context "when something changes and an if option is set" do
+       it "should not reindex if the if proc returns false" do
+         obj = stub_object_no_index
+         obj.expects(:check_parent_solr_if_statement).returns false
+         obj.save
+       end
+       it "should reindex if the if proc returns true" do
+         obj = stub_object_will_index
+         obj.expects(:check_parent_solr_if_statement).returns true
+         obj.save
+       end
+     end
+     context "included_attributes" do
+       it "should not index if no included attribute is changed" do
+         obj = stub_object_no_index
+         obj.class._sunspot_submodel_options[:included_attributes] = [:test, :test2]
+         obj.stubs(:changed).returns ["test3"]
+         obj.save
+       end
+       it "should index if any included attribute is changed" do
+         obj = stub_object_will_index
+         obj.class._sunspot_submodel_options[:included_attributes] = [:test, :test2]
+         obj.stubs(:changed).returns ["test2"]
+         obj.save
+       end
+       it "should not index if no changes are made" do
+         obj = stub_object_no_index
+         obj.class._sunspot_submodel_options[:included_attributes] = [:test, :test2]
+         obj.stubs(:changed).returns []
+         obj.save
+       end
+     end
+     context "ignored attributes" do
+       it "should not index if only ignored attributes are changed" do
+         obj = stub_object_no_index
+         obj.class._sunspot_submodel_options[:ignored_attributes] = [:test, :test2]
+         obj.stubs(:changed).returns ["test2","test"]
+         obj.save
+       end
+       it "should not index if no attributes are changed" do
+         obj = stub_object_no_index
+         obj.class._sunspot_submodel_options[:ignored_attributes] = [:test, :test2]
+         obj.stubs(:changed).returns []
+         obj.save
+       end
+       it "should index if a non ignored attribute is changed" do
+         obj = stub_object_will_index
+         obj.class._sunspot_submodel_options[:ignored_attributes] = [:test, :test2]
+         obj.stubs(:changed).returns ["test3"]
+         obj.save
+       end
+       it "should use included attributes if both are set" do
+         obj = stub_object_will_index
+         obj.class._sunspot_submodel_options[:included_attributes] = [:test]
+         obj.class._sunspot_submodel_options[:ignored_attributes] = [:test, :test2]
+         obj.stubs(:changed).returns ["test"]
+         obj.save
+       end
+     end
+   end
+   
+   context "parents that are multiple objects" do
+     #Example is a has_many or has_and_belongs_to_many
+     it "should index several parents if they are an array" do
+       obj = stub_object_array_parents(2,false,true)
+       obj.class._sunspot_submodel_options[:included_attributes] = [:test]
+       obj.stubs(:changed).returns ["test"]
+       obj.save
+     end
+     it "should not fail if the array is empty" do
+       obj = stub_object_array_parents(0,false,true)
+       obj.class._sunspot_submodel_options[:included_attributes] = [:test]
+       obj.stubs(:changed).returns ["test"]
+       obj.save
+     end
+     it "should respect the if statement even if the parents are an array" do
+       obj = stub_object_array_parents(2,false,false)
+       obj.class._sunspot_submodel_options[:included_attributes] = [:test]
+       obj.stubs(:changed).returns ["test"]
+       obj.class._sunspot_submodel_options[:if] = Proc.new {|t| false }
+       obj.save
+     end
+   end
+    
+   
+   context "on destroy" do
+     it "should call parents index" do
+       obj = stub_object_will_index
+       obj.destroy
+     end
+   end
+   
+   
+   context "force association reload" do
+     it "should call parent with true with option is set" do
+       obj = SunspotSubmodelTestModel.new
+       obj.class._sunspot_submodel_options[:force_association_reload] = true
+       parent_mock = mock()
+       parent_mock.expects(:solr_index)
+       obj.expects(:parent_model).with().returns(parent_mock)
+       obj.expects(:parent_model).with(true).returns(parent_mock)
+       obj.expects(:parent_model).with().returns(parent_mock)
+       obj.expects(:parent_model).with().returns(parent_mock)
+       obj.call_parent_solr_index
+     end
+     it "should not call parent with true if option is not set" do
+       obj = SunspotSubmodelTestModel.new
+       obj.class._sunspot_submodel_options[:force_association_reload] = false
+       parent_mock = mock()
+       parent_mock.expects(:solr_index)
+       obj.expects(:parent_model).with().returns(parent_mock).times(3)
+       obj.call_parent_solr_index
+     end
+   end
+   
+   
+   context "check_parent_solr_if_statement" do
+     before do
+       @obj = SunspotSubmodelTestModel.new
+       @obj.class._sunspot_submodel_options[:if] = nil
+     end
+     after do
+       @obj.class._sunspot_submodel_options[:if] = nil
+     end
+     it "should return true if no option is set" do
+       @obj.send(:check_parent_solr_if_statement).should == true
+     end
+     it "should return true if the if option is not a proc" do
+       @obj.class._sunspot_submodel_options[:if] = "not a proc"
+       @obj.send(:check_parent_solr_if_statement).should == true
+     end
+     it "should return true if the if proc returns true" do
+       @obj.class._sunspot_submodel_options[:if] = Proc.new {|t| true }
+       @obj.send(:check_parent_solr_if_statement).should == true
+     end
+     it "should return false if the if proc returns false" do
+       @obj.class._sunspot_submodel_options[:if] = Proc.new {|t| false }
+       @obj.send(:check_parent_solr_if_statement).should == false
+     end
+     it "should pass in the instance of the model" do
+       @obj.class._sunspot_submodel_options[:if] = Proc.new {|t| t.proc_test }
+       @obj.stubs(:proc_test).returns(false)
+       @obj.send(:check_parent_solr_if_statement).should == false
+     end
+   end 
+
+end

data/sunspot_submodel_index.gemspec

@@ -0,0 +1,26 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "sunspot_submodel_index/version"
+
+Gem::Specification.new do |s|
+  s.name        = "sunspot_submodel_index"
+  s.version     = SunspotSubmodelIndex::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Scott Diedrick"]
+  s.email       = ["swalterd@gmail.com"]
+  s.homepage    = "http://github.com/mumboe/sunspot_submodel_index"
+  s.summary     = %q{Support for Sunspot indexing of Rails models when an associated model is updated or deleted.}
+  s.description = %q{This gem ties into the Rails model lifecycle to add support for calling Sunspot index on another model when data it relies on for its index is from an associated model.}
+
+  s.rubyforge_project = "sunspot_submodel_index"
+  
+  s.add_development_dependency "rspec"
+  s.add_development_dependency("sqlite3", [">= 0"])
+  s.add_development_dependency("activerecord", [">= 2.2"])
+  s.add_development_dependency("mocha", [">= 0.9.5"])
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+end

metadata

@@ -0,0 +1,139 @@
+--- !ruby/object:Gem::Specification 
+name: sunspot_submodel_index
+version: !ruby/object:Gem::Version 
+  hash: 27
+  prerelease: 
+  segments: 
+  - 0
+  - 0
+  - 2
+  version: 0.0.2
+platform: ruby
+authors: 
+- Scott Diedrick
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-08-16 00:00:00 -05:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: sqlite3
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: activerecord
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 7
+        segments: 
+        - 2
+        - 2
+        version: "2.2"
+  type: :development
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: mocha
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 49
+        segments: 
+        - 0
+        - 9
+        - 5
+        version: 0.9.5
+  type: :development
+  version_requirements: *id004
+description: This gem ties into the Rails model lifecycle to add support for calling Sunspot index on another model when data it relies on for its index is from an associated model.
+email: 
+- swalterd@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- MIT_LICENSE
+- README.rdoc
+- Rakefile
+- lib/sunspot_submodel_index.rb
+- lib/sunspot_submodel_index/submodel_index.rb
+- lib/sunspot_submodel_index/version.rb
+- spec/lib/sunspot_submodel_test_model.rb
+- spec/spec_helper.rb
+- spec/submodel_index_spec.rb
+- sunspot_submodel_index.gemspec
+has_rdoc: true
+homepage: http://github.com/mumboe/sunspot_submodel_index
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: sunspot_submodel_index
+rubygems_version: 1.6.2
+signing_key: 
+specification_version: 3
+summary: Support for Sunspot indexing of Rails models when an associated model is updated or deleted.
+test_files: 
+- spec/lib/sunspot_submodel_test_model.rb
+- spec/spec_helper.rb
+- spec/submodel_index_spec.rb