chewy 0.10.1 → 5.0.0

data/lib/chewy/query/filters.rb

@@ -24,18 +24,20 @@ module Chewy
     # You can use logic operations <tt>&</tt> and <tt>|</tt> to concat
     # expressions.
     #
+    # @example
     #   UsersIndex.filter{ (article.title =~ /Honey/) & (age < 42) & !rate }
     #
     #
     class Filters
       def initialize(outer = nil, &block)
         @block = block
-        @outer = outer || eval('self', block.binding)
+        @outer = outer || eval('self', block.binding, __FILE__, __LINE__)
       end
 
       # Outer scope call
       # Block evaluates in the external context
       #
+      # @example
       #   def name
       #     'Friend'
       #   end
@@ -50,12 +52,14 @@ module Chewy
       # Used if method_missing is not working by some reason.
       # Additional expression options might be passed as second argument hash.
       #
+      # @example
       #   UsersIndex.filter{ f(:name) == 'Name' } == UsersIndex.filter{ name == 'Name' } # => true
       #   UsersIndex.filter{ f(:name, execution: :bool) == ['Name1', 'Name2'] } ==
       #     UsersIndex.filter{ name(execution: :bool) == ['Name1', 'Name2'] } # => true
       #
       # Supports block for getting field name from the outer scope
       #
+      # @example
       #   def field
       #     :name
       #   end
@@ -70,11 +74,13 @@ module Chewy
       # Returns script filter
       # Just script filter. Supports additional params.
       #
+      # @example
       #   UsersIndex.filter{ s('doc["num1"].value > 1') }
       #   UsersIndex.filter{ s('doc["num1"].value > param1', param1: 42) }
       #
       # Supports block for getting script from the outer scope
       #
+      # @example
       #   def script
       #     'doc["num1"].value > param1 || 1'
       #   end
@@ -90,10 +96,12 @@ module Chewy
 
       # Returns query filter
       #
+      # @example
       #   UsersIndex.filter{ q(query_string: {query: 'name: hello'}) }
       #
       # Supports block for getting query from the outer scope
       #
+      # @example
       #   def query
       #     {query_string: {query: 'name: hello'}}
       #   end
@@ -107,11 +115,13 @@ module Chewy
       # Returns raw expression
       # Same as filter with arguments instead of block, but can participate in expressions
       #
+      # @example
       #   UsersIndex.filter{ r(term: {name: 'Name'}) }
       #   UsersIndex.filter{ r(term: {name: 'Name'}) & (age < 42) }
       #
       # Supports block for getting raw filter from the outer scope
       #
+      # @example
       #   def filter
       #     {term: {name: 'Name'}}
       #   end
@@ -126,6 +136,7 @@ module Chewy
       # Bool filter chainable methods
       # Used to create bool query. Nodes are passed as arguments.
       #
+      # @example
       #   UsersIndex.filter{ must(age < 42, name == 'Name') }
       #   UsersIndex.filter{ should(age < 42, name == 'Name') }
       #   UsersIndex.filter{ must(age < 42).should(name == 'Name1', name == 'Name2') }
@@ -141,12 +152,14 @@ module Chewy
       # Chainable interface acts the same as main query interface. You can pass plain
       # filters or plain queries or filter with DSL block.
       #
+      # @example
       #   UsersIndex.filter{ has_child('user').filter(term: {role: 'Admin'}) }
       #   UsersIndex.filter{ has_child('user').filter{ role == 'Admin' } }
       #   UsersIndex.filter{ has_child('user').query(match: {name: 'borogoves'}) }
       #
       # Filters and queries might be combined and filter_mode and query_mode are configurable:
       #
+      # @example
       #   UsersIndex.filter do
       #     has_child('user')
       #       .filter{ name: 'Peter' }
@@ -155,7 +168,7 @@ module Chewy
       #       .filter_mode(:or)
       #   end
       #
-      def has_child(type) # rubocop:disable Style/PredicateName
+      def has_child(type) # rubocop:disable Naming/PredicateName
         Nodes::HasChild.new(type, @outer)
       end
 
@@ -163,12 +176,14 @@ module Chewy
       # Chainable interface acts the same as main query interface. You can pass plain
       # filters or plain queries or filter with DSL block.
       #
+      # @example
       #   UsersIndex.filter{ has_parent('user').filter(term: {role: 'Admin'}) }
       #   UsersIndex.filter{ has_parent('user').filter{ role == 'Admin' } }
       #   UsersIndex.filter{ has_parent('user').query(match: {name: 'borogoves'}) }
       #
       # Filters and queries might be combined and filter_mode and query_mode are configurable:
       #
+      # @example
       #   UsersIndex.filter do
       #     has_parent('user')
       #       .filter{ name: 'Peter' }
@@ -177,7 +192,7 @@ module Chewy
       #       .filter_mode(:or)
       #   end
       #
