elastic_searchable 0.7.3 → 1.0.0

data/.gitignore

@@ -19,15 +19,6 @@ 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
@@ -39,6 +30,10 @@ 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
@@ -47,4 +42,6 @@ test/*.sqlite3
 #*~
 #\#*
 #.\#*
-
+#
+# For vim:
+#*.swp

data/LICENSE.txt

@@ -1,22 +1,20 @@
-The MIT License
+Copyright (c) 2011 Ryan Sonnek
 
-Copyright (c) 2011 Socialcast, 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:
 
-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.
+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,44 @@
+= elastic_searchable
+
+Integrate the elasticsearch library into Rails.
+
+== Usage
+  class Blog < ActiveRecord::Base
+    elastic_searchable
+  end
+
+  results = Blog.search 'foo'
+
+== Features
+
+* fast. fast! FAST! 30% faster than rubberband on average.
+* active record callbacks automatically keep search index up to date as your data changes
+* out of the box background indexing of data using backgrounded.  Don't lock up a foreground process waiting on a background job!
+* integrates with will_paginate library for easy pagination of search results
+
+== Installation
+  #Gemfile
+  gem 'elastic_searchable'
+
+== Configuration
+
+  #config/initializers/elastic_searchable.rb
+  #customize elasticsearch host
+  #defaults to localhost:9200
+  ElasticSearchable.base_uri = 'server:9200'
+
+== Contributing to elastic_searchable
+ 
+* 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.
+
+== Copyright
+
+Copyright (c) 2011 Ryan Sonnek. See LICENSE.txt for
+further details.
+

data/VERSION

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

data/elastic_searchable.gemspec

@@ -14,18 +14,18 @@ Gem::Specification.new do |s|
 
   s.rubyforge_project = "elastic_searchable"
   
-  s.add_runtime_dependency(%q<activerecord>, ["~> 2.3.5"])
+  s.add_runtime_dependency(%q<activerecord>, ["~> 3.0.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_runtime_dependency(%q<larsklevan-after_commit>, ["~> 1.0.5"])
   s.add_development_dependency(%q<shoulda>, [">= 0"])
   s.add_development_dependency(%q<mocha>, [">= 0"])
-  s.add_development_dependency(%q<jeweler>, ["~> 1.5.2"])
+  s.add_development_dependency(%q<bundler>, [">= 0"])
   s.add_development_dependency(%q<rcov>, [">= 0"])
   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.rb

@@ -0,0 +1,67 @@
+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

data/lib/elastic_searchable/index.rb

@@ -1,5 +1,3 @@
-require 'will_paginate'
-
 module ElasticSearchable
   module Indexing
     module ClassMethods
@@ -13,17 +11,16 @@ module ElasticSearchable
       # http://www.elasticsearch.com/docs/elasticsearch/rest_api/admin/indices/put_mapping/
       def update_index_mapping
         if mapping = self.elastic_options[:mapping]
-          ElasticSearchable.request :put, index_type_path('_mapping'), :json_body => {index_type => mapping}
+          ElasticSearchable.request :put, index_type_path('_mapping'), :body => {index_type => mapping}.to_json
         end
       end
 
       # create the index
-      # http://www.elasticsearch.org/guide/reference/api/admin-indices-create-index.html
+      # http://www.elasticsearch.com/docs/elasticsearch/rest_api/admin/indices/create_index/
       def create_index
-        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, :json_body => options
+        options = self.elastic_options[:index_options] ? self.elastic_options[:index_options].to_json : ''
+        ElasticSearchable.request :put, index_path, :body => options
+        self.update_index_mapping
       end
 
       # explicitly refresh the index, making all operations performed since the last refresh
@@ -44,8 +41,6 @@ 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
@@ -59,26 +54,26 @@ module ElasticSearchable
       end
 
       # reindex all records using bulk api
-      # 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
+      #   :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
       def reindex(options = {})
         self.update_index_mapping
-        options.reverse_merge! :page => 1, :per_page => 1000, :total_entries => 1
+        batch = options.delete(:batch) || 1
+        options[:batch_size] ||= 1000
+        options[:start] ||= (batch - 1) * options[:batch_size]
         scope = options.delete(:scope) || self
-
-        records = scope.paginate(options)
-        while records.any? do
-          ElasticSearchable.logger.debug "reindexing batch ##{records.current_page}..."
-
+        scope.find_in_batches(options) do |records|
+          ElasticSearchable.logger.info "reindexing batch ##{batch}..."
+          batch += 1
           actions = []
           records.each do |record|
             next unless record.should_index?
             begin
-              doc = ElasticSearchable.encode_json(record.as_json_for_index)
-              actions << ElasticSearchable.encode_json({:index => {'_index' => index_name, '_type' => index_type, '_id' => record.id}})
+              doc = record.as_json_for_index.to_json
+              actions << {:index => {'_index' => index_name, '_type' => index_type, '_id' => record.id}}.to_json
               actions << doc
             rescue => e
               ElasticSearchable.logger.warn "Unable to bulk index record: #{record.inspect} [#{e.message}]"
@@ -87,12 +82,9 @@ 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 ##{options[:page]}: #{e.message}"
+            ElasticSearchable.logger.warn "Error indexing batch ##{batch}: #{e.message}"
             ElasticSearchable.logger.warn e
           end
-
-          options.merge! :page => (options[:page] + 1)
-          records = scope.paginate(options)
         end
       end
 
@@ -111,20 +103,22 @@ module ElasticSearchable
       # see http://www.elasticsearch.org/guide/reference/api/index_.html
       def reindex(lifecycle = nil)
         query = {}
-        query.merge! :percolate => "*" if self.class.elastic_options[:percolate]
-        response = ElasticSearchable.request :put, self.class.index_type_path(self.id), :query => query, :json_body => self.as_json_for_index
+        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
 
-        self.run_callbacks("after_index_on_#{lifecycle}".to_sym) if lifecycle
-        self.run_callbacks(:after_index)
+        @index_lifecycle = lifecycle ? lifecycle.to_sym : nil
+        _run_index_callbacks
 
-        if percolate_callback = self.class.elastic_options[:percolate]
-          matches = response['matches']
-          self.send percolate_callback, matches if matches.any?
-        end
+        @percolations = response['matches']
+        _run_percolate_callbacks if @percolations.any?
       end
       # document to index in elasticsearch
       def as_json_for_index
-        self.as_json self.class.elastic_options[:json]
+        original_include_root_in_json = ::ActiveRecord::Base.include_root_in_json
+        ::ActiveRecord::Base.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
       end
       def should_index?
         [self.class.elastic_options[:if]].flatten.compact.all? { |m| evaluate_elastic_condition(m) } &&
@@ -135,14 +129,11 @@ module ElasticSearchable
       # can be done automatically when indexing using :percolate => true config option
       # http://www.elasticsearch.org/blog/2011/02/08/percolator.html
       def percolate
-        response = ElasticSearchable.request :get, self.class.index_type_path('_percolate'), :json_body => {:doc => self.as_json_for_index}
+        response = ElasticSearchable.request :get, self.class.index_type_path('_percolate'), :body => {:doc => self.as_json_for_index}.to_json
         response['matches']
       end
 
       private
-      def elasticsearch_offline?
-        ElasticSearchable.offline?
-      end
       # ripped from activesupport
       def evaluate_elastic_condition(method)
         case method

data/lib/elastic_searchable/queries.rb

@@ -13,27 +13,11 @@ module ElasticSearchable
     def search(query, options = {})
       page = (options.delete(:page) || 1).to_i
       options[:fields] ||= '_id'
+      options[:q] ||= query
       options[:size] ||= per_page_for_search(options)
       options[:from] ||= options[:size] * (page - 1)
-      if query.is_a?(Hash)
-        options[:query] = query
-      else
-        options[:query] = {
-          :query_string => {
-            :query => query,
-            :default_operator => options.delete(:default_operator)
-          }
-        }
-      end
-      query = {}
-      case sort = options.delete(:sort)
-      when Array,Hash
-        options[:sort] = sort
-      when String
-        query[:sort] = sort
-      end
 
-      response = ElasticSearchable.request :get, index_type_path('_search'), :query => query, :json_body => options
+      response = ElasticSearchable.request :get, index_type_path('_search'), :query => options
       hits = response['hits']
       ids = hits['hits'].collect {|h| h['_id'].to_i }
       results = self.find(ids).sort_by {|result| ids.index(result.id) }

data/lib/elastic_searchable/version.rb

@@ -1,4 +1,4 @@
 module ElasticSearchable
-  VERSION = '0.7.3'
+  VERSION = '1.0.0'
 end
 

data/lib/elastic_searchable.rb

@@ -1,40 +1,35 @@
 require 'httparty'
 require 'logger'
-require 'elastic_searchable/active_record_extensions'
+require 'elastic_searchable/active_record'
 
 module ElasticSearchable
-  DEFAULT_INDEX = 'elastic_searchable'
   include HTTParty
   format :json
   base_uri 'localhost:9200'
+  #debug_output
 
   class ElasticError < StandardError; end
   class << self
-    attr_accessor :logger, :default_index, :offline
-
-    # execute a block of work without reindexing objects
-    def offline(&block)
-      @offline = true
-      yield
-    ensure
-      @offline = false
+    # 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
-    def offline?
-      !!@offline
+
+    @@logger = Logger.new(STDOUT)
+    @@logger.level = Logger::INFO
+    def logger=(logger)
+      @@logger = logger
     end
-    # encapsulate encoding hash into json string
-    # support Yajl encoder if installed
-    def encode_json(options = {})
-      defined?(Yajl) ? Yajl::Encoder.encode(options) : ActiveSupport::JSON.encode(options)
+    def logger
+      @@logger
     end
-    # 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
+    #perform a request to the elasticsearch server
     def request(method, url, options = {})
-      options.merge! :headers => {'Content-Type' => 'application/json'}
-      options.merge! :body => ElasticSearchable.encode_json(options[:json_body]) if options[:json_body]
-
       response = self.send(method, url, options)
       logger.debug "elasticsearch request: #{method} #{url} #{"took #{response['took']}ms" if response['took']}"
       validate_response response
@@ -51,11 +46,4 @@ module ElasticSearchable
   end
 end
 
-# 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
-
+ActiveRecord::Base.send(:include, ElasticSearchable::ActiveRecord)

data/test/helper.rb

@@ -10,12 +10,15 @@ 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'
-require 'setup_database'
+
+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'])
 
 class Test::Unit::TestCase
   def delete_index

data/test/test_elastic_searchable.rb

@@ -1,24 +1,40 @@
 require File.join(File.dirname(__FILE__), 'helper')
 
 class TestElasticSearchable < Test::Unit::TestCase
-  def setup
-    delete_index
-  end
-  ElasticSearchable.debug_output
-
-  context 'non elastic activerecord class' do
-    class Cat < ActiveRecord::Base
+  ActiveRecord::Schema.define(:version => 1) do
+    create_table :posts, :force => true do |t|
+      t.column :title, :string
+      t.column :body, :string
+    end
+    create_table :blogs, :force => true do |t|
+      t.column :title, :string
+      t.column :body, :string
     end
-    should 'not respond to elastic_options' do
-      assert !Cat.respond_to?(:elastic_options)
+    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
+    end
+    create_table :books, :force => true do |t|
+      t.column :title, :string
+    end
+    create_table :max_page_size_classes, :force => true do |t|
+      t.column :name, :string
     end
   end
 
+  def setup
+    delete_index
+  end
+  def teardown
+    delete_index
+  end
   class Post < ActiveRecord::Base
-    elastic_searchable :index_options => {'number_of_replicas' => 0, 'number_of_shards' => 1}
+    elastic_searchable :index_options => { "analysis.analyzer.default.tokenizer" => 'standard', "analysis.analyzer.default.filter" => ["standard", "lowercase", 'porterStem'] }
     after_index :indexed
-    after_index_on_create :indexed_on_create
-    after_index_on_update :indexed_on_update
+    after_index :indexed_on_create, :on => :create
     def indexed
       @indexed = true
     end
@@ -31,14 +47,8 @@ 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 'activerecord class with default elastic_searchable config' do
+  context 'Post class with default elastic_searchable config' do
     setup do
       @clazz = Post
     end
@@ -50,7 +60,7 @@ class TestElasticSearchable < Test::Unit::TestCase
     end
   end
 
-  context 'Model.request with invalid url' do
+  context 'ElasticSearchable.request with invalid url' do
     should 'raise error' do
       assert_raises ElasticSearchable::ElasticError do
         ElasticSearchable.request :get, '/elastic_searchable/foobar/notfound'
@@ -58,95 +68,66 @@ class TestElasticSearchable < Test::Unit::TestCase
     end
   end
 
-  context 'Model.create_index' do
+  context 'Post.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 'Model.create' do
-    setup do
-      @post = Post.create :title => 'foo', :body => "bar"
-    end
-    should 'have fired after_index callback' do
-      assert @post.indexed?
-    end
-    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?
+  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 'Model.update' do
+  context 'Post.create' do
     setup do
-      Post.create :title => 'foo', :body => 'bar'
-      @post = Post.last
-      @post.title = 'baz'
-      @post.save
+      @post = Post.create :title => 'foo', :body => "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
-      ElasticSearchable.offline do
-        @post = Post.create :title => 'foo', :body => "bar"
-      end
-    end
-    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?
+    should 'have fired after_index_on_create callback' do
+      assert @post.indexed_on_create?
     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.delete_index
-      Post.create_index
+      Post.clean_index
     end
     should 'not raise error if error occurs reindexing model' do
       ElasticSearchable.expects(:request).raises(ElasticSearchable::ElasticError.new('faux error'))
-      assert_nothing_raised do
-        Post.reindex
-      end
-    end
-    should 'not raise error if destroying one instance' do
-      Logger.any_instance.expects(:warn)
-      assert_nothing_raised do
-        @first_post.destroy
-      end
+      Post.reindex
     end
-    context 'Model.reindex' do
+    context 'Post.reindex' do
       setup do
-        Post.reindex :per_page => 1, :scope => Post.scoped(:order => 'body desc')
+        Post.reindex
         Post.refresh_index
       end
       should 'have reindexed both records' do
-        assert_nothing_raised do
-          ElasticSearchable.request :get, "/elastic_searchable/posts/#{@first_post.id}"
-          ElasticSearchable.request :get, "/elastic_searchable/posts/#{@second_post.id}"
-        end
+        ElasticSearchable.request :get, "/elastic_searchable/posts/#{@first_post.id}"
+        ElasticSearchable.request :get, "/elastic_searchable/posts/#{@second_post.id}"
       end
     end
   end
@@ -168,33 +149,11 @@ class TestElasticSearchable < Test::Unit::TestCase
       end
       should 'be paginated' do
         assert_equal 1, @results.current_page
-        assert_equal Post.per_page, @results.per_page
+        assert_equal 20, @results.per_page
         assert_nil @results.previous_page
         assert_nil @results.next_page
       end
     end
-    
-    context 'searching for results using a query Hash' do
-      setup do
-        @results = Post.search({
-          :filtered => {
-            :query => {
-              :term => {:title => 'foo'},
-            },
-            :filter => {
-              :or => [
-                {:term => {:body => 'second'}},
-                {:term => {:body => 'third'}}
-              ]
-            }
-          }
-        })
-      end
-      should 'find only the object which ' do
-        assert_does_not_contain @results, @first_post
-        assert_contains @results, @second_post
-      end
-    end
 
     context 'searching for second page using will_paginate params' do
       setup do
@@ -223,16 +182,6 @@ class TestElasticSearchable < Test::Unit::TestCase
         assert_equal @first_post, @results.last
       end
     end
-    
-    context 'advanced sort options' do
-      setup do
-        @results = Post.search 'foo', :sort => [{:id => 'desc'}]
-      end
-      should 'sort results correctly' do
-        assert_equal @second_post, @results.first
-        assert_equal @first_post, @results.last
-      end
-    end
 
     context 'destroying one object' do
       setup do
@@ -248,7 +197,7 @@ class TestElasticSearchable < Test::Unit::TestCase
 
 
   class Blog < ActiveRecord::Base
-    elastic_searchable :if => proc {|b| b.should_index? }, :index_options => {'number_of_replicas' => 0, 'number_of_shards' => 1}
+    elastic_searchable :if => proc {|b| b.should_index? }
     def should_index?
       false
     end
@@ -268,32 +217,15 @@ class TestElasticSearchable < Test::Unit::TestCase
   end
 
   class User < ActiveRecord::Base
-    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}}}
+    elastic_searchable :mapping => {:properties => {:name => {:type => :string, :index => :not_analyzed}}}
   end
-  context 'activerecord class with :index_options and :mapping' do
+  context 'activerecord class with :mapping=>{}' do
     context 'creating index' do
       setup do
         User.create_index
-      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
+        @status = ElasticSearchable.request :get, '/elastic_searchable/users/_mapping'
       end
       should 'have set mapping' do
-        @status = ElasticSearchable.request :get, '/elastic_searchable/users/_mapping'
         expected = {
           "users"=> {
             "properties"=> {
@@ -307,27 +239,19 @@ class TestElasticSearchable < Test::Unit::TestCase
   end
 
   class Friend < ActiveRecord::Base
-    belongs_to :book
-    elastic_searchable :json => {:include => {:book => {:only => :title}}, :only => :name}, :index_options => {'number_of_replicas' => 0, 'number_of_shards' => 1}
+    elastic_searchable :json => {:only => [:name]}
   end
-  context 'activerecord class with optional :json config' do
+  context 'activerecord class with optiona :json config' do
     context 'creating index' do
       setup do
         Friend.create_index
-        @book = Book.create! :isbn => '123abc', :title => 'another world'
-        @friend = Friend.new :name => 'bob', :favorite_color => 'red'
-        @friend.book = @book
-        @friend.save!
+        @friend = Friend.create! :name => 'bob', :favorite_color => 'red'
         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',
-          'book' => {'title' => 'another world'}
+          "name" => 'bob' #favorite_color should not be indexed
         }
         assert_equal expected, @response['_source'], @response.inspect
       end
@@ -339,7 +263,7 @@ class TestElasticSearchable < Test::Unit::TestCase
       ElasticSearchable.default_index = 'my_new_index'
     end
     teardown do
-      ElasticSearchable.default_index = ElasticSearchable::DEFAULT_INDEX
+      ElasticSearchable.default_index = nil
     end
     should 'change default index' do
       assert_equal 'my_new_index', ElasticSearchable.default_index
@@ -347,24 +271,32 @@ class TestElasticSearchable < Test::Unit::TestCase
   end
 
   class Book < ActiveRecord::Base
-    elastic_searchable :percolate => :on_percolated
-    def on_percolated(percolated)
-      @percolated = percolated
+    elastic_searchable
+    after_percolate :on_percolated
+    def on_percolated
+      @percolated = percolations
     end
     def percolated
       @percolated
     end
   end
-  context 'Book class with percolate=true' do
+  context 'Book class with after_percolate callback' do
     context 'with created index' do
       setup do
         Book.create_index
       end
       context "when index has configured percolation" do
         setup do
-          ElasticSearchable.request :put, '/_percolator/elastic_searchable/myfilter', :json_body => {:query => {:query_string => {:query => 'foo' }}}
+          ElasticSearchable.request :put, '/_percolator/elastic_searchable/myfilter', :body => {:query => {:query_string => {:query => 'foo' }}}.to_json
           ElasticSearchable.request :post, '/_percolator/_refresh'
         end
+        context 'creating an object that does not match the percolation' do
+          setup do
+            Book.any_instance.expects(:on_percolated).never
+            @book = Book.create! :title => 'bar'
+          end
+          should 'not percolate the record' do end #see expectations
+        end
         context 'creating an object that matches the percolation' do
           setup do
             @book = Book.create :title => "foo"
@@ -386,7 +318,7 @@ class TestElasticSearchable < Test::Unit::TestCase
   end
 
   class MaxPageSizeClass < ActiveRecord::Base
-    elastic_searchable :index_options => {'number_of_replicas' => 0, 'number_of_shards' => 1}
+    elastic_searchable
     def self.max_per_page
       1
     end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: elastic_searchable
 version: !ruby/object:Gem::Version 
-  hash: 5
+  hash: 23
   prerelease: 
   segments: 
+  - 1
   - 0
-  - 7
-  - 3
-  version: 0.7.3
+  - 0
+  version: 1.0.0
 platform: ruby
 authors: 
 - Ryan Sonnek
@@ -15,7 +15,8 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-05-04 00:00:00 Z
+date: 2011-03-30 00:00:00 -05:00
+default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: activerecord
@@ -25,12 +26,12 @@ dependencies:
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
-        hash: 9
+        hash: 7
         segments: 
-        - 2
         - 3
-        - 5
-        version: 2.3.5
+        - 0
+        - 0
+        version: 3.0.0
   type: :runtime
   version_requirements: *id001
 - !ruby/object:Gem::Dependency 
@@ -82,23 +83,21 @@ dependencies:
   type: :runtime
   version_requirements: *id004
 - !ruby/object:Gem::Dependency 
-  name: larsklevan-after_commit
+  name: shoulda
   prerelease: false
   requirement: &id005 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
-    - - ~>
+    - - ">="
       - !ruby/object:Gem::Version 
-        hash: 29
+        hash: 3
         segments: 
-        - 1
         - 0
-        - 5
-        version: 1.0.5
-  type: :runtime
+        version: "0"
+  type: :development
   version_requirements: *id005
 - !ruby/object:Gem::Dependency 
-  name: shoulda
+  name: mocha
   prerelease: false
   requirement: &id006 !ruby/object:Gem::Requirement 
     none: false
@@ -112,7 +111,7 @@ dependencies:
   type: :development
   version_requirements: *id006
 - !ruby/object:Gem::Dependency 
-  name: mocha
+  name: bundler
   prerelease: false
   requirement: &id007 !ruby/object:Gem::Requirement 
     none: false
@@ -125,26 +124,10 @@ dependencies:
         version: "0"
   type: :development
   version_requirements: *id007
-- !ruby/object:Gem::Dependency 
-  name: jeweler
-  prerelease: false
-  requirement: &id008 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
-    - - ~>
-      - !ruby/object:Gem::Version 
-        hash: 7
-        segments: 
-        - 1
-        - 5
-        - 2
-        version: 1.5.2
-  type: :development
-  version_requirements: *id008
 - !ruby/object:Gem::Dependency 
   name: rcov
   prerelease: false
-  requirement: &id009 !ruby/object:Gem::Requirement 
+  requirement: &id008 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ">="
@@ -154,11 +137,11 @@ dependencies:
         - 0
         version: "0"
   type: :development
-  version_requirements: *id009
+  version_requirements: *id008
 - !ruby/object:Gem::Dependency 
   name: sqlite3-ruby
   prerelease: false
-  requirement: &id010 !ruby/object:Gem::Requirement 
+  requirement: &id009 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ~>
@@ -170,11 +153,11 @@ dependencies:
         - 2
         version: 1.3.2
   type: :development
-  version_requirements: *id010
+  version_requirements: *id009
 - !ruby/object:Gem::Dependency 
   name: ruby-debug
   prerelease: false
-  requirement: &id011 !ruby/object:Gem::Requirement 
+  requirement: &id010 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ">="
@@ -184,7 +167,7 @@ dependencies:
         - 0
         version: "0"
   type: :development
-  version_requirements: *id011
+  version_requirements: *id010
 description: integrate the elastic search engine with rails
 email: 
 - ryan@codecrate.com
@@ -197,22 +180,22 @@ extra_rdoc_files: []
 files: 
 - .document
 - .gitignore
-- CONTRIBUTORS.txt
 - Gemfile
 - LICENSE.txt
-- README.md
+- README.rdoc
 - Rakefile
+- VERSION
 - elastic_searchable.gemspec
 - lib/elastic_searchable.rb
-- lib/elastic_searchable/active_record_extensions.rb
+- lib/elastic_searchable/active_record.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: []
 
@@ -242,12 +225,11 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: elastic_searchable
-rubygems_version: 1.7.2
+rubygems_version: 1.6.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/CONTRIBUTORS.txt

@@ -1,6 +0,0 @@
-Ryan Sonnek - Original Author
-
-
-Complete list of contributors:
-https://github.com/socialcast/elastic_searchable/contributors
-

data/README.md

@@ -1,51 +0,0 @@
-# elastic_searchable
-
-Integrate the elasticsearch library into Rails.
-
-## Usage
-
-```ruby
-class Blog < ActiveRecord::Base
-  elastic_searchable
-end
-
-results = Blog.search 'foo'
-```
-
-## Features
-
-* fast. fast! FAST! 30% faster than rubberband on average.
-* active record callbacks automatically keep search index up to date as your data changes
-* out of the box background indexing of data using backgrounded.  Don't lock up a foreground process waiting on a background job!
-* integrates with will_paginate library for easy pagination of search results
-
-## Installation
-
-```ruby
-# Bundler Gemfile
-gem 'elastic_searchable'
-```
-
-## Configuration
-
-```ruby
-# config/initializers/elastic_searchable.rb
-# (optional) customize elasticsearch host
-# default is localhost:9200
-ElasticSearchable.base_uri = 'server:9200'
-```
-
-## Contributing
- 
-* Fork the project
-* Fix the issue
-* Add unit tests
-* Submit pull request on github
-
-See CONTRIBUTORS.txt for list of project contributors
-
-## Copyright
-
-Copyright (c) 2011 Socialcast, Inc. 
-See LICENSE.txt for further details.
-

data/lib/elastic_searchable/active_record_extensions.rb

@@ -1,41 +0,0 @@
-require 'active_record'
-require 'after_commit'
-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)
-    def elastic_searchable(options = {})
-      cattr_accessor :elastic_options
-      self.elastic_options = options.symbolize_keys.merge(:unless => Array.wrap(options[:unless]).push(:elasticsearch_offline?))
-
-      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
-
-      define_callbacks :after_index_on_create, :after_index_on_update, :after_index
-      after_commit_on_create :update_index_on_create_backgrounded, :if => :should_index?
-      after_commit_on_update :update_index_on_update_backgrounded, :if => :should_index?
-      after_commit_on_destroy :delete_from_index
-    end
-  end
-end
-
-ActiveRecord::Base.send(:extend, ElasticSearchable::ActiveRecordExtensions)

data/test/setup_database.rb

@@ -1,33 +0,0 @@
-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
-end
-
-WillPaginate.enable_activerecord
-