chewy 0.5.0 → 0.5.1

data/lib/chewy/query/criteria.rb

@@ -4,7 +4,7 @@ module Chewy
   class Query
     class Criteria
       include Compose
-      ARRAY_STORAGES = [:queries, :filters, :post_filters, :sort, :fields, :types]
+      ARRAY_STORAGES = [:queries, :filters, :post_filters, :sort, :fields, :types, :scores]
       HASH_STORAGES = [:options, :request_options, :facets, :aggregations, :suggest]
       STORAGES = ARRAY_STORAGES + HASH_STORAGES
 
@@ -52,6 +52,10 @@ module Chewy
         facets.merge!(modifer)
       end
 
+      def update_scores(modifer)
+        @scores = scores + Array.wrap(modifer).reject(&:blank?)
+      end
+
       def update_aggregations(modifer)
         aggregations.merge!(modifer)
       end
@@ -99,6 +103,7 @@ module Chewy
       def request_body
         body = {}
 
+
         body.merge!(_filtered_query(_request_query, _request_filter, options.slice(:strategy)))
         body.merge!(post_filter: _request_post_filter) if post_filters?
         body.merge!(facets: facets) if facets?
@@ -107,9 +112,15 @@ module Chewy
         body.merge!(sort: sort) if sort?
         body.merge!(_source: fields) if fields?
 
+        body = _boost_query(body)
+
         { body: body.merge!(request_options) }
       end
 
+      def delete_all_request_body
+        { body: _filtered_query(_request_query, _request_filter, options.slice(:strategy)).presence || { query: { match_all: {} } } }
+      end
+
     protected
 
       def storages
@@ -123,6 +134,27 @@ module Chewy
         end
       end
 
+      def _boost_query(body)
+        scores? or return body
+        query = body.delete :query
+        filter = body.delete :filter
+        if query && filter
+          query = { filtered: { query: query, filter: filter } }
+          filter = nil
+        end
+        score = { }
+        score[:functions] = scores
+        score[:boost_mode] = options[:boost_mode] if options[:boost_mode]
+        score[:score_mode] = options[:score_mode] if options[:score_mode]
+        score[:query] = query if query
+        score[:filter] = filter if filter
+        body.tap { |b| b[:query] = { function_score: score } }
+      end
+
+      def _request_options
+        options.slice(:size, :from, :explain, :highlight, :rescore)
+      end
+
       def _request_query
         _queries_join(queries, options[:query_mode])
       end

data/lib/chewy/railtie.rb

@@ -18,6 +18,11 @@ module Chewy
         duration = ((finish - start).to_f * 10000).round / 10.0
         Rails.logger.debug("  \e[1m\e[32m#{payload[:index]} Search (#{duration}ms)\e[0m #{payload[:request]}")
       end
+
+      ActiveSupport::Notifications.subscribe('delete_query.chewy') do |name, start, finish, id, payload|
+        duration = ((finish - start).to_f * 10000).round / 10.0
+        Rails.logger.debug("  \e[1m\e[32m#{payload[:index]} Delete by Query (#{duration}ms)\e[0m #{payload[:request]}")
+      end
     end
   end
 end

data/lib/chewy/rspec/update_index.rb

@@ -22,6 +22,11 @@ require 'i18n/core_ext/hash'
 #
 RSpec::Matchers.define :update_index do |type_name, options = {}|
 
+  if !respond_to?(:failure_message) && respond_to?(:failure_message_for_should)
+    alias :failure_message :failure_message_for_should
+    alias :failure_message_when_negated :failure_message_for_should_not
+  end
+
   # Specify indexed records by passing record itself or id.
   #
   #   specify { expect { user.save! }.to update_index(UsersIndex::User).and_reindex(user)
@@ -82,19 +87,22 @@ RSpec::Matchers.define :update_index do |type_name, options = {}|
     @only = true
   end
 
+  def supports_block_expectations?
+    true
+  end
+
   match do |block|
     @reindex ||= {}
     @delete ||= {}
     @missed_reindex = []
     @missed_delete = []
