chewy 0.8.4 → 0.9.0

data/lib/chewy/repository.rb

@@ -5,10 +5,10 @@ module Chewy
     attr_reader :analyzers, :tokenizers, :filters, :char_filters
 
     def self.delegated
-      public_instance_methods - self.superclass.public_instance_methods - Singleton.public_instance_methods
+      public_instance_methods - superclass.public_instance_methods - Singleton.public_instance_methods
     end
 
-    def self.repository name
+    def self.repository(name)
       plural_name = name.to_s.pluralize
 
       class_eval <<-METHOD, __FILE__, __LINE__ + 1

data/lib/chewy/rspec.rb

@@ -1 +1 @@
-require 'chewy/rspec/update_index'
+require 'chewy/rspec/update_index'

data/lib/chewy/rspec/update_index.rb

@@ -20,11 +20,10 @@ require 'i18n/core_ext/hash'
 #   specify { expect { user1.destroy!; user2.save! } }
 #     .to update_index(UsersIndex::User).and_reindex(user2).and_delete(user1) }
 #
-RSpec::Matchers.define :update_index do |type_name, options = {}|
-
+RSpec::Matchers.define :update_index do |type_name, options = {}| # rubocop:disable BlockLength
   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
+    alias_method :failure_message, :failure_message_for_should
+    alias_method :failure_message_when_negated, :failure_message_for_should_not
   end
 
   # Specify indexed records by passing record itself or id.
@@ -83,7 +82,11 @@ RSpec::Matchers.define :update_index do |type_name, options = {}|
   #   specify { expect { [user1, user2].map(&:save!) }
   #     .to update_index(UsersIndex.user).and_reindex(user1).only }
   #
-  chain(:only) do |*args|
+  chain(:only) do |*_args|
+    if @reindex.blank? && @delete.blank?
+      raise 'Use `only` in conjunction with `and_reindex` or `and_delete`'
+    end
+
     @only = true
   end
 
@@ -91,17 +94,16 @@ RSpec::Matchers.define :update_index do |type_name, options = {}|
     true
   end
 
-  match do |block|
+  match do |block| # rubocop:disable BlockLength
     @reindex ||= {}
     @delete ||= {}
     @missed_reindex = []
     @missed_delete = []
     @updated = []
 
-    type = Chewy.derive_type(type_name)
-
     instance_eval <<-RUBY, __FILE__, __LINE__ + 1
-       #{agnostic_stub} do |bulk_options|
+      type = Chewy.derive_type(type_name)
+      #{agnostic_stub} do |bulk_options|
         @updated += bulk_options[:body].map do |updated_document|
           updated_document.deep_symbolize_keys
         end
@@ -113,18 +115,18 @@ RSpec::Matchers.define :update_index do |type_name, options = {}|
     Chewy.strategy(options[:strategy] || :atomic) { block.call }
 
     @updated.each do |updated_document|
-      if body = updated_document[:index]
-        if document = @reindex[body[:_id].to_s]
+      if (body = updated_document[:index])
+        if (document = @reindex[body[:_id].to_s])
           document[:real_count] += 1
           document[:real_attributes].merge!(body[:data])
-        else
-          @missed_reindex.push(body[:_id].to_s) if @only
+        elsif @only
+          @missed_reindex.push(body[:_id].to_s)
         end
-      elsif body = updated_document[:delete]
-        if document = @delete[body[:_id].to_s]
+      elsif (body = updated_document[:delete])
+        if (document = @delete[body[:_id].to_s])
           document[:real_count] += 1
-        else
-          @missed_delete.push(body[:_id].to_s) if @only
+        elsif @only
+          @missed_delete.push(body[:_id].to_s)
         end
       end
     end
@@ -141,11 +143,11 @@ RSpec::Matchers.define :update_index do |type_name, options = {}|
     end
 
     @updated.present? && @missed_reindex.none? && @missed_delete.none? &&
-    @reindex.all? { |_, document| document[:match_count] && document[:match_attributes] } &&
-    @delete.all? { |_, document| document[:match_count] }
+      @reindex.all? { |_, document| document[:match_count] && document[:match_attributes] } &&
+      @delete.all? { |_, document| document[:match_count] }
   end
 
-  failure_message do
+  failure_message do # rubocop:disable BlockLength
     output = ''
 
     if @updated.none?
@@ -166,28 +168,28 @@ RSpec::Matchers.define :update_index do |type_name, options = {}|
       output << message
     end
 
