chewy 7.1.0 → 7.2.0

data/lib/chewy/search/response.rb

@@ -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,7 +27,7 @@ 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] ||= []
         end

data/lib/chewy/search/scrolling.rb

@@ -40,6 +40,7 @@ module Chewy
           yield(hits) if hits.present?
           scroll_id = result['_scroll_id']
           break if fetched >= total
+
           result = perform_scroll(scroll: scroll, scroll_id: scroll_id)
         end
       ensure
@@ -61,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
@@ -79,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
@@ -89,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
 
@@ -113,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
@@ -127,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/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
@@ -43,32 +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.map(&:index).uniq.each do |index|
+        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.rb

@@ -3,13 +3,6 @@ require 'chewy/strategy/bypass'
 require 'chewy/strategy/urgent'
 require 'chewy/strategy/atomic'
 
-begin
-  require 'resque'
-  require 'chewy/strategy/resque'
-rescue LoadError
-  nil
-end
-
 begin
   require 'sidekiq'
   require 'chewy/strategy/sidekiq'
@@ -17,13 +10,6 @@ rescue LoadError
   nil
 end
 
-begin
-  require 'shoryuken'
-  require 'chewy/strategy/shoryuken'
-rescue LoadError
-  nil
-end
-
 begin
   require 'active_job'
   require 'chewy/strategy/active_job'
@@ -60,6 +46,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 +62,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/strategy/sidekiq.rb

@@ -22,6 +22,7 @@ module Chewy
       def leave
         @stash.each do |type, ids|
           next if ids.empty?
