elastic_searchable 2.0.1 → 2.0.2

data/elastic_searchable.gemspec

@@ -28,4 +28,5 @@ Gem::Specification.new do |s|
   s.add_development_dependency(%q<pry>, ["0.9.6.2"])
   s.add_development_dependency(%q<shoulda>, ["2.11.3"])
   s.add_development_dependency(%q<mocha>, ["0.10.0"])
+  s.add_development_dependency(%q<pry>, ["0.9.9.3"])
 end

data/lib/elastic_searchable/active_record_extensions.rb

@@ -1,79 +1,282 @@
 require 'active_record'
 require 'backgrounded'
-require 'elastic_searchable/queries'
-require 'elastic_searchable/callbacks'
-require 'elastic_searchable/index'
 require 'elastic_searchable/paginator'
 
 module ElasticSearchable
   module ActiveRecordExtensions
-    # Valid options:
-    # :type (optional) configue type to store data in.  default to model table name
-    # :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.merge(:unless => Array.wrap(options[:unless]).push(:elasticsearch_offline?))
-
-      if self.elastic_options[:index_options]
-        ActiveSupport::Deprecation.warn ":index_options has been deprecated.  Use ElasticSearchable.index_settings instead.", caller
-      end
-      if self.elastic_options[:index]
-        ActiveSupport::Deprecation.warn ":index has been deprecated.  Use ElasticSearchable.index_name instead.", caller
-      end
+    extend ActiveSupport::Concern
 
-      extend ElasticSearchable::Indexing::ClassMethods
-      extend ElasticSearchable::Queries
+    included do
+      define_model_callbacks :index, :percolate, :only => :after
+    end
 
-      include ElasticSearchable::Indexing::InstanceMethods
-      include ElasticSearchable::Callbacks::InstanceMethods
+    module ClassMethods
+      # Valid options:
+      # :type (optional) configue type to store data in.  default to model table name
+      # :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)
+      #
+      # 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 = {})
+        include ElasticSearchable::ActiveRecordExtensions::LocalMethods
 
-      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
+        cattr_accessor :elastic_options
+        self.elastic_options = options.symbolize_keys.merge(:unless => Array.wrap(options[:unless]).push(:elasticsearch_offline?))
+        attr_reader :hit
+        attr_accessor :index_lifecycle
 
-      attr_reader :hit # the hit json for this result
-      attr_accessor :index_lifecycle, :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, :unless => :elasticsearch_offline?, :on => :destroy
-
-      class_eval do
-        # retuns list of percolation matches found during indexing
-        def percolations
-          @percolations || []
+        if self.elastic_options[:index_options]
+          ActiveSupport::Deprecation.warn ":index_options has been deprecated.  Use ElasticSearchable.index_settings instead.", caller
+        end
+        if self.elastic_options[:index]
+          ActiveSupport::Deprecation.warn ":index has been deprecated.  Use ElasticSearchable.index_name instead.", caller
         end
 
+        backgrounded :update_index_on_create => ElasticSearchable.backgrounded_options, :update_index_on_update => ElasticSearchable.backgrounded_options
         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]}"
+          backgrounded :delete_id_from_index => ElasticSearchable.backgrounded_options
+        end
+
+        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, :unless => :elasticsearch_offline?, :on => :destroy
+      end
+    end
+
+    module LocalMethods
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+        PER_PAGE_DEFAULT = 20
+
+        # Available callback method after indexing is complete
+        # 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
+        # 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
+
+        # default number of search results for this model
+        # can be overridden by implementing classes
+        def per_page
+          PER_PAGE_DEFAULT
+        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
+        #
+        # TODO: move this to AREL relation to remove the options scope param
+        def reindex(options = {})
+          self.create_mapping
+          options.reverse_merge! :page => 1, :per_page => 1000
+          scope = options.delete(:scope) || self
+          page = options[:page]
+          per_page = options[:per_page]
+          records = scope.limit(per_page).offset(per_page * (page -1)).all
+          while records.any? do
+            ElasticSearchable.logger.debug "reindexing batch ##{page}..."
+            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' => ElasticSearchable.index_name, '_type' => index_type, '_id' => record.id}})
+                actions << doc
+              rescue => e
+                ElasticSearchable.logger.warn "Unable to bulk index record: #{record.inspect} [#{e.message}]"
+              end
+            end
+            begin
+              ElasticSearchable.request(:put, '/_bulk', :body => "\n#{actions.join("\n")}\n") if actions.any?
+            rescue ElasticError => e
+              ElasticSearchable.logger.warn "Error indexing batch ##{page}: #{e.message}"
+              ElasticSearchable.logger.warn e
             end