-      def has_parent(type) # rubocop:disable Style/PredicateName
+      def has_parent(type) # rubocop:disable Naming/PredicateName
         Nodes::HasParent.new(type, @outer)
       end
 
@@ -190,6 +205,7 @@ module Chewy
       # Creates field or exists node
       # Additional options for further expression might be passed as hash
       #
+      # @example
       #   UsersIndex.filter{ name == 'Name' } == UsersIndex.filter(term: {name: 'Name'}) # => true
       #   UsersIndex.filter{ name? } == UsersIndex.filter(exists: {term: 'name'}) # => true
       #   UsersIndex.filter{ name(execution: :bool) == ['Name1', 'Name2'] } ==
@@ -197,6 +213,7 @@ module Chewy
       #
       # Also field names might be chained to use dot-notation for ES field names
       #
+      # @example
       #   UsersIndex.filter{ article.title =~ 'Hello' }
       #   UsersIndex.filter{ article.tags? }
       #

data/lib/chewy/query/loading.rb

@@ -94,7 +94,6 @@ module Chewy
         loaded_objects = Hash[_results.group_by(&:class).map do |type, objects|
           next if except.include?(type.type_name)
           next if only.present? && !only.include?(type.type_name)
-
           loaded = type.adapter.load(objects.map(&:id), options.merge(_type: type)) || objects
           [type, loaded.index_by.with_index do |loaded_object, i|
             objects[i]._object = loaded_object

data/lib/chewy/railtie.rb

@@ -14,7 +14,7 @@ module Chewy
         if Rails.application.config.respond_to?(:assets) && env['PATH_INFO'].start_with?(Rails.application.config.assets.prefix)
           @app.call(env)
         else
-          Chewy.logger.info("Chewy request strategy is `#{Chewy.request_strategy}`") if @request_strategy != Chewy.request_strategy
+          Chewy.logger.info("Chewy request strategy is `#{Chewy.request_strategy}`") if Chewy.logger && @request_strategy != Chewy.request_strategy
           @request_strategy = Chewy.request_strategy
           Chewy.strategy(Chewy.request_strategy) { @app.call(env) }
         end
@@ -43,14 +43,12 @@ module Chewy
     end
 
     console do |app|
-      Chewy.logger = ActiveRecord::Base.logger if defined?(ActiveRecord)
-
       if app.sandbox?
         Chewy.strategy(:bypass)
       else
         Chewy.strategy(:urgent)
       end
-      Chewy.logger.info("Chewy console strategy is `#{Chewy.strategy.current.name}`")
+      puts "Chewy console strategy is `#{Chewy.strategy.current.name}`"
     end
 
     initializer 'chewy.logger', after: 'active_record.logger' do

data/lib/chewy/rake_helper.rb

@@ -1,9 +1,9 @@
 module Chewy
   module RakeHelper
-    IMPORT_CALLBACK = lambda do |output, _name, start, finish, _id, payload| # rubocop:disable Metrics/ParameterLists
+    IMPORT_CALLBACK = lambda do |output, _name, start, finish, _id, payload|
       duration = (finish - start).ceil
       stats = payload.fetch(:import, {}).map { |key, count| "#{key} #{count}" }.join(', ')
-      output.puts "  Imported #{payload[:type]} for #{human_duration(duration)}, stats: #{stats}"
+      output.puts "  Imported #{payload[:type]} in #{human_duration(duration)}, stats: #{stats}"
       if payload[:errors]
         payload[:errors].each do |action, errors|
           output.puts "    #{action.to_s.humanize} errors:"
@@ -15,7 +15,7 @@ module Chewy
       end
     end
 
-    JOURNAL_CALLBACK = lambda do |output, _, _, _, _, payload| # rubocop:disable Metrics/ParameterLists
+    JOURNAL_CALLBACK = lambda do |output, _, _, _, _, payload|
       count = payload[:groups].values.map(&:size).sum
       targets = payload[:groups].keys.sort_by(&:derivable_name)
       output.puts "  Applying journal to #{targets}, #{count} entries, stage #{payload[:stage]}"
@@ -196,12 +196,12 @@ module Chewy
       end
 
       # Eager loads and returns all the indexes defined in the application
-      # except the Chewy::Stash.
+      # except Chewy::Stash::Specification and Chewy::Stash::Journal.
       #
       # @return [Array<Chewy::Index>] indexes found
       def all_indexes
         Chewy.eager_load!
-        Chewy::Index.descendants - [Chewy::Stash]
+        Chewy::Index.descendants - [Chewy::Stash::Journal, Chewy::Stash::Specification]
       end
 
       def normalize_indexes(*identifiers)

data/lib/chewy/rspec/update_index.rb

@@ -83,9 +83,7 @@ RSpec::Matchers.define :update_index do |type_name, options = {}| # rubocop:disa
   #     .to update_index(UsersIndex.user).and_reindex(user1).only }
   #
   chain(:only) do |*_args|
-    if @reindex.blank? && @delete.blank?
-      raise 'Use `only` in conjunction with `and_reindex` or `and_delete`'
-    end
+    raise 'Use `only` in conjunction with `and_reindex` or `and_delete`' if @reindex.blank? && @delete.blank?
 
     @only = true
   end
@@ -128,13 +126,13 @@ RSpec::Matchers.define :update_index do |type_name, options = {}| # rubocop:disa
       end
     end
 
-    @reindex.each do |_, document|
+    @reindex.each_value do |document|
       document[:match_count] = (!document[:expected_count] && document[:real_count] > 0) ||
         (document[:expected_count] && document[:expected_count] == document[:real_count])
       document[:match_attributes] = document[:expected_attributes].blank? ||
         compare_attributes(document[:expected_attributes], document[:real_attributes])
     end
-    @delete.each do |_, document|
+    @delete.each_value do |document|
       document[:match_count] = (!document[:expected_count] && document[:real_count] > 0) ||
         (document[:expected_count] && document[:expected_count] == document[:real_count])
     end

data/lib/chewy/search.rb

@@ -91,12 +91,12 @@ 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
-          delegate_scoped index, self, index_scopes
         end
+
         delegate_scoped self, search_class, scopes
         const_set('Query', search_class)
       end

data/lib/chewy/search/parameters/concerns/query_storage.rb

@@ -20,16 +20,17 @@ module Chewy
         # rendering logic.
         #
         # @!attribute must
-        #   @return [Array<Hash>]
+        #   @return [Array<Hash>, Hash, nil]
         # @!attribute should
-        #   @return [Array<Hash>]
+        #   @return [Array<Hash>, Hash, nil]
         # @!attribute must_not
-        #   @return [Array<Hash>]
+        #   @return [[Array<Hash>, Hash, nil]
         # @!attribute minimum_should_match
         #   @return [String, Integer, nil]
         class Bool
           # Acceptable bool query keys
           KEYS = %i[must should must_not minimum_should_match].freeze
+          # @!ignorewarning
           attr_reader(*KEYS)
 
           # @param must [Array<Hash>, Hash, nil]

data/lib/chewy/stash.rb

@@ -1,26 +1,23 @@
 module Chewy
   # This class is the main storage for Chewy service data,
-  # Now index raw specifications are stored in the `chewy_stash`
-  # index. In the future the journal will be moved here as well.
+  # Now index raw specifications are stored in the `chewy_specifications`
+  # index.
+  # Journal entries are stored in `chewy_journal`
   #
   # @see Chewy::Index::Specification
-  class Stash < Chewy::Index
-    index_name 'chewy_stash'
+  module Stash
+    class Specification < Chewy::Index
+      index_name 'chewy_specifications'
 
-    define_type :specification do
-      default_import_options journal: false
+      define_type :specification do
+        default_import_options journal: false
 
-      field :value, index: 'no'
+        field :specification, type: 'binary'
+      end
     end
 
-    define_type :journal do # rubocop:disable Metrics/BlockLength
-      default_import_options journal: false
-
-      field :index_name, type: 'string', index: 'not_analyzed'
-      field :type_name, type: 'string', index: 'not_analyzed'
-      field :action, type: 'string', index: 'not_analyzed'
-      field :references, type: 'string', index: 'no'
-      field :created_at, type: 'date'
+    class Journal < Chewy::Index
+      index_name 'chewy_journal'
 
       # Loads all entries since the specified time.
       #
@@ -52,18 +49,30 @@ module Chewy
         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)})
