chewy 5.1.0 → 7.2.7

data/lib/chewy/search/response.rb

@@ -23,7 +23,7 @@ module Chewy
       #
       # @return [Integer]
       def total
-        @total ||= hits_root['total'] || 0
+        @total ||= hits_root.fetch('total', {}).fetch('value', 0)
       end
 
       # Response `max_score` field.
@@ -64,12 +64,12 @@ module Chewy
       end
       alias_method :aggregations, :aggs
 
-      # {Chewy::Type} wrappers collection instantiated on top of hits.
+      # {Chewy::Index} wrappers collection instantiated on top of hits.
       #
-      # @return [Array<Chewy::Type>]
+      # @return [Array<Chewy::Index>]
       def wrappers
         @wrappers ||= hits.map do |hit|
-          @loader.derive_type(hit['_index'], hit['_type']).build(hit)
+          @loader.derive_index(hit['_index']).build(hit)
         end
       end
 
@@ -102,7 +102,7 @@ module Chewy
       #   end
       # @see #wrappers
       # @see #objects
-      # @return [{Chewy::Type => Object}] a hash with wrappers as keys and ORM/ODM objects as values
+      # @return [{Chewy::Index => Object}] a hash with wrappers as keys and ORM/ODM objects as values
       def object_hash
         @object_hash ||= wrappers.zip(objects).to_h
       end

data/lib/chewy/search/scoping.rb

@@ -9,17 +9,16 @@ module Chewy
     #       query(match: {name: name})
     #     end
     #
-    #     define_type :user do
-    #       def self.by_age(age)
-    #         filter(term: {age: age})
-    #       end
+    #
+    #     def self.by_age(age)
+    #       filter(term: {age: age})
     #     end
     #   end
     #
     #   UsersIndex.limit(10).by_name('Martin')
     #   # => <UsersIndex::Query {..., :body=>{:size=>10, :query=>{:match=>{:name=>"Martin"}}}}>
-    #   UsersIndex::User.limit(10).by_name('Martin').by_age(42)
-    #   # => <UsersIndex::User::Query {..., :body=>{:size=>10, :query=>{:bool=>{
+    #   UsersIndex.limit(10).by_name('Martin').by_age(42)
+    #   # => <UsersIndex::Query {..., :body=>{:size=>10, :query=>{:bool=>{
     #   #      :must=>{:match=>{:name=>"Martin"}},
     #   #      :filter=>{:term=>{:age=>42}}}}}}>
     module Scoping
@@ -28,9 +27,9 @@ module Chewy
       module ClassMethods
         # The scopes stack.
         #
-        # @return [Array<Chewy::Search::Reques>] array of scopes
+        # @return [Array<Chewy::Search::Request>] array of scopes
         def scopes
-          Thread.current[:chewy_scopes] ||= []
+          Chewy.current[:chewy_scopes] ||= []
         end
       end
 

data/lib/chewy/search/scrolling.rb

@@ -28,19 +28,23 @@ module Chewy
         return enum_for(:scroll_batches, batch_size: batch_size, scroll: scroll) unless block_given?
 
         result = perform(size: batch_size, scroll: scroll)
-        total = [raw_limit_value, result.fetch('hits', {}).fetch('total', 0)].compact.min
+        total = [raw_limit_value, result.fetch('hits', {}).fetch('total', {}).fetch('value', 0)].compact.min
         last_batch_size = total % batch_size
         fetched = 0
+        scroll_id = nil
 
         loop do
           hits = result.fetch('hits', {}).fetch('hits', [])
           fetched += hits.size
           hits = hits.first(last_batch_size) if last_batch_size != 0 && fetched >= total
           yield(hits) if hits.present?
-          break if fetched >= total
           scroll_id = result['_scroll_id']
+          break if fetched >= total
+
           result = perform_scroll(scroll: scroll, scroll_id: scroll_id)
         end
+      ensure
+        Chewy.client.clear_scroll(body: {scroll_id: scroll_id}) if scroll_id
       end
 
       # @!method scroll_hits(batch_size: 1000, scroll: '1m')