-            set_callback(:index, :after, *args, &block)
+
+            page += 1
+            records = scope.limit(per_page).offset(per_page* (page-1)).all
           end
+        end
+
+        # search returns a will_paginate collection of ActiveRecord objects for the search results
+        # supported options:
+        # :page - page of results to search for
+        # :per_page - number of results per page
+        #
+        # http://www.elasticsearch.com/docs/elasticsearch/rest_api/search/
+        def search(query, options = {})
+          page = (options.delete(:page) || 1).to_i
+          options[:fields] ||= '_id'
+          options[:size] ||= per_page_for_search(options)
+          options[:from] ||= options[:size] * (page - 1)
+          options[:query] ||= if query.is_a?(Hash)
+            query
+          else
+            {}.tap do |q|
+              q[:query_string] = { :query => query }
+              q[:query_string][:default_operator] = options.delete(:default_operator) if options.has_key?(:default_operator)
+            end
+          end
+          query = {}
+          case sort = options.delete(:sort)
+          when Array,Hash
+            options[:sort] = sort
+          when String
+            query[:sort] = sort
+          end
+
+          response = ElasticSearchable.request :get, index_mapping_path('_search'), :query => query, :json_body => options
+          hits = response['hits']
+          ids = hits['hits'].collect {|h| h['_id'].to_i }
+          results = self.find(ids).sort_by {|result| ids.index(result.id) }
+
+          results.each do |result|
+            result.instance_variable_set '@hit', hits['hits'][ids.index(result.id)]
+          end
+
+          ElasticSearchable::Paginator.handler.new(results, page, options[:size], hits['total'])
+        end
 