-    output << @reindex.each.with_object('') do |(id, document), output|
+    output << @reindex.each.with_object('') do |(id, document), result|
       unless document[:match_count] && document[:match_attributes]
-        output << "Expected document with id `#{id}` to be reindexed"
+        result << "Expected document with id `#{id}` to be reindexed"
         if document[:real_count] > 0
-          output << "\n   #{document[:expected_count]} times, but was reindexed #{document[:real_count]} times" if document[:expected_count] && !document[:match_count]
-          output << "\n   with #{document[:expected_attributes]}, but it was reindexed with #{document[:real_attributes]}" if document[:expected_attributes].present? && !document[:match_attributes]
+          result << "\n   #{document[:expected_count]} times, but was reindexed #{document[:real_count]} times" if document[:expected_count] && !document[:match_count]
+          result << "\n   with #{document[:expected_attributes]}, but it was reindexed with #{document[:real_attributes]}" if document[:expected_attributes].present? && !document[:match_attributes]
         else
-          output << ", but it was not"
+          result << ', but it was not'
         end
-        output << "\n"
+        result << "\n"
       end
     end
 
-    output << @delete.each.with_object('') do |(id, document), output|
+    output << @delete.each.with_object('') do |(id, document), result|
       unless document[:match_count]
-        output << "Expected document with id `#{id}` to be deleted"
-        if document[:real_count] > 0 && document[:expected_count] && !document[:match_count]
-          output << "\n   #{document[:expected_count]} times, but was deleted #{document[:real_count]} times"
-        else
-          output << ", but it was not"
-        end
-        output << "\n"
+        result << "Expected document with id `#{id}` to be deleted"
+        result << if document[:real_count] > 0 && document[:expected_count]
+                    "\n   #{document[:expected_count]} times, but was deleted #{document[:real_count]} times"
+                  else
+                    ', but it was not'
+                  end
+        result << "\n"
       end
     end
 
@@ -196,23 +198,21 @@ RSpec::Matchers.define :update_index do |type_name, options = {}|
 
   failure_message_when_negated do
     if @updated.present?
-      "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|
-          "\n  document id `#{id}` (#{documents.count} times)"
-        end.join
-      }\n"
+      "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|
+                                                                            "\n  document id `#{id}` (#{documents.count} times)"
+                                                                          end.join}\n"
     end
   end
 
   def agnostic_stub
     if defined?(Mocha) && RSpec.configuration.mock_framework.to_s == 'RSpec::Core::MockingAdapters::Mocha'
-      "type.stubs(:bulk).with"
+      'type.stubs(:bulk).with'
     else
-      "allow(type).to receive(:bulk)"
+      'allow(type).to receive(:bulk)'
     end
   end
 
-  def extract_documents *args
+  def extract_documents(*args)
     options = args.extract_options!
 
     expected_count = options[:times] || options[:count]
@@ -230,7 +230,7 @@ RSpec::Matchers.define :update_index do |type_name, options = {}|
     end]
   end
 
-  def compare_attributes expected, real
+  def compare_attributes(expected, real)
     expected.inject(true) do |result, (key, value)|
       equal = if value.is_a?(Array) && real[key].is_a?(Array)
         array_difference(value, real[key]) && array_difference(real[key], value)
@@ -243,12 +243,11 @@ RSpec::Matchers.define :update_index do |type_name, options = {}|
     end
   end
 
-  def array_difference first, second
+  def array_difference(first, second)
     difference = first.to_ary.dup
     second.to_ary.each do |element|
-      if index = difference.index(element)
-        difference.delete_at(index)
-      end
+      index = difference.index(element)
+      difference.delete_at(index) if index
     end
     difference.none?
   end

data/lib/chewy/runtime/version.rb

@@ -4,21 +4,21 @@ module Chewy
       include Comparable
       attr_reader :major, :minor, :patch
 
-      def initialize version
-        @major, @minor, @patch = *(version.to_s.split('.', 3) + [0]*3).first(3).map(&:to_i)
+      def initialize(version)
+        @major, @minor, @patch = *(version.to_s.split('.', 3) + [0] * 3).first(3).map(&:to_i)
       end
 
       def to_s
         [major, minor, patch].join('.')
       end
 
-      def <=> other
+      def <=>(other)
         other = self.class.new(other) unless other.is_a?(self.class)
         [
           major <=> other.major,
           minor <=> other.minor,
           patch <=> other.patch
-        ].detect { |c| c != 0 } || 0
+        ].detect(&:nonzero?) || 0
       end
     end
   end

data/lib/chewy/search.rb