+    @updated = []
 
     type = Chewy.derive_type(type_name)
-    updated = []
-    type.stub(:bulk) do |options|
-      updated += options[:body].map do |updated_document|
-        updated_document = updated_document.deep_symbolize_keys
-        body = updated_document[:index] || updated_document[:delete]
-        updated_document
+
+    allow(type).to receive(:bulk) do |bulk_options|
+      @updated += bulk_options[:body].map do |updated_document|
+        updated_document.deep_symbolize_keys
       end
       {}
     end
@@ -105,7 +113,6 @@ RSpec::Matchers.define :update_index do |type_name, options = {}|
       Chewy.atomic { block.call }
     end
 
-    @updated = updated
     @updated.each do |updated_document|
       if body = updated_document[:index]
         if document = @reindex[body[:_id].to_s]
@@ -139,7 +146,7 @@ RSpec::Matchers.define :update_index do |type_name, options = {}|
     @delete.all? { |_, document| document[:match_count] }
   end
 
-  failure_message_for_should do
+  failure_message do
     output = ''
 
     if @updated.none?
@@ -177,7 +184,7 @@ RSpec::Matchers.define :update_index do |type_name, options = {}|
     output
   end
 
-  failure_message_for_should_not do
+  failure_message_when_negated do
     if @updated.any?
       "Expected index `#{type_name}` not to be updated, but it was with #{
         @updated.map(&:values).flatten.group_by { |documents| documents[:_id] }.map do |id, documents|

data/lib/chewy/type/actions.rb

@@ -0,0 +1,19 @@
+module Chewy
+  module Type
+    module Actions
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+        # Delete all documents of a type and reimport them
+        # Returns true or false depending on success.
+        #
+        #   UsersIndex::User.reset
+        #
+        def reset
+          delete_all
+          import
+        end
+      end
+    end
+  end
+end

data/lib/chewy/type/adapter/active_record.rb

@@ -104,7 +104,7 @@ module Chewy
         attr_reader :model, :scope, :options
 
         def import_ids(ids, import_options = {}, &block)
-          ids = ids.map(&:to_i).uniq
+          ids.uniq!
 
           indexed = true
           merged_scope(scoped_model(ids)).find_in_batches(import_options.slice(:batch_size)) do |objects|

data/lib/chewy/type/base.rb

@@ -2,6 +2,7 @@ require 'chewy/index/search'
 require 'chewy/type/mapping'
 require 'chewy/type/wrapper'
 require 'chewy/type/observe'
+require 'chewy/type/actions'
 require 'chewy/type/import'
 require 'chewy/type/adapter/object'
 require 'chewy/type/adapter/active_record'
@@ -13,6 +14,7 @@ module Chewy
       include Mapping
       include Wrapper
       include Observe
+      include Actions
       include Import
 
       singleton_class.delegate :client, to: :index

data/lib/chewy/type/import.rb

@@ -22,10 +22,12 @@ module Chewy
           bulk_options = import_options.reject { |k, v| ![:refresh, :suffix].include?(k) }.reverse_merge!(refresh: true)
 
           index.create!(bulk_options.slice(:suffix)) unless index.exists?
+          build_root unless self.root_object
 
           ActiveSupport::Notifications.instrument 'import_objects.chewy', type: self do |payload|
             adapter.import(*args, import_options) do |action_objects|
-              body = bulk_body(action_objects)
+              indexed_objects = self.root_object.parent_id && fetch_indexed_objects(action_objects.values.flatten, bulk_options)
+              body = bulk_body(action_objects, indexed_objects)
               errors = bulk(bulk_options.merge(body: body)) if body.any?
 
               fill_payload_import payload, action_objects
@@ -72,13 +74,30 @@ module Chewy
 
       private
 