@@ -58,17 +62,17 @@ module Chewy
       #   @example
       #     PlaceIndex.scroll_hits.map { |hit| hit['_id'] }
       #   @return [Enumerator] a standard ruby Enumerator
-      def scroll_hits(**options)
+      def scroll_hits(**options, &block)
         return enum_for(:scroll_hits, **options) unless block_given?
 
         scroll_batches(**options).each do |batch|
-          batch.each { |hit| yield hit }
+          batch.each(&block)
         end
       end
 
       # @!method scroll_wrappers(batch_size: 1000, scroll: '1m')
       # Iterates through the documents of the scope in batches. Yields
-      # each hit wrapped with {Chewy::Type}.
+      # each hit wrapped with {Chewy::Index}.
       #
       # @param batch_size [Integer] batch size obviously, replaces `size` query parameter
       # @param scroll [String] cursor expiration time
@@ -76,7 +80,7 @@ module Chewy
       # @overload scroll_wrappers(batch_size: 1000, scroll: '1m')
       #   @example
       #     PlaceIndex.scroll_wrappers { |object| p object.id }
-      #   @yieldparam object [Chewy::Type] block is executed for each hit object
+      #   @yieldparam object [Chewy::Index] block is executed for each hit object
       #
       # @overload scroll_wrappers(batch_size: 1000, scroll: '1m')
       #   @example
@@ -86,7 +90,7 @@ module Chewy
         return enum_for(:scroll_wrappers, **options) unless block_given?
 
         scroll_hits(**options).each do |hit|
-          yield loader.derive_type(hit['_index'], hit['_type']).build(hit)
+          yield loader.derive_index(hit['_index']).build(hit)
         end
       end
 
@@ -110,12 +114,12 @@ module Chewy
       #   @example
       #     PlaceIndex.scroll_objects.map { |record| record.id }
       #   @return [Enumerator] a standard ruby Enumerator
-      def scroll_objects(**options)
+      def scroll_objects(**options, &block)
         return enum_for(:scroll_objects, **options) unless block_given?
 
         except(:source, :stored_fields, :script_fields, :docvalue_fields)
           .source(false).scroll_batches(**options).each do |batch|
-            loader.load(batch).each { |object| yield object }
+            loader.load(batch).each(&block)
           end
       end
       alias_method :scroll_records, :scroll_objects
@@ -124,10 +128,9 @@ module Chewy
     private
 
       def perform_scroll(body)
-        ActiveSupport::Notifications.instrument 'search_query.chewy',
-          notification_payload(request: body) do
-            Chewy.client.scroll(body)
-          end
+        ActiveSupport::Notifications.instrument 'search_query.chewy', notification_payload(request: body) do
+          Chewy.client.scroll(body)
+        end
       end
     end
   end

data/lib/chewy/search.rb

@@ -1,5 +1,4 @@
 require 'chewy/search/scoping'
-require 'chewy/query'
 require 'chewy/search/scrolling'
 require 'chewy/search/query_proxy'
 require 'chewy/search/parameters'
@@ -7,31 +6,22 @@ require 'chewy/search/response'
 require 'chewy/search/loader'
 require 'chewy/search/request'
 require 'chewy/search/pagination/kaminari'
-require 'chewy/search/pagination/will_paginate'
 
 module Chewy
   # This module being included to any provides an interface to the
-  # request DSL. By default it is included to {Chewy::Index} and
-  # {Chewy::Type}.
+  # request DSL. By default it is included to {Chewy::Index}.
   #
   # The class used as a request DSL provider is
-  # inherited from {Chewy::Search::Request} by default, but if you
-  # need ES < 2.0 DSL support - you can switch it to {Chewy::Query}
-  # using {Chewy::Config#search_class}
+  # inherited from {Chewy::Search::Request}
   #
-  # Also, the search class is refined with one of the pagination-
-  # providing modules: {Chewy::Search::Pagination::Kaminari} or
-  # {Chewy::Search::Pagination::WillPaginate}.
+  # Also, the search class is refined with the pagination module {Chewy::Search::Pagination::Kaminari}.
   #
   # @example
   #   PlacesIndex.query(match: {name: 'Moscow'})
-  #   PlacesIndex::City.query(match: {name: 'Moscow'})
   # @see Chewy::Index