@@ -7,10 +7,11 @@ module Chewy
     included do
       singleton_class.delegate :explain, :query_mode, :filter_mode, :post_filter_mode,
         :timeout, :limit, :offset, :highlight, :min_score, :rescore, :facets, :script_score,
-        :boost_factor, :random_score, :field_value_factor, :decay, :aggregations,
+        :boost_factor, :weight, :random_score, :field_value_factor, :decay, :aggregations,
         :suggest, :none, :strategy, :query, :filter, :post_filter, :boost_mode,
         :score_mode, :order, :reorder, :only, :types, :delete_all, :find, :total,
-        :total_count, :total_entries, to: :all
+        :total_count, :total_entries, :unlimited, :script_fields, :track_scores, :preference,
+        to: :all
     end
 
     module ClassMethods
@@ -18,11 +19,12 @@ module Chewy
         query_class.scopes.last || query_class.new(self)
       end
 
-      def search_string query, options = {}
+      def search_string(query, options = {})
         options = options.merge(
           index: all._indexes.map(&:index_name),
           type: all._types.map(&:type_name),
-          q: query)
+          q: query
+        )
         Chewy.client.search(options)
       end
 
@@ -42,7 +44,7 @@ module Chewy
         end
       end
 
-      def delegate_scoped source, destination, methods
+      def delegate_scoped(source, destination, methods)
         methods.each do |method|
           destination.class_eval do
             define_method method do |*args, &block|

data/lib/chewy/strategy.rb

@@ -7,18 +7,21 @@ begin
   require 'resque'
   require 'chewy/strategy/resque'
 rescue LoadError
+  nil
 end
 
 begin
   require 'sidekiq'
   require 'chewy/strategy/sidekiq'
 rescue LoadError
+  nil
 end
 
 begin
   require 'active_job'
   require 'chewy/strategy/active_job'
 rescue LoadError
+  nil
 end
 
 module Chewy
@@ -42,7 +45,7 @@ module Chewy
       @stack.last
     end
 
-    def push name
+    def push(name)
       result = @stack.push resolve(name).new
       debug "[#{@stack.size}] <- #{current.name}"
       result
@@ -55,7 +58,7 @@ module Chewy
       result
     end
 
-    def wrap name
+    def wrap(name)
       stack = push(name)
       yield
     ensure
@@ -64,14 +67,13 @@ module Chewy
 
   private
 
-    def debug string
-      if Chewy.logger && Chewy.logger.debug?
-        line = caller.detect { |line| line !~ %r{lib/chewy/strategy.rb:|lib/chewy.rb:} }
-        Chewy.logger.debug(["DEBUG: Chewy strategies stack: #{string}", line.sub(/:in\s.+$/, '')].join(' @ '))
-      end
+    def debug(string)
+      return unless Chewy.logger && Chewy.logger.debug?
+      line = caller.detect { |l| l !~ %r{lib/chewy/strategy.rb:|lib/chewy.rb:} }
+      Chewy.logger.debug(["DEBUG: Chewy strategies stack: #{string}", line.sub(/:in\s.+$/, '')].join(' @ '))
     end
 
-    def resolve name
+    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

data/lib/chewy/strategy/atomic.rb

@@ -16,8 +16,8 @@ module Chewy
         @stash = {}
       end
 
-      def update type, objects, options = {}
-        ActiveSupport::Deprecation.warn("`urgent: true` option is deprecated and is not effective inside `:atomic` strategy, use `Chewy.strategy(:urgent)` strategy instead") if options.key?(:urgent)
+      def update(type, objects, options = {})
+        ActiveSupport::Deprecation.warn('`urgent: true` option is deprecated and is not effective inside `:atomic` strategy, use `Chewy.strategy(:urgent)` strategy instead') if options.key?(:urgent)
 
         @stash[type] ||= []
         @stash[type] |= type.send(:build_root).id ? Array.wrap(objects) : type.adapter.identify(objects)

data/lib/chewy/strategy/base.rb

@@ -11,17 +11,17 @@ module Chewy
       def name
         self.class.name.demodulize.underscore.to_sym
       end
+
       # This method called when some model tries to update index
       #
-      def update type, objects, options = {}
-        raise UndefinedUpdateStrategy.new(type)
+      def update(type, _objects, _options = {})
+        raise UndefinedUpdateStrategy, type
       end
 
       # This method called when strategy pops from the
       # strategies stack
       #
-      def leave
-      end
+      def leave; end
     end
   end
 end

data/lib/chewy/strategy/bypass.rb

@@ -8,8 +8,7 @@ module Chewy
     #   end
     #
     class Bypass < Base
