chewy 7.1.0 → 7.2.0

data/lib/chewy/index.rb

@@ -1,23 +1,48 @@
 require 'chewy/search'
 require 'chewy/index/actions'
+require 'chewy/index/adapter/active_record'
+require 'chewy/index/adapter/object'
 require 'chewy/index/aliases'
+require 'chewy/index/crutch'
+require 'chewy/index/import'
+require 'chewy/index/mapping'
+require 'chewy/index/observe'
 require 'chewy/index/settings'
 require 'chewy/index/specification'
+require 'chewy/index/syncer'
+require 'chewy/index/witchcraft'
+require 'chewy/index/wrapper'
 
 module Chewy
   class Index
+    IMPORT_OPTIONS_KEYS = %i[
+      batch_size bulk_size consistency direct_import journal
+      pipeline raw_import refresh replication
+    ].freeze
+
     include Search
     include Actions
     include Aliases
+    include Import
+    include Mapping
+    include Observe
+    include Crutch
+    include Witchcraft
+    include Wrapper
 
     singleton_class.delegate :client, to: 'Chewy'
 
-    class_attribute :type_hash
-    self.type_hash = {}
+    class_attribute :adapter
+    self.adapter = Chewy::Index::Adapter::Object.new(:default)
+
+    class_attribute :index_scope_defined
 
     class_attribute :_settings
     self._settings = Chewy::Index::Settings.new
 
+    class_attribute :_default_import_options
+    self._default_import_options = {}
+
     class << self
       # @overload index_name(suggest)
       #   If suggested name is passed, it is set up as the new base name for
@@ -47,7 +72,8 @@ module Chewy
       #     UsersIndex.index_name(prefix: '', suffix: '2017') # => 'users_2017'
       #
       #   @param prefix [String] index name prefix, uses {.prefix} method by default
-      #   @param suffix [String] index name suffix, used for creating several indexes for the same alias during the zero-downtime reset
+      #   @param suffix [String] index name suffix, used for creating several indexes for the same
+      #     alias during the zero-downtime reset
       #   @raise [UndefinedIndex] if the base name is blank
       #   @return [String] result index name
       def index_name(suggest = nil, prefix: nil, suffix: nil)
@@ -55,7 +81,7 @@ module Chewy
           @base_name = suggest.to_s.presence
         else
           [
-            prefix || prefix_with_deprecation,
+            prefix || self.prefix,
             base_name,
             suffix
           ].reject(&:blank?).join('_')
@@ -77,6 +103,7 @@ module Chewy
       def base_name
         @base_name ||= name.sub(/Index\z/, '').demodulize.underscore if name
         raise UndefinedIndex if @base_name.blank?
+
         @base_name
       end
 
@@ -111,69 +138,30 @@ module Chewy
         Chewy.configuration[:prefix]
       end
 
-      # Defines type for the index. Arguments depends on adapter used. For
+      # Defines scope and options for the index. Arguments depends on adapter used. For
       # ActiveRecord you can pass model or scope and options
       #
       #   class CarsIndex < Chewy::Index
-      #     define_type Car do
-      #       ...
-      #     end # defines VehiclesIndex::Car type
-      #   end
-      #
-      # Type name might be passed in complicated cases:
-      #
-      #   class VehiclesIndex < Chewy::Index
-      #     define_type Vehicle.cars.includes(:manufacturer), name: 'cars' do
-      #        ...
-      #     end # defines VehiclesIndex::Cars type
-      #
-      #     define_type Vehicle.motocycles.includes(:manufacturer), name: 'motocycles' do
-      #        ...
-      #     end # defines VehiclesIndex::Motocycles type
+      #     index_scope Car
+      #     ...
       #   end
       #
-      # For plain objects:
+      # For plain objects you can completely omit this directive, unless you need to specify some options:
       #
       #   class PlanesIndex < Chewy::Index
-      #     define_type :plane do
-      #       ...
-      #     end # defines PlanesIndex::Plane type
+      #     ...
       #   end
       #
       # The main difference between using plain objects or ActiveRecord models for indexing
-      # is import. If you will call `CarsIndex::Car.import` - it will import all the cars
-      # automatically, while `PlanesIndex::Plane.import(my_planes)` requires import data to be
+      # is import. If you will call `CarsIndex.import` - it will import all the cars
+      # automatically, while `PlanesIndex.import(my_planes)` requires import data to be
       # passed.
       #
-      def define_type(target, options = {}, &block)
-        raise 'Multiple types are deprecated' if type_hash.present?
-
-        type_class = Chewy.create_type(self, target, options, &block)
-        self.type_hash = type_hash.merge(type_class.type_name => type_class)
-      end
-
-      # Returns defined type:
-      #
-      #   UsersIndex.types # => [UsersIndex::User]
-      #
-      def types
-        type_hash.values
-      end
-
-      # Returns defined types names:
-      #
-      #   UsersIndex.type_names # => ['admin', 'manager', 'user']
-      #
-      def type_names
-        type_hash.keys
-      end
+      def index_scope(target, options = {})
+        raise 'Index scope is already defined' if index_scope_defined?
 