-        def bulk_body action_objects
-          action_objects.each.with_object([]) do |(action, objects), result|
-            result.concat(if action == :delete
-              objects.map { |object| { action => {_id: object.respond_to?(:id) ? object.id : object} } }
-            else
-              objects.map { |object| { action => {_id: object.id, data: object_data(object)} } }
-            end)
+        def bulk_body(action_objects, indexed_objects = nil)
+          action_objects.inject([]) do |result, (action, objects)|
+            result.concat(objects.map { |object| bulk_entries(action, object, indexed_objects) }.flatten)
+          end
+        end
+
+        def bulk_entries(action, object, indexed_objects = nil)
+          entry = {}
+
+          entry[:_id] = object.respond_to?(:id) ? object.id : object
+          entry[:data] = object_data(object) unless action == :delete
+
+          if self.root_object.parent_id
+            entry[:parent] = self.root_object.compose_parent(object) if object.respond_to?(:id)
+          end
+
+          indexed_object = indexed_objects && indexed_objects[entry[:_id].to_s]
+
+          if indexed_object && self.root_object.parent_id && action == :delete
+            [{ action => entry.merge(parent: indexed_object[:parent]) }]
+          elsif indexed_object && self.root_object.parent_id && entry[:parent].to_s != indexed_object[:parent]
+            [{ :delete => entry.except(:data).merge(parent: indexed_object[:parent]) }, { action => entry }]
+          else
+            [{ action => entry }]
           end
         end
 
@@ -118,6 +137,23 @@ module Chewy
             {action => errors}
           end.reduce(&:merge) || {}
         end
+
+        def fetch_indexed_objects(objects, options = {})
+          ids = objects.map { |object| object.respond_to?(:id) ? object.id : object }
+          result = client.search index: index.build_index_name(suffix: options[:suffix]), type: type_name, fields: '_parent', body: { query: { ids: { values: ids } } }, search_type: 'scan', scroll: '1m'
+
+          indexed_objects = {}
+
+          while result = client.scroll(scroll_id: result['_scroll_id'], scroll: '1m') do
+            break if result['hits']['hits'].empty?
+
+            result['hits']['hits'].map do |hit|
+              indexed_objects[hit['_id']] = { parent: hit['fields']['_parent'] }
+            end
+          end
+
+          indexed_objects
+        end
       end
     end
   end

data/lib/chewy/version.rb

@@ -1,3 +1,3 @@
 module Chewy
-  VERSION = '0.5.0'
+  VERSION = '0.5.1'
 end

data/lib/generators/chewy/install_generator.rb

@@ -0,0 +1,11 @@
+module Chewy
+  module Generators
+    class InstallGenerator < Rails::Generators::Base
+      source_root File.expand_path("../../templates", __FILE__)
+
+      def copy_configuration
+        template "chewy.yml", "config/chewy.yml"
+      end
+    end
+  end
+end

data/lib/generators/templates/chewy.yml

@@ -0,0 +1,7 @@
+# config/chewy.yml
+# separate environment configs
+test:
+  host: 'localhost:9250'
+  prefix: 'test'
+development:
+  host: 'localhost:9200'

data/lib/tasks/chewy.rake

@@ -14,7 +14,7 @@ end
 
 def eager_load_chewy!
   Rails.application.config.paths['app/chewy'].existent.each do |dir|
-    Dir.glob(File.join(dir, '**/*.rb')).each { |file| require file }
+    Dir.glob(File.join(dir, '**/*.rb')).each { |file| require_dependency file }
   end
 end
 

data/spec/chewy/config_spec.rb

@@ -61,9 +61,9 @@ describe Chewy::Config do
   end
 
   describe '#atomic?' do
-    its(:atomic?) { should be_false }
-    specify { subject.atomic { subject.atomic?.should be_true } }
-    specify { subject.atomic { }; subject.atomic?.should be_false }
+    its(:atomic?) { should eq(false) }
+    specify { subject.atomic { subject.atomic?.should eq(true) } }
+    specify { subject.atomic { }; subject.atomic?.should eq(false) }
   end
 
   describe '#atomic' do

data/spec/chewy/index/actions_spec.rb