+              .filter(terms: {type_name: index_types.map(&:type_name)})
           )
         end
         scope
       end
 
-      def type
-        @type ||= Chewy.derive_type("#{index_name}##{type_name}")
-      end
+      define_type :journal do
+        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 references
-        @references ||= Array.wrap(@attributes['references']).map { |r| JSON.load(r) } # rubocop:disable Security/JSONLoad
+        def type
+          @type ||= Chewy.derive_type("#{index_name}##{type_name}")
+        end
+
+        def references
+          @references ||= Array.wrap(@attributes['references']).map do |item|
+            JSON.load(Base64.decode64(item)) # rubocop:disable Security/JSONLoad
+          end
+        end
       end
     end
   end

data/lib/chewy/strategy/atomic.rb

@@ -18,7 +18,7 @@ module Chewy
 
       def update(type, objects, _options = {})
         @stash[type] ||= []
-        @stash[type] |= type.send(:build_root).id ? Array.wrap(objects) : type.adapter.identify(objects)
+        @stash[type] |= type.root.id ? Array.wrap(objects) : type.adapter.identify(objects)
       end
 
       def leave

data/lib/chewy/type.rb

@@ -14,7 +14,7 @@ require 'chewy/type/witchcraft'
 
 module Chewy
   class Type
-    IMPORT_OPTIONS_KEYS = %i[batch_size bulk_size refresh consistency replication raw_import journal].freeze
+    IMPORT_OPTIONS_KEYS = %i[batch_size bulk_size refresh consistency replication raw_import journal pipeline].freeze
 
     include Search
     include Mapping