-      # Returns named type:
-      #
-      #    UserIndex.type('admin') # => UsersIndex::Admin
-      #
-      def type(type_name)
-        type_hash.fetch(type_name) { raise UndefinedType, "Unknown type in #{name}: #{type_name}" }
+        self.adapter = Chewy.adapters.find { |klass| klass.accepts?(target) }.new(target, **options)
+        self.index_scope_defined = true
       end
 
       # Used as a part of index definition DSL. Defines settings:
@@ -210,7 +198,7 @@ module Chewy
       end
 
       def mappings_hash
-        mappings = types.map(&:mappings_hash).inject(:merge)
+        mappings = root.mappings_hash
         mappings.present? ? {mappings: mappings} : {}
       end
 
@@ -223,44 +211,15 @@ module Chewy
         [settings_hash, mappings_hash].inject(:merge)
       end
 
-      def index_params
-        ActiveSupport::Deprecation.warn '`Chewy::Index.index_params` is deprecated and will be removed soon, use `Chewy::Index.specification_hash`'
-        specification_hash
-      end
-
       # @see Chewy::Index::Specification
       # @return [Chewy::Index::Specification] a specification object instance for this particular index
       def specification
         @specification ||= Specification.new(self)
       end
 
-      def derivable_index_name
-        ActiveSupport::Deprecation.warn '`Chewy::Index.derivable_index_name` is deprecated and will be removed soon, use `Chewy::Index.derivable_name` instead'
-        derivable_name
-      end
-
-      # Handling old default_prefix if it is not defined.
-      def method_missing(name, *args, &block) # rubocop:disable Style/MethodMissing
-        if name == :default_prefix
-          ActiveSupport::Deprecation.warn '`Chewy::Index.default_prefix` is deprecated and will be removed soon, use `Chewy::Index.prefix` instead'
-          prefix
-        else
-          super
-        end
-      end
-
-      def prefix_with_deprecation
-        if respond_to?(:default_prefix)
-          ActiveSupport::Deprecation.warn '`Chewy::Index.default_prefix` is deprecated and will be removed soon, define `Chewy::Index.prefix` method instead'
-          default_prefix
-        else
-          prefix
-        end
-      end
-
-      def build_index_name(*args)
-        ActiveSupport::Deprecation.warn '`Chewy::Index.build_index_name` is deprecated and will be removed soon, use `Chewy::Index.index_name` instead'
-        index_name(args.extract_options!)
+      def default_import_options(params)
+        params.assert_valid_keys(IMPORT_OPTIONS_KEYS)
+        self._default_import_options = _default_import_options.merge(params)
       end
     end
   end

data/lib/chewy/index/actions.rb

@@ -129,37 +129,6 @@ module Chewy
           create! suffix
         end
 
-        # Perform import operation for every defined type
-        #
-        #   UsersIndex.import                           # imports default data for every index type
-        #   UsersIndex.import user: User.active         # imports specified objects for user type and default data for other types
-        #   UsersIndex.import refresh: false            # to disable index refreshing after import
-        #   UsersIndex.import suffix: Time.now.to_i     # imports data to index with specified suffix if such is exists
-        #   UsersIndex.import batch_size: 300           # import batch size
-        #
-        # See [import.rb](lib/chewy/type/import.rb) for more details.
-        #
-        %i[import import!].each do |method|
-          class_eval <<-METHOD, __FILE__, __LINE__ + 1
-            def #{method}(*args)
-              return true if args.first.blank? && !args.first.nil?
-
-              options = args.extract_options!
-              if args.one? && type_names.one?
-                objects = {type_names.first.to_sym => args.first}
-              elsif args.one?
-                fail ArgumentError, "Please pass objects for `#{method}` as a hash with type names"
-              else
-                objects = options.reject { |k, v| !type_names.map(&:to_sym).include?(k) }
-              end
-              types.map do |type|
-                args = [objects[type.type_name.to_sym], options.dup].reject(&:blank?)
-                type.#{method} *args
-              end.all?
-            end
-          METHOD
-        end
-
         # Deletes, creates and imports data to the index. Returns the
         # import result. If index name suffix is passed as the first
         # argument - performs zero-downtime index resetting.
@@ -187,7 +156,11 @@ module Chewy
             suffixed_name = index_name(suffix: suffix)
 
             optimize_index_settings suffixed_name