@@ -6,32 +6,32 @@ describe Chewy::Index::Actions do
   before { stub_index :dummies }
 
   describe '.exists?' do
-    specify { DummiesIndex.exists?.should be_false }
+    specify { DummiesIndex.exists?.should eq(false) }
 
     context do
       before { DummiesIndex.create }
-      specify { DummiesIndex.exists?.should be_true }
+      specify { DummiesIndex.exists?.should eq(true) }
     end
   end
 
   describe '.create' do
-    specify { DummiesIndex.create.should be_true }
-    specify { DummiesIndex.create('2013').should be_true }
+    specify { DummiesIndex.create["acknowledged"].should eq(true) }
+    specify { DummiesIndex.create('2013')["acknowledged"].should eq(true) }
 
     context do
       before { DummiesIndex.create }
-      specify { DummiesIndex.create.should be_false }
-      specify { DummiesIndex.create('2013').should be_false }
+      specify { DummiesIndex.create.should eq(false) }
+      specify { DummiesIndex.create('2013').should eq(false) }
     end
 
     context do
       before { DummiesIndex.create '2013' }
-      specify { Chewy.client.indices.exists(index: 'dummies').should be_true }
-      specify { Chewy.client.indices.exists(index: 'dummies_2013').should be_true }
+      specify { Chewy.client.indices.exists(index: 'dummies').should eq(true) }
+      specify { Chewy.client.indices.exists(index: 'dummies_2013').should eq(true) }
       specify { DummiesIndex.aliases.should == [] }
       specify { DummiesIndex.indexes.should == ['dummies_2013'] }
-      specify { DummiesIndex.create('2013').should be_false }
-      specify { DummiesIndex.create('2014').should be_true }
+      specify { DummiesIndex.create('2013').should eq(false) }
+      specify { DummiesIndex.create('2014')["acknowledged"].should eq(true) }
 
       context do
         before { DummiesIndex.create '2014' }
@@ -41,16 +41,16 @@ describe Chewy::Index::Actions do
 
     context do
       before { DummiesIndex.create '2013', alias: false }
-      specify { Chewy.client.indices.exists(index: 'dummies').should be_false }
-      specify { Chewy.client.indices.exists(index: 'dummies_2013').should be_true }
+      specify { Chewy.client.indices.exists(index: 'dummies').should eq(false) }
+      specify { Chewy.client.indices.exists(index: 'dummies_2013').should eq(true) }
       specify { DummiesIndex.aliases.should == [] }
       specify { DummiesIndex.indexes.should == [] }
     end
   end
 
   describe '.create!' do
-    specify { DummiesIndex.create!.should be_true }
-    specify { DummiesIndex.create!('2013').should be_true }
+    specify { DummiesIndex.create!["acknowledged"].should eq(true) }
+    specify { DummiesIndex.create!('2013')["acknowledged"].should eq(true) }
 
     context do
       before { DummiesIndex.create }
@@ -60,12 +60,12 @@ describe Chewy::Index::Actions do
 
     context do
       before { DummiesIndex.create! '2013' }
-      specify { Chewy.client.indices.exists(index: 'dummies').should be_true }
-      specify { Chewy.client.indices.exists(index: 'dummies_2013').should be_true }
+      specify { Chewy.client.indices.exists(index: 'dummies').should eq(true) }
+      specify { Chewy.client.indices.exists(index: 'dummies_2013').should eq(true) }
       specify { DummiesIndex.aliases.should == [] }
       specify { DummiesIndex.indexes.should == ['dummies_2013'] }
       specify { expect { DummiesIndex.create!('2013') }.to raise_error }
-      specify { DummiesIndex.create!('2014').should be_true }
+      specify { DummiesIndex.create!('2014')["acknowledged"].should eq(true) }
 
       context do
         before { DummiesIndex.create! '2014' }
@@ -75,53 +75,53 @@ describe Chewy::Index::Actions do
 
     context do
       before { DummiesIndex.create! '2013', alias: false }
