chewy 7.0.0 → 7.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c03ccd9ded0ee8f14a062ef7ed00604a2830b3a2d74ecc2dbdfacb6e2287ff69
-  data.tar.gz: 9d88e52adef73db5324a59d4f943cc8f870f7daac47fa23ace747f6bfd5e179a
+  metadata.gz: 229c412b1e3464060b367c9c378d3662bccf2329b4e4eaa7617541243dbd6e38
+  data.tar.gz: 9bc674550cd6152e8a18853fa46c91873c7a626c426cd50aa2cb8c67b1c9455e
 SHA512:
-  metadata.gz: 7f1b0e62272ebb745d544ebcaa35fe593874ddcbc56aac806907a0c72fa141a359af8f15887e9c4b7426dd92e289e66ded1e68963225ac0375c0009756d48ff3
-  data.tar.gz: d90b624d9cfddc6e3bdf2985e535e25471209ad40d203f6c29384ddcdfe36630d9a348ff3fa8b1cc37d93da194224905df179329765061e0d83a6b2ec4ed650c
+  metadata.gz: e3e8409f81bc2504e9edbf5093fc9329bf443862cb96e113c9c00fc586c1e0e3a4273b3d6e82466f9b3d301e3d9eafcc72892cce718aff7dcfbbce85aba1698d
+  data.tar.gz: 33b5b0e21ef7c9896f1ed381130f225a1d51e073112213f631fb1c57c6d69c49af54817b1de3afc9be325c79ac24f9c173275b4448ffb7b43e82403bee03bd70

data/.github/workflows/ruby.yml

@@ -0,0 +1,58 @@
+name: CI
+
+on: [push]
+
+jobs:
+  tests:
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        ruby: [2.6, 2.7]
+        gemfile: [rails.5.2.activerecord, rails.6.0.activerecord, rails.6.1.activerecord]
+    name: ${{ matrix.ruby }}-${{ matrix.gemfile }}
+
+    env:
+      BUNDLE_GEMFILE: gemfiles/${{ matrix.gemfile }}.gemfile
+
+    steps:
+      - uses: actions/checkout@v2
+      - uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: ${{ matrix.ruby }}
+          bundler-cache: true
+      - name: Run Elasticsearch
+        uses: elastic/elastic-github-actions/elasticsearch@master
+        with:
+          stack-version: 7.10.1
+          port: 9250
+      - name: Tests
+        run: bundle exec rspec
+
+  ruby-3-0-activerecord-6-1:
+    runs-on: ubuntu-latest
+    env:
+      BUNDLE_GEMFILE: gemfiles/rails.6.1.activerecord.gemfile
+    steps:
+      - uses: actions/checkout@v2
+      - uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: '3.0'
+          bundler-cache: true
+      - name: Run Elasticsearch
+        uses: elastic/elastic-github-actions/elasticsearch@master
+        with:
+          stack-version: 7.10.1
+          port: 9250
+      - name: Tests
+        run: bundle exec rspec
+
+  rubocop:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: 2.7
+          bundler-cache: true
+      - run: bundle exec rubocop --format simple

data/.rubocop.yml

@@ -1,24 +1,31 @@
 inherit_from: .rubocop_todo.yml
 
+AllCops:
+  NewCops: enable
+  TargetRubyVersion: 2.6
+
 Layout/AccessModifierIndentation:
   EnforcedStyle: outdent
 
-Layout/AlignHash:
+Layout/HashAlignment:
   EnforcedLastArgumentHashStyle: always_ignore
 
-Layout/AlignParameters:
+Layout/ParameterAlignment:
   EnforcedStyle: with_fixed_indentation
 
 Layout/CaseIndentation:
   EnforcedStyle: end
 
-Layout/IndentArray:
+Layout/EndAlignment:
+  EnforcedStyleAlignWith: variable
+
+Layout/FirstArrayElementIndentation:
   EnforcedStyle: consistent
 
-Layout/IndentHash:
+Layout/FirstHashElementIndentation:
   EnforcedStyle: consistent
 
-Layout/IndentHeredoc:
+Layout/HeredocIndentation:
   Enabled: false
 
 Layout/MultilineMethodCallIndentation:
@@ -33,9 +40,6 @@ Layout/SpaceInsideHashLiteralBraces:
 Lint/AmbiguousBlockAssociation:
   Enabled: false
 
-Lint/EndAlignment:
-  EnforcedStyleAlignWith: variable
-
 Style/Alias:
   EnforcedStyle: prefer_alias_method
 
@@ -53,4 +57,5 @@ Metrics/BlockLength:
 
 Metrics/ModuleLength:
   Exclude:
+    - 'lib/chewy/rake_helper.rb'
     - '**/*_spec.rb'

data/.rubocop_todo.yml

@@ -1,44 +1,132 @@
 # This configuration was generated by
 # `rubocop --auto-gen-config`
-# on 2016-09-09 17:05:47 +0700 using RuboCop version 0.42.0.
+# on 2021-04-02 12:44:05 UTC using RuboCop version 1.11.0.
 # The point is for the user to remove these configuration records
 # one by one as the offenses are removed from the code base.
 # Note that changes in the inspected code, or installation of new
 # versions of RuboCop, may require this file to be generated again.
 
-# Offense count: 42
+# Offense count: 1
+# Configuration parameters: Include.
+# Include: **/*.gemspec
+Gemspec/RequiredRubyVersion:
+  Exclude:
+    - 'chewy.gemspec'
+
+# Offense count: 2
+# Configuration parameters: AllowedMethods.
+# AllowedMethods: enums
+Lint/ConstantDefinitionInBlock:
+  Exclude:
+    - 'lib/chewy/rspec/update_index.rb'
+    - 'spec/chewy/config_spec.rb'
+
+# Offense count: 10
+# Configuration parameters: AllowComments, AllowEmptyLambdas.
+Lint/EmptyBlock:
+  Exclude:
+    - 'spec/chewy/minitest/helpers_spec.rb'
+    - 'spec/chewy/rspec/update_index_spec.rb'
+    - 'spec/chewy/search/scrolling_spec.rb'
+    - 'spec/chewy/strategy/atomic_spec.rb'
+    - 'spec/chewy/strategy_spec.rb'
+    - 'spec/chewy/index/import/bulk_request_spec.rb'
+    - 'spec/chewy/index/witchcraft_spec.rb'
+    - 'spec/chewy_spec.rb'
+
+# Offense count: 3
+Lint/MissingSuper:
+  Exclude:
+    - 'lib/chewy/strategy/atomic.rb'
+    - 'lib/chewy/index/adapter/object.rb'
+    - 'lib/chewy/index/adapter/orm.rb'
+
+# Offense count: 35
+# Configuration parameters: IgnoredMethods, CountRepeatedAttributes.
 Metrics/AbcSize:
-  Max: 48
+  Max: 41
 
 # Offense count: 4
-# Configuration parameters: CountComments.
+# Configuration parameters: CountComments, CountAsOne.
 Metrics/ClassLength:
-  Max: 300
+  Max: 267
 
-# Offense count: 14
+# Offense count: 13
+# Configuration parameters: IgnoredMethods.
 Metrics/CyclomaticComplexity:
-  Max: 13
-
-# Offense count: 1450
-# Configuration parameters: AllowHeredoc, AllowURI, URISchemes.
-# URISchemes: http, https
-Metrics/LineLength:
-  Max: 198
+  Max: 12
 
-# Offense count: 38
-# Configuration parameters: CountComments.
+# Offense count: 43
+# Configuration parameters: CountComments, CountAsOne, ExcludedMethods, IgnoredMethods.
 Metrics/MethodLength:
-  Max: 33
+  Max: 29
 