-      def update type, objects, options = {}
-      end
+      def update(type, objects, options = {}); end
     end
   end
 end

data/lib/chewy/strategy/sidekiq.rb

@@ -13,6 +13,8 @@ module Chewy
       class Worker
         include ::Sidekiq::Worker
 
+        sidekiq_options queue: :chewy
+
         def perform(type, ids, options = {})
           type.constantize.import!(ids, options)
         end

data/lib/chewy/strategy/urgent.rb

@@ -9,7 +9,7 @@ module Chewy
     #   end
     #
     class Urgent < Base
-      def update type, objects, options = {}
+      def update(type, objects, _options = {})
         type.import!(Array.wrap(objects))
       end
     end

data/lib/chewy/type.rb

@@ -13,7 +13,7 @@ require 'chewy/type/adapter/sequel'
 
 module Chewy
   class Type
-    IMPORT_OPTIONS_KEYS = [:batch_size, :bulk_size, :refresh, :consistency, :replication]
+    IMPORT_OPTIONS_KEYS = [:batch_size, :bulk_size, :refresh, :consistency, :replication, :raw_import, :journal].freeze
 
     include Search
     include Mapping
@@ -24,66 +24,72 @@ module Chewy
     include Witchcraft
     include Import
 
-    singleton_class.delegate :index_name, :client, to: :index
+    singleton_class.delegate :index_name, :_index_name, :derivable_index_name, :client, to: :index
 
     class_attribute :_default_import_options
     self._default_import_options = {}
 
-    # Chewy index current type belongs to. Defined inside `Chewy.create_type`
-    #
-    def self.index
-      raise NotImplementedError
-    end
+    class << self
+      # Chewy index current type belongs to. Defined inside `Chewy.create_type`
+      #
+      def index
+        raise NotImplementedError
+      end
 
-    # Current type adapter. Defined inside `Chewy.create_type`, derived from
-    # `Chewy::Index.define_type` arguments.
-    #
-    def self.adapter
-      raise NotImplementedError
-    end
+      # Current type adapter. Defined inside `Chewy.create_type`, derived from
+      # `Chewy::Index.define_type` arguments.
+      #
+      def adapter
+        raise NotImplementedError
+      end
 
-    # Returns type name string
-    #
-    def self.type_name
-      adapter.type_name
-    end
+      # Returns type name string
+      #
+      def type_name
+        adapter.type_name
+      end
 
-    # Returns list of public class methods defined in current type
-    #
-    def self.scopes
-      public_methods - Chewy::Type.public_methods
-    end
+      # Returns list of public class methods defined in current type
+      #
+      def scopes
+        public_methods - Chewy::Type.public_methods
+      end
 
-    def self.default_import_options(params)
-      params.assert_valid_keys(IMPORT_OPTIONS_KEYS)
-      self._default_import_options = _default_import_options.merge(params)
-    end
+      def default_import_options(params)
+        params.assert_valid_keys(IMPORT_OPTIONS_KEYS)
+        self._default_import_options = _default_import_options.merge(params)
+      end
 
-    def self.method_missing(method, *args, &block)
-      if index.scopes.include?(method)
-        define_singleton_method method do |*args, &block|
-          all.scoping { index.public_send(method, *args, &block) }
+      def method_missing(method, *args, &block)
+        if index.scopes.include?(method)
+          define_singleton_method method do |*method_args, &method_block|
+            all.scoping { index.public_send(method, *method_args, &method_block) }
+          end
+          send(method, *args, &block)
+        else
+          super
         end
-        send(method, *args, &block)
-      else
-        super
       end
-    end
 
-    def self.const_missing(name)
-      to_resolve = "#{self.to_s}::#{name}"
-      to_resolve[index.to_s] = ''
+      def respond_to_missing?(method, _)
+        index.scopes.include?(method) || super
+      end
+
+      def const_missing(name)
+        to_resolve = "#{self}::#{name}"
+        to_resolve[index.to_s] = ''
 
-      @__resolved_constants ||= {}
+        @__resolved_constants ||= {}
 
-      if to_resolve.empty? || @__resolved_constants[to_resolve]
+        if to_resolve.empty? || @__resolved_constants[to_resolve]
+          super
+        else
+          @__resolved_constants[to_resolve] = true
+          to_resolve.constantize
+        end
+      rescue NotImplementedError
         super
-      else
-        @__resolved_constants[to_resolve] = true
-        to_resolve.constantize
       end
-    rescue NotImplementedError
-      super
     end
   end
 end