-            result = import import_options.merge(suffix: suffix, journal: journal, refresh: !Chewy.reset_disable_refresh_interval)
+            result = import import_options.merge(
+              suffix: suffix,
+              journal: journal,
+              refresh: !Chewy.reset_disable_refresh_interval
+            )
             original_index_settings suffixed_name
 
             delete if indexes.blank?
@@ -209,6 +182,7 @@ module Chewy
           specification.lock!
           result
         end
+        alias_method :reset, :reset!
 
         # A {Chewy::Journal} instance for the particular index
         #
@@ -217,6 +191,50 @@ module Chewy
           @journal ||= Chewy::Journal.new(self)
         end
 
+        def clear_cache(args = {index: index_name})
+          client.indices.clear_cache(args)
+        end
+
+        def reindex(source: index_name, dest: index_name)
+          client.reindex(
+            {
+              body:
+                {
+                  source: {index: source},
+                  dest: {index: dest}
+                }
+            }
+          )
+        end
+
+        # Adds new fields to an existing data stream or index.
+        # Change the search settings of existing fields.
+        #
+        # @example
+        #   Chewy.client.update_mapping('cities', {properties: {new_field: {type: :text}}})
+        #
+        def update_mapping(name = index_name, body = root.mappings_hash)
+          client.indices.put_mapping(
+            index: name,
+            body: body
+          )['acknowledged']
+        end
+
+        # Performs missing and outdated objects synchronization for the current index.
+        #
+        # @example
+        #   UsersIndex.sync
+        #
+        # @see Chewy::Index::Syncer
+        # @param parallel [true, Integer, Hash] options for parallel execution or the number of processes
+        # @return [Hash{Symbol, Object}, nil] a number of missing and outdated documents re-indexed and their ids,
+        #   nil in case of errors
+        def sync(parallel: nil)
+          syncer = Syncer.new(self, parallel: parallel)
+          count = syncer.perform
+          {count: count, missing: syncer.missing_ids, outdated: syncer.outdated_ids} if count
+        end
+
       private
 
         def optimize_index_settings(index_name)
@@ -242,6 +260,7 @@ module Chewy
 
         def index_settings(setting_name)
           return {} unless settings_hash.key?(:settings) && settings_hash[:settings].key?(:index)
+
           settings_hash[:settings][:index].slice(setting_name)
         end
       end

data/lib/chewy/{type → index}/adapter/active_record.rb

@@ -1,7 +1,7 @@
-require 'chewy/type/adapter/orm'
+require 'chewy/index/adapter/orm'
 
 module Chewy
-  class Type
+  class Index
     module Adapter
       class ActiveRecord < Orm
         def self.accepts?(target)
@@ -60,7 +60,15 @@ module Chewy
         end
 
         def pluck_in_batches(scope, fields: [], batch_size: nil, typecast: true)
-          return enum_for(:pluck_in_batches, scope, fields: fields, batch_size: batch_size, typecast: typecast) unless block_given?
+          unless block_given?
+            return enum_for(
+              :pluck_in_batches,
+              scope,
+              fields: fields,
+              batch_size: batch_size,
+              typecast: typecast
+            )
+          end
 
           scope = scope.reorder(target_id.asc).limit(batch_size)
           ids = pluck(scope, fields: fields, typecast: typecast)
@@ -69,6 +77,7 @@ module Chewy
           while ids.present?
             yield ids
             break if ids.size < batch_size
+
             last_id = ids.last.is_a?(Array) ? ids.last.first : ids.last
             ids = pluck(scope.where(target_id.gt(last_id)), fields: fields, typecast: typecast)
           end

data/lib/chewy/{type → index}/adapter/base.rb

@@ -1,5 +1,5 @@
 module Chewy
-  class Type
+  class Index
     module Adapter
       # Basic adapter class. Contains interface, need to implement to add any classes support
       class Base
@@ -13,8 +13,7 @@ module Chewy
           true
         end
 
-        # Camelcased name, used as type class constant name.
-        # For returned value 'Product' will be generated class name `ProductsIndex::Product`
+        # Camelcased name.
         #
         def name
           raise NotImplementedError

data/lib/chewy/{type → index}/adapter/object.rb

@@ -1,7 +1,7 @@
-require 'chewy/type/adapter/base'
+require 'chewy/index/adapter/base'
 
 module Chewy
-  class Type
+  class Index
     module Adapter
       # This adapter provides an ability to import documents from any
       # source. You can actually use any class or even a symbol as
@@ -14,15 +14,15 @@ module Chewy
       # @see #import
       # @see #load
       class Object < Base
-        # The signature of the type definition.
+        # The signature of the index scope definition.
         #
         # @example
-        #   define_type :geoname
-        #   define_type Geoname
-        #   define_type -> { Geoname.all_the_places }, name: 'geoname'
+        #   index_scope :geoname
+        #   index_scope Geoname
+        #   index_scope -> { Geoname.all_the_places }, name: 'geoname'
         #
         # @param target [Class, Symbol, String, Proc] a source of data and everything