@@ -34,7 +34,7 @@ module Chewy
       # Chewy index current type belongs to. Defined inside `Chewy.create_type`
       #
       def index
-        raise NotImplementedError, 'Looks like this type ws defined outside the index scope and `.index` method is undefined for it'
+        raise NotImplementedError, 'Looks like this type was defined outside the index scope and `.index` method is undefined for it'
       end
 
       # Current type adapter. Defined inside `Chewy.create_type`, derived from

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

@@ -41,19 +41,19 @@ module Chewy
         #
         #   { delete: [object_or_id1, object_or_id2], index: [object3, object4, object5] }
         #
-        # @yield batch [Array<Object>] each batch of objects
+        # @yieldparam _batch [Array<Object>] each batch of objects
         # @return [true, false] returns true if all the block call returns true and false otherwise
-        def import(*_args, &_block)
+        def import(_batch, &_block)
           raise NotImplementedError
         end
 
         # Unlike {#import} fetches only ids (references) to the imported objects,
         # using the same procedures as {#import}.
         #
-        # @param fields [Array<Symbol>] additional fields to fetch
-        # @param batch_size [Integer] batch size, defaults to 1000
-        # @yield batch [Array<Object>] each batch of objects
-        def import_fields(*_args, &_block)
+        # @param _fields [Array<Symbol>] additional fields to fetch
+        # @param _batch_size [Integer] batch size, defaults to 1000
+        # @yieldparam batch [Array<Object>] each batch of objects
+        def import_fields(_fields, _batch_size, &_block)
           raise NotImplementedError
         end
 
@@ -61,9 +61,9 @@ module Chewy
         # an array of references to the passed objects. Returns ids if possible.
         # Otherwise - and array of objects themselves.
         #
-        # @param batch_size [Integer] batch size, defaults to 1000
-        # @yield batch [Array<Object>] each batch of objects
-        def import_references(*_args, &_block)
+        # @param _batch_size [Integer] batch size, defaults to 1000
+        # @yieldparam batch [Array<Object>] each batch of objects
+        def import_references(_batch_size, &_block)
           raise NotImplementedError
         end
 

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

@@ -17,9 +17,7 @@ module Chewy
       private
 
         def cleanup_default_scope!
-          if Chewy.logger && @default_scope.options.values_at(:sort, :limit, :skip).compact.present?
-            Chewy.logger.warn('Default type scope order, limit and offset are ignored and will be nullified')
-          end
+          Chewy.logger.warn('Default type scope order, limit and offset are ignored and will be nullified') if Chewy.logger && @default_scope.options.values_at(:sort, :limit, :skip).compact.present?
 
           @default_scope.options.delete(:limit)
           @default_scope.options.delete(:skip)

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

@@ -16,9 +16,7 @@ module Chewy
       private
 
         def cleanup_default_scope!
-          if Chewy.logger && @default_scope != @default_scope.unordered.unlimited
-            Chewy.logger.warn('Default type scope order, limit and offset are ignored and will be nullified')
-          end
+          Chewy.logger.warn('Default type scope order, limit and offset are ignored and will be nullified') if Chewy.logger && @default_scope != @default_scope.unordered.unlimited
 
           @default_scope = @default_scope.unordered.unlimited
         end
@@ -34,7 +32,7 @@ module Chewy
         end
 
         def full_column_name(column)
-          "#{target.table_name}__#{column}".to_sym
+          ::Sequel.qualify(target.table_name, column)
         end
 
         def all_scope
@@ -55,7 +53,7 @@ module Chewy
         def pluck_in_batches(scope, fields: [], batch_size: nil, **options)
           return enum_for(:pluck_in_batches, scope, fields: fields, batch_size: batch_size, **options) unless block_given?
 
-          scope = scope.unordered.order(::Sequel.asc(full_column_name(primary_key))).limit(batch_size)
+          scope = scope.unordered.order(full_column_name(primary_key).asc).limit(batch_size)
 
           ids = pluck(scope, fields: fields)
           count = 0
@@ -64,7 +62,7 @@ module Chewy
             yield ids
             break if ids.size < batch_size
             last_id = ids.last.is_a?(Array) ? ids.last.first : ids.last
-            ids = pluck(scope.where { |o| o.__send__(full_column_name(primary_key)) > last_id }, fields: fields)
+            ids = pluck(scope.where { |_o| full_column_name(primary_key) > last_id }, fields: fields)
           end
 
           count