+        def index_type
+          self.elastic_options[:type] || self.table_name
+        end
+
+        # helper method to generate elasticsearch url for this object type
+        def index_mapping_path(action = nil)
+          ElasticSearchable.request_path [index_type, action].compact.join('/')
+        end
+
+        # delete all documents of this type in the index
+        # http://www.elasticsearch.com/docs/elasticsearch/rest_api/admin/indices/delete_mapping/
+        def delete_mapping
+          ElasticSearchable.request :delete, index_mapping_path
+        end
+
+        # configure the index for this type
+        # http://www.elasticsearch.com/docs/elasticsearch/rest_api/admin/indices/put_mapping/
+        def create_mapping
+          return unless self.elastic_options[:mapping]
+          ElasticSearchable.request :put, index_mapping_path('_mapping'), :json_body => {index_type => self.elastic_options[:mapping]}
+        end
+
+        # delete one record from the index
+        # http://www.elasticsearch.com/docs/elasticsearch/rest_api/delete/
+        def delete_id_from_index(id)
+          ElasticSearchable.request :delete, index_mapping_path(id)
+        rescue ElasticSearchable::ElasticError => e
+          ElasticSearchable.logger.warn e
+        end
+
+        private
+        # determine the number of search results per page
+        # supports will_paginate configuration by using:
+        # Model.per_page
+        # Model.max_per_page
+        def per_page_for_search(options = {})
+          per_page = (options.delete(:per_page) || self.per_page).to_i
+          per_page = [per_page, self.max_per_page].min if self.respond_to?(:max_per_page)
+          per_page
+        end
+      end
+
+      # retuns list of percolation matches found during indexing
+      # usable when the model is configured with an :after_index callback
+      def percolations
+        @percolations || []
+      end
+
+      # reindex the object in elasticsearch
+      # fires after_index callbacks after operation is complete
+      # see http://www.elasticsearch.org/guide/reference/api/index_.html
+      def reindex(lifecycle = nil)
+        query = {}
+        query[:percolate] = "*" if _percolate_callbacks.any?
+        response = ElasticSearchable.request :put, self.class.index_mapping_path(self.id), :query => query, :json_body => self.as_json_for_index
+
+        self.index_lifecycle = lifecycle ? lifecycle.to_sym : nil
+        _run_index_callbacks
+
+        @percolations = response['matches'] || []
+        _run_percolate_callbacks if @percolations.any?
+      end
+
+      # document to index in elasticsearch
+      # can be overridden by implementing class to customize the content
+      def as_json_for_index
+        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
+        self.class.include_root_in_json = original_include_root_in_json
+      end
+
+      # flag to tell if this instance should be indexed
+      def should_index?
+        [self.class.elastic_options[:if]].flatten.compact.all? { |m| evaluate_elastic_condition(m) } &&
+        ![self.class.elastic_options[:unless]].flatten.compact.any? { |m| evaluate_elastic_condition(m) }
+      end
+
+      # percolate this object to see what registered searches match
+      # can be done on transient/non-persisted objects!
+      # can be done automatically when indexing using :percolate => true config option
+      # http://www.elasticsearch.org/blog/2011/02/08/percolator.html
+      def percolate(percolator_query = nil)
+        body = {:doc => self.as_json_for_index}
+        body[:query] = percolator_query if percolator_query
+        response = ElasticSearchable.request :get, self.class.index_mapping_path('_percolate'), :json_body => body
+        @percolations = response['matches'] || []
+      end
+
+      private
+      def delete_from_index
+        self.class.delete_id_from_index_backgrounded self.id
+      end
+      def update_index_on_create
+        reindex :create
+      end
+      def update_index_on_update
+        reindex :update
+      end
+      def elasticsearch_offline?
+        ElasticSearchable.offline?
+      end
+      # ripped from activesupport
+      def evaluate_elastic_condition(method)
+        case method
+          when Symbol
+            self.send method
+          when String
+            eval(method, self.instance_eval { binding })
+          when Proc, Method
+            method.call
+          else
+            if method.respond_to?(kind)
+              method.send kind
+            else
+              raise ArgumentError,
+                "Callbacks must be a symbol denoting the method to call, a string to be evaluated, " +
+                "a block to be invoked, or an object responding to the callback method."
+            end
         end
       end
     end
   end
 end
 
-ActiveRecord::Base.send(:extend, ElasticSearchable::ActiveRecordExtensions)
+ActiveRecord::Base.send(:include, ElasticSearchable::ActiveRecordExtensions)

data/lib/elastic_searchable/version.rb

@@ -1,3 +1,3 @@
 module ElasticSearchable
-  VERSION = '2.0.1'
+  VERSION = '2.0.2'
 end

data/lib/elastic_searchable.rb

@@ -43,6 +43,11 @@ module ElasticSearchable
       response
     end
 