-        # @option options [String, Symbol] :name redefines the inferred type name if necessary
+        # @option options [String, Symbol] :name redefines the inferred name if necessary
         # @option options [String, Symbol] :import_all_method redefines import method name
         # @option options [String, Symbol] :load_all_method redefines batch load method name
         # @option options [String, Symbol] :load_one_method redefines per-object load method name
@@ -31,14 +31,13 @@ module Chewy
           @options = options
         end
 
-        # Name is used for the type class creation. Inferred from the target
-        # by default if possible.
+        # Inferred from the target by default if possible.
         #
         # @example
-        #   # defines MyIndex::Geoname
-        #   define_type :geoname
-        #   # still defines MyIndex::Geoname
-        #   define_type -> { Geoname.all_the_places }, name: 'geoname'
+        #   # defines name = Geoname
+        #   index_scope :geoname
+        #   # still defines name = Geoname
+        #   index_scope -> { Geoname.all_the_places }, name: 'geoname'
         #
         # @return [String]
         def name
@@ -54,14 +53,14 @@ module Chewy
           Array.wrap(collection)
         end
 
-        # This method is used internally by `Chewy::Type.import`.
+        # This method is used internally by `Chewy::Index.import`.
         #
         # The idea is that any object can be imported to ES if
         # it responds to `#to_json` method.
         #
         # If method `destroyed?` is defined for object (or, in case of hash object,
         # it has `:_destroyed` or `'_destroyed'` key) and returns `true` or object
-        # satisfy `delete_if` type option then object will be deleted from index.
+        # satisfy `delete_if` option then object will be deleted from index.
         # But in order to be destroyable, objects need to respond to `id` method
         # or have an `id` key so ElasticSearch could know which one to delete.
         #
@@ -78,10 +77,10 @@ module Chewy
         #     end
         #   end
         #
-        #   # All the folloving variants will work:
-        #   define_type Geoname
-        #   define_type Geoname, import_all_method: 'import_all'
-        #   define_type -> { FancyGeoAPI.all_points_collection }, name: 'geoname'
+        #   # All the following variants will work:
+        #   index_scope Geoname
+        #   index_scope Geoname, import_all_method: 'import_all'
+        #   index_scope -> { FancyGeoAPI.all_points_collection }, name: 'geoname'
         #
         # @param args [Array<#to_json>]
         # @option options [Integer] :batch_size import processing batch size
@@ -113,16 +112,15 @@ module Chewy
         #     end
         #   end
         #
-        # @see Chewy::Type::Adapter::Base#import_fields
-        def import_fields(*args)
+        # @see Chewy::Index::Adapter::Base#import_fields
+        def import_fields(*args, &block)
           return enum_for(:import_fields, *args) unless block_given?
+
           options = args.extract_options!
           options[:batch_size] ||= BATCH_SIZE
 
           if args.empty? && @target.respond_to?(pluck_method)
-            @target.send(pluck_method, :id, *options[:fields]).each_slice(options[:batch_size]) do |batch|
-              yield batch
-            end
+            @target.send(pluck_method, :id, *options[:fields]).each_slice(options[:batch_size], &block)
           elsif options[:fields].blank?
             import_references(*args, options) do |batch|
               yield batch.map { |object| object_field(object, :id) || object }
@@ -140,14 +138,12 @@ module Chewy
 
         # For the Object adapter returns the objects themselves in batches.
         #
-        # @see Chewy::Type::Adapter::Base#import_references
-        def import_references(*args)
+        # @see Chewy::Index::Adapter::Base#import_references
+        def import_references(*args, &block)
           return enum_for(:import_references, *args) unless block_given?
 
           collection, options = import_args(*args)
-          collection.each_slice(options[:batch_size]) do |batch|
-            yield batch
-          end
+          collection.each_slice(options[:batch_size], &block)
         end
 
         # This method is used internally by the request DSL when the
@@ -157,7 +153,7 @@ module Chewy
         #
         # If none of the `load_all_method` or `load_one_method` is implemented
         # for the target - the method will return nil. This means that the
-        # loader will return an array `Chewy::Type` objects that actually was passed.
+        # loader will return an array `Chewy::Index` objects that actually was passed.
         #
         # To use loading for objects it is obviously required to provide
         # some meaningful ids for ES documents.
@@ -175,7 +171,7 @@ module Chewy
         #     end
         #   end
         #
-        #   MyIndex::Geoname.load(additional_data: true).objects
+        #   MyIndex.load(additional_data: true).objects
         #
         # @param ids [Array<Hash>] an array of ids from ES hits
         # @param options [Hash] any options passed here with the request DSL `load` method.