elastic_searchable 1.0.2 → 1.1.0

data/.gitignore

@@ -19,6 +19,15 @@ pkg
 test/*.log
 test/*.sqlite3
 
+# For vim:
+*.swp
+
+# For MacOS:
+.DS_Store
+
+# git files
+*.orig
+
 # Have editor/IDE/OS specific files you need to ignore? Consider using a global gitignore: 
 #
 # * Create a file at ~/.gitignore
@@ -30,10 +39,6 @@ test/*.sqlite3
 #
 # Not sure what to needs to be ignored for particular editors/OSes? Here's some ideas to get you started. (Remember, remove the leading # of the line)
 #
-# For MacOS:
-#
-#.DS_Store
-#
 # For TextMate
 #*.tmproj
 #tmtags
@@ -42,6 +47,4 @@ test/*.sqlite3
 #*~
 #\#*
 #.\#*
-#
-# For vim:
-#*.swp
+

data/.rvmrc

@@ -0,0 +1,4 @@
+rvm use ree-1.8.7-2011.03@rails3
+
+# use rails2 gemset for testing as well
+#ree-1.8.7-2011.03@rails2

data/README.rdoc

@@ -27,15 +27,12 @@ Integrate the elasticsearch library into Rails.
   #defaults to localhost:9200
   ElasticSearchable.base_uri = 'server:9200'
 
-== Contributing to elastic_searchable
+== Contributing
  
-* Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet
-* Check out the issue tracker to make sure someone already hasn't requested it and/or contributed it
 * Fork the project
-* Start a feature/bugfix branch
-* Commit and push until you are happy with your contribution
-* Make sure to add tests for it. This is important so I don't break it in a future version unintentionally.
-* Please try not to mess with the Rakefile, version, or history. If you want to have your own version, or is otherwise necessary, that is fine, but please isolate to its own commit so I can cherry-pick around it.
+* Fix the issue
+* Add unit tests
+* Submit pull request on github
 
 == Copyright
 

data/elastic_searchable.gemspec

@@ -14,10 +14,10 @@ Gem::Specification.new do |s|
 
   s.rubyforge_project = "elastic_searchable"
   
-  s.add_runtime_dependency(%q<activerecord>, ["~> 3.0.0"])
+  s.add_runtime_dependency(%q<activerecord>, [">= 2.3.11"])
+  s.add_runtime_dependency(%q<will_paginate>, [">= 2.3.0"])
   s.add_runtime_dependency(%q<httparty>, ["~> 0.6.0"])
   s.add_runtime_dependency(%q<backgrounded>, ["~> 0.7.0"])
-  s.add_runtime_dependency(%q<will_paginate>, [">= 2.3.15"])
   s.add_development_dependency(%q<shoulda>, [">= 0"])
   s.add_development_dependency(%q<mocha>, [">= 0"])
   s.add_development_dependency(%q<bundler>, [">= 0"])
@@ -25,7 +25,6 @@ Gem::Specification.new do |s|
   s.add_development_dependency(%q<sqlite3-ruby>, ["~> 1.3.2"])
   s.add_development_dependency(%q<ruby-debug>, [">= 0"])
 
-
   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) }

data/lib/elastic_searchable/active_record_extensions.rb

@@ -0,0 +1,72 @@
+require 'active_record'
+require 'backgrounded'
+require 'elastic_searchable/queries'
+require 'elastic_searchable/callbacks'
+require 'elastic_searchable/index'
+
+module ElasticSearchable
+  module ActiveRecordExtensions
+    # Valid options:
+    # :index (optional) configure index to store data in.  default to ElasticSearchable.default_index
+    # :type (optional) configue type to store data in.  default to model table name
+    # :index_options (optional) configure index properties (ex: tokenizer)
+    # :mapping (optional) configure field properties for this model (ex: skip analyzer for field)
+    # :if (optional) reference symbol/proc condition to only index when condition is true 
+    # :unless (optional) reference symbol/proc condition to skip indexing when condition is true
+    # :json (optional) configure the json document to be indexed (see http://api.rubyonrails.org/classes/ActiveModel/Serializers/JSON.html#method-i-as_json for available options)
+    #
+    # Available callbacks:
+    # after_index
+    # called after the object is indexed in elasticsearch
+    # (optional) :on => :create/:update can be used to only fire callback when object is created or updated
+    #
+    # after_percolate
+    # called after object is indexed in elasticsearch
+    # only fires if the update index call returns a non-empty set of registered percolations
+    # use the "percolations" instance method from within callback to inspect what percolations were returned
+    def elastic_searchable(options = {})
+      cattr_accessor :elastic_options
+      self.elastic_options = options.symbolize_keys
+
+      extend ElasticSearchable::Indexing::ClassMethods
+      extend ElasticSearchable::Queries
+
+      include ElasticSearchable::Indexing::InstanceMethods
+      include ElasticSearchable::Callbacks::InstanceMethods
+
+      backgrounded :update_index_on_create => ElasticSearchable::Callbacks.backgrounded_options, :update_index_on_update => ElasticSearchable::Callbacks.backgrounded_options
+      class << self
+        backgrounded :delete_id_from_index => ElasticSearchable::Callbacks.backgrounded_options
+      end
+
+      attr_accessor :index_lifecycle, :percolations
+      define_model_callbacks :index, :percolate, :only => :after
+      after_commit :update_index_on_create_backgrounded, :if => :should_index?, :unless => :elasticsearch_offline?, :on => :create
+      after_commit :update_index_on_update_backgrounded, :if => :should_index?, :unless => :elasticsearch_offline?, :on => :update
+      after_commit :delete_from_index, :unless => :elasticsearch_offline?, :on => :destroy
+
+      class_eval do
+        # retuns list of percolation matches found during indexing
+        def percolations
+          @percolations || []
+        end
+
+        class << self
+          # override default after_index callback definition to support :on option
+          # see ActiveRecord::Transactions::ClassMethods#after_commit for example
+          def after_index(*args, &block)
+            options = args.last
+            if options.is_a?(Hash) && options[:on]
+              options[:if] = Array.wrap(options[:if])
+              options[:if] << "self.index_lifecycle == :#{options[:on]}"
+            end
+            set_callback(:index, :after, *args, &block)
+          end
+
+        end
+      end
+    end
+  end
+end
+
+ActiveRecord::Base.send(:extend, ElasticSearchable::ActiveRecordExtensions)

data/lib/elastic_searchable/index.rb

@@ -1,3 +1,5 @@
+require 'will_paginate'
+
 module ElasticSearchable
   module Indexing
     module ClassMethods
@@ -16,11 +18,12 @@ module ElasticSearchable
       end
 
       # create the index
-      # http://www.elasticsearch.com/docs/elasticsearch/rest_api/admin/indices/create_index/
+      # http://www.elasticsearch.org/guide/reference/api/admin-indices-create-index.html
       def create_index
-        options = self.elastic_options[:index_options] ? self.elastic_options[:index_options].to_json : ''
-        ElasticSearchable.request :put, index_path, :body => options
-        self.update_index_mapping
+        options = {}
+        options.merge! :settings => self.elastic_options[:index_options] if self.elastic_options[:index_options]
+        options.merge! :mappings => {index_type => self.elastic_options[:mapping]} if self.elastic_options[:mapping]
+        ElasticSearchable.request :put, index_path, :body => options.to_json
       end
 
       # explicitly refresh the index, making all operations performed since the last refresh
@@ -41,6 +44,8 @@ module ElasticSearchable
       # http://www.elasticsearch.com/docs/elasticsearch/rest_api/delete/
       def delete_id_from_index(id)
         ElasticSearchable.request :delete, index_type_path(id)
+      rescue ElasticSearchable::ElasticError => e
+        ElasticSearchable.logger.warn e
       end
 
       # helper method to generate elasticsearch url for this object type
@@ -54,20 +59,22 @@ module ElasticSearchable
       end
 
       # reindex all records using bulk api
-      # options:
-      #   :scope - scope the find_in_batches to only a subset of records
-      #   :batch - counter to start indexing at
-      #   :include - passed to find_in_batches to hydrate objects
       # see http://www.elasticsearch.org/guide/reference/api/bulk.html
+      # options:
+      #   :scope - scope to use for looking up records to reindex. defaults to self (all)
+      #   :page - page/batch to begin indexing at. defaults to 1
+      #   :per_page - number of records to index per batch. defaults to 1000
+      #
+      # TODO: move this to AREL relation to remove the options scope param
       def reindex(options = {})
         self.update_index_mapping
-        batch = options.delete(:batch) || 1
-        options[:batch_size] ||= 1000
-        options[:start] ||= (batch - 1) * options[:batch_size]
+        options.reverse_merge! :page => 1, :per_page => 1000, :total_entries => 1
         scope = options.delete(:scope) || self
-        scope.find_in_batches(options) do |records|
-          ElasticSearchable.logger.info "reindexing batch ##{batch}..."
-          batch += 1
+
+        records = scope.paginate(options)
+        while records.any? do
+          ElasticSearchable.logger.debug "reindexing batch ##{records.current_page}..."
+
           actions = []
           records.each do |record|
             next unless record.should_index?
@@ -82,9 +89,12 @@ module ElasticSearchable
           begin
             ElasticSearchable.request(:put, '/_bulk', :body => "\n#{actions.join("\n")}\n") if actions.any?
           rescue ElasticError => e
-            ElasticSearchable.logger.warn "Error indexing batch ##{batch}: #{e.message}"
+            ElasticSearchable.logger.warn "Error indexing batch ##{options[:page]}: #{e.message}"
             ElasticSearchable.logger.warn e
           end
+
+          options.merge! :page => (records.current_page + 1)
+          records = scope.paginate(options)
         end
       end
 
@@ -106,19 +116,19 @@ module ElasticSearchable
         query.merge! :percolate => "*" if _percolate_callbacks.any?
         response = ElasticSearchable.request :put, self.class.index_type_path(self.id), :query => query, :body => self.as_json_for_index.to_json
 
-        @index_lifecycle = lifecycle ? lifecycle.to_sym : nil
+        self.index_lifecycle = lifecycle ? lifecycle.to_sym : nil
         _run_index_callbacks
 
-        @percolations = response['matches'] || []
-        _run_percolate_callbacks if @percolations.any?
+        self.percolations = response['matches'] || []
+        _run_percolate_callbacks if self.percolations.any?
       end
       # document to index in elasticsearch
       def as_json_for_index
-        original_include_root_in_json = ::ActiveRecord::Base.include_root_in_json
-        ::ActiveRecord::Base.include_root_in_json = false
+        original_include_root_in_json = self.class.include_root_in_json
+        self.class.include_root_in_json = false
         return self.as_json self.class.elastic_options[:json]
       ensure
-        ::ActiveRecord::Base.include_root_in_json = original_include_root_in_json
+        self.class.include_root_in_json = original_include_root_in_json
       end
       def should_index?
         [self.class.elastic_options[:if]].flatten.compact.all? { |m| evaluate_elastic_condition(m) } &&
@@ -130,10 +140,14 @@ module ElasticSearchable
       # http://www.elasticsearch.org/blog/2011/02/08/percolator.html
       def percolate
         response = ElasticSearchable.request :get, self.class.index_type_path('_percolate'), :body => {:doc => self.as_json_for_index}.to_json
-        response['matches']
+        self.percolations = response['matches'] || []
+        self.percolations
       end
 
       private
+      def elasticsearch_offline?
+        ElasticSearchable.offline?
+      end
       # ripped from activesupport
       def evaluate_elastic_condition(method)
         case method

data/lib/elastic_searchable/version.rb

@@ -1,4 +1,4 @@
 module ElasticSearchable
-  VERSION = '1.0.2'
+  VERSION = '1.1.0'
 end
 

data/lib/elastic_searchable.rb

@@ -1,34 +1,31 @@
 require 'httparty'
 require 'logger'
-require 'elastic_searchable/active_record'
+require 'elastic_searchable/active_record_extensions'
 
 module ElasticSearchable
+  DEFAULT_INDEX = 'elastic_searchable'
   include HTTParty
   format :json
   base_uri 'localhost:9200'
-  #debug_output
 
   class ElasticError < StandardError; end
   class << self
-    # setup the default index to use
-    # one index can hold many object 'types'
-    @@default_index = nil
-    def default_index=(index)
-      @@default_index = index
-    end
-    def default_index
-      @@default_index || 'elastic_searchable'
-    end
+    attr_accessor :logger, :default_index, :offline
 
-    @@logger = Logger.new(STDOUT)
-    @@logger.level = Logger::INFO
-    def logger=(logger)
-      @@logger = logger
+    # execute a block of work without reindexing objects
+    def offline(&block)
+      @offline = true
+      yield
+    ensure
+      @offline = false
     end
-    def logger
-      @@logger
+    def offline?
+      !!@offline
     end
-    #perform a request to the elasticsearch server
+    # perform a request to the elasticsearch server
+    # configuration:
+    # ElasticSearchable.base_uri 'host:port' controls where to send request to
+    # ElasticSearchable.debug_output outputs all http traffic to console
     def request(method, url, options = {})
       response = self.send(method, url, options)
       logger.debug "elasticsearch request: #{method} #{url} #{"took #{response['took']}ms" if response['took']}"
@@ -46,4 +43,11 @@ module ElasticSearchable
   end
 end
 
-ActiveRecord::Base.send(:include, ElasticSearchable::ActiveRecord)
+# configure default logger to standard out with info log level
+ElasticSearchable.logger = Logger.new STDOUT
+ElasticSearchable.logger.level = Logger::INFO
+
+# configure default index to be elastic_searchable
+# one index can hold many object 'types'
+ElasticSearchable.default_index = ElasticSearchable::DEFAULT_INDEX
+

data/test/helper.rb

@@ -10,15 +10,12 @@ end
 require 'test/unit'
 require 'shoulda'
 require 'mocha'
-require "ruby-debug"
+require 'ruby-debug'
 
 $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
 $LOAD_PATH.unshift(File.dirname(__FILE__))
 require 'elastic_searchable'
-
-config = YAML::load(IO.read(File.dirname(__FILE__) + '/database.yml'))
-ActiveRecord::Base.logger = Logger.new(File.dirname(__FILE__) + "/debug.log")
-ActiveRecord::Base.establish_connection(config[ENV['DB'] || 'sqlite'])
+require 'setup_database'
 
 class Test::Unit::TestCase
   def delete_index

data/test/setup_database.rb

@@ -0,0 +1,48 @@
+config = YAML::load(IO.read(File.dirname(__FILE__) + '/database.yml'))
+ActiveRecord::Base.logger = Logger.new(File.dirname(__FILE__) + "/debug.log")
+ActiveRecord::Base.establish_connection(config[ENV['DB'] || 'sqlite'])
+
+ActiveRecord::Schema.define(:version => 1) do
+  create_table :posts, :force => true do |t|
+    t.column :title, :string
+    t.column :body, :string
+    t.column :name, :string
+  end
+  create_table :blogs, :force => true do |t|
+    t.column :title, :string
+    t.column :body, :string
+  end
+  create_table :users, :force => true do |t|
+    t.column :name, :string
+  end
+  create_table :friends, :force => true do |t|
+    t.column :name, :string
+    t.column :favorite_color, :string
+    t.belongs_to :book
+  end
+  create_table :books, :force => true do |t|
+    t.column :title, :string
+    t.column :isbn, :string
+  end
+  create_table :max_page_size_classes, :force => true do |t|
+    t.column :name, :string
+  end
+  create_table :parents, :force => true do |t|
+    t.column :name, :string
+    t.column :description, :string
+  end
+  create_table :children, :force => true do |t|
+    t.column :name, :string
+    t.column :description, :string
+    t.belongs_to :parent
+  end
+end
+
+if WillPaginate.respond_to?(:enable_activerecord)
+  puts 'configuring will_paginate v2.x'
+  WillPaginate.enable_activerecord
+else
+  puts 'configuring will_paginate v3.x'
+  require 'will_paginate/finders/active_record'
+  WillPaginate::Finders::ActiveRecord.enable!
+end

data/test/test_elastic_searchable.rb

@@ -1,40 +1,38 @@
 require File.join(File.dirname(__FILE__), 'helper')
 
 class TestElasticSearchable < Test::Unit::TestCase
-  ActiveRecord::Schema.define(:version => 1) do
-    create_table :posts, :force => true do |t|
-      t.column :title, :string
-      t.column :body, :string
+  def setup
+    delete_index
+  end
+  ElasticSearchable.debug_output
+  SINGLE_NODE_CLUSTER_CONFIG = {'number_of_replicas' => 0, 'number_of_shards' => 1}
+
+  context 'non elastic activerecord class' do
+    class Parent < ActiveRecord::Base
     end
-    create_table :blogs, :force => true do |t|
-      t.column :title, :string
-      t.column :body, :string
+    setup do
+      @clazz = Parent
     end
-    create_table :users, :force => true do |t|
-      t.column :name, :string
+    should 'not respond to elastic_options' do
+      assert !@clazz.respond_to?(:elastic_options)
     end
-    create_table :friends, :force => true do |t|
-      t.column :name, :string
-      t.column :favorite_color, :string
+  end
+  context 'instance of non-elastic_searchable activerecord class' do
+    class Parent < ActiveRecord::Base
     end
-    create_table :books, :force => true do |t|
-      t.column :title, :string
+    setup do
+      @instance = Parent.new
     end
-    create_table :max_page_size_classes, :force => true do |t|
-      t.column :name, :string
+    should 'not respond to percolations' do
+      assert !@instance.respond_to?(:percolations)
     end
   end
 
-  def setup
-    delete_index
-  end
-  def teardown
-    delete_index
-  end
   class Post < ActiveRecord::Base
-    elastic_searchable :index_options => { "analysis.analyzer.default.tokenizer" => 'standard', "analysis.analyzer.default.filter" => ["standard", "lowercase", 'porterStem'] }
+    elastic_searchable :index_options => SINGLE_NODE_CLUSTER_CONFIG
     after_index :indexed
     after_index :indexed_on_create, :on => :create
+    after_index :indexed_on_update, :on => :update
     def indexed
       @indexed = true
     end
@@ -47,8 +45,14 @@ class TestElasticSearchable < Test::Unit::TestCase
     def indexed_on_create?
       @indexed_on_create
     end
+    def indexed_on_update
+      @indexed_on_update = true
+    end
+    def indexed_on_update?
+      @indexed_on_update
+    end
   end
-  context 'Post class with default elastic_searchable config' do
+  context 'activerecord class with default elastic_searchable config' do
     setup do
       @clazz = Post
     end
@@ -58,9 +62,13 @@ class TestElasticSearchable < Test::Unit::TestCase
     should 'define elastic_options' do
       assert @clazz.elastic_options
     end
+    should 'respond to :percolations' do
+      assert @clazz.new.respond_to?(:percolations)
+      assert_equal [], @clazz.new.percolations
+    end
   end
 
-  context 'ElasticSearchable.request with invalid url' do
+  context 'Model.request with invalid url' do
     should 'raise error' do
       assert_raises ElasticSearchable::ElasticError do
         ElasticSearchable.request :get, '/elastic_searchable/foobar/notfound'
@@ -68,36 +76,18 @@ class TestElasticSearchable < Test::Unit::TestCase
     end
   end
 
-  context 'Post.create_index' do
+  context 'Model.create_index' do
     setup do
       Post.create_index
+      Post.refresh_index
       @status = ElasticSearchable.request :get, '/elastic_searchable/_status'
     end
     should 'have created index' do
       assert @status['ok']
     end
-    should 'have used custom index_options' do
-      expected = {
-        "index.number_of_replicas" => "1",
-        "index.number_of_shards" => "5",
-        "index.analysis.analyzer.default.tokenizer" => "standard",
-        "index.analysis.analyzer.default.filter.0" => "standard",
-        "index.analysis.analyzer.default.filter.1" => "lowercase",
-        "index.analysis.analyzer.default.filter.2" => "porterStem"
-      }
-      assert_equal expected, @status['indices']['elastic_searchable']['settings'], @status.inspect
-    end
-  end
-
-  context 'deleting object that does not exist in search index' do
-    should 'raise error' do
-      assert_raises ElasticSearchable::ElasticError do
-        Post.delete_id_from_index 123
-      end
-    end
   end
 
-  context 'Post.create' do
+  context 'Model.create' do
     setup do
       @post = Post.create :title => 'foo', :body => "bar"
     end
@@ -107,27 +97,78 @@ class TestElasticSearchable < Test::Unit::TestCase
     should 'have fired after_index_on_create callback' do
       assert @post.indexed_on_create?
     end
+    should 'not have fired after_index_on_update callback' do
+      assert !@post.indexed_on_update?
+    end
+  end
+
+  context 'Model.update' do
+    setup do
+      Post.create! :title => 'foo'
+      @post = Post.last
+      @post.update_attribute :title, 'bar'
+    end
+    should 'have fired after_index callback' do
+      assert @post.indexed?
+    end
+    should 'not have fired after_index_on_create callback' do
+      assert !@post.indexed_on_create?
+    end
+    should 'have fired after_index_on_update callback' do
+      assert @post.indexed_on_update?
+    end
+  end
+
+  context 'Model.create within ElasticSearchable.offline block' do
+    setup do
+      Post.any_instance.expects(:update_index_on_create).never
+      ElasticSearchable.offline do
+        @post = Post.create :title => 'foo', :body => "bar"
+      end
+    end
+    should 'not have triggered indexing behavior' do end #see expectations
+    should 'not have fired after_index callback' do
+      assert !@post.indexed?
+    end
+    should 'not have fired after_index_on_create callback' do
+      assert !@post.indexed_on_create?
+    end
+    should 'not have fired after_index_on_update callback' do
+      assert !@post.indexed_on_update?
+    end
   end
 
   context 'with empty index when multiple database records' do
     setup do
+      Post.delete_all
       Post.create_index
       @first_post = Post.create :title => 'foo', :body => "first bar"
       @second_post = Post.create :title => 'foo', :body => "second bar"
-      Post.clean_index
+      Post.delete_index
+      Post.create_index
     end
     should 'not raise error if error occurs reindexing model' do
       ElasticSearchable.expects(:request).raises(ElasticSearchable::ElasticError.new('faux error'))
-      Post.reindex
+      assert_nothing_raised do
+        Post.reindex
+      end
     end
-    context 'Post.reindex' do
+    should 'not raise error if destroying one instance' do
+      Logger.any_instance.expects(:warn)
+      assert_nothing_raised do
+        @first_post.destroy
+      end
+    end
+    context 'Model.reindex' do
       setup do
-        Post.reindex
+        Post.reindex :per_page => 1, :scope => Post.scoped(:order => 'body desc')
         Post.refresh_index
       end
       should 'have reindexed both records' do
-        ElasticSearchable.request :get, "/elastic_searchable/posts/#{@first_post.id}"
-        ElasticSearchable.request :get, "/elastic_searchable/posts/#{@second_post.id}"
+        assert_nothing_raised do
+          ElasticSearchable.request :get, "/elastic_searchable/posts/#{@first_post.id}"
+          ElasticSearchable.request :get, "/elastic_searchable/posts/#{@second_post.id}"
+        end
       end
     end
   end
@@ -149,7 +190,7 @@ class TestElasticSearchable < Test::Unit::TestCase
       end
       should 'be paginated' do
         assert_equal 1, @results.current_page
-        assert_equal 20, @results.per_page
+        assert_equal Post.per_page, @results.per_page
         assert_nil @results.previous_page
         assert_nil @results.next_page
       end
@@ -197,7 +238,7 @@ class TestElasticSearchable < Test::Unit::TestCase
 
 
   class Blog < ActiveRecord::Base
-    elastic_searchable :if => proc {|b| b.should_index? }
+    elastic_searchable :if => proc {|b| b.should_index? }, :index_options => SINGLE_NODE_CLUSTER_CONFIG
     def should_index?
       false
     end
@@ -217,15 +258,32 @@ class TestElasticSearchable < Test::Unit::TestCase
   end
 
   class User < ActiveRecord::Base
-    elastic_searchable :mapping => {:properties => {:name => {:type => :string, :index => :not_analyzed}}}
+    elastic_searchable :index_options => {
+      'number_of_replicas' => 0,
+      'number_of_shards' => 1,
+      "analysis.analyzer.default.tokenizer" => 'standard',
+      "analysis.analyzer.default.filter" => ["standard", "lowercase", 'porterStem']},
+    :mapping => {:properties => {:name => {:type => :string, :index => :not_analyzed}}}
   end
-  context 'activerecord class with :mapping=>{}' do
+  context 'activerecord class with :index_options and :mapping' do
     context 'creating index' do
       setup do
         User.create_index
-        @status = ElasticSearchable.request :get, '/elastic_searchable/users/_mapping'
+      end
+      should 'have used custom index_options' do
+        @status = ElasticSearchable.request :get, '/elastic_searchable/_status'
+        expected = {
+          "index.number_of_replicas" => "0",
+          "index.number_of_shards" => "1",
+          "index.analysis.analyzer.default.tokenizer" => "standard",
+          "index.analysis.analyzer.default.filter.0" => "standard",
+          "index.analysis.analyzer.default.filter.1" => "lowercase",
+          "index.analysis.analyzer.default.filter.2" => "porterStem"
+        }
+        assert_equal expected, @status['indices']['elastic_searchable']['settings'], @status.inspect
       end
       should 'have set mapping' do
+        @status = ElasticSearchable.request :get, '/elastic_searchable/users/_mapping'
         expected = {
           "users"=> {
             "properties"=> {
@@ -239,19 +297,27 @@ class TestElasticSearchable < Test::Unit::TestCase
   end
 
   class Friend < ActiveRecord::Base
-    elastic_searchable :json => {:only => [:name]}
+    belongs_to :book
+    elastic_searchable :json => {:include => {:book => {:only => :title}}, :only => :name}, :index_options => SINGLE_NODE_CLUSTER_CONFIG
   end
-  context 'activerecord class with optiona :json config' do
+  context 'activerecord class with optional :json config' do
     context 'creating index' do
       setup do
         Friend.create_index
-        @friend = Friend.create! :name => 'bob', :favorite_color => 'red'
+        @book = Book.create! :isbn => '123abc', :title => 'another world'
+        @friend = Friend.new :name => 'bob', :favorite_color => 'red'
+        @friend.book = @book
+        @friend.save!
         Friend.refresh_index
       end
       should 'index json with configuration' do
         @response = ElasticSearchable.request :get, "/elastic_searchable/friends/#{@friend.id}"
+        # should not index:
+        # friend.favorite_color
+        # book.isbn
         expected = {
-          "name" => 'bob' #favorite_color should not be indexed
+          "name" => 'bob',
+          'book' => {'title' => 'another world'}
         }
         assert_equal expected, @response['_source'], @response.inspect
       end
@@ -263,7 +329,7 @@ class TestElasticSearchable < Test::Unit::TestCase
       ElasticSearchable.default_index = 'my_new_index'
     end
     teardown do
-      ElasticSearchable.default_index = nil
+      ElasticSearchable.default_index = ElasticSearchable::DEFAULT_INDEX
     end
     should 'change default index' do
       assert_equal 'my_new_index', ElasticSearchable.default_index
@@ -318,7 +384,7 @@ class TestElasticSearchable < Test::Unit::TestCase
   end
 
   class MaxPageSizeClass < ActiveRecord::Base
-    elastic_searchable
+    elastic_searchable :index_options => SINGLE_NODE_CLUSTER_CONFIG
     def self.max_per_page
       1
     end

metadata

@@ -5,9 +5,9 @@ version: !ruby/object:Gem::Version
   prerelease: 
   segments: 
   - 1
+  - 1
   - 0
-  - 2
-  version: 1.0.2
+  version: 1.1.0
 platform: ruby
 authors: 
 - Ryan Sonnek
@@ -15,8 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-03-30 00:00:00 -05:00
-default_executable: 
+date: 2011-04-15 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: activerecord
@@ -24,62 +23,62 @@ dependencies:
   requirement: &id001 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
-    - - ~>
+    - - ">="
       - !ruby/object:Gem::Version 
-        hash: 7
+        hash: 21
         segments: 
+        - 2
         - 3
-        - 0
-        - 0
-        version: 3.0.0
+        - 11
+        version: 2.3.11
   type: :runtime
   version_requirements: *id001
 - !ruby/object:Gem::Dependency 
-  name: httparty
+  name: will_paginate
   prerelease: false
   requirement: &id002 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
-    - - ~>
+    - - ">="
       - !ruby/object:Gem::Version 
-        hash: 7
+        hash: 3
         segments: 
+        - 2
+        - 3
         - 0
-        - 6
-        - 0
-        version: 0.6.0
+        version: 2.3.0
   type: :runtime
   version_requirements: *id002
 - !ruby/object:Gem::Dependency 
-  name: backgrounded
+  name: httparty
   prerelease: false
   requirement: &id003 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
-        hash: 3
+        hash: 7
         segments: 
         - 0
-        - 7
+        - 6
         - 0
-        version: 0.7.0
+        version: 0.6.0
   type: :runtime
   version_requirements: *id003
 - !ruby/object:Gem::Dependency 
-  name: will_paginate
+  name: backgrounded
   prerelease: false
   requirement: &id004 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
-    - - ">="
+    - - ~>
       - !ruby/object:Gem::Version 
-        hash: 29
+        hash: 3
         segments: 
-        - 2
-        - 3
-        - 15
-        version: 2.3.15
+        - 0
+        - 7
+        - 0
+        version: 0.7.0
   type: :runtime
   version_requirements: *id004
 - !ruby/object:Gem::Dependency 
@@ -180,22 +179,22 @@ extra_rdoc_files: []
 files: 
 - .document
 - .gitignore
+- .rvmrc
 - Gemfile
 - LICENSE.txt
 - README.rdoc
 - Rakefile
-- VERSION
 - elastic_searchable.gemspec
 - lib/elastic_searchable.rb
-- lib/elastic_searchable/active_record.rb
+- lib/elastic_searchable/active_record_extensions.rb
 - lib/elastic_searchable/callbacks.rb
 - lib/elastic_searchable/index.rb
 - lib/elastic_searchable/queries.rb
 - lib/elastic_searchable/version.rb
 - test/database.yml
 - test/helper.rb
+- test/setup_database.rb
 - test/test_elastic_searchable.rb
-has_rdoc: true
 homepage: http://github.com/wireframe/elastic_searchable
 licenses: []
 
@@ -225,11 +224,12 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: elastic_searchable
-rubygems_version: 1.6.2
+rubygems_version: 1.7.2
 signing_key: 
 specification_version: 3
 summary: elastic search for activerecord
 test_files: 
 - test/database.yml
 - test/helper.rb
+- test/setup_database.rb
 - test/test_elastic_searchable.rb

data/VERSION

@@ -1 +0,0 @@
-0.6.1

data/lib/elastic_searchable/active_record.rb

@@ -1,67 +0,0 @@
-require 'active_record'
-require 'backgrounded'
-require 'elastic_searchable/queries'
-require 'elastic_searchable/callbacks'
-require 'elastic_searchable/index'
-
-module ElasticSearchable
-  module ActiveRecord
-    def self.included(base)
-      base.send :extend, ClassMethods
-    end
-
-    module ClassMethods
-      attr_accessor :elastic_options
-
-      # Valid options:
-      # :index (optional) configure index to store data in.  default to ElasticSearchable.default_index
-      # :type (optional) configue type to store data in.  default to model table name
-      # :index_options (optional) configure index properties (ex: tokenizer)
-      # :mapping (optional) configure field properties for this model (ex: skip analyzer for field)
-      # :if (optional) reference symbol/proc condition to only index when condition is true 
-      # :unless (optional) reference symbol/proc condition to skip indexing when condition is true
-      # :json (optional) configure the json document to be indexed (see http://api.rubyonrails.org/classes/ActiveModel/Serializers/JSON.html#method-i-as_json for available options)
-      #
-      # Available callbacks:
-      # after_index
-      # called after the object is indexed in elasticsearch
-      # (optional) :on => :create/:update can be used to only fire callback when object is created or updated
-      #
-      # after_percolate
-      # called after object is indexed in elasticsearch
-      # only fires if the update index call returns a non-empty set of registered percolations
-      # use the "percolations" instance method from within callback to inspect what percolations were returned
-      def elastic_searchable(options = {})
-        options.symbolize_keys!
-        self.elastic_options = options
-
-        extend ElasticSearchable::Indexing::ClassMethods
-        extend ElasticSearchable::Queries
-
-        include ElasticSearchable::Indexing::InstanceMethods
-        include ElasticSearchable::Callbacks::InstanceMethods
-
-        backgrounded :update_index_on_create => ElasticSearchable::Callbacks.backgrounded_options, :update_index_on_update => ElasticSearchable::Callbacks.backgrounded_options
-        class << self
-          backgrounded :delete_id_from_index => ElasticSearchable::Callbacks.backgrounded_options
-        end
-
-        attr_accessor :percolations
-        define_model_callbacks :index, :percolate, :only => :after
-        after_commit :update_index_on_create_backgrounded, :if => :should_index?, :on => :create
-        after_commit :update_index_on_update_backgrounded, :if => :should_index?, :on => :update
-        after_commit :delete_from_index, :on => :destroy
-      end
-      # override default after_index callback definition to support :on option
-      # see ActiveRecord::Transactions::ClassMethods#after_commit for example
-      def after_index(*args, &block)
-        options = args.last
-        if options.is_a?(Hash) && options[:on]
-          options[:if] = Array.wrap(options[:if])
-          options[:if] << "@index_lifecycle == :#{options[:on]}"
-        end
-        set_callback(:index, :after, *args, &block)
-      end
-    end
-  end
-end