-  # @see Chewy::Type
   # @see Chewy::Search::Request
   # @see Chewy::Search::ClassMethods
   # @see Chewy::Search::Pagination::Kaminari
-  # @see Chewy::Search::Pagination::WillPaginate
   module Search
     extend ActiveSupport::Concern
 
@@ -58,16 +48,15 @@ module Chewy
       # @see https://www.elastic.co/guide/en/elasticsearch/reference/current/search-uri-request.html
       # @return [Hash] the request result
       def search_string(query, options = {})
-        options = options.merge(all.render.slice(:index, :type).merge(q: query))
+        options = options.merge(all.render.slice(:index).merge(q: query))
         Chewy.client.search(options)
       end
 
-      # Delegates methods from the request class to the index or type class
+      # Delegates methods from the request class to the index class
       #
       # @example
       #   PlacesIndex.query(match: {name: 'Moscow'})
-      #   PlacesIndex::City.query(match: {name: 'Moscow'})
-      def method_missing(name, *args, &block)
+      ruby2_keywords def method_missing(name, *args, &block)
         if search_class::DELEGATED_METHODS.include?(name)
           all.send(name, *args, &block)
         else
@@ -88,11 +77,6 @@ module Chewy
       def build_search_class(base)
         search_class = Class.new(base)
 
-        if self < Chewy::Type
-          index_scopes = index.scopes - scopes
-          delegate_scoped index, search_class, index_scopes
-        end
-
         delegate_scoped self, search_class, scopes
         const_set('Query', search_class)
       end
@@ -103,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/stash.rb

@@ -9,11 +9,9 @@ module Chewy
     class Specification < Chewy::Index
       index_name 'chewy_specifications'
 
-      define_type :specification do
-        default_import_options journal: false
+      default_import_options journal: false
 
-        field :specification, type: 'binary'
-      end
+      field :specification, type: 'binary'
     end
 
     class Journal < Chewy::Index
@@ -24,18 +22,18 @@ module Chewy
       # @param since_time [Time, DateTime] a timestamp from which we load a journal
       # @param only [Chewy::Index, Array<Chewy::Index>] journal entries related to these indices will be loaded only
       def self.entries(since_time, only: [])
-        self.for(only).filter(range: {created_at: {gt: since_time}})
+        self.for(only).filter(range: {created_at: {gt: since_time}}).filter.minimum_should_match(1)
       end
 
       # Cleans up all the journal entries until the specified time. If nothing is
       # specified - cleans up everything.
       #
-      # @param since_time [Time, DateTime] the time top boundary
+      # @param until_time [Time, DateTime] Clean everything before that date
       # @param only [Chewy::Index, Array<Chewy::Index>] indexes to clean up journal entries for
-      def self.clean(until_time = nil, only: [])
+      def self.clean(until_time = nil, only: [], delete_by_query_options: {})
         scope = self.for(only)
         scope = scope.filter(range: {created_at: {lte: until_time}}) if until_time
-        scope.delete_all
+        scope.delete_all(**delete_by_query_options)
       end
 
       # Selects all the journal entries for the specified indices.
@@ -43,35 +41,26 @@ module Chewy
       # @param indices [Chewy::Index, Array<Chewy::Index>]
       def self.for(*something)
         something = something.flatten.compact
-        types = something.flat_map { |s| Chewy.derive_types(s) }
-        return none if something.present? && types.blank?
+        indexes = something.flat_map { |s| Chewy.derive_name(s) }
+        return none if something.present? && indexes.blank?
+
         scope = all
-        types.group_by(&:index).each do |index, index_types|
-          scope = scope.or(
-            filter(term: {index_name: index.derivable_name})
-              .filter(terms: {type_name: index_types.map(&:type_name)})
-          )
+        indexes.each do |index|
+          scope = scope.or(filter(term: {index_name: index.derivable_name}))
         end
         scope
       end
 
-      define_type :journal do
-        default_import_options journal: false
+      default_import_options journal: false
 