-      specify { Chewy.client.indices.exists(index: 'dummies').should be_false }
-      specify { Chewy.client.indices.exists(index: 'dummies_2013').should be_true }
+      specify { Chewy.client.indices.exists(index: 'dummies').should eq(false) }
+      specify { Chewy.client.indices.exists(index: 'dummies_2013').should eq(true) }
       specify { DummiesIndex.aliases.should == [] }
       specify { DummiesIndex.indexes.should == [] }
     end
   end
 
   describe '.delete' do
-    specify { DummiesIndex.delete.should be_false }
-    specify { DummiesIndex.delete('dummies_2013').should be_false }
+    specify { DummiesIndex.delete.should eq(false) }
+    specify { DummiesIndex.delete('dummies_2013').should eq(false) }
 
     context do
       before { DummiesIndex.create }
-      specify { DummiesIndex.delete.should be_true }
+      specify { DummiesIndex.delete["acknowledged"].should eq(true) }
 
       context do
         before { DummiesIndex.delete }
-        specify { Chewy.client.indices.exists(index: 'dummies').should be_false }
+        specify { Chewy.client.indices.exists(index: 'dummies').should eq(false) }
       end
     end
 
     context do
       before { DummiesIndex.create '2013' }
-      specify { DummiesIndex.delete('2013').should be_true }
+      specify { DummiesIndex.delete('2013')["acknowledged"].should eq(true) }
 
       context do
         before { DummiesIndex.delete('2013') }
-        specify { Chewy.client.indices.exists(index: 'dummies').should be_false }
-        specify { Chewy.client.indices.exists(index: 'dummies_2013').should be_false }
+        specify { Chewy.client.indices.exists(index: 'dummies').should eq(false) }
+        specify { Chewy.client.indices.exists(index: 'dummies_2013').should eq(false) }
       end
 
       context do
         before { DummiesIndex.create '2014' }
-        specify { DummiesIndex.delete.should be_true }
+        specify { DummiesIndex.delete["acknowledged"].should eq(true) }
 
         context do
           before { DummiesIndex.delete }
-          specify { Chewy.client.indices.exists(index: 'dummies').should be_false }
-          specify { Chewy.client.indices.exists(index: 'dummies_2013').should be_false }
-          specify { Chewy.client.indices.exists(index: 'dummies_2014').should be_false }
+          specify { Chewy.client.indices.exists(index: 'dummies').should eq(false) }
+          specify { Chewy.client.indices.exists(index: 'dummies_2013').should eq(false) }
+          specify { Chewy.client.indices.exists(index: 'dummies_2014').should eq(false) }
         end
 
         context do
           before { DummiesIndex.delete('2014') }
-          specify { Chewy.client.indices.exists(index: 'dummies').should be_true }
-          specify { Chewy.client.indices.exists(index: 'dummies_2013').should be_true }
-          specify { Chewy.client.indices.exists(index: 'dummies_2014').should be_false }
+          specify { Chewy.client.indices.exists(index: 'dummies').should eq(true) }
+          specify { Chewy.client.indices.exists(index: 'dummies_2013').should eq(true) }
+          specify { Chewy.client.indices.exists(index: 'dummies_2014').should eq(false) }
         end
       end
     end
@@ -133,48 +133,48 @@ describe Chewy::Index::Actions do
 
     context do
       before { DummiesIndex.create }
-      specify { DummiesIndex.delete!.should be_true }
+      specify { DummiesIndex.delete!["acknowledged"].should eq(true) }
 
       context do
         before { DummiesIndex.delete! }
-        specify { Chewy.client.indices.exists(index: 'dummies').should be_false }
+        specify { Chewy.client.indices.exists(index: 'dummies').should eq(false) }
       end
     end
 
     context do
       before { DummiesIndex.create '2013' }
-      specify { DummiesIndex.delete!('2013').should be_true }
+      specify { DummiesIndex.delete!('2013')["acknowledged"].should eq(true) }
 
       context do
         before { DummiesIndex.delete!('2013') }