-# Offense count: 1
-# Configuration parameters: CountComments.
+# Offense count: 2
+# Configuration parameters: CountComments, CountAsOne.
 Metrics/ModuleLength:
-  Max: 180
+  Max: 158
 
-# Offense count: 14
+# Offense count: 18
+# Configuration parameters: IgnoredMethods.
 Metrics/PerceivedComplexity:
-  Max: 15
+  Max: 13
 
-# Offense count: 93
+# Offense count: 11
+# Configuration parameters: EnforcedStyle, CheckMethodNames, CheckSymbols, AllowedIdentifiers.
+# SupportedStyles: snake_case, normalcase, non_integer
+# AllowedIdentifiers: capture3, iso8601, rfc1123_date, rfc822, rfc2822, rfc3339
+Naming/VariableNumber:
+  Exclude:
+    - 'spec/chewy/fields/root_spec.rb'
+
+# Offense count: 5
+Style/DocumentDynamicEvalDefinition:
+  Exclude:
+    - 'lib/chewy/index/actions.rb'
+    - 'lib/chewy/repository.rb'
+    - 'lib/chewy/search/pagination/kaminari.rb'
+    - 'lib/chewy/index/crutch.rb'
+    - 'lib/chewy/index/witchcraft.rb'
+
+# Offense count: 58
 Style/Documentation:
   Enabled: false
+
+# Offense count: 2
+# Cop supports --auto-correct.
+Style/EvalWithLocation:
+  Exclude:
+    - 'spec/chewy/index_spec.rb'
+
+# Offense count: 191
+# Cop supports --auto-correct.
+# Configuration parameters: EnforcedStyle.
+# SupportedStyles: always, always_true, never
+Style/FrozenStringLiteralComment:
+  Enabled: false
+
+# Offense count: 2
+# Configuration parameters: MinBodyLength.
+Style/GuardClause:
+  Exclude:
+    - 'lib/chewy.rb'
+    - 'spec/support/active_record.rb'
+
+# Offense count: 10
+# Cop supports --auto-correct.
+Style/IfUnlessModifier:
+  Exclude:
+    - 'lib/chewy.rb'
+    - 'lib/chewy/railtie.rb'
+    - 'lib/chewy/rspec/update_index.rb'
+    - 'lib/chewy/search/query_proxy.rb'
+    - 'lib/chewy/index/import.rb'
+    - 'lib/chewy/index/witchcraft.rb'
+    - 'spec/support/active_record.rb'
+
+# Offense count: 53
+# Cop supports --auto-correct.
+# Configuration parameters: AutoCorrect, AllowHeredoc, AllowURI, URISchemes, IgnoreCopDirectives, IgnoredPatterns.
+# URISchemes: http, https
+Layout/LineLength:
+  Max: 191

data/CHANGELOG.md

@@ -8,6 +8,107 @@
 
 ### Bugs Fixed
 