-        field :index_name, type: 'keyword'
-        field :type_name, type: 'keyword'
-        field :action, type: 'keyword'
-        field :references, type: 'binary'
-        field :created_at, type: 'date'
-
-        def type
-          @type ||= Chewy.derive_type("#{index_name}##{type_name}")
-        end
+      field :index_name, type: 'keyword'
+      field :action, type: 'keyword'
+      field :references, type: 'binary'
+      field :created_at, type: 'date'
 
-        def references
-          @references ||= Array.wrap(@attributes['references']).map do |item|
-            JSON.load(Base64.decode64(item)) # rubocop:disable Security/JSONLoad
-          end
+      def references
+        @references ||= Array.wrap(@attributes['references']).map do |item|
+          JSON.load(Base64.decode64(item)) # rubocop:disable Security/JSONLoad
         end
       end
     end

data/lib/chewy/strategy/active_job.rb

@@ -11,11 +11,11 @@ module Chewy
     #
     class ActiveJob < Atomic
       class Worker < ::ActiveJob::Base
-        queue_as :chewy
+        queue_as { Chewy.settings.dig(:active_job, :queue) || 'chewy' }
 
         def perform(type, ids, options = {})
           options[:refresh] = !Chewy.disable_refresh_async if Chewy.disable_refresh_async
-          type.constantize.import!(ids, options)
+          type.constantize.import!(ids, **options)
         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/sidekiq.rb

@@ -15,13 +15,14 @@ module Chewy
 
         def perform(type, ids, options = {})
           options[:refresh] = !Chewy.disable_refresh_async if Chewy.disable_refresh_async
-          type.constantize.import!(ids, options)
+          type.constantize.import!(ids, **options)
         end
       end
 
       def leave
         @stash.each do |type, ids|
           next if ids.empty?
+
           ::Sidekiq::Client.push(
             'queue' => sidekiq_queue,
             'class' => Chewy::Strategy::Sidekiq::Worker,
@@ -33,7 +34,7 @@ module Chewy
     private
 
       def sidekiq_queue
-        Chewy.settings.fetch(:sidekiq, {})[:queue] || 'chewy'
+        Chewy.settings.dig(:sidekiq, :queue) || 'chewy'
       end
     end
   end

data/lib/chewy/strategy.rb

@@ -2,24 +2,12 @@ require 'chewy/strategy/base'
 require 'chewy/strategy/bypass'
 require 'chewy/strategy/urgent'
 require 'chewy/strategy/atomic'
-
-begin
-  require 'resque'
-  require 'chewy/strategy/resque'
-rescue LoadError
-  nil
-end
+require 'chewy/strategy/atomic_no_refresh'
 
 begin
   require 'sidekiq'
   require 'chewy/strategy/sidekiq'
-rescue LoadError
-  nil
-end
-
-begin
-  require 'shoryuken'
-  require 'chewy/strategy/shoryuken'
+  require 'chewy/strategy/lazy_sidekiq'
 rescue LoadError
   nil
 end
@@ -60,6 +48,7 @@ module Chewy
 
     def pop
       raise "Can't pop root strategy" if @stack.one?
+
       result = @stack.pop.tap(&:leave)
       debug "[#{@stack.size}] -> #{result.name}, now #{current.name}" if @stack.size > 1
       result
@@ -75,17 +64,14 @@ module Chewy
   private
 
     def debug(string)
-      return unless Chewy.logger && Chewy.logger.debug?
+      return unless Chewy.logger&.debug?
+
       line = caller.detect { |l| l !~ %r{lib/chewy/strategy.rb:|lib/chewy.rb:} }
       Chewy.logger.debug(["Chewy strategies stack: #{string}", line.sub(/:in\s.+$/, '')].join(' @ '))
     end
 
     def resolve(name)
       "Chewy::Strategy::#{name.to_s.camelize}".safe_constantize or raise "Can't find update strategy `#{name}`"
-    rescue NameError => ex
-      # WORKAROUND: Strange behavior of `safe_constantize` with mongoid gem
-      raise "Can't find update strategy `#{name}`" if ex.name.to_s.demodulize == name.to_s.camelize
-      raise
     end
   end
 end

data/lib/chewy/version.rb

@@ -1,3 +1,3 @@
 module Chewy
-  VERSION = '5.1.0'.freeze
+  VERSION = '7.2.7'.freeze
 end