+    # options for automatic active record indexing
+    def backgrounded_options
+      {:queue => 'elasticsearch'}
+    end
+
     # escape lucene special characters
     def escape_query(string)
       string.to_s.gsub(/([\(\)\[\]\{\}\?\\\"!\^\+\-\*:~])/,'\\\\\1')
@@ -92,4 +97,3 @@ ElasticSearchable.logger.level = Logger::INFO
 # configure default index to be elastic_searchable
 # one index can hold many object 'types'
 ElasticSearchable.index_name = 'elastic_searchable'
-

data/test/test_elastic_searchable.rb

@@ -388,6 +388,7 @@ class TestElasticSearchable < Test::Unit::TestCase
       end
       context "when index has configured percolation" do
         setup do
+          ElasticSearchable.request :delete, '/_percolator'
           ElasticSearchable.request :put, '/_percolator/elastic_searchable/myfilter', :json_body => {:query => {:query_string => {:query => 'foo' }}}
           ElasticSearchable.request :post, '/_percolator/_refresh'
         end
@@ -416,6 +417,7 @@ class TestElasticSearchable < Test::Unit::TestCase
         end
         context "with multiple percolators" do
           setup do
+            ElasticSearchable.request :delete, '/_percolator'
             ElasticSearchable.request :put, '/_percolator/elastic_searchable/greenfilter', :json_body => { :color => 'green', :query => {:query_string => {:query => 'foo' }}}
             ElasticSearchable.request :put, '/_percolator/elastic_searchable/bluefilter', :json_body => { :color => 'blue', :query => {:query_string => {:query => 'foo' }}}
             ElasticSearchable.request :post, '/_percolator/_refresh'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: elastic_searchable
 version: !ruby/object:Gem::Version
-  version: 2.0.1
+  version: 2.0.2
   prerelease: 
 platform: ruby
 authors:
@@ -13,7 +13,7 @@ date: 2012-04-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
-  requirement: &2151868260 !ruby/object:Gem::Requirement
+  requirement: &2151881900 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,10 +21,10 @@ dependencies:
         version: 3.0.5
   type: :runtime
   prerelease: false
-  version_requirements: *2151868260
+  version_requirements: *2151881900
 - !ruby/object:Gem::Dependency
   name: httparty
-  requirement: &2151867400 !ruby/object:Gem::Requirement
+  requirement: &2151881240 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -32,10 +32,10 @@ dependencies:
         version: 0.6.0
   type: :runtime
   prerelease: false
-  version_requirements: *2151867400
+  version_requirements: *2151881240
 - !ruby/object:Gem::Dependency
   name: backgrounded
-  requirement: &2151866680 !ruby/object:Gem::Requirement
+  requirement: &2151880600 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -43,10 +43,10 @@ dependencies:
         version: 0.7.0
   type: :runtime
   prerelease: false
-  version_requirements: *2151866680
+  version_requirements: *2151880600
 - !ruby/object:Gem::Dependency
   name: multi_json
-  requirement: &2151866000 !ruby/object:Gem::Requirement
+  requirement: &2151880000 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -54,10 +54,10 @@ dependencies:
         version: 1.0.0
   type: :runtime
   prerelease: false
-  version_requirements: *2151866000
+  version_requirements: *2151880000
 - !ruby/object:Gem::Dependency
   name: rake
-  requirement: &2151865340 !ruby/object:Gem::Requirement
+  requirement: &2151879320 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - =
@@ -65,10 +65,10 @@ dependencies:
         version: 0.9.2.2
   type: :development
   prerelease: false
-  version_requirements: *2151865340
+  version_requirements: *2151879320
 - !ruby/object:Gem::Dependency
   name: sqlite3
-  requirement: &2151864760 !ruby/object:Gem::Requirement
+  requirement: &2151894960 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - =
@@ -76,10 +76,10 @@ dependencies:
         version: 1.3.4
   type: :development
   prerelease: false
-  version_requirements: *2151864760
+  version_requirements: *2151894960
 - !ruby/object:Gem::Dependency
   name: pry
-  requirement: &2151864020 !ruby/object:Gem::Requirement
+  requirement: &2151894160 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - =
@@ -87,10 +87,10 @@ dependencies:
         version: 0.9.6.2
   type: :development
   prerelease: false
-  version_requirements: *2151864020
+  version_requirements: *2151894160
 - !ruby/object:Gem::Dependency
   name: shoulda
-  requirement: &2151863260 !ruby/object:Gem::Requirement
+  requirement: &2151893480 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - =
@@ -98,10 +98,10 @@ dependencies:
         version: 2.11.3
   type: :development
   prerelease: false
-  version_requirements: *2151863260
+  version_requirements: *2151893480
 - !ruby/object:Gem::Dependency
   name: mocha
-  requirement: &2151862580 !ruby/object:Gem::Requirement
+  requirement: &2151892820 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - =
@@ -109,7 +109,18 @@ dependencies:
         version: 0.10.0
   type: :development
   prerelease: false
-  version_requirements: *2151862580
+  version_requirements: *2151892820
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: &2151892120 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - =
+      - !ruby/object:Gem::Version
+        version: 0.9.9.3
+  type: :development
+  prerelease: false
+  version_requirements: *2151892120
 description: integrate the elastic search engine with rails
 email:
 - ryan@codecrate.com
@@ -128,12 +139,9 @@ files:
 - elastic_searchable.gemspec
 - lib/elastic_searchable.rb
 - lib/elastic_searchable/active_record_extensions.rb
-- lib/elastic_searchable/callbacks.rb
-- lib/elastic_searchable/index.rb
 - lib/elastic_searchable/pagination/kaminari.rb
 - lib/elastic_searchable/pagination/will_paginate.rb
 - lib/elastic_searchable/paginator.rb
-- lib/elastic_searchable/queries.rb
 - lib/elastic_searchable/version.rb
 - test/database.yml
 - test/helper.rb
@@ -153,7 +161,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 808032034448504633
+      hash: 2660925478965356473
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -162,7 +170,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 808032034448504633
+      hash: 2660925478965356473
 requirements: []
 rubyforge_project: elastic_searchable
 rubygems_version: 1.8.15

data/lib/elastic_searchable/callbacks.rb

@@ -1,22 +0,0 @@
-module ElasticSearchable
-  module Callbacks
-    class << self
-      def backgrounded_options
-        {:queue => 'elasticsearch'}
-      end
-    end
-
-    module InstanceMethods
-      private
-      def delete_from_index
-        self.class.delete_id_from_index_backgrounded self.id
-      end
-      def update_index_on_create
-        reindex :create
-      end
-      def update_index_on_update
-        reindex :update
-      end
-    end
-  end
-end

data/lib/elastic_searchable/index.rb

@@ -1,140 +0,0 @@
-module ElasticSearchable
-  module Indexing
-    module ClassMethods
-      # delete all documents of this type in the index
-      # http://www.elasticsearch.com/docs/elasticsearch/rest_api/admin/indices/delete_mapping/
-      def delete_mapping
-        ElasticSearchable.request :delete, index_mapping_path
-      end
-
-      # configure the index for this type
-      # http://www.elasticsearch.com/docs/elasticsearch/rest_api/admin/indices/put_mapping/
-      def create_mapping
-        return unless self.elastic_options[:mapping]
-        ElasticSearchable.request :put, index_mapping_path('_mapping'), :json_body => {index_type => self.elastic_options[:mapping]}
-      end
-
-      # delete one record from the index
-      # http://www.elasticsearch.com/docs/elasticsearch/rest_api/delete/
-      def delete_id_from_index(id)
-        ElasticSearchable.request :delete, index_mapping_path(id)
-      rescue ElasticSearchable::ElasticError => e
-        ElasticSearchable.logger.warn e
-      end
-
-      # helper method to generate elasticsearch url for this object type
-      def index_mapping_path(action = nil)
-        ElasticSearchable.request_path [index_type, action].compact.join('/')
-      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
-      #
-      # TODO: move this to AREL relation to remove the options scope param
-      def reindex(options = {})
-        self.create_mapping
-        options.reverse_merge! :page => 1, :per_page => 1000
-        scope = options.delete(:scope) || self
-        page = options[:page]
-        per_page = options[:per_page]
-        records = scope.limit(per_page).offset(per_page * (page -1)).all
-        while records.any? do
-          ElasticSearchable.logger.debug "reindexing batch ##{page}..."
-          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' => ElasticSearchable.index_name, '_type' => index_type, '_id' => record.id}})
-              actions << doc
-            rescue => e
-              ElasticSearchable.logger.warn "Unable to bulk index record: #{record.inspect} [#{e.message}]"
-            end
-          end
-          begin
-            ElasticSearchable.request(:put, '/_bulk', :body => "\n#{actions.join("\n")}\n") if actions.any?
-          rescue ElasticError => e
-            ElasticSearchable.logger.warn "Error indexing batch ##{page}: #{e.message}"
-            ElasticSearchable.logger.warn e
-          end
-
-          page += 1
-          records = scope.limit(per_page).offset(per_page* (page-1)).all
-        end
-      end
-
-      private
-      def index_type
-        self.elastic_options[:type] || self.table_name
-      end
-    end
-
-    module InstanceMethods
-      # reindex the object in elasticsearch
-      # fires after_index callbacks after operation is complete
-      # see http://www.elasticsearch.org/guide/reference/api/index_.html
-      def reindex(lifecycle = nil)
-        query = {}
-        query[:percolate] = "*" if _percolate_callbacks.any?
-        response = ElasticSearchable.request :put, self.class.index_mapping_path(self.id), :query => query, :json_body => self.as_json_for_index
-
-        self.index_lifecycle = lifecycle ? lifecycle.to_sym : nil
-        _run_index_callbacks
-
-        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 = self.class.include_root_in_json
-        self.class.include_root_in_json = false
-        return self.as_json self.class.elastic_options[:json]
-      ensure
-        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) } &&
-        ![self.class.elastic_options[:unless]].flatten.compact.any? { |m| evaluate_elastic_condition(m) }
-      end
-      # percolate this object to see what registered searches match
-      # can be done on transient/non-persisted objects!
-      # can be done automatically when indexing using :percolate => true config option
-      # http://www.elasticsearch.org/blog/2011/02/08/percolator.html
-      def percolate(percolator_query = nil)
-        body = {:doc => self.as_json_for_index}
-        body[:query] = percolator_query if percolator_query
-        response = ElasticSearchable.request :get, self.class.index_mapping_path('_percolate'), :json_body => body
-        self.percolations = response['matches'] || []
-        self.percolations
-      end
-
-      private
-      def elasticsearch_offline?
-        ElasticSearchable.offline?
-      end
-      # ripped from activesupport
-      def evaluate_elastic_condition(method)
-        case method
-          when Symbol
-            self.send method
-          when String
-            eval(method, self.instance_eval { binding })
-          when Proc, Method
-            method.call
-          else
-            if method.respond_to?(kind)
-              method.send kind
-            else
-              raise ArgumentError,
-                "Callbacks must be a symbol denoting the method to call, a string to be evaluated, " +
-                "a block to be invoked, or an object responding to the callback method."
-            end
-        end
-      end
-    end
-  end
-end

data/lib/elastic_searchable/queries.rb

@@ -1,59 +0,0 @@
-module ElasticSearchable
-  module Queries
-    PER_PAGE_DEFAULT = 20
-
-    def per_page
-      PER_PAGE_DEFAULT
-    end
-
-    # search returns a will_paginate collection of ActiveRecord objects for the search results
-    # supported options:
-    # :page - page of results to search for
-    # :per_page - number of results per page
-    #
-    # http://www.elasticsearch.com/docs/elasticsearch/rest_api/search/
-    def search(query, options = {})
-      page = (options.delete(:page) || 1).to_i
-      options[:fields] ||= '_id'
-      options[:size] ||= per_page_for_search(options)
-      options[:from] ||= options[:size] * (page - 1)
-      options[:query] ||= if query.is_a?(Hash)
-        query
-      else
-        {}.tap do |q|
-          q[:query_string] = { :query => query }
-          q[:query_string][:default_operator] = options.delete(:default_operator) if options.has_key?(:default_operator)
-        end
-      end
-      query = {}
-      case sort = options.delete(:sort)
-      when Array,Hash
-        options[:sort] = sort
-      when String
-        query[:sort] = sort
-      end
-
-      response = ElasticSearchable.request :get, index_mapping_path('_search'), :query => query, :json_body => options
-      hits = response['hits']
-      ids = hits['hits'].collect {|h| h['_id'].to_i }
-      results = self.find(ids).sort_by {|result| ids.index(result.id) }
-
-      results.each do |result|
-        result.instance_variable_set '@hit', hits['hits'][ids.index(result.id)]
-      end
-
-      ElasticSearchable::Paginator.handler.new(results, page, options[:size], hits['total'])
-    end
-
-    private
-    # determine the number of search results per page
-    # supports will_paginate configuration by using:
-    # Model.per_page
-    # Model.max_per_page
-    def per_page_for_search(options = {})
-      per_page = (options.delete(:per_page) || (self.respond_to?(:per_page) ? self.per_page : nil) || ElasticSearchable::Queries::PER_PAGE_DEFAULT).to_i
-      per_page = [per_page, self.max_per_page].min if self.respond_to?(:max_per_page)
-      per_page
-    end
-  end
-end