-        specify { Chewy.client.indices.exists(index: 'dummies').should be_false }
-        specify { Chewy.client.indices.exists(index: 'dummies_2013').should be_false }
+        specify { Chewy.client.indices.exists(index: 'dummies').should eq(false) }
+        specify { Chewy.client.indices.exists(index: 'dummies_2013').should eq(false) }
       end
 
       context do
         before { DummiesIndex.create '2014' }
-        specify { DummiesIndex.delete!.should be_true }
+        specify { DummiesIndex.delete!["acknowledged"].should eq(true) }
 
         context do
           before { DummiesIndex.delete! }
-          specify { Chewy.client.indices.exists(index: 'dummies').should be_false }
-          specify { Chewy.client.indices.exists(index: 'dummies_2013').should be_false }
-          specify { Chewy.client.indices.exists(index: 'dummies_2014').should be_false }
+          specify { Chewy.client.indices.exists(index: 'dummies').should eq(false) }
+          specify { Chewy.client.indices.exists(index: 'dummies_2013').should eq(false) }
+          specify { Chewy.client.indices.exists(index: 'dummies_2014').should eq(false) }
         end
 
         context do
           before { DummiesIndex.delete!('2014') }
-          specify { Chewy.client.indices.exists(index: 'dummies').should be_true }
-          specify { Chewy.client.indices.exists(index: 'dummies_2013').should be_true }
-          specify { Chewy.client.indices.exists(index: 'dummies_2014').should be_false }
+          specify { Chewy.client.indices.exists(index: 'dummies').should eq(true) }
+          specify { Chewy.client.indices.exists(index: 'dummies_2013').should eq(true) }
+          specify { Chewy.client.indices.exists(index: 'dummies_2014').should eq(false) }
         end
       end
     end
   end
 
   describe '.purge' do
-    specify { DummiesIndex.purge.should be_true }
-    specify { DummiesIndex.purge('2013').should be_true }
+    specify { DummiesIndex.purge["acknowledged"].should eq(true) }
+    specify { DummiesIndex.purge('2013')["acknowledged"].should eq(true) }
 
     context do
       before { DummiesIndex.purge }
@@ -220,8 +220,8 @@ describe Chewy::Index::Actions do
   end
 
   describe '.purge!' do
-    specify { DummiesIndex.purge!.should be_true }
-    specify { DummiesIndex.purge!('2013').should be_true }
+    specify { DummiesIndex.purge!["acknowledged"].should eq(true) }
+    specify { DummiesIndex.purge!('2013')["acknowledged"].should eq(true) }
 
     context do
       before { DummiesIndex.purge! }
@@ -324,8 +324,8 @@ describe Chewy::Index::Actions do
 
     before { City.create!(name: 'Moscow') }
 
-    specify { CitiesIndex.reset!.should be_true }
-    specify { CitiesIndex.reset!('2013').should be_true }
+    specify { CitiesIndex.reset!.should eq(true) }
+    specify { CitiesIndex.reset!('2013').should eq(true) }
 
     context do
       before { CitiesIndex.reset! }
@@ -364,7 +364,7 @@ describe Chewy::Index::Actions do
         specify { CitiesIndex.all.should have(1).item }
         specify { CitiesIndex.aliases.should == [] }
         specify { CitiesIndex.indexes.should == ['cities_2014'] }
-        specify { Chewy.client.indices.exists(index: 'cities_2013').should be_false }
+        specify { Chewy.client.indices.exists(index: 'cities_2013').should eq(false) }
       end
 
       context do
@@ -373,7 +373,7 @@ describe Chewy::Index::Actions do
         specify { CitiesIndex.all.should have(1).item }
         specify { CitiesIndex.aliases.should == [] }
         specify { CitiesIndex.indexes.should == [] }
-        specify { Chewy.client.indices.exists(index: 'cities_2013').should be_false }
+        specify { Chewy.client.indices.exists(index: 'cities_2013').should eq(false) }
       end
     end
   end