+
           ::Sidekiq::Client.push(
             'queue' => sidekiq_queue,
             'class' => Chewy::Strategy::Sidekiq::Worker,

data/lib/chewy/version.rb

@@ -1,3 +1,3 @@
 module Chewy
-  VERSION = '7.1.0'.freeze
+  VERSION = '7.2.0'.freeze
 end

data/lib/generators/chewy/install_generator.rb

@@ -1,7 +1,7 @@
 module Chewy
   module Generators
     class InstallGenerator < Rails::Generators::Base
-      source_root File.expand_path('../../templates', __FILE__)
+      source_root File.expand_path('../templates', __dir__)
 
       def copy_configuration
         template 'chewy.yml', 'config/chewy.yml'

data/lib/tasks/chewy.rake

@@ -47,6 +47,16 @@ namespace :chewy do
     Chewy::RakeHelper.sync(except: processed)
   end
 
+  desc 'Reindex data from source index to destination index'
+  task :reindex, %i[source dest] => :environment do |_task, args|
+    Chewy::RakeHelper.reindex(source: args[:source], dest: args[:dest])
+  end
+
+  desc 'Update mapping of exising index with body hash'
+  task :update_mapping, %i[index_name] => :environment do |_task, args|
+    Chewy::RakeHelper.update_mapping(name: args[:name])
+  end
+
   namespace :parallel do
     desc 'Parallel version of `rake chewy:reset`'
     task reset: :environment do |_task, args|
@@ -87,26 +97,4 @@ namespace :chewy do
       Chewy::RakeHelper.journal_clean(**parse_journal_args(args.extras))
     end
   end
-
-  task apply_changes_from: :environment do |_task, args|
-    ActiveSupport::Deprecation.warn '`rake chewy:apply_changes_from` is deprecated and will be removed soon, use `rake chewy:journal:apply` instead'
-
-    Chewy::RakeHelper.subscribed_task_stats do
-      params = args.extras
-
-      if params.empty?
-        puts 'Please specify a timestamp like chewy:apply_changes_from[1469528705]'
-      else
-        timestamp, retries = params
-        time = Time.at(timestamp.to_i)
-        Chewy::Journal.new.apply(time, retries: (retries.to_i if retries))
-      end
-    end
-  end
-
-  task clean_journal: :environment do |_task, args|
-    ActiveSupport::Deprecation.warn '`rake chewy:clean_journal` is deprecated and will be removed soon, use `rake chewy:journal:clean` instead'
-
-    Chewy::Journal.new.clean(args.extras.first)
-  end
 end

data/migration_guide.md

@@ -17,6 +17,20 @@ In order to upgrade Chewy 6/Elasticsearch 6 to Chewy 7/Elasticsearch 7 in the mo
 * Run your test suite on Chewy 7.1 / Elasticsearch 7
 * Run manual tests on Chewy 7.1 / Elasticsearch 7
 * Upgrade to Chewy 7.1
+* Upgrade to Chewy 7.2:
+  * Remove all the the `Chewy::Type` class usages, e.g. remove `CitiesIndex::City` / `CitiesIndex.city`
+    * `CitiesIndex::City.import! ...` becomes `CitiesIndex.import! ...`
+  * Update indexes with simplified DSL:
+    * `define_type` block -> `index_scope` clause
+      * it can be omitted completely, if you don't need to specify the scope or options, e.g. `name`
+  * Remove type names from string representations:
+    * in `update_index` ActiveRecord helper and RSpec matcher, e.g.
+      * `update_index('cities#city')` -> `update_index('cities')`
+      * `update_index(UsersIndex::User)` -> `update_index(UsersIndex)`
+    * in rake tasks (e.g. `rake chewy:update[cities#city]` -> `rake chewy:update[cities]`)
+    * rake tasks output is also changed (e.g. `Imported CitiesIndex::City in 1s, stats: index 3` -> `Imported CitiesIndex in 1s, stats: index 3`)
+  * Use index name instead of type name in loader additional scope
+    * e.g. `CitiesIndex.filter(...).load(city: {scope: City.where(...)})` -> `CitiesIndex.filter(...).load(cities: {scope: City.where(...)})`
 
 ## Chewy 5/Elasticsearch 5 to Chewy 6/Elasticsearch 6
 

data/spec/chewy/config_spec.rb

@@ -8,6 +8,7 @@ describe Chewy::Config do
   its(:transport_logger) { should be_nil }
   its(:root_strategy) { should == :base }
   its(:request_strategy) { should == :atomic }
+  its(:console_strategy) { should == :urgent }
   its(:use_after_commit_callbacks) { should == true }
   its(:indices_path) { should == 'app/chewy' }
   its(:reset_disable_refresh_interval) { should == false }
@@ -55,58 +56,19 @@ describe Chewy::Config do
     context 'nothing is defined' do
       before do
         hide_const('Kaminari')
-        hide_const('WillPaginate')
       end
 
       specify do
         expect(subject.search_class.included_modules)
           .not_to include(Chewy::Search::Pagination::Kaminari)
       end
-
-      specify do
-        expect(subject.search_class.included_modules)
-          .not_to include(Chewy::Search::Pagination::WillPaginate)
-      end
     end
 
     context 'kaminari' do
-      before { hide_const('WillPaginate') }
-
-      specify do
-        expect(subject.search_class.included_modules)
-          .to include(Chewy::Search::Pagination::Kaminari)
-      end
-
-      specify do
-        expect(subject.search_class.included_modules)
-          .not_to include(Chewy::Search::Pagination::WillPaginate)
-      end
-    end
-
-    context 'will_paginate' do
-      before { hide_const('Kaminari') }
-
-      specify do
-        expect(subject.search_class.included_modules)
-          .not_to include(Chewy::Search::Pagination::Kaminari)
-      end
-
-      specify do
-        expect(subject.search_class.included_modules)
-          .to include(Chewy::Search::Pagination::WillPaginate)
-      end
-    end
-
-    context 'both are defined' do
       specify do
         expect(subject.search_class.included_modules)
           .to include(Chewy::Search::Pagination::Kaminari)
       end
-
-      specify do
-        expect(subject.search_class.included_modules)
-          .not_to include(Chewy::Search::Pagination::WillPaginate)
-      end
     end
   end
 
@@ -133,4 +95,17 @@ describe Chewy::Config do
       end
     end
   end
+
+  describe '.console_strategy' do
+    context 'sets .console_strategy' do
+      let(:default_strategy) { subject.console_strategy }
+      let(:new_strategy) { :atomic }
+      after { subject.console_strategy = default_strategy }
+
+      specify do
+        expect { subject.console_strategy = new_strategy }
+          .to change { subject.console_strategy }.to(new_strategy)
+      end
+    end
+  end
 end

data/spec/chewy/fields/base_spec.rb

@@ -10,8 +10,12 @@ describe Chewy::Fields::Base do
     specify { expect(field.compose(double(value: 'hello'))).to eq(name: 'hello') }
     specify { expect(field.compose(double(value: %w[hello world]))).to eq(name: %w[hello world]) }
 
-    specify { expect(described_class.new(:name, value: :last_name).compose(double(last_name: 'hello'))).to eq(name: 'hello') }
-    specify { expect(described_class.new(:name, value: :last_name).compose('last_name' => 'hello')).to eq(name: 'hello') }
+    specify do
+      expect(described_class.new(:name, value: :last_name).compose(double(last_name: 'hello'))).to eq(name: 'hello')
+    end
+    specify do
+      expect(described_class.new(:name, value: :last_name).compose('last_name' => 'hello')).to eq(name: 'hello')
+    end
     specify { expect(described_class.new(:name).compose(double(name: 'hello'))).to eq(name: 'hello') }
     specify { expect(described_class.new(:false_value).compose(false_value: false)).to eq(false_value: false) }
     specify { expect(described_class.new(:true_value).compose(true_value: true)).to eq(true_value: true) }
@@ -40,9 +44,24 @@ describe Chewy::Fields::Base do
     end
 
     context 'parent objects' do
-      let!(:country) { described_class.new(:name, value: ->(country, crutches) { country.cities.map { |city| double(districts: city.districts, name: crutches.city_name) } }) }
-      let!(:city) { described_class.new(:name, value: ->(city, country, crutches) { city.districts.map { |district| [district, country.name, crutches.suffix] } }) }
-      let!(:district) { described_class.new(:name, value: ->(district, city, country, crutches) { [district, city.name, country.name, crutches] }) }
+      let!(:country) do
+        described_class.new(:name, value: lambda { |country, crutches|
+                                            country.cities.map do |city|
+                                              double(districts: city.districts, name: crutches.city_name)
+                                            end
+                                          })
+      end
+      let!(:city) do
+        described_class.new(:name, value: lambda { |city, country, crutches|
+                                            city.districts.map do |district|
+                                              [district, country.name, crutches.suffix]
+                                            end
+                                          })
+      end
+      let(:district_value) { ->(district, city, country, crutches) { [district, city.name, country.name, crutches] } }
+      let!(:district) do
+        described_class.new(:name, value: district_value)
+      end
       let(:crutches) { double(suffix: 'suffix', city_name: 'Bangkok') }
 
       before do
@@ -122,14 +141,12 @@ describe Chewy::Fields::Base do
     context 'default field type' do
       before do
         stub_index(:events) do
-          define_type :event do
+          field :id
+          field :category do
             field :id
-            field :category do
+            field :licenses do
               field :id
-              field :licenses do
-                field :id
-                field :created_at, type: 'time'
-              end
+              field :created_at, type: 'time'
             end
           end
         end
@@ -143,18 +160,20 @@ describe Chewy::Fields::Base do
       end
 
       specify do
-        expect(EventsIndex::Event.mappings_hash).to eq(
-          properties: {
-            id: {type: 'integer'},
-            category: {
-              type: 'object',
-              properties: {
-                id: {type: 'integer'},
-                licenses: {
-                  type: 'object',
-                  properties: {
-                    id: {type: 'integer'},
-                    created_at: {type: 'time'}
+        expect(EventsIndex.mappings_hash).to eq(
+          mappings: {
+            properties: {
+              id: {type: 'integer'},
+              category: {
+                type: 'object',
+                properties: {
+                  id: {type: 'integer'},
+                  licenses: {
+                    type: 'object',
+                    properties: {
+                      id: {type: 'integer'},
+                      created_at: {type: 'time'}
+                    }
                   }
                 }
               }
@@ -167,153 +186,191 @@ describe Chewy::Fields::Base do
     context 'objects, hashes and arrays' do
       before do
         stub_index(:events) do
-          define_type :event do
+          field :id
+          field :category do
             field :id
-            field :category do
+            field :licenses do
               field :id
-              field :licenses do
-                field :id
-                field :name
-              end
+              field :name
             end
           end
         end
       end
 
-      # rubocop:disable Style/BracesAroundHashParameters
       specify do
-        expect(EventsIndex::Event.root.compose({
-          id: 1, category: {id: 2, licenses: {id: 3, name: 'Name'}}
-        })).to eq('id' => 1, 'category' => {'id' => 2, 'licenses' => {'id' => 3, 'name' => 'Name'}})
+        expect(
+          EventsIndex.root.compose({id: 1, category: {id: 2, licenses: {id: 3, name: 'Name'}}})
+        ).to eq('id' => 1, 'category' => {'id' => 2, 'licenses' => {'id' => 3, 'name' => 'Name'}})
       end
 
       specify do
-        expect(EventsIndex::Event.root.compose({id: 1, category: [
-          {id: 2, 'licenses' => {id: 3, name: 'Name1'}},
-          {id: 4, licenses: nil}
-        ]})).to eq('id' => 1, 'category' => [
+        expect(
+          EventsIndex.root.compose({id: 1, category: [
+            {id: 2, 'licenses' => {id: 3, name: 'Name1'}},
+            {id: 4, licenses: nil}
+          ]})
+        ).to eq('id' => 1, 'category' => [
           {'id' => 2, 'licenses' => {'id' => 3, 'name' => 'Name1'}},
           {'id' => 4, 'licenses' => nil.as_json}
         ])
       end
 
       specify do
-        expect(EventsIndex::Event.root.compose({'id' => 1, category: {id: 2, licenses: [
-          {id: 3, name: 'Name1'}, {id: 4, name: 'Name2'}
-        ]}})).to eq('id' => 1, 'category' => {'id' => 2, 'licenses' => [
-          {'id' => 3, 'name' => 'Name1'}, {'id' => 4, 'name' => 'Name2'}
-        ]})
+        expect(
+          EventsIndex.root.compose({
+            'id' => 1,
+            category: {
+              id: 2, licenses: [
+                {id: 3, name: 'Name1'},
+                {id: 4, name: 'Name2'}
+              ]
+            }
+          })
+        ).to eq(
+          'id' => 1,
+          'category' => {
+            'id' => 2,
+            'licenses' => [
+              {'id' => 3, 'name' => 'Name1'},
+              {'id' => 4, 'name' => 'Name2'}
+            ]
+          }
+        )
       end
 
       specify do
-        expect(EventsIndex::Event.root.compose({id: 1, category: [
-          {id: 2, licenses: [
-            {id: 3, 'name' => 'Name1'}, {id: 4, name: 'Name2'}
-          ]},
-          {id: 5, licenses: []}
-        ]})).to eq('id' => 1, 'category' => [
-          {'id' => 2, 'licenses' => [
-            {'id' => 3, 'name' => 'Name1'}, {'id' => 4, 'name' => 'Name2'}
-          ]},
-          {'id' => 5, 'licenses' => []}
-        ])
+        expect(
+          EventsIndex.root.compose({id: 1, category: [
+            {id: 2, licenses: [
+              {id: 3, 'name' => 'Name1'}, {id: 4, name: 'Name2'}
+            ]},
+            {id: 5, licenses: []}
+          ]})
+        ).to eq(
+          'id' => 1,
+          'category' => [
+            {'id' => 2, 'licenses' => [
+              {'id' => 3, 'name' => 'Name1'},
+              {'id' => 4, 'name' => 'Name2'}
+            ]},
+            {'id' => 5, 'licenses' => []}
+          ]
+        )
       end
-      # rubocop:enable Style/BracesAroundHashParameters
-
       specify do
-        expect(EventsIndex::Event.root.compose(
-                 double(id: 1, category: double(id: 2, licenses: double(id: 3, name: 'Name')))
-        )).to eq('id' => 1, 'category' => {'id' => 2, 'licenses' => {'id' => 3, 'name' => 'Name'}})
+        expect(
+          EventsIndex.root.compose(double(id: 1, category: double(id: 2, licenses: double(id: 3, name: 'Name'))))
+        ).to eq('id' => 1, 'category' => {'id' => 2, 'licenses' => {'id' => 3, 'name' => 'Name'}})
       end
 
       specify do
-        expect(EventsIndex::Event.root.compose(double(id: 1, category: [
-          double(id: 2, licenses: double(id: 3, name: 'Name1')),
-          double(id: 4, licenses: nil)
-        ]))).to eq('id' => 1, 'category' => [
+        expect(
+          EventsIndex.root.compose(double(id: 1, category: [
+            double(id: 2, licenses: double(id: 3, name: 'Name1')),
+            double(id: 4, licenses: nil)
+          ]))
+        ).to eq('id' => 1, 'category' => [
           {'id' => 2, 'licenses' => {'id' => 3, 'name' => 'Name1'}},
           {'id' => 4, 'licenses' => nil.as_json}
         ])
       end
 
       specify do
-        expect(EventsIndex::Event.root.compose(double(id: 1, category: double(id: 2, licenses: [
-          double(id: 3, name: 'Name1'), double(id: 4, name: 'Name2')
-        ])))).to eq('id' => 1, 'category' => {'id' => 2, 'licenses' => [
+        expect(
+          EventsIndex.root.compose(double(id: 1, category: double(id: 2, licenses: [
+            double(id: 3, name: 'Name1'), double(id: 4, name: 'Name2')
+          ])))
+        ).to eq('id' => 1, 'category' => {'id' => 2, 'licenses' => [
           {'id' => 3, 'name' => 'Name1'}, {'id' => 4, 'name' => 'Name2'}
         ]})
       end
 
       specify do
-        expect(EventsIndex::Event.root.compose(double(id: 1, category: [
-          double(id: 2, licenses: [
-            double(id: 3, name: 'Name1'), double(id: 4, name: 'Name2')
-          ]),
-          double(id: 5, licenses: [])
-        ]))).to eq('id' => 1, 'category' => [
-          {'id' => 2, 'licenses' => [
-            {'id' => 3, 'name' => 'Name1'}, {'id' => 4, 'name' => 'Name2'}
-          ]},
-          {'id' => 5, 'licenses' => []}
-        ])
+        expect(
+          EventsIndex.root.compose(double(id: 1, category: [
+            double(id: 2, licenses: [
+              double(id: 3, name: 'Name1'), double(id: 4, name: 'Name2')
+            ]),
+            double(id: 5, licenses: [])
+          ]))
+        ).to eq(
+          'id' => 1, 'category' => [
+            {'id' => 2, 'licenses' => [
+              {'id' => 3, 'name' => 'Name1'}, {'id' => 4, 'name' => 'Name2'}
+            ]},
+            {'id' => 5, 'licenses' => []}
+          ]
+        )
       end
     end
 
     context 'custom methods' do
       before do
         stub_index(:events) do
-          define_type :event do
+          field :id, type: 'integer'
+          field :category, value: -> { categories } do
             field :id, type: 'integer'
-            field :category, value: -> { categories } do
+            field :licenses, value: -> { license } do
               field :id, type: 'integer'
-              field :licenses, value: -> { license } do
-                field :id, type: 'integer'
-                field :name
-              end
+              field :name
             end
           end
         end
       end
 
       specify do
-        expect(EventsIndex::Event.root.compose(
-                 double(id: 1, categories: double(id: 2, license: double(id: 3, name: 'Name')))
-        )).to eq('id' => 1, 'category' => {'id' => 2, 'licenses' => {'id' => 3, 'name' => 'Name'}})
+        expect(
+          EventsIndex.root.compose(
+            double(
+              id: 1, categories: double(
+                id: 2, license: double(
+                  id: 3, name: 'Name'
+                )
+              )
+            )
+          )
+        ).to eq('id' => 1, 'category' => {'id' => 2, 'licenses' => {'id' => 3, 'name' => 'Name'}})
       end
     end
 
     context 'objects and multi_fields' do
       before do
         stub_index(:events) do
-          define_type :event do
-            field :id, type: 'integer'
-            field :name, type: 'integer' do
-              field :raw, analyzer: 'my_own'
-            end
-            field :category, type: 'object'
+          field :id, type: 'integer'
+          field :name, type: 'integer' do
+            field :raw, analyzer: 'my_own'
           end
+          field :category, type: 'object'
         end
       end
 
       specify do
-        expect(EventsIndex::Event.mappings_hash).to eq(
-          properties: {
-            id: {type: 'integer'},
-            name: {
-              type: 'integer',
-              fields: {
-                raw: {analyzer: 'my_own', type: Chewy.default_field_type}
-              }
-            },
-            category: {type: 'object'}
+        expect(EventsIndex.mappings_hash).to eq(
+          mappings: {
+            properties: {
+              id: {type: 'integer'},
+              name: {
+                type: 'integer',
+                fields: {
+                  raw: {analyzer: 'my_own', type: Chewy.default_field_type}
+                }
+              },
+              category: {type: 'object'}
+            }
           }
         )
       end
 
       specify do
-        expect(EventsIndex::Event.root.compose(
-                 double(id: 1, name: 'Jonny', category: double(id: 2, as_json: {'name' => 'Borogoves'}))
-        )).to eq(
+        expect(
+          EventsIndex.root.compose(
+            double(
+              id: 1, name: 'Jonny', category: double(
+                id: 2, as_json: {'name' => 'Borogoves'}
+              )
+            )
+          )
+        ).to eq(
           'id' => 1,
           'name' => 'Jonny',
           'category' => {'name' => 'Borogoves'}
@@ -321,12 +378,14 @@ describe Chewy::Fields::Base do
       end
 
       specify do
-        expect(EventsIndex::Event.root.compose(
-                 double(id: 1, name: 'Jonny', category: [
-                   double(id: 2, as_json: {'name' => 'Borogoves1'}),
-                   double(id: 3, as_json: {'name' => 'Borogoves2'})
-                 ])
-        )).to eq(
+        expect(
+          EventsIndex.root.compose(
+            double(id: 1, name: 'Jonny', category: [
+              double(id: 2, as_json: {'name' => 'Borogoves1'}),
+              double(id: 3, as_json: {'name' => 'Borogoves2'})
+            ])
+          )
+        ).to eq(
           'id' => 1,
           'name' => 'Jonny',
           'category' => [
@@ -337,56 +396,262 @@ describe Chewy::Fields::Base do
       end
     end
 
-    context 'objects and scopes', :orm do
+    context 'ignore_blank option for field method', :orm do
       before do
+        stub_model(:location)
         stub_model(:city)
         stub_model(:country)
 
-        case adapter
-        when :active_record
-          City.belongs_to :country
-          if ActiveRecord::VERSION::MAJOR >= 4
-            Country.has_many :cities, -> { order :id }
-          else
-            Country.has_many :cities, order: :id
-          end
-        when :mongoid
-          if Mongoid::VERSION.start_with?('6')
-            City.belongs_to :country, optional: true
-          else
-            City.belongs_to :country
-          end
-          Country.has_many :cities, order: :id.asc
-        when :sequel
-          City.many_to_one :country
-          Country.one_to_many :cities, order: :id
-        end
+        City.belongs_to :country
+        Location.belongs_to :city
+        City.has_one :location, -> { order :id }
+        Country.has_many :cities, -> { order :id }
+      end
 
-        stub_index(:countries) do
-          define_type Country do
+      context 'text fields with and without ignore_blank option' do
+        before do
+          stub_index(:countries) do
+            index_scope Country
             field :id
             field :cities do
               field :id
               field :name
+              field :historical_name, ignore_blank: false
+              field :description, ignore_blank: true
             end
           end
         end
+
+        let(:country_with_cities) do
+          cities = [
+            City.create!(id: 1, name: '', historical_name: '', description: ''),
+            City.create!(id: 2, name: '', historical_name: '', description: '')
+          ]
+
+          Country.create!(id: 1, cities: cities)
+        end
+
+        specify do
+          expect(CountriesIndex.root.compose(country_with_cities)).to eq(
+            'id' => 1, 'cities' => [
+              {'id' => 1, 'name' => '', 'historical_name' => ''},
+              {'id' => 2, 'name' => '', 'historical_name' => ''}
+            ]
+          )
+        end
       end
 
-      let(:country_with_cities) do
-        cities = [City.create!(id: 1, name: 'City1'), City.create!(id: 2, name: 'City2')]
+      context 'nested fields' do
+        context 'with ignore_blank: true option' do
+          before do
+            stub_index(:countries) do
+              index_scope Country
+              field :id
+              field :cities, ignore_blank: true do
+                field :id
+                field :name
+                field :historical_name, ignore_blank: true
+                field :description
+              end
+            end
+          end
 
-        if adapter == :sequel
-          Country.create(id: 1).tap do |country|
-            cities.each { |city| country.add_city(city) }
+          let(:country) { Country.create!(id: 1, cities: cities) }
+          context('without cities') do
+            let(:cities) { [] }
+            specify do
+              expect(CountriesIndex.root.compose(country))
+                .to eq('id' => 1)
+            end
+          end
+          context('with cities') do
+            let(:cities) { [City.create!(id: 1, name: '', historical_name: '')] }
+            specify do
+              expect(CountriesIndex.root.compose(country)).to eq(
+                'id' => 1, 'cities' => [
+                  {'id' => 1, 'name' => '', 'description' => nil}
+                ]
+              )
+            end
+          end
+        end
+
+        context 'with ignore_blank: false option' do
+          before do
+            stub_index(:countries) do
+              index_scope Country
+              field :id
+              field :cities, ignore_blank: false do
+                field :id
+                field :name
+                field :historical_name
+                field :description
+              end
+            end
+          end
+
+          let(:country_with_cities) { Country.create!(id: 1) }
+
+          specify do
+            expect(CountriesIndex.root.compose(country_with_cities))
+              .to eq('id' => 1, 'cities' => [])
+          end
+        end
+
+        context 'without ignore_blank: true option' do
+          before do
+            stub_index(:countries) do
+              index_scope Country
+              field :id
+              field :cities do
+                field :id
+                field :name
+                field :historical_name
+                field :description
+              end
+            end
+          end
+
+          let(:country_with_cities) { Country.create!(id: 1) }
+
+          specify do
+            expect(CountriesIndex.root.compose(country_with_cities))
+              .to eq('id' => 1, 'cities' => [])
           end
-        else
-          Country.create!(id: 1, cities: cities)
         end
       end
 
+      context 'geo_point field type' do
+        context 'with ignore_blank: true option' do
+          before do
+            stub_index(:countries) do
+              index_scope Country
+              field :id
+              field :cities do
+                field :id
+                field :name
+                field :location, type: :geo_point, ignore_blank: true do
+                  field :lat
+                  field :lon
+                end
+              end
+            end
+          end
+
+          specify do
+            expect(
+              CountriesIndex.root.compose({
+                'id' => 1,
+                'cities' => [
+                  {'id' => 1, 'name' => 'City1', 'location' => {}},
+                  {'id' => 2, 'name' => 'City2', 'location' => {}}
+                ]
+              })
+            ).to eq(
+              'id' => 1, 'cities' => [
+                {'id' => 1, 'name' => 'City1'},
+                {'id' => 2, 'name' => 'City2'}
+              ]
+            )
+          end
+        end
+
+        context 'without ignore_blank option' do
+          before do
+            stub_index(:countries) do
+              index_scope Country
+              field :id
+              field :cities do
+                field :id
+                field :name
+                field :location, type: :geo_point do
+                  field :lat
+                  field :lon
+                end
+              end
+            end
+          end
+
+          specify do
+            expect(
+              CountriesIndex.root.compose({
+                'id' => 1,
+                'cities' => [
+                  {'id' => 1, 'name' => 'City1', 'location' => {}},
+                  {'id' => 2, 'name' => 'City2', 'location' => {}}
+                ]
+              })
+            ).to eq(
+              'id' => 1, 'cities' => [
+                {'id' => 1, 'name' => 'City1'},
+                {'id' => 2, 'name' => 'City2'}
+              ]
+            )
+          end
+        end
+
+        context 'with ignore_blank: false flag' do
+          before do
+            stub_index(:countries) do
+              index_scope Country
+              field :id
+              field :cities do
+                field :id
+                field :name
+                field :location, type: :geo_point, ignore_blank: false do
+                  field :lat
+                  field :lon
+                end
+              end
+            end
+          end
+
+          specify do
+            expect(
+              CountriesIndex.root.compose({
+                'id' => 1,
+                'cities' => [
+                  {'id' => 1, 'location' => {}, 'name' => 'City1'},
+                  {'id' => 2, 'location' => '', 'name' => 'City2'}
+                ]
+              })
+            ).to eq(
+              'id' => 1, 'cities' => [
+                {'id' => 1, 'location' => {}, 'name' => 'City1'},
+                {'id' => 2, 'location' => '', 'name' => 'City2'}
+              ]
+            )
+          end
+        end
+      end
+    end
+
+    context 'objects and scopes', :orm do
+      before do
+        stub_model(:city)
+        stub_model(:country)
+
+        City.belongs_to :country
+        Country.has_many :cities, -> { order :id }
+
+        stub_index(:countries) do
+          index_scope Country
+          field :id
+          field :cities do
+            field :id
+            field :name
+          end
+        end
+      end
+
+      let(:country_with_cities) do
+        cities = [City.create!(id: 1, name: 'City1'), City.create!(id: 2, name: 'City2')]
+
+        Country.create!(id: 1, cities: cities)
+      end
+
       specify do
-        expect(CountriesIndex::Country.root.compose(country_with_cities)).to eq('id' => 1, 'cities' => [
+        expect(CountriesIndex.root.compose(country_with_cities)).to eq('id' => 1, 'cities' => [
           {'id' => 1, 'name' => 'City1'}, {'id' => 2, 'name' => 'City2'}
         ])
       end
@@ -394,20 +659,19 @@ describe Chewy::Fields::Base do
       context 'nested object' do
         before do
           stub_index(:cities) do
-            define_type City do
+            index_scope City
+            field :id
+            field :country do
               field :id
-              field :country do
-                field :id
-                field :name
-              end
+              field :name
             end
           end
         end
 
         specify do
-          expect(CitiesIndex::City.root.compose(
-                   City.create!(id: 1, country: Country.create!(id: 1, name: 'Country'))
-          )).to eq('id' => 1, 'country' => {'id' => 1, 'name' => 'Country'})
+          expect(
+            CitiesIndex.root.compose(City.create!(id: 1, country: Country.create!(id: 1, name: 'Country')))
+          ).to eq('id' => 1, 'country' => {'id' => 1, 'name' => 'Country'})
         end
       end
     end