chewy 7.2.4 → 7.2.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0de5ea12714d98c68dc3d74d1b6bb9debefea211a025749b8958a804a285bdcd
-  data.tar.gz: f9256684493364e7f6b1ae1b3da4d6376624369df3ff950750a6148cd7d6da2f
+  metadata.gz: 37685481eff7312e08ba8d113f030ee5ab38e3414788c6cd2a0385829c99a712
+  data.tar.gz: d4a2a9d86d93e9a9c6ec5d11cabe51f67511f6b347faee3be9e276cf528c4dc2
 SHA512:
-  metadata.gz: f35594db25143614d6c88ac2aef7081975502e0434993e9b60495d6f3d63d2f13fee246275bd5b6b6c5b1deae4db06f5b734bf73369e77aeea22c7141b177417
-  data.tar.gz: 92dbe74fb416105b4c38dcb95b40646c53597d17c2cdd2800107c27a979da24abceccb0d6ab51b0b3783f769327a3a9fed323b9d504de65cc3541e90df0bd273
+  metadata.gz: c973f623b179e98284019a2b2dddc1cb7506719585064673cccab0e1c790f599dce43a1395e364d5ed8be814ee0af1fe4985e188f25dcaa32e75eefa57a4f6e3
+  data.tar.gz: bd1c55232fd02520382a20109899f3b4d59a174c1d1ff875592f08582b5f3072dd7d6f47760df3be58f38756718f31f802832476a1e0c64ebfb9909748e31eac

data/CHANGELOG.md

@@ -8,6 +8,18 @@
 
 ### Bugs Fixed
 
+## 7.2.5 (2022-03-04)
+
+### New Features
+
+ * [#827](https://github.com/toptal/chewy/pull/827): Add `:lazy_sidekiq` strategy, that defers not only importing but also `update_index` callback evaluation for created and updated objects. ([@sl4vr][])
+ * [#827](https://github.com/toptal/chewy/pull/827): Add `:atomic_no_refresh` strategy. Like `:atomic`, but `refresh=false` parameter is set. ([@barthez][])
+ * [#827](https://github.com/toptal/chewy/pull/827): Add `:no_refresh` chain call to `update_index` matcher to ensure import was called with `refresh=false`. ([@barthez][])
+ 
+### Bugs Fixed
+
+ * [#835](https://github.com/toptal/chewy/pull/835): Support keyword arguments in named scopes. ([@milk1000cc][])
+
 ## 7.2.4 (2022-02-03)
 
 ### New Features

data/README.md

@@ -754,6 +754,23 @@ The default queue name is `chewy`, you can customize it in settings: `sidekiq.qu
 Chewy.settings[:sidekiq] = {queue: :low}
 ```
 
+#### `:lazy_sidekiq`
+
+This does the same thing as `:sidekiq`, but with lazy evaluation. Beware it does not allow you to use any non-persistent record state for indices and conditions because record will be re-fetched from database asynchronously using sidekiq. However for destroying records strategy will fallback to `:sidekiq` because it's not possible to re-fetch deleted records from database.
+
+The purpose of this strategy is to improve the response time of the code that should update indexes, as it does not only defer actual ES calls to a background job but `update_index` callbacks evaluation (for created and updated objects) too. Similar to `:sidekiq`, index update is asynchronous so this strategy cannot be used when data and index synchronization is required.
+
+```ruby
+Chewy.strategy(:lazy_sidekiq) do
+  City.popular.map(&:do_some_update_action!)
+end
+```
+
+The default queue name is `chewy`, you can customize it in settings: `sidekiq.queue_name`
+```
+Chewy.settings[:sidekiq] = {queue: :low}
+```
+
 #### `:active_job`
 
 This does the same thing as `:atomic`, but using ActiveJob. This will inherit the ActiveJob configuration settings including the `active_job.queue_adapter` setting for the environment. Patch `Chewy::Strategy::ActiveJob::Worker` for index updates improving.

data/lib/chewy/config.rb

@@ -32,7 +32,7 @@ module Chewy
                   # Set number_of_replicas to 0 before reset and put the original value after
                   # https://www.elastic.co/guide/en/elasticsearch/reference/current/indices-update-settings.html
                   :reset_no_replicas,
-                  # Refresh or not when import async (sidekiq, activejob)
+                  # Refresh or not when import async (sidekiq, lazy_sidekiq, activejob)
                   :disable_refresh_async,
                   # Default options for root of Chewy type. Allows to set default options
                   # for type mappings like `_all`.

data/lib/chewy/index/observe/active_record_methods.rb

@@ -0,0 +1,87 @@
+module Chewy
+  class Index
+    module Observe
+      module Helpers
+        def update_proc(index_name, *args, &block)
+          options = args.extract_options!
+          method = args.first
+
+          proc do
+            reference = if index_name.is_a?(Proc)
+              if index_name.arity.zero?
+                instance_exec(&index_name)
+              else
+                index_name.call(self)
+              end
+            else
+              index_name
+            end
+
+            index = Chewy.derive_name(reference)
+
+            next if Chewy.strategy.current.name == :bypass
+
+            backreference = if method && method.to_s == 'self'
+              self
+            elsif method
+              send(method)
+            else
+              instance_eval(&block)
+            end
+
+            index.update_index(backreference, options)
+          end
+        end
+
+        def extract_callback_options!(args)
+          options = args.extract_options!
+          result = options.each_key.with_object({}) do |key, hash|
+            hash[key] = options.delete(key) if %i[if unless].include?(key)
+          end
+          args.push(options) unless options.empty?
+          result
+        end
+      end
+
+      extend Helpers
+
+      module ActiveRecordMethods
+        extend ActiveSupport::Concern
+
+        def run_chewy_callbacks
+          chewy_callbacks.each { |callback| callback.call(self) }
+        end
+
+        def update_chewy_indices
+          Chewy.strategy.current.update_chewy_indices(self)
+        end
+
+        included do
+          class_attribute :chewy_callbacks, default: []
+        end
+
+        class_methods do
+          def initialize_chewy_callbacks
+            if Chewy.use_after_commit_callbacks
+              after_commit :update_chewy_indices, on: %i[create update]
+              after_commit :run_chewy_callbacks, on: :destroy
+            else
+              after_save :update_chewy_indices
+              after_destroy :run_chewy_callbacks
+            end
+          end
+
+          ruby2_keywords def update_index(type_name, *args, &block)
+            callback_options = Observe.extract_callback_options!(args)
+            update_proc = Observe.update_proc(type_name, *args, &block)
+            callback = Chewy::Index::Observe::Callback.new(update_proc, callback_options)
+
+            initialize_chewy_callbacks if chewy_callbacks.empty?
+
+            self.chewy_callbacks = chewy_callbacks.dup << callback
+          end
+        end
+      end
+    end
+  end
+end

data/lib/chewy/index/observe/callback.rb

@@ -0,0 +1,34 @@
+module Chewy
+  class Index
+    module Observe
+      class Callback
+        def initialize(executable, filters = {})
+          @executable = executable
+          @if_filter = filters[:if]
+          @unless_filter = filters[:unless]
+        end
+
+        def call(context)
+          return if !@if_filter.nil? && !eval_filter(@if_filter, context)
+          return if !@unless_filter.nil? && eval_filter(@unless_filter, context)
+
+          eval_proc(@executable, context)
+        end
+
+      private
+
+        def eval_filter(filter, context)
+          case filter
+          when Symbol then context.send(filter)
+          when Proc then eval_proc(filter, context)
+          else filter
+          end
+        end
+
+        def eval_proc(executable, context)
+          executable.arity.zero? ? context.instance_exec(&executable) : executable.call(context)
+        end
+      end
+    end
+  end
+end

data/lib/chewy/index/observe.rb

@@ -1,66 +1,11 @@
+require 'chewy/index/observe/callback'
+require 'chewy/index/observe/active_record_methods'
+
 module Chewy
   class Index
     module Observe
       extend ActiveSupport::Concern
 
-      module Helpers
-        def update_proc(index_name, *args, &block)
-          options = args.extract_options!
-          method = args.first
-
-          proc do
-            reference = if index_name.is_a?(Proc)
-              if index_name.arity.zero?
-                instance_exec(&index_name)
-              else
-                index_name.call(self)
-              end
-            else
-              index_name
-            end
-
-            index = Chewy.derive_name(reference)
-
-            next if Chewy.strategy.current.name == :bypass
-
-            backreference = if method && method.to_s == 'self'
-              self
-            elsif method
-              send(method)
-            else
-              instance_eval(&block)
-            end
-
-            index.update_index(backreference, options)
-          end
-        end
-
-        def extract_callback_options!(args)
-          options = args.extract_options!
-          result = options.each_key.with_object({}) do |key, hash|
-            hash[key] = options.delete(key) if %i[if unless].include?(key)
-          end
-          args.push(options) unless options.empty?
-          result
-        end
-      end
-
-      extend Helpers
-
-      module ActiveRecordMethods
-        ruby2_keywords def update_index(type_name, *args, &block)
-          callback_options = Observe.extract_callback_options!(args)
-          update_proc = Observe.update_proc(type_name, *args, &block)
-
-          if Chewy.use_after_commit_callbacks
-            after_commit(**callback_options, &update_proc)
-          else
-            after_save(**callback_options, &update_proc)
-            after_destroy(**callback_options, &update_proc)
-          end
-        end
-      end
-
       module ClassMethods
         def update_index(objects, options = {})
           Chewy.strategy.current.update(self, objects, options)

data/lib/chewy/rspec/update_index.rb

@@ -88,6 +88,11 @@ RSpec::Matchers.define :update_index do |index_name, options = {}| # rubocop:dis
     @only = true
   end
 
+  # Expect import to be called with refresh=false parameter
+  chain(:no_refresh) do
+    @no_refresh = true
+  end
+
   def supports_block_expectations?
     true
   end
@@ -100,11 +105,13 @@ RSpec::Matchers.define :update_index do |index_name, options = {}| # rubocop:dis
 
     index = Chewy.derive_name(index_name)
     if defined?(Mocha) && RSpec.configuration.mock_framework.to_s == 'RSpec::Core::MockingAdapters::Mocha'
-      Chewy::Index::Import::BulkRequest.stubs(:new).with(index, any_parameters).returns(mock_bulk_request)
+      params_matcher = @no_refresh ? has_entry(refresh: false) : any_parameters
+      Chewy::Index::Import::BulkRequest.stubs(:new).with(index, params_matcher).returns(mock_bulk_request)
     else
       mocked_already = ::RSpec::Mocks.space.proxy_for(Chewy::Index::Import::BulkRequest).method_double_if_exists_for_message(:new)
       allow(Chewy::Index::Import::BulkRequest).to receive(:new).and_call_original unless mocked_already
-      allow(Chewy::Index::Import::BulkRequest).to receive(:new).with(index, any_args).and_return(mock_bulk_request)
+      params_matcher = @no_refresh ? hash_including(refresh: false) : any_args
+      allow(Chewy::Index::Import::BulkRequest).to receive(:new).with(index, params_matcher).and_return(mock_bulk_request)
     end
 
     Chewy.strategy(options[:strategy] || :atomic) { block.call }
@@ -146,7 +153,7 @@ RSpec::Matchers.define :update_index do |index_name, options = {}| # rubocop:dis
     output = ''
 
     if mock_bulk_request.updates.none?
-      output << "Expected index `#{index_name}` to be updated, but it was not\n"
+      output << "Expected index `#{index_name}` to be updated#{' with no refresh' if @no_refresh}, but it was not\n"
     elsif @missed_reindex.present? || @missed_delete.present?
       message = "Expected index `#{index_name}` "
       message << [

data/lib/chewy/search.rb

@@ -87,6 +87,7 @@ module Chewy
             define_method method do |*args, &block|
               scoping { source.public_send(method, *args, &block) }
             end
+            ruby2_keywords method
           end
         end
       end

data/lib/chewy/strategy/atomic_no_refresh.rb

@@ -0,0 +1,18 @@
+module Chewy
+  class Strategy
+    # This strategy works like atomic but import objects with `refresh=false` parameter.
+    #
+    #   Chewy.strategy(:atomic_no_refresh) do
+    #     User.all.map(&:save) # Does nothing here
+    #     Post.all.map(&:save) # And here
+    #     # It imports all the changed users and posts right here
+    #     # before block leaving with bulk ES API, kinda optimization
+    #   end
+    #
+    class AtomicNoRefresh < Atomic
+      def leave
+        @stash.all? { |type, ids| type.import!(ids, refresh: false) }
+      end
+    end
+  end
+end

data/lib/chewy/strategy/base.rb

@@ -22,6 +22,16 @@ module Chewy
       # strategies stack
       #
       def leave; end
+
+      # This method called when some model record is created or updated.
+      # Normally it will just evaluate all the Chewy callbacks and pass results
+      # to current strategy's update method.
+      # However it's possible to override it to achieve delayed evaluation of
+      # callbacks, e.g. using sidekiq.
+      #
+      def update_chewy_indices(object)
+        object.run_chewy_callbacks
+      end
     end
   end
 end

data/lib/chewy/strategy/lazy_sidekiq.rb

@@ -0,0 +1,64 @@
+module Chewy
+  class Strategy
+    # The strategy works the same way as sidekiq, but performs
+    # async evaluation of all index callbacks on model create and update
+    # driven by sidekiq
+    #
+    #   Chewy.strategy(:lazy_sidekiq) do
+    #     User.all.map(&:save) # Does nothing here
+    #     Post.all.map(&:save) # And here
+    #     # It schedules import of all the changed users and posts right here
+    #   end
+    #
+    class LazySidekiq < Sidekiq
+      class IndicesUpdateWorker
+        include ::Sidekiq::Worker
+
+        def perform(models)
+          Chewy.strategy(strategy) do
+            models.each do |model_type, model_ids|
+              model_type.constantize.where(id: model_ids).each(&:run_chewy_callbacks)
+            end
+          end
+        end
+
+      private
+
+        def strategy
+          Chewy.disable_refresh_async ? :atomic_no_refresh : :atomic
+        end
+      end
+
+      def initialize
+        # Use parent's @stash to store destroyed records, since callbacks for them have to
+        # be run immediately on the strategy block end because we won't be able to fetch
+        # records further in IndicesUpdateWorker. This will be done by avoiding of
+        # LazySidekiq#update_chewy_indices call and calling LazySidekiq#update instead.
+        super
+
+        # @lazy_stash is used to store all the lazy evaluated callbacks with call of
+        # strategy's #update_chewy_indices.
+        @lazy_stash = {}
+      end
+
+      def leave
+        # Fallback to Sidekiq#leave implementation for destroyed records stored in @stash.
+        super
+
+        # Proceed with other records stored in @lazy_stash
+        return if @lazy_stash.empty?
+
+        ::Sidekiq::Client.push(
+          'queue' => sidekiq_queue,
+          'class' => Chewy::Strategy::LazySidekiq::IndicesUpdateWorker,
+          'args'  => [@lazy_stash]
+        )
+      end
+
+      def update_chewy_indices(object)
+        @lazy_stash[object.class.name] ||= []
+        @lazy_stash[object.class.name] |= Array.wrap(object.id)
+      end
+    end
+  end
+end

data/lib/chewy/strategy.rb

@@ -2,10 +2,12 @@ require 'chewy/strategy/base'
 require 'chewy/strategy/bypass'
 require 'chewy/strategy/urgent'
 require 'chewy/strategy/atomic'
+require 'chewy/strategy/atomic_no_refresh'
 
 begin
   require 'sidekiq'
   require 'chewy/strategy/sidekiq'
+  require 'chewy/strategy/lazy_sidekiq'
 rescue LoadError
   nil
 end

data/lib/chewy/version.rb

@@ -1,3 +1,3 @@
 module Chewy
-  VERSION = '7.2.4'.freeze
+  VERSION = '7.2.5'.freeze
 end

data/lib/chewy.rb

@@ -50,7 +50,7 @@ require 'chewy/journal'
 require 'chewy/railtie' if defined?(::Rails::Railtie)
 
 ActiveSupport.on_load(:active_record) do
-  extend Chewy::Index::Observe::ActiveRecordMethods
+  include Chewy::Index::Observe::ActiveRecordMethods
 end
 
 module Chewy

data/migration_guide.md

@@ -9,7 +9,7 @@ Chewy alongside a matching Elasticsearch version.
 In order to upgrade Chewy 6/Elasticsearch 6 to Chewy 7/Elasticsearch 7 in the most seamless manner you have to:
 
 * Upgrade to the latest 6.x stable releases, namely Chewy 6.0, Elasticsearch 6.8
-* Study carefully [Breaking changes in 7.0](https://www.elastic.co/guide/en/elasticsearch/reference/current/breaking-changes-7.0.html), make sure your application conforms.
+* Study carefully [Breaking changes in 7.0](https://www.elastic.co/guide/en/elasticsearch/reference/7.17/breaking-changes-7.0.html), make sure your application conforms.
 * Run your test suite on Chewy 7.0 / Elasticsearch 7
 * Run manual tests on Chewy 7.0 / Elasticsearch 7
 * Upgrade to Chewy 7.0

data/spec/chewy/index/observe/active_record_methods_spec.rb

@@ -0,0 +1,68 @@
+require 'spec_helper'
+
+describe Chewy::Index::Observe::ActiveRecordMethods do
+  describe '.update_index' do
+    before { stub_model(:city) }
+
+    it 'initializes chewy callbacks when first update_index is evaluated' do
+      expect(City).to receive(:initialize_chewy_callbacks).once
+      City.update_index 'cities', :self
+      City.update_index 'countries', -> {}
+    end
+
+    it 'adds chewy callbacks to model' do
+      expect(City.chewy_callbacks.count).to eq(0)
+
+      City.update_index 'cities', :self
+      City.update_index 'countries', -> {}
+
+      expect(City.chewy_callbacks.count).to eq(2)
+    end
+  end
+
+  describe 'callbacks' do
+    before { stub_model(:city) { update_index 'cities', :self } }
+    before { stub_index(:cities) { index_scope City } }
+    before { allow(Chewy).to receive(:use_after_commit_callbacks).and_return(use_after_commit_callbacks) }
+
+    let(:city) do
+      Chewy.strategy(:bypass) do
+        City.create!
+      end
+    end
+
+    shared_examples 'handles callbacks correctly' do
+      it 'handles callbacks with strategy for possible lazy evaluation on save!' do
+        Chewy.strategy(:urgent) do
+          expect(city).to receive(:update_chewy_indices).and_call_original
+          expect(Chewy.strategy.current).to receive(:update_chewy_indices).with(city)
+          expect(city).not_to receive(:run_chewy_callbacks)
+
+          city.save!
+        end
+      end
+
+      it 'runs callbacks at the moment on destroy' do
+        Chewy.strategy(:urgent) do
+          expect(city).not_to receive(:update_chewy_indices)
+          expect(Chewy.strategy.current).not_to receive(:update_chewy_indices)
+          expect(city).to receive(:run_chewy_callbacks)
+
+          city.destroy
+        end
+      end
+    end
+
+    context 'when Chewy.use_after_commit_callbacks is true' do
+      let(:use_after_commit_callbacks) { true }
+
+      include_examples 'handles callbacks correctly'
+    end
+
+    context 'when Chewy.use_after_commit_callbacks is false' do
+      let(:use_after_commit_callbacks) { false }
+
+      include_examples 'handles callbacks correctly'
+    end
+  end
+end

data/spec/chewy/index/observe/callback_spec.rb

@@ -0,0 +1,139 @@
+require 'spec_helper'
+
+describe Chewy::Index::Observe::Callback do
+  subject(:callback) { described_class.new(executable) }
+
+  before do
+    stub_model(:city) do
+      attr_accessor :population
+    end
+  end
+
+  let(:city) { City.create!(population: 100) }
+
+  describe '#call' do
+    context 'when executable is has arity 0' do
+      let(:executable) { -> { population } }
+
+      it 'calls exectuable within context' do
+        expect(callback.call(city)).to eq(city.population)
+      end
+    end
+
+    context 'when executable is has arity 1' do
+      let(:executable) { ->(record) { record.population } }
+
+      it 'calls exectuable within context' do
+        expect(callback.call(city)).to eq(city.population)
+      end
+    end
+
+    describe 'filters' do
+      let(:executable) { ->(_) {} }
+
+      describe 'if' do
+        subject(:callback) { described_class.new(executable, if: filter) }
+
+        shared_examples 'an if filter' do
+          context 'when condition is true' do
+            let(:condition) { true }
+
+            specify do
+              expect(executable).to receive(:call).with(city)
+
+              callback.call(city)
+            end
+          end
+
+          context 'when condition is false' do
+            let(:condition) { false }
+
+            specify do
+              expect(executable).not_to receive(:call)
+
+              callback.call(city)
+            end
+          end
+        end
+
+        context 'when filter is symbol' do
+          let(:filter) { :condition }
+
+          before do
+            allow(city).to receive(:condition).and_return(condition)
+          end
+
+          include_examples 'an if filter'
+        end
+
+        context 'when filter is proc' do
+          let(:filter) { -> { condition_state } }
+
+          before do
+            allow_any_instance_of(City).to receive(:condition_state).and_return(condition)
+          end
+
+          include_examples 'an if filter'
+        end
+
+        context 'when filter is literal' do
+          let(:filter) { condition }
+
+          include_examples 'an if filter'
+        end
+      end
+
+      describe 'unless' do
+        subject(:callback) { described_class.new(executable, unless: filter) }
+
+        shared_examples 'an unless filter' do
+          context 'when condition is true' do
+            let(:condition) { true }
+
+            specify do
+              expect(executable).not_to receive(:call)
+
+              callback.call(city)
+            end
+          end
+
+          context 'when condition is false' do
+            let(:condition) { false }
+
+            specify do
+              expect(executable).to receive(:call).with(city)
+
+              callback.call(city)
+            end
+          end
+        end
+
+        context 'when filter is symbol' do
+          let(:filter) { :condition }
+
+          before do
+            allow(city).to receive(:condition).and_return(condition)
+          end
+
+          include_examples 'an unless filter'
+        end
+
+        context 'when filter is proc' do
+          let(:filter) { -> { condition_state } }
+
+          before do
+            allow_any_instance_of(City).to receive(:condition_state).and_return(condition)
+          end
+
+          include_examples 'an unless filter'
+        end
+
+        context 'when filter is literal' do
+          let(:filter) { condition }
+
+          include_examples 'an unless filter'
+        end
+      end
+    end
+  end
+end

data/spec/chewy/index/observe_spec.rb

@@ -57,6 +57,9 @@ describe Chewy::Index::Observe do
       specify { expect { city.save! }.to update_index('cities').and_reindex(city).only }
       specify { expect { city.save! }.to update_index('countries').and_reindex(country1).only }
 
+      specify { expect { city.destroy }.to update_index('cities') }
+      specify { expect { city.destroy }.to update_index('countries').and_reindex(country1).only }
+
       specify { expect { city.update!(country: nil) }.to update_index('cities').and_reindex(city).only }
       specify { expect { city.update!(country: nil) }.to update_index('countries').and_reindex(country1).only }
 
@@ -78,9 +81,13 @@ describe Chewy::Index::Observe do
       specify { expect { country.save! }.to update_index('cities').and_reindex(country.cities).only }
       specify { expect { country.save! }.to update_index('countries').and_reindex(country).only }
 
+      specify { expect { country.destroy }.to update_index('cities').and_reindex(country.cities).only }
+      specify { expect { country.destroy }.to update_index('countries') }
+
       context 'conditional update' do
         let(:update_condition) { false }
         specify { expect { country.save! }.not_to update_index('cities') }
+        specify { expect { country.destroy }.not_to update_index('cities') }
       end
     end
   end
@@ -97,6 +104,16 @@ describe Chewy::Index::Observe do
           end
         end
       end
+
+      specify do
+        city = Chewy.strategy(:bypass) { City.create! }
+
+        Chewy.strategy(:urgent) do
+          ActiveRecord::Base.transaction do
+            expect { city.destroy }.not_to update_index('cities')
+          end
+        end
+      end
     end
 
     context do
@@ -111,6 +128,16 @@ describe Chewy::Index::Observe do
           end
         end
       end
+
+      specify do
+        city = Chewy.strategy(:bypass) { City.create! }
+
+        Chewy.strategy(:urgent) do
+          ActiveRecord::Base.transaction do
+            expect { city.destroy }.to update_index('cities')
+          end
+        end
+      end
     end
   end
 end

data/spec/chewy/search_spec.rb

@@ -48,6 +48,10 @@ describe Chewy::Search do
           filter { match name: "Name#{index}" }
         end
 
+        def self.by_rating_with_kwargs(value, options:) # rubocop:disable Lint/UnusedMethodArgument
+          filter { match rating: value }
+        end
+
         index_scope City
         field :name, type: 'keyword'
         field :rating, type: :integer
@@ -114,5 +118,10 @@ describe Chewy::Search do
     specify { expect(CountriesIndex.by_rating(3).by_name(5).map(&:class)).to eq([CountriesIndex]) }
     specify { expect(CountriesIndex.order(:name).by_rating(3).map(&:rating)).to eq([3]) }
     specify { expect(CountriesIndex.order(:name).by_rating(3).map(&:class)).to eq([CountriesIndex]) }
+
+    specify 'supports keyword arguments' do
+      expect(CitiesIndex.by_rating_with_kwargs(3, options: 'blah blah blah').map(&:rating)).to eq([3])
+      expect(CitiesIndex.order(:name).by_rating_with_kwargs(3, options: 'blah blah blah').map(&:rating)).to eq([3])
+    end
   end
 end

data/spec/chewy/strategy/atomic_no_refresh_spec.rb

@@ -0,0 +1,60 @@
+require 'spec_helper'
+
+describe Chewy::Strategy::AtomicNoRefresh, :orm do
+  around { |example| Chewy.strategy(:bypass) { example.run } }
+
+  before do
+    stub_model(:country) do
+      update_index('countries') { self }
+    end
+
+    stub_index(:countries) do
+      index_scope Country
+    end
+  end
+
+  let(:country) { Country.create!(name: 'hello', country_code: 'HL') }
+  let(:other_country) { Country.create!(name: 'world', country_code: 'WD') }
+
+  specify do
+    expect { [country, other_country].map(&:save!) }
+      .to update_index(CountriesIndex, strategy: :atomic_no_refresh)
+      .and_reindex(country, other_country).only.no_refresh
+  end
+
+  specify do
+    expect { [country, other_country].map(&:destroy) }
+      .to update_index(CountriesIndex, strategy: :atomic_no_refresh)
+      .and_delete(country, other_country).only.no_refresh
+  end
+
+  context do
+    before do
+      stub_index(:countries) do
+        index_scope Country
+        root id: -> { country_code }
+      end
+    end
+
+    specify do
+      expect { [country, other_country].map(&:save!) }
+        .to update_index(CountriesIndex, strategy: :atomic_no_refresh)
+        .and_reindex('HL', 'WD').only.no_refresh
+    end
+
+    specify do
+      expect { [country, other_country].map(&:destroy) }
+        .to update_index(CountriesIndex, strategy: :atomic_no_refresh)
+        .and_delete('HL', 'WD').only.no_refresh
+    end
+
+    specify do
+      expect do
+        country.save!
+        other_country.destroy
+      end
+        .to update_index(CountriesIndex, strategy: :atomic_no_refresh)
+        .and_reindex('HL').and_delete('WD').only.no_refresh
+    end
+  end
+end

data/spec/chewy/strategy/lazy_sidekiq_spec.rb

@@ -0,0 +1,214 @@
+require 'spec_helper'
+
+if defined?(::Sidekiq)
+  require 'sidekiq/testing'
+
+  describe Chewy::Strategy::LazySidekiq do
+    around do |example|
+      sidekiq_settings = Chewy.settings[:sidekiq]
+      Chewy.settings[:sidekiq] = {queue: 'low'}
+      Chewy.strategy(:bypass) { example.run }
+      Chewy.settings[:sidekiq] = sidekiq_settings
+    end
+    before { ::Sidekiq::Worker.clear_all }
+
+    context 'strategy' do
+      before do
+        stub_model(:city) do
+          update_index('cities') { self }
+        end
+
+        stub_index(:cities) do
+          index_scope City
+        end
+      end
+
+      let(:city) { City.create!(name: 'hello') }
+      let(:other_city) { City.create!(name: 'world') }
+
+      it 'does not update indices synchronously' do
+        expect { [city, other_city].map(&:save!) }
+          .not_to update_index(CitiesIndex, strategy: :lazy_sidekiq)
+      end
+
+      it 'updates indices asynchronously on record save' do
+        expect(::Sidekiq::Client).to receive(:push)
+          .with(hash_including(
+                  'class' => Chewy::Strategy::LazySidekiq::IndicesUpdateWorker,
+                  'queue' => 'low'
+                ))
+          .and_call_original
+          .once
+        ::Sidekiq::Testing.inline! do
+          expect { [city, other_city].map(&:save!) }
+            .to update_index(CitiesIndex, strategy: :lazy_sidekiq)
+            .and_reindex(city, other_city).only
+        end
+      end
+
+      it 'updates indices asynchronously with falling back to sidekiq strategy on record destroy' do
+        expect(::Sidekiq::Client).not_to receive(:push)
+          .with(hash_including(
+                  'class' => Chewy::Strategy::LazySidekiq::IndicesUpdateWorker,
+                  'queue' => 'low'
+                ))
+        expect(::Sidekiq::Client).to receive(:push)
+          .with(hash_including(
+                  'class' => Chewy::Strategy::Sidekiq::Worker,
+                  'queue' => 'low',
+                  'args' => ['CitiesIndex', [city.id, other_city.id]]
+                ))
+          .and_call_original
+          .once
+        ::Sidekiq::Testing.inline! do
+          expect { [city, other_city].map(&:destroy) }.to update_index(CitiesIndex, strategy: :sidekiq)
+        end
+      end
+
+      it 'calls Index#import!' do
+        allow(City).to receive(:where).with(id: [city.id, other_city.id]).and_return([city, other_city])
+        expect(city).to receive(:run_chewy_callbacks).and_call_original
+        expect(other_city).to receive(:run_chewy_callbacks).and_call_original
+
+        expect do
+          ::Sidekiq::Testing.inline! do
+            Chewy::Strategy::LazySidekiq::IndicesUpdateWorker.new.perform({'City' => [city.id, other_city.id]})
+          end
+        end.to update_index(CitiesIndex).and_reindex(city, other_city).only
+      end
+
+      context 'when Chewy.disable_refresh_async is true' do
+        before do
+          allow(Chewy).to receive(:disable_refresh_async).and_return(true)
+        end
+
+        it 'calls Index#import! with refresh false' do
+          allow(City).to receive(:where).with(id: [city.id, other_city.id]).and_return([city, other_city])
+          expect(city).to receive(:run_chewy_callbacks).and_call_original
+          expect(other_city).to receive(:run_chewy_callbacks).and_call_original
+
+          expect do
+            ::Sidekiq::Testing.inline! do
+              Chewy::Strategy::LazySidekiq::IndicesUpdateWorker.new.perform({'City' => [city.id, other_city.id]})
+            end
+          end.to update_index(CitiesIndex).and_reindex(city, other_city).only.no_refresh
+        end
+      end
+    end
+
+    context 'integration' do
+      around { |example| ::Sidekiq::Testing.inline! { example.run } }
+
+      let(:update_condition) { true }
+
+      before do
+        city_model
+        country_model
+
+        City.belongs_to :country
+        Country.has_many :cities
+
+        stub_index(:cities) do
+          index_scope City
+        end
+
+        stub_index(:countries) do
+          index_scope Country
+        end
+      end
+
+      context 'state dependent' do
+        let(:city_model) do
+          stub_model(:city) do
+            update_index(-> { 'cities' }, :self)
+            update_index('countries') { changes['country_id'] || previous_changes['country_id'] || country }
+          end
+        end
+
+        let(:country_model) do
+          stub_model(:country) do
+            update_index('cities', if: -> { state_dependent_update_condition }) { cities }
+            update_index(-> { 'countries' }, :self)
+            attr_accessor :state_dependent_update_condition
+          end
+        end
+
+        context 'city updates' do
+          let!(:country1) { Country.create!(id: 1) }
+          let!(:country2) { Country.create!(id: 2) }
+          let!(:city) { City.create!(id: 1, country: country1) }
+
+          it 'does not update index of removed entity because model state on the moment of save cannot be fetched' do
+            expect { city.update!(country: nil) }.not_to update_index('countries', strategy: :lazy_sidekiq)
+          end
+          it 'does not update index of removed entity because model state on the moment of save cannot be fetched' do
+            expect { city.update!(country: country2) }.to update_index('countries', strategy: :lazy_sidekiq).and_reindex(country2).only
+          end
+        end
+
+        context 'country updates' do
+          let!(:country) do
+            cities = Array.new(2) { |i| City.create!(id: i) }
+            Country.create!(id: 1, cities: cities, state_dependent_update_condition: update_condition)
+          end
+
+          it 'does not update index because state of attribute cannot be fetched' do
+            expect { country.save! }.not_to update_index('cities', strategy: :lazy_sidekiq)
+          end
+        end
+      end
+
+      context 'state independent' do
+        let(:city_model) do
+          stub_model(:city) do
+            update_index(-> { 'cities' }, :self)
+            update_index('countries') { country }
+          end
+        end
+
+        let(:country_model) do
+          stub_model(:country) do
+            update_index('cities', if: -> { state_independent_update_condition }) { cities }
+            update_index(-> { 'countries' }, :self)
+          end
+        end
+
+        before do
+          allow_any_instance_of(Country).to receive(:state_independent_update_condition).and_return(update_condition)
+        end
+
+        context 'when city updates' do
+          let!(:country1) { Country.create!(id: 1) }
+          let!(:country2) { Country.create!(id: 2) }
+          let!(:city) { City.create!(id: 1, country: country1) }
+
+          specify { expect { city.save! }.to update_index('cities', strategy: :lazy_sidekiq).and_reindex(city).only }
+          specify { expect { city.save! }.to update_index('countries', strategy: :lazy_sidekiq).and_reindex(country1).only }
+
+          specify { expect { city.destroy }.not_to update_index('cities').and_reindex(city).only }
+          specify { expect { city.destroy }.to update_index('countries', strategy: :sidekiq).and_reindex(country1).only }
+
+          specify { expect { city.update!(country: nil) }.to update_index('cities', strategy: :lazy_sidekiq).and_reindex(city).only }
+          specify { expect { city.update!(country: country2) }.to update_index('cities', strategy: :lazy_sidekiq).and_reindex(city).only }
+        end
+
+        context 'when country updates' do
+          let!(:country) do
+            cities = Array.new(2) { |i| City.create!(id: i) }
+            Country.create!(id: 1, cities: cities)
+          end
+          specify { expect { country.save! }.to update_index('cities', strategy: :lazy_sidekiq).and_reindex(country.cities).only }
+          specify { expect { country.save! }.to update_index('countries', strategy: :lazy_sidekiq).and_reindex(country).only }
+
+          specify { expect { country.destroy }.to update_index('cities', strategy: :sidekiq).and_reindex(country.cities).only }
+          specify { expect { country.destroy }.not_to update_index('countries').and_reindex(country).only }
+
+          context 'when update condition is false' do
+            let(:update_condition) { false }
+            specify { expect { country.save! }.not_to update_index('cities', strategy: :lazy_sidekiq) }
+          end
+        end
+      end
+    end
+  end
+end

metadata

@@ -1,15 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: chewy
 version: !ruby/object:Gem::Version
-  version: 7.2.4
+  version: 7.2.5
 platform: ruby
 authors:
 - Toptal, LLC
 - pyromaniac
-autorequire:
+autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-02-03 00:00:00.000000000 Z
+date: 2022-03-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: database_cleaner
@@ -265,6 +265,8 @@ files:
 - lib/chewy/index/import/routine.rb
 - lib/chewy/index/mapping.rb
 - lib/chewy/index/observe.rb
+- lib/chewy/index/observe/active_record_methods.rb
+- lib/chewy/index/observe/callback.rb
 - lib/chewy/index/settings.rb
 - lib/chewy/index/specification.rb
 - lib/chewy/index/syncer.rb
@@ -337,8 +339,10 @@ files:
 - lib/chewy/strategy.rb
 - lib/chewy/strategy/active_job.rb
 - lib/chewy/strategy/atomic.rb
+- lib/chewy/strategy/atomic_no_refresh.rb
 - lib/chewy/strategy/base.rb
 - lib/chewy/strategy/bypass.rb
+- lib/chewy/strategy/lazy_sidekiq.rb
 - lib/chewy/strategy/sidekiq.rb
 - lib/chewy/strategy/urgent.rb
 - lib/chewy/version.rb
@@ -360,6 +364,8 @@ files:
 - spec/chewy/index/import/routine_spec.rb
 - spec/chewy/index/import_spec.rb
 - spec/chewy/index/mapping_spec.rb
+- spec/chewy/index/observe/active_record_methods_spec.rb
+- spec/chewy/index/observe/callback_spec.rb
 - spec/chewy/index/observe_spec.rb
 - spec/chewy/index/settings_spec.rb
 - spec/chewy/index/specification_spec.rb
@@ -426,7 +432,9 @@ files:
 - spec/chewy/search_spec.rb
 - spec/chewy/stash_spec.rb
 - spec/chewy/strategy/active_job_spec.rb
+- spec/chewy/strategy/atomic_no_refresh_spec.rb
 - spec/chewy/strategy/atomic_spec.rb
+- spec/chewy/strategy/lazy_sidekiq_spec.rb
 - spec/chewy/strategy/sidekiq_spec.rb
 - spec/chewy/strategy_spec.rb
 - spec/chewy_spec.rb
@@ -438,7 +446,7 @@ homepage: https://github.com/toptal/chewy
 licenses:
 - MIT
 metadata: {}
-post_install_message:
+post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -453,8 +461,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.32
-signing_key:
+rubygems_version: 3.1.6
+signing_key: 
 specification_version: 4
 summary: Elasticsearch ODM client wrapper
 test_files:
@@ -472,6 +480,8 @@ test_files:
 - spec/chewy/index/import/routine_spec.rb
 - spec/chewy/index/import_spec.rb
 - spec/chewy/index/mapping_spec.rb
+- spec/chewy/index/observe/active_record_methods_spec.rb
+- spec/chewy/index/observe/callback_spec.rb
 - spec/chewy/index/observe_spec.rb
 - spec/chewy/index/settings_spec.rb
 - spec/chewy/index/specification_spec.rb
@@ -538,7 +548,9 @@ test_files:
 - spec/chewy/search_spec.rb
 - spec/chewy/stash_spec.rb
 - spec/chewy/strategy/active_job_spec.rb
+- spec/chewy/strategy/atomic_no_refresh_spec.rb
 - spec/chewy/strategy/atomic_spec.rb
+- spec/chewy/strategy/lazy_sidekiq_spec.rb
 - spec/chewy/strategy/sidekiq_spec.rb
 - spec/chewy/strategy_spec.rb
 - spec/chewy_spec.rb