+## 7.2.2 (2021-05-24)
+
+### Changes
+
+  * [#800](https://github.com/toptal/chewy/pull/800): Revert [#787](https://github.com/toptal/chewy/pull/787) progressbar feature to avoid performance degradation in parallel import ([@rabotyaga][])
+
+  * [#795](https://github.com/toptal/chewy/issues/795): **(Breaking)** Change the Chewy::Search::Parameters::Order implementation to use Array ([@jiajiawang][]):
+    * To allow multiple sorting options that may have the same key name. For example script based sorting whose key will always be `_script`.
+    * Behaviour change of chained `order` calls.
+      * e.g. `.order(_script: {a: 1}).order(_script: {b: 2})`
+        * Before `{:sort=>[{"_script"=>{:b=>2}}]}`
+        * After  `{:sort=>[{"_script"=>{:a=>1}},{"_script"=>{:b=>2}}]}`
+
+  * [#654](https://github.com/toptal/chewy/issues/654): Add helpers and matchers for testing ([@Vitalina-Vakulchyk][]):
+    * `mock_elasticsearch_response` helpers both Rspec and Minitest - to mock elasticsearch response
+    * `mock_elasticsearch_response_sources` helpers both Rspec and Minitest - to mock elasticsearch response sources
+    * `assert_elasticsearch_query` helper for Minitest - to compare request and expected query (returns `true`/`false`)
+    * `build_query` matcher for Rspec - to compare request and expected query (returns `true`/`false`)
+
+## 7.2.1 (2021-05-11)
+
+### New Features
+
+  * [#469](https://github.com/toptal/chewy/issues/469): Add ability to output the progressbar with `ENV['PROGRESS']` during `reset` rake tasks ([@Vitalina-Vakulchyk][]):
+    * for `rake chewy:reset` and `rake chewy:parallel:reset`
+    * progressbar is hidden by default, set `ENV['PROGRESS']` to `true` to display it
+
+### Bugs Fixed
+
+  * [#796](https://github.com/toptal/chewy/pull/796): Fix clear scroll: pass `scroll_id` in body, as passing in path parameters is deprecated and can overflow `http.max_initial_line_length` ([@rabotyaga][])
+
+## 7.0.1 (2021-05-03)
+
+### Changes
+
+  * [#792](https://github.com/toptal/chewy/pull/792): Skip ES version memoization for search requests ([@rabotyaga][])
+    * See the Migration Guide for details
+
+## 7.2.0 (2021-04-19)
+
+### New Features
+
+  * [#778](https://github.com/toptal/chewy/pull/778): Add `ignore_blank` option to `field` method ([@Vitalina-Vakulchyk][]):
+    * `true` by default for the `geo_point` type
+    * `false` by default for other types
+
+### Changes
+
+  * [#783](https://github.com/toptal/chewy/pull/783): **(Breaking)** Remove `Chewy::Type`, simplify DSL ([@rabotyaga][])
+    * Remove the `Chewy::Type` class
+        * e.g. remove `CitiesIndex::City` / `CitiesIndex.city`
+            * `CitiesIndex::City.import! ...` becomes `CitiesIndex.import! ...`
+    * Simplify index 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]`)
+        * in rake tasks output (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(...)})`
+  * [#692](https://github.com/toptal/chewy/issues/692): Add `.update_mapping` to Index class ([@Vitalina-Vakulchyk][]):
+    * Wrapped Elasticsearch gem `.put_mapping` with `.update_mapping` in Index class
+    * Add `rake chewy:update_mapping` task
+  * [#594](https://github.com/toptal/chewy/issues/594): Add `.reindex` to Index class ([@Vitalina-Vakulchyk][]):
+    * Wrapped Elasticsearch gem `.reindex` with `.reindex` in Index class
+    * Add `rake chewy:reindex` task
+  * [#679](https://github.com/toptal/chewy/issues/679): Wrapped `Elasticsearch::API::Indices::Actions#clear_cache` with `.clear_cache` in Index class ([@Vitalina-Vakulchyk][])
+  * [#495](https://github.com/toptal/chewy/issues/495): Ability to change Rails console strategy with `Chewy.console_strategy` ([@Vitalina-Vakulchyk][])
+  * [#778](https://github.com/toptal/chewy/pull/778): **(Breaking)** Drop support for Ruby 2.5 ([@Vitalina-Vakulchyk][])
+  * [#776](https://github.com/toptal/chewy/pull/776): **(Breaking)** Removal of unnecessary features and integrations ([@Vitalina-Vakulchyk][]):
+    * `aws-sdk-sqs` / `shoryuken`
+    * `mongoid`
+    * `sequel`
+    * `will_paginate`
+    * `resque`
+  * [#769](https://github.com/toptal/chewy/pull/769): **(Breaking)** Removal of deprecated methods and rake tasks ([@Vitalina-Vakulchyk][]):
+    * `Chewy::Index.index_params` is removed, use `Chewy::Index.specification_hash` instead
+    * `Chewy::Index.derivable_index_name` is removed, use `Chewy::Index.derivable_name` instead
+    * `Chewy::Index.default_prefix` is removed, use `Chewy::Index.prefix` instead
+    * `Chewy::Index.build_index_name` is removed, use `Chewy::Index.index_name` instead
+    * `Chewy::RakeHelper.reset_index` is removed, use `Chewy::RakeHelper.reset` instead
+    * `Chewy::RakeHelper.reset_all` is removed, use `Chewy::RakeHelper.reset` instead
+    * `Chewy::RakeHelper.update_index` is removed, use `Chewy::RakeHelper.update` instead
+    * `Chewy::RakeHelper.update_all` is removed, use `Chewy::RakeHelper.update` instead
+    * `rake chewy:apply_changes_from` is removed, use `rake chewy:journal:apply` instead
+    * `rake chewy:clean_journal` is removed, use `rake chewy:journal:clean` instead
+
+## 7.1.0 (2021-03-03)
+
+### Changes
+
+  * [#766](https://github.com/toptal/chewy/pull/766): **(Breaking)** Drop support for Elasticsearch 6.x ([@rabotyaga][])
+  * [#765](https://github.com/toptal/chewy/pull/765): Fix ruby 2.7 warnings in rake tasks ([@aglushkov][])
+
+### Bugs Fixed
+
+  * [#722](https://github.com/toptal/chewy/issues/722): Remove alias_method_chain, use Module#prepend instead ([@dalthon][])
+
 ## 7.0.0 (2021-02-22)
 
 ### New Features
@@ -549,6 +650,7 @@
 [@inbeom]: https://github.com/inbeom
 [@jesjos]: https://github.com/jesjos
 [@JF-Lalonde]: https://github.com/JF-Lalonde
+[@jiajiawang]: https://github.com/jiajiawang
 [@jimmybaker]: https://github.com/jimmybaker
 [@jirikolarik]: https://github.com/jirikolarik
 [@jirutka]: https://github.com/jirutka
@@ -596,5 +698,6 @@
 [@taylor-au]: https://github.com/taylor-au
 [@TikiTDO]: https://github.com/TikiTDO
 [@undr]: https://github.com/undr
+[@Vitalina-Vakulchyk]: https://github.com/Vitalina-Vakulchyk
 [@webgago]: https://github.com/webgago
 [@yahooguntu]: https://github.com/yahooguntu

data/Gemfile

@@ -3,18 +3,11 @@ source 'https://rubygems.org'
 gemspec
 
 gem 'activerecord'
-# gem 'mongoid'
-# gem 'sequel'
 
 gem 'activejob', require: false
-gem 'resque', require: false
 gem 'sidekiq', require: false
 
-gem 'aws-sdk-sqs', require: false
-gem 'shoryuken', require: false
-
 gem 'kaminari-core', require: false
-gem 'will_paginate', require: false
 
 gem 'parallel', require: false
 gem 'ruby-progressbar', require: false

data/Guardfile

@@ -9,7 +9,9 @@ guard :rspec, cmd: 'rspec' do
   # Rails example
   watch(%r{^app/(.+)\.rb$})                           { |m| "spec/#{m[1]}_spec.rb" }
   watch(%r{^app/(.*)(\.erb|\.haml|\.slim)$})          { |m| "spec/#{m[1]}#{m[2]}_spec.rb" }
-  watch(%r{^app/controllers/(.+)_(controller)\.rb$})  { |m| ["spec/routing/#{m[1]}_routing_spec.rb", "spec/#{m[2]}s/#{m[1]}_#{m[2]}_spec.rb", "spec/acceptance/#{m[1]}_spec.rb"] }
+  watch(%r{^app/controllers/(.+)_(controller)\.rb$})  do |m|
+    ["spec/routing/#{m[1]}_routing_spec.rb", "spec/#{m[2]}s/#{m[1]}_#{m[2]}_spec.rb", "spec/acceptance/#{m[1]}_spec.rb"]
+  end
   watch(%r{^spec/support/(.+)\.rb$})                  { 'spec' }
   watch('config/routes.rb')                           { 'spec/routing' }
   watch('app/controllers/application_controller.rb')  { 'spec/controllers' }

data/README.md

@@ -1,5 +1,5 @@
 [![Gem Version](https://badge.fury.io/rb/chewy.svg)](http://badge.fury.io/rb/chewy)
-[![CircleCI](https://circleci.com/gh/toptal/chewy/tree/master.svg?style=svg)](https://circleci.com/gh/toptal/chewy/tree/master)
+[![GitHub Actions](https://github.com/toptal/chewy/actions/workflows/ruby.yml/badge.svg)](https://github.com/toptal/chewy/actions/workflows/ruby.yml)
 [![Code Climate](https://codeclimate.com/github/toptal/chewy.svg)](https://codeclimate.com/github/toptal/chewy)
 [![Inline docs](http://inch-ci.org/github/toptal/chewy.svg?branch=master)](http://inch-ci.org/github/toptal/chewy)
 
@@ -7,58 +7,10 @@
 
 Chewy is an ODM (Object Document Mapper), built on top of the [the official Elasticsearch client](https://github.com/elastic/elasticsearch-ruby).
 
-## Table of Contents
-
-* [Why Chewy?](#why-chewy)
-* [Installation](#installation)
-* [Usage](#usage)
-  * [Client settings](#client-settings)
-    * [AWS ElasticSearch configuration](#aws-elastic-search)
-  * [Index definition](#index-definition)
-  * [Type default import options](#type-default-import-options)
-  * [Multi (nested) and object field types](#multi-nested-and-object-field-types)
-  * [Parent and children types](#parent-and-children-types)
-  * [Geo Point fields](#geo-point-fields)
-  * [Crutches™ technology](#crutches-technology)
-  * [Witchcraft™ technology](#witchcraft-technology)
-  * [Raw Import](#raw-import)
-  * [Index creation during import](#index-creation-during-import)
-  * [Journaling](#journaling)
-  * [Types access](#types-access)
-  * [Index manipulation](#index-manipulation)
-  * [Index update strategies](#index-update-strategies)
-    * [Nesting](#nesting)
-    * [Non-block notation](#non-block-notation)
-    * [Designing your own strategies](#designing-your-own-strategies)
-  * [Rails application strategies integration](#rails-application-strategies-integration)
-  * [ActiveSupport::Notifications support](#activesupportnotifications-support)
-  * [NewRelic integration](#newrelic-integration)
-  * [Search requests](#search-requests)
-    * [Composing requests](#composing-requests)
-    * [Pagination](#pagination)
-    * [Named scopes](#named-scopes)
-    * [Scroll API](#scroll-api)
-    * [Loading objects](#loading-objects)
-  * [Rake tasks](#rake-tasks)
-    * [chewy:reset](#chewyreset)
-    * [chewy:upgrade](#chewyupgrade)
-    * [chewy:update](#chewyupdate)
-    * [chewy:sync](#chewysync)
-    * [chewy:deploy](#chewydeploy)
-    * [Parallelizing rake tasks](#parallelizing-rake-tasks)
-    * [chewy:journal](#chewyjournal)
-  * [RSpec integration](#rspec-integration)
-  * [Minitest integration](#minitest-integration)
-* [Contributing](#contributing)
-
 ## Why Chewy?
 
 In this section we'll cover why you might want to use Chewy instead of the official `elasticsearch-ruby` client gem.
 
-* Multi-model indices.
-
-  Index classes are independent from ORM/ODM models. Now, implementing e.g. cross-model autocomplete is much easier. You can just define the index and work with it in an object-oriented style. You can define several types for index - one per indexed model.
-
 * Every index is observable by all the related models.
 
   Most of the indexed models are related to other and sometimes it is necessary to denormalize this related data and put at the same object. For example, you need to index an array of tags together with an article. Chewy allows you to specify an updateable index for every model separately - so corresponding articles will be reindexed on any tag update.
@@ -71,7 +23,7 @@ In this section we'll cover why you might want to use Chewy instead of the offic
 
   Chewy has an ActiveRecord-style query DSL. It is chainable, mergeable and lazy, so you can produce queries in the most efficient way. It also has object-oriented query and filter builders.
 
-* Support for ActiveRecord, [Mongoid](https://github.com/mongoid/mongoid) and [Sequel](https://github.com/jeremyevans/sequel).
+* Support for ActiveRecord.
 
 ## Installation
 
@@ -91,7 +43,7 @@ Or install it yourself as:
 
 ### Ruby
 
-Chewy is compatible with MRI 2.5-3.0¹.
+Chewy is compatible with MRI 2.6-3.0¹.
 
 > ¹ Ruby 3 is only supported with Rails 6.1
 
@@ -99,29 +51,169 @@ Chewy is compatible with MRI 2.5-3.0¹.
 
 | Chewy version | Elasticsearch version              |
 | ------------- | ---------------------------------- |
-| 7.0.0         | 6.8, 7.x                           |
+| 7.2.x         | 7.x                                |
+| 7.1.x         | 7.x                                |
+| 7.0.x         | 6.8, 7.x                           |
 | 6.0.0         | 5.x, 6.x                           |
 | 5.x           | 5.x, limited support for 1.x & 2.x |
 
-See [Migration guide](migration_guide.md).
+**Important:** Chewy doesn't follow SemVer, so you should always
+check the release notes before upgrading. The major version is linked to the
+newest supported Elasticsearch and the minor version bumps may include breaking changes.
 
-## Usage
+See our [migration guide](migration_guide.md) for detailed upgrade instructions between
+various Chewy versions.
 
-### Client settings
+### Active Record
+
+5.2, 6.0, 6.1 Active Record versions are supported by all Chewy versions.
+
+## Getting Started
+
+Chewy provides functionality for Elasticsearch index handling, documents import mappings, index update strategies and chainable query DSL.
+
+### Minimal client setting
+
+Create `config/initializers/chewy.rb` with this line:
+
+```ruby
+Chewy.settings = {host: 'localhost:9250'}
+```
+
+And run `rails g chewy:install` to generate `chewy.yml`:
+
+```yaml
+# config/chewy.yml
+# separate environment configs
+test:
+  host: 'localhost:9250'
+  prefix: 'test'
+development:
+  host: 'localhost:9200'
+```
+
+### Elasticsearch
+
+Make sure you have Elasticsearch up and running. You can [install](https://www.elastic.co/guide/en/elasticsearch/reference/current/install-elasticsearch.html) it locally, but the easiest way is to use [Docker](https://www.docker.com/get-started):
+
+```shell
+$ docker run --rm --name elasticsearch -p 9200:9200 -p 9300:9300 -e "discovery.type=single-node" elasticsearch:7.11.1
+```
+
+### Index
+
+Create `app/chewy/users_index.rb` with User Index:
+
+```ruby
+class UsersIndex < Chewy::Index
+  settings analysis: {
+    analyzer: {
+      email: {
+        tokenizer: 'keyword',
+        filter: ['lowercase']
+      }
+    }
+  }
+
+  index_scope User
+  field :first_name
+  field :last_name
+  field :email, analyzer: 'email'
+end
+```
+
+### Model
 
-There are two ways to configure the Chewy client:
+Add User model, table and migrate it:
 
-* via the hash `Chewy.settings`
-* via the configuration file `chewy.yml`
+```shell
+$ bundle exec rails g model User first_name last_name email
+$ bundle exec rails db:migrate
+```
+
+Add `update_index` to app/models/user.rb:
+
+```ruby
+class User < ApplicationRecord
+  update_index('users') { self }
+end
+```
+
+### Example of data request
+
+1. Once a record is created (could be done via the Rails console), it creates User index too:
+
+```
+User.create(
+  first_name: "test1",
+  last_name: "test1",
+  email: 'test1@example.com',
+  # other fields
+)
+# UsersIndex Import (355.3ms) {:index=>1}
+# => #<User id: 1, first_name: "test1", last_name: "test1", email: "test1@example.com", # other fields>
+```
+
+2. A query could be exposed at a given `UsersController`:
+
+```ruby
+def search
+  @users = UsersIndex.query(query_string: { fields: [:first_name, :last_name, :email, ...], query: search_params[:query], default_operator: 'and' })
+  render json: @users.to_json, status: :ok
+end
+
+private
+
+def search_params
+  params.permit(:query, :page, :per)
+end
+```
 
-You can create `chewy.yml` manually or run `rails g chewy:install` to
-generate it.
+3. So a request against `http://localhost:3000/users/search?query=test1@example.com` issuing a response like:
+
+```json
+[
+  {
+    "attributes":{
+      "id":"1",
+      "first_name":"test1",
+      "last_name":"test1",
+      "email":"test1@example.com",
+      ...
+      "_score":0.9808291,
+      "_explanation":null
+    },
+    "_data":{
+      "_index":"users",
+      "_type":"_doc",
+      "_id":"1",
+      "_score":0.9808291,
+      "_source":{
+        "first_name":"test1",
+        "last_name":"test1",
+        "email":"test1@example.com",
+        ...
+      }
+    }
+  }
+]
+```
+
+## Usage and configuration
+
+### Client settings
+
+To configure the Chewy client you need to add `chewy.rb` file with `Chewy.settings` hash:
 
 ```ruby
 # config/initializers/chewy.rb
 Chewy.settings = {host: 'localhost:9250'} # do not use environments
 ```
 
+And add `chewy.yml` configuration file.
+
+You can create `chewy.yml` manually or run `rails g chewy:install` to generate it:
+
 ```yaml
 # config/chewy.yml
 # separate environment configs
@@ -171,7 +263,7 @@ Chewy.settings = {
 }
 ```
 
-### Index definition
+#### Index definition
 
 1. Create `/app/chewy/users_index.rb`
 
@@ -181,41 +273,38 @@ Chewy.settings = {
   end
   ```
 
-2. Add one or more types mapping
+2. Define index scope (you can omit this part if you don't need to specify a scope (i.e. use PORO objects for import) or options)
 
   ```ruby
   class UsersIndex < Chewy::Index
-    define_type User.active # or just model instead_of scope: define_type User
+    index_scope User.active # or just model instead_of scope: index_scope User
   end
   ```
 
-  Newly-defined index type class is accessible via `UsersIndex.user` or `UsersIndex::User`
-
-3. Add some type mappings
+3. Add some mappings
 
   ```ruby
   class UsersIndex < Chewy::Index
-    define_type User.active.includes(:country, :badges, :projects) do
-      field :first_name, :last_name # multiple fields without additional options
-      field :email, analyzer: 'email' # Elasticsearch-related options
-      field :country, value: ->(user) { user.country.name } # custom value proc
-      field :badges, value: ->(user) { user.badges.map(&:name) } # passing array values to index
-      field :projects do # the same block syntax for multi_field, if `:type` is specified
-        field :title
-        field :description # default data type is `text`
-        # additional top-level objects passed to value proc:
-        field :categories, value: ->(project, user) { project.categories.map(&:name) if user.active? }
-      end
-      field :rating, type: 'integer' # custom data type
-      field :created, type: 'date', include_in_all: false,
-        value: ->{ created_at } # value proc for source object context
+    index_scope User.active.includes(:country, :badges, :projects)
+    field :first_name, :last_name # multiple fields without additional options
+    field :email, analyzer: 'email' # Elasticsearch-related options
+    field :country, value: ->(user) { user.country.name } # custom value proc
+    field :badges, value: ->(user) { user.badges.map(&:name) } # passing array values to index
+    field :projects do # the same block syntax for multi_field, if `:type` is specified
+      field :title
+      field :description # default data type is `text`
+      # additional top-level objects passed to value proc:
+      field :categories, value: ->(project, user) { project.categories.map(&:name) if user.active? }
     end
+    field :rating, type: 'integer' # custom data type
+    field :created, type: 'date', include_in_all: false,
+      value: ->{ created_at } # value proc for source object context
   end
   ```
 
   [See here for mapping definitions](https://www.elastic.co/guide/en/elasticsearch/reference/current/mapping.html).
 
-4. Add some index- and type-related settings. Analyzer repositories might be used as well. See `Chewy::Index.settings` docs for details:
+4. Add some index-related settings. Analyzer repositories might be used as well. See `Chewy::Index.settings` docs for details:
 
   ```ruby
   class UsersIndex < Chewy::Index
@@ -228,23 +317,22 @@ Chewy.settings = {
       }
     }
 
-    define_type User.active.includes(:country, :badges, :projects) do
-      root date_detection: false do
-        template 'about_translations.*', type: 'text', analyzer: 'standard'
-
-        field :first_name, :last_name
-        field :email, analyzer: 'email'
-        field :country, value: ->(user) { user.country.name }
-        field :badges, value: ->(user) { user.badges.map(&:name) }
-        field :projects do
-          field :title
-          field :description
-        end
-        field :about_translations, type: 'object' # pass object type explicitly if necessary
-        field :rating, type: 'integer'
-        field :created, type: 'date', include_in_all: false,
-          value: ->{ created_at }
+    index_scope User.active.includes(:country, :badges, :projects)
+    root date_detection: false do
+      template 'about_translations.*', type: 'text', analyzer: 'standard'
+
+      field :first_name, :last_name
+      field :email, analyzer: 'email'
+      field :country, value: ->(user) { user.country.name }
+      field :badges, value: ->(user) { user.badges.map(&:name) }
+      field :projects do
+        field :title
+        field :description
       end
+      field :about_translations, type: 'object' # pass object type explicitly if necessary
+      field :rating, type: 'integer'
+      field :created, type: 'date', include_in_all: false,
+        value: ->{ created_at }
     end
   end
   ```
@@ -258,39 +346,32 @@ Chewy.settings = {
 
   ```ruby
   class User < ActiveRecord::Base
-    update_index('users#user') { self } # specifying index, type and back-reference
+    update_index('users') { self } # specifying index and back-reference
                                         # for updating after user save or destroy
   end
 
   class Country < ActiveRecord::Base
     has_many :users
 
-    update_index('users#user') { users } # return single object or collection
+    update_index('users') { users } # return single object or collection
   end
 
   class Project < ActiveRecord::Base
-    update_index('users#user') { user if user.active? } # you can return even `nil` from the back-reference
-  end
-
-  class Badge < ActiveRecord::Base
-    has_and_belongs_to_many :users
-
-    update_index('users') { users } # if index has only one type
-                                    # there is no need to specify updated type
+    update_index('users') { user if user.active? } # you can return even `nil` from the back-reference
   end
 
   class Book < ActiveRecord::Base
-    update_index(->(book) {"books#book_#{book.language}"}) { self } # dynamic index and type with proc.
-                                                                    # For book with language == "en"
-                                                                    # this code will generate `books#book_en`
+    update_index(->(book) {"books_#{book.language}"}) { self } # dynamic index name with proc.
+                                                               # For book with language == "en"
+                                                               # this code will generate `books_en`
   end
   ```
 
   Also, you can use the second argument for method name passing:
 
   ```ruby
-  update_index('users#user', :self)
-  update_index('users#user', :users)
+  update_index('users', :self)
+  update_index('users', :users)
   ```
 
   In the case of a belongs_to association you may need to update both associated objects, previous and current:
@@ -299,47 +380,28 @@ Chewy.settings = {
   class City < ActiveRecord::Base
     belongs_to :country
 
-    update_index('cities#city') { self }
-    update_index 'countries#country' do
-      # For the latest active_record changed values are
-      # already in `previous_changes` hash,
-      # but for mongoid you have to use `changes` hash
+    update_index('cities') { self }
+    update_index 'countries' do
       previous_changes['country_id'] || country
     end
   end
   ```
 
-  You can observe Sequel models in the same way as ActiveRecord:
-
-  ```ruby
-  class User < Sequel::Model
-    update_index('users#user') { self }
-  end
-  ```
+### Default import options
 
-  However, to make it work, you must load the chewy plugin into Sequel model:
-
-  ```ruby
-  Sequel::Model.plugin :chewy_observe  # for all models, or...
-  User.plugin :chewy_observe           # just for User
-  ```
-
-### Type default import options
-
-Every type has `default_import_options` configuration to specify, suddenly, default import options:
+Every index has `default_import_options` configuration to specify, suddenly, default import options:
 
 ```ruby
 class ProductsIndex < Chewy::Index
-  define_type Post.includes(:tags) do
-    default_import_options batch_size: 100, bulk_size: 10.megabytes, refresh: false
+  index_scope Post.includes(:tags)
+  default_import_options batch_size: 100, bulk_size: 10.megabytes, refresh: false
 
-    field :name
-    field :tags, value: -> { tags.map(&:name) }
-  end
+  field :name
+  field :tags, value: -> { tags.map(&:name) }
 end
 ```
 
-See [import.rb](lib/chewy/type/import.rb) for available options.
+See [import.rb](lib/chewy/index/import.rb) for available options.
 
 ### Multi (nested) and object field types
 
@@ -365,18 +427,6 @@ end
 
 The `value:` option for internal fields will no longer be effective.
 
-### Parent and children types
-
-To define [parent](https://www.elastic.co/guide/en/elasticsearch/guide/current/parent-child-mapping.html) type for a given index_type, you can include root options for the type where you can specify parent_type and parent_id
-
-```ruby
-define_type User.includes(:account) do
-  root parent: 'account', parent_id: ->{ account_id } do
-    field :created_at, type: 'date'
-    field :task_id, type: 'integer'
-  end
-end
-```
 ### Geo Point fields
 
 You can use [Elasticsearch's geo mapping](https://www.elastic.co/guide/en/elasticsearch/reference/current/geo-point.html) with the `geo_point` field type, allowing you to query, filter and order by latitude and longitude. You can use the following hash format:
@@ -402,14 +452,13 @@ Assume you are defining your index like this (product has_many categories throug
 
 ```ruby
 class ProductsIndex < Chewy::Index
-  define_type Product.includes(:categories) do
-    field :name
-    field :category_names, value: ->(product) { product.categories.map(&:name) } # or shorter just -> { categories.map(&:name) }
-  end
+  index_scope Product.includes(:categories)
+  field :name
+  field :category_names, value: ->(product) { product.categories.map(&:name) } # or shorter just -> { categories.map(&:name) }
 end
 ```
 
-Then the Chewy reindexing flow will look like the following pseudo-code (even in Mongoid):
+Then the Chewy reindexing flow will look like the following pseudo-code:
 
 ```ruby
 Product.includes(:categories).find_in_batches(1000) do |batch|
@@ -421,26 +470,23 @@ Product.includes(:categories).find_in_batches(1000) do |batch|
 end
 ```
 
-But in Rails 4.1 and 4.2 you may face a problem with slow associations (take a look at https://github.com/rails/rails/pull/19423). Also, there might be really complicated cases when associations are not applicable.
-
-Then you can replace Rails associations with Chewy Crutches™ technology:
+If you meet complicated cases when associations are not applicable you can replace Rails associations with Chewy Crutches™ technology:
 
 ```ruby
 class ProductsIndex < Chewy::Index
-  define_type Product do
-    crutch :categories do |collection| # collection here is a current batch of products
-      # data is fetched with a lightweight query without objects initialization
-      data = ProductCategory.joins(:category).where(product_id: collection.map(&:id)).pluck(:product_id, 'categories.name')
-      # then we have to convert fetched data to appropriate format
-      # this will return our data in structure like:
-      # {123 => ['sweets', 'juices'], 456 => ['meat']}
-      data.each.with_object({}) { |(id, name), result| (result[id] ||= []).push(name) }
-    end
-
-    field :name
-    # simply use crutch-fetched data as a value:
-    field :category_names, value: ->(product, crutches) { crutches.categories[product.id] }
+  index_scope Product
+  crutch :categories do |collection| # collection here is a current batch of products
+    # data is fetched with a lightweight query without objects initialization
+    data = ProductCategory.joins(:category).where(product_id: collection.map(&:id)).pluck(:product_id, 'categories.name')
+    # then we have to convert fetched data to appropriate format
+    # this will return our data in structure like:
+    # {123 => ['sweets', 'juices'], 456 => ['meat']}
+    data.each.with_object({}) { |(id, name), result| (result[id] ||= []).push(name) }
   end
+
+  field :name
+  # simply use crutch-fetched data as a value:
+  field :category_names, value: ->(product, crutches) { crutches.categories[product.id] }
 end
 ```
 
@@ -462,22 +508,21 @@ So Chewy Crutches™ technology is able to increase your indexing performance in
 
 ### Witchcraft™ technology
 
-One more experimental technology to increase import performance. As far as you know, chewy defines value proc for every imported field in mapping, so at the import time each of this procs is executed on imported object to extract result document to import. It would be great for performance to use one huge whole-document-returning proc instead. So basically the idea or Witchcraft™ technology is to compile a single document-returning proc from the type definition.
+One more experimental technology to increase import performance. As far as you know, chewy defines value proc for every imported field in mapping, so at the import time each of this procs is executed on imported object to extract result document to import. It would be great for performance to use one huge whole-document-returning proc instead. So basically the idea or Witchcraft™ technology is to compile a single document-returning proc from the index definition.
 
 ```ruby
-define_type Product do
-  witchcraft!
-
-  field :title
-  field :tags, value: -> { tags.map(&:name) }
-  field :categories do
-    field :name, value: -> (product, category) { category.name }
-    field :type, value: -> (product, category, crutch) { crutch.types[category.name] }
-  end
+index_scope Product
+witchcraft!
+
+field :title
+field :tags, value: -> { tags.map(&:name) }
+field :categories do
+  field :name, value: -> (product, category) { category.name }
+  field :type, value: -> (product, category, crutch) { crutch.types[category.name] }
 end
 ```
 
-The type definition above will be compiled to something close to:
+The index definition above will be compiled to something close to:
 
 ```ruby
 -> (object, crutches) do
@@ -507,7 +552,7 @@ Obviously not every type of definition might be compiled. There are some restric
   end
   ```
 
-However, it is quite possible that your type definition will be supported by Witchcraft™ technology out of the box in the most of the cases.
+However, it is quite possible that your index definition will be supported by Witchcraft™ technology out of the box in the most of the cases.
 
 ### Raw Import
 
@@ -534,13 +579,12 @@ class LightweightProduct
   end
 end
 
-define_type Product do
-  default_import_options raw_import: ->(hash) {
-    LightweightProduct.new(hash)
-  }
+index_scope Product
+default_import_options raw_import: ->(hash) {
+  LightweightProduct.new(hash)
+}
 
-  field :created_at, 'datetime'
-end
+field :created_at, 'datetime'
 ```
 
 Also, you can pass `:raw_import` option to the `import` method explicitly.
@@ -551,6 +595,24 @@ By default, when you perform import Chewy checks whether an index exists and cre
 You can turn off this feature to decrease Elasticsearch hits count.
 To do so you need to set `skip_index_creation_on_import` parameter to `false` in your `config/chewy.yml`
 
+### Skip record fields during import
+
+You can use `ignore_blank: true` to skip fields that return `true` for the `.blank?` method:
+
+```ruby
+index_scope Country
+field :id
+field :cities, ignore_blank: true do
+  field :id
+  field :name
+  field :surname, ignore_blank: true
+  field :description
+end
+```
+
+#### Default values for different types
+
+By default `ignore_blank` is false on every type except `geo_point`.
 
 ### Journaling
 
@@ -564,7 +626,6 @@ Common journal record looks like this:
   "action": "index",
   "object_id": [1, 2, 3],
   "index_name": "...",
-  "type_name": "...",
   "created_at": "<timestamp>"
 }
 ```
@@ -590,9 +651,8 @@ Or as a default import option for an index:
 
 ```ruby
 class CityIndex
-  define_type City do
-    default_import_options journal: true
-  end
+  index_scope City
+  default_import_options journal: true
 end
 ```
 
@@ -600,19 +660,6 @@ You may be wondering why do you need it? The answer is simple: not to lose the d
 
 Imagine that you reset your index in a zero-downtime manner (to separate index), and at the meantime somebody keeps updating the data frequently (to old index). So all these actions will be written to the journal index and you'll be able to apply them after index reset using the `Chewy::Journal` interface.
 
-### Types access
-
-You can access index-defined types with the following API:
-
-```ruby
-UsersIndex::User # => UsersIndex::User
-UsersIndex.type_hash['user'] # => UsersIndex::User
-UsersIndex.type('user') # => UsersIndex::User
-UsersIndex.type('foo') # => raises error UndefinedType("Unknown type in UsersIndex: foo")
-UsersIndex.types # => [UsersIndex::User]
-UsersIndex.type_names # => ['user']
-```
-
 ### Index manipulation
 
 ```ruby
@@ -625,25 +672,21 @@ UsersIndex.create! # use bang or non-bang methods
 UsersIndex.purge
 UsersIndex.purge! # deletes then creates index
 
-UsersIndex::User.import # import with 0 arguments process all the data specified in type definition
-                        # literally, User.active.includes(:country, :badges, :projects).find_in_batches
-UsersIndex::User.import User.where('rating > 100') # or import specified users scope
-UsersIndex::User.import User.where('rating > 100').to_a # or import specified users array
-UsersIndex::User.import [1, 2, 42] # pass even ids for import, it will be handled in the most effective way
-UsersIndex::User.import User.where('rating > 100'), update_fields: [:email] # if update fields are specified - it will update their values only with the `update` bulk action.
+UsersIndex.import # import with 0 arguments process all the data specified in index_scope definition
+UsersIndex.import User.where('rating > 100') # or import specified users scope
+UsersIndex.import User.where('rating > 100').to_a # or import specified users array
+UsersIndex.import [1, 2, 42] # pass even ids for import, it will be handled in the most effective way
+UsersIndex.import User.where('rating > 100'), update_fields: [:email] # if update fields are specified - it will update their values only with the `update` bulk action
 
-UsersIndex.import # import every defined type
-UsersIndex.import user: User.where('rating > 100') # import only active users to `user` type.
-  # Other index types, if exists, will be imported with default scope from the type definition.
 UsersIndex.reset! # purges index and imports default data for all types
 ```
 
-If the passed user is `#destroyed?`, or satisfies a `delete_if` type option, or the specified id does not exist in the database, import will perform delete from index action for this object.
+If the passed user is `#destroyed?`, or satisfies a `delete_if` index_scope option, or the specified id does not exist in the database, import will perform delete from index action for this object.
 
 ```ruby
-define_type User, delete_if: :deleted_at
-define_type User, delete_if: -> { deleted_at }
-define_type User, delete_if: ->(user) { user.deleted_at }
+index_scope User, delete_if: :deleted_at
+index_scope User, delete_if: -> { deleted_at }
+index_scope User, delete_if: ->(user) { user.deleted_at }
 ```
 
 See [actions.rb](lib/chewy/index/actions.rb) for more details.
@@ -654,13 +697,12 @@ Assume you've got the following code:
 
 ```ruby
 class City < ActiveRecord::Base
-  update_index 'cities#city', :self
+  update_index 'cities', :self
 end
 
 class CitiesIndex < Chewy::Index
-  define_type City do
-    field :name
-  end
+  index_scope City
+  field :name
 end
 ```
 
@@ -680,16 +722,6 @@ end
 
 Using this strategy delays the index update request until the end of the block. Updated records are aggregated and the index update happens with the bulk API. So this strategy is highly optimized.
 
-#### `:resque`
-
-This does the same thing as `:atomic`, but asynchronously using resque. The default queue name is `chewy`. Patch `Chewy::Strategy::Resque::Worker` for index updates improving.
-
-```ruby
-Chewy.strategy(:resque) do
-  City.popular.map(&:do_some_update_action!)
-end
-```
-
 #### `:sidekiq`
 
 This does the same thing as `:atomic`, but asynchronously using sidekiq. Patch `Chewy::Strategy::Sidekiq::Worker` for index updates improving.
@@ -720,16 +752,6 @@ The default queue name is `chewy`, you can customize it in settings: `active_job
 Chewy.settings[:active_job] = {queue: :low}
 ```
 
-#### `:shoryuken`
-
-This does the same thing as `:atomic`, but asynchronously using shoryuken. Patch `Chewy::Strategy::Shoryuken::Worker` for index updates improving.
-
-```ruby
-Chewy.strategy(:shoryuken) do
-  City.popular.map(&:do_some_update_action!)
-end
-```
-
 #### `:urgent`
 
 The following strategy is convenient if you are going to update documents in your index one by one.
@@ -805,6 +827,12 @@ RSpec.configure do |config|
 end
 ```
 
+### Elasticsearch client options
+
+All connection options, except the `:prefix`, are passed to the `Elasticseach::Client.new` ([chewy/lib/chewy.rb](https://github.com/toptal/chewy/blob/f5bad9f83c21416ac10590f6f34009c645062e89/lib/chewy.rb#L153-L160)):
+
+Here's the relevant Elasticsearch documentation on the subject: https://rubydoc.info/gems/elasticsearch-transport#setting-hosts
+
 ### `ActiveSupport::Notifications` support
 
 Chewy has notifying the following events:
@@ -816,7 +844,7 @@ Chewy has notifying the following events:
 
 #### `import_objects.chewy` payload
 
-  * `payload[:type]`: currently imported type
+  * `payload[:index]`: currently imported index name
   * `payload[:import]`: imports stats, total imported and deleted objects count:
 
     ```ruby
@@ -920,22 +948,27 @@ Quick introduction.
 
 #### Composing requests
 
-The request DSL have the same chainable nature as AR or Mongoid ones. The main class is `Chewy::Search::Request`. It is possible to perform requests on behalf of indices or types:
+The request DSL have the same chainable nature as AR. The main class is `Chewy::Search::Request`.
 
 ```ruby
-PlaceIndex.query(match: {name: 'London'}) # returns documents of any type
-PlaceIndex::City.query(match: {name: 'London'}) # returns cities only.
+CitiesIndex.query(match: {name: 'London'})
 ```
 
-Main methods of the request DSL are: `query`, `filter` and `post_filter`, it is possible to pass pure query hashes or use `elasticsearch-dsl`. Also, there is an additional
+Main methods of the request DSL are: `query`, `filter` and `post_filter`, it is possible to pass pure query hashes or use `elasticsearch-dsl`.
 
 ```ruby
-PlaceIndex
+CitiesIndex
   .filter(term: {name: 'Bangkok'})
   .query { match name: 'London' }
   .query.not(range: {population: {gt: 1_000_000}})
 ```
 
+You can query a set of indexes at once:
+
+```ruby
+CitiesIndex.indices(CountriesIndex).query(match: {name: 'Some'})
+```
+
 See https://www.elastic.co/guide/en/elasticsearch/reference/current/query-dsl.html and https://github.com/elastic/elasticsearch-ruby/tree/master/elasticsearch-dsl for more details.
 
 An important part of requests manipulation is merging. There are 4 methods to perform it: `merge`, `and`, `or`, `not`. See [Chewy::Search::QueryProxy](lib/chewy/search/query_proxy.rb) for details. Also, `only` and `except` methods help to remove unneeded parts of the request.
@@ -943,14 +976,14 @@ An important part of requests manipulation is merging. There are 4 methods to pe
 Every other request part is covered by a bunch of additional methods, see [Chewy::Search::Request](lib/chewy/search/request.rb) for details:
 
 ```ruby
-PlaceIndex.limit(10).offset(30).order(:name, {population: {order: :desc}})
+CitiesIndex.limit(10).offset(30).order(:name, {population: {order: :desc}})
 ```
 
 Request DSL also provides additional scope actions, like `delete_all`, `exists?`, `count`, `pluck`, etc.
 
 #### Pagination
 
-The request DSL supports pagination with `Kaminari` and `WillPaginate`. An appropriate extension is enabled on initializtion if any of libraries is available. See [Chewy::Search](lib/chewy/search.rb) and [Chewy::Search::Pagination](lib/chewy/search/pagination/) namespace for details.
+The request DSL supports pagination with `Kaminari`. An extension is enabled on initializtion if `Kaminari` is available. See [Chewy::Search](lib/chewy/search.rb) and [Chewy::Search::Pagination::Kaminari](lib/chewy/search/pagination/kaminari.rb) for details.
 
 #### Named scopes
 
@@ -969,8 +1002,8 @@ See [Chewy::Search::Scrolling](lib/chewy/search/scrolling.rb) for details.
 It is possible to load ORM/ODM source objects with the `objects` method. To provide additional loading options use `load` method:
 
 ```ruby
-PlacesIndex.load(scope: -> { active }).to_a # to_a returns `Chewy::Type` wrappers.
-PlacesIndex.load(scope: -> { active }).objects # An array of AR source objects.
+CitiesIndex.load(scope: -> { active }).to_a # to_a returns `Chewy::Index` wrappers.
+CitiesIndex.load(scope: -> { active }).objects # An array of AR source objects.
 ```
 
 See [Chewy::Search::Loader](lib/chewy/search/loader.rb) for more details.
@@ -978,7 +1011,7 @@ See [Chewy::Search::Loader](lib/chewy/search/loader.rb) for more details.
 In case when it is necessary to iterate through both of the wrappers and objects simultaneously, `object_hash` method helps a lot:
 
 ```ruby
-scope = PlacesIndex.load(scope: -> { active })
+scope = CitiesIndex.load(scope: -> { active })
 scope.each do |wrapper|
   scope.object_hash[wrapper]
 end
@@ -995,8 +1028,8 @@ Performs zero-downtime reindexing as described [here](https://www.elastic.co/blo
 ```bash
 rake chewy:reset # resets all the existing indices
 rake chewy:reset[users] # resets UsersIndex only
-rake chewy:reset[users,places] # resets UsersIndex and PlacesIndex
-rake chewy:reset[-users,places] # resets every index in the application except specified ones
+rake chewy:reset[users,cities] # resets UsersIndex and CitiesIndex
+rake chewy:reset[-users,cities] # resets every index in the application except specified ones
 ```
 
 #### `chewy:upgrade`
@@ -1011,43 +1044,41 @@ See [Chewy::Stash::Specification](lib/chewy/stash.rb) and [Chewy::Index::Specifi
 ```bash
 rake chewy:upgrade # upgrades all the existing indices
 rake chewy:upgrade[users] # upgrades UsersIndex only
-rake chewy:upgrade[users,places] # upgrades UsersIndex and PlacesIndex
-rake chewy:upgrade[-users,places] # upgrades every index in the application except specified ones
+rake chewy:upgrade[users,cities] # upgrades UsersIndex and CitiesIndex
+rake chewy:upgrade[-users,cities] # upgrades every index in the application except specified ones
 ```
 
 #### `chewy:update`
 
 It doesn't create indexes, it simply imports everything to the existing ones and fails if the index was not created before.
 
-Unlike `reset` or `upgrade` tasks, it is possible to pass type references to update the particular type. In index name is passed without the type specified, it will update all the types defined for this index.
-
 ```bash
 rake chewy:update # updates all the existing indices
 rake chewy:update[users] # updates UsersIndex only
-rake chewy:update[users,places#city] # updates the whole UsersIndex and PlacesIndex::City type
-rake chewy:update[-users,places#city] # updates every index in the application except every type defined in UsersIndex and the rest of the types defined in PlacesIndex
+rake chewy:update[users,cities] # updates UsersIndex and CitiesIndex
+rake chewy:update[-users,cities] # updates every index in the application except UsersIndex and CitiesIndex
 ```
 
 #### `chewy:sync`
 
-Provides a way to synchronize outdated indexes with the source quickly and without doing a full reset. By default field `updated_at` is used to find outdated records, but this could be customized by `outdated_sync_field` as described at [Chewy::Type::Syncer](lib/chewy/type/syncer.rb).
+Provides a way to synchronize outdated indexes with the source quickly and without doing a full reset. By default field `updated_at` is used to find outdated records, but this could be customized by `outdated_sync_field` as described at [Chewy::Index::Syncer](lib/chewy/index/syncer.rb).
 
-Arguments are similar to the ones taken by `chewy:update` task. It is possible to specify a particular type or a whole index.
+Arguments are similar to the ones taken by `chewy:update` task.
 
-See [Chewy::Type::Syncer](lib/chewy/type/syncer.rb) for more details.
+See [Chewy::Index::Syncer](lib/chewy/index/syncer.rb) for more details.
 
 ```bash
 rake chewy:sync # synchronizes all the existing indices
 rake chewy:sync[users] # synchronizes UsersIndex only
-rake chewy:sync[users,places#city] # synchronizes the whole UsersIndex and PlacesIndex::City type
-rake chewy:sync[-users,places#city] # synchronizes every index in the application except every type defined in UsersIndex and the rest of the types defined in PlacesIndex
+rake chewy:sync[users,cities] # synchronizes UsersIndex and CitiesIndex
+rake chewy:sync[-users,cities] # synchronizes every index in the application except except UsersIndex and CitiesIndex
 ```
 
 #### `chewy:deploy`
 
 This rake task is especially useful during the production deploy. It is a combination of `chewy:upgrade` and `chewy:sync` and the latter is called only for the indexes that were not reset during the first stage.
 
-It is not possible to specify any particular types/indexes for this task as it doesn't make much sense.
+It is not possible to specify any particular indexes for this task as it doesn't make much sense.
 
 Right now the approach is that if some data had been updated, but index definition was not changed (no changes satisfying the synchronization algorithm were done), it would be much faster to perform manual partial index update inside data migrations or even manually after the deploy.
 
@@ -1064,14 +1095,14 @@ If the number of processes is not specified explicitly - `parallel` gem tries to
 ```bash
 rake chewy:parallel:reset
 rake chewy:parallel:upgrade[4]
-rake chewy:parallel:update[4,places#city]
+rake chewy:parallel:update[4,cities]
 rake chewy:parallel:sync[4,-users]
 rake chewy:parallel:deploy[4] # performs parallel upgrade and parallel sync afterwards
 ```
 
 #### `chewy:journal`
 
-This namespace contains two tasks for the journal manipulations: `chewy:journal:apply` and `chewy:journal:clean`. Both are taking time as the first argument (optional for clean) and a list of indexes/types exactly as the tasks above. Time can be in any format parsable by ActiveSupport.
+This namespace contains two tasks for the journal manipulations: `chewy:journal:apply` and `chewy:journal:clean`. Both are taking time as the first argument (optional for clean) and a list of indexes exactly as the tasks above. Time can be in any format parsable by ActiveSupport.
 
 ```bash
 rake chewy:journal:apply["$(date -v-1H -u +%FT%TZ)"] # apply journaled changes for the past hour
@@ -1080,7 +1111,16 @@ rake chewy:journal:apply["$(date -v-1H -u +%FT%TZ)",users] # apply journaled cha
 
 ### RSpec integration
 
-Just add `require 'chewy/rspec'` to your spec_helper.rb and you will get additional features: See [update_index.rb](lib/chewy/rspec/update_index.rb) for more details.
+Just add `require 'chewy/rspec'` to your spec_helper.rb and you will get additional features:
+
+[update_index](lib/chewy/rspec/update_index.rb) helper
+`mock_elasticsearch_response` helper to mock elasticsearch response
+`mock_elasticsearch_response_sources` helper to mock elasticsearch response sources
+`build_query` matcher to compare request and expected query (returns `true`/`false`)
+
+To use `mock_elasticsearch_response` and `mock_elasticsearch_response_sources` helpers add `include Chewy::Rspec::Helpers` to your tests.
+
+See [chewy/rspec/](lib/chewy/rspec/) for more details.
 
 ### Minitest integration
 
@@ -1090,6 +1130,14 @@ Since you can set `:bypass` strategy for test suites and manually handle import
 
 But if you require chewy to index/update model regularly in your test suite then you can specify `:urgent` strategy for documents indexing. Add `Chewy.strategy(:urgent)` to test_helper.rb.
 
+Also, you can use additional helpers:
+
+`mock_elasticsearch_response` to mock elasticsearch response
+`mock_elasticsearch_response_sources` to mock elasticsearch response sources
+`assert_elasticsearch_query` to compare request and expected query (returns `true`/`false`)
+
+See [chewy/minitest/](lib/chewy/minitest/) for more details.
+
 ### DatabaseCleaner
 
 If you use `DatabaseCleaner` in your tests with [the `transaction` strategy](https://github.com/DatabaseCleaner/database_cleaner#how-to-use), you may run into the problem that `ActiveRecord`'s models are not indexed automatically on save despite the fact that you set the callbacks to do this with the `update_index` method. The issue arises because `chewy` indices data on `after_commit` run as default, but all `after_commit` callbacks are not run with the `DatabaseCleaner`'s' `transaction` strategy. You can solve this issue by changing the `Chewy.use_after_commit_callbacks` option. Just add the following initializer in your Rails application:
@@ -1108,7 +1156,7 @@ Chewy.use_after_commit_callbacks = !Rails.env.test?
 5. Push to the branch (`git push origin my-new-feature`)
 6. Create new Pull Request
 
-Use the following Rake tasks to control the Elasticsearch cluster while developing.
+Use the following Rake tasks to control the Elasticsearch cluster while developing, if you prefer native Elasticsearch installation over the dockerized one:
 
 ```bash
 rake elasticsearch:start # start Elasticsearch cluster on 9250 port for tests