chewy 7.0.1 → 7.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1dd4e22b7f5c013837c2799973a115efec21cac6555a8ec9f30c85b63525f155
-  data.tar.gz: d938f5225426da6b649179bcacced5f24974a80995cf4dd62ac77f8e9484df8b
+  metadata.gz: 58a5011ecef1ca511a28d4d3299d61f852c4c11ffe6fd124db3e0a5b370a0f9e
+  data.tar.gz: fa0ce61841d579210c2de4a84624b265cca533f887e6125d8e07cee59315c4a6
 SHA512:
-  metadata.gz: f54a6ae762f36af260a07f7da838d802e5152431b14b8120c1be2fa083510ecaf1ae650e115294a2bac3ad4ae17bac399b0873d4259e63f4ad9a655c05bfa224
-  data.tar.gz: d2c4cf7030995844d04841ad0739497dacffd3fb57d52ca6d7aed871d30e112fe6eb88f084a678c7090d359f91f944b21fc4f45b65f1f9fffa6da2775f9845b0
+  metadata.gz: '0925c5bb8f3adfc79b5914d975c71f2677d6232ccbac074d65ee63d99d23cfbc16c85adf88c953e003fbebfcff2fc9b0bb5a11d735ce6432cdcd57d76e7f81e4'
+  data.tar.gz: fefd812c6daea408e90b6f235efd169b195b5d1003fe4d3042c2e502b375d0b7cdf6d4d41133d012bf05a0f0e417ce95e43fbd1eb8e99b9ba3d72f6a4b50e548

data/.circleci/config.yml

@@ -23,8 +23,6 @@ workflows:
       - rspec-ruby-27-activerecord52
       - rspec-ruby-27-mongoid
       - rspec-ruby-30-activerecord61
-      - rspec-ruby-27-activerecord61-es6
-      - rspec-ruby-30-activerecord61-es6
 
 commands:
   rspec-test:
@@ -214,27 +212,3 @@ jobs:
       GEMFILE: gemfiles/rails.6.1.activerecord.gemfile
     steps:
       - rspec-test
-
-  rspec-ruby-27-activerecord61-es6:
-    docker:
-      - image: circleci/ruby:2.7
-      - image: docker.elastic.co/elasticsearch/elasticsearch:6.8.13
-        environment:
-          <<: *es-env
-    working_directory: ~/repo
-    environment:
-      GEMFILE: gemfiles/rails.6.1.activerecord.gemfile
-    steps:
-      - rspec-test
-
-  rspec-ruby-30-activerecord61-es6:
-    docker:
-      - image: circleci/ruby:3.0
-      - image: docker.elastic.co/elasticsearch/elasticsearch:6.8.13
-        environment:
-          <<: *es-env
-    working_directory: ~/repo
-    environment:
-      GEMFILE: gemfiles/rails.6.1.activerecord.gemfile
-    steps:
-      - rspec-test

data/CHANGELOG.md

@@ -8,12 +8,16 @@
 
 ### Bugs Fixed
 
-## 7.0.1 (2021-05-03)
+## 7.1.0 (2021-03-03)
 
 ### Changes
 
-  * [#792](https://github.com/toptal/chewy/pull/792): Skip ES version memoization for search requests ([@rabotyaga][])
-    * See the Migration Guide for details
+  * [#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)
 

data/README.md

@@ -17,7 +17,6 @@ Chewy is an ODM (Object Document Mapper), built on top of the [the official Elas
   * [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)
@@ -55,10 +54,6 @@ Chewy is an ODM (Object Document Mapper), built on top of the [the official Elas
 
 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.
@@ -99,6 +94,7 @@ Chewy is compatible with MRI 2.5-3.0¹.
 
 | Chewy version | Elasticsearch version              |
 | ------------- | ---------------------------------- |
+| 7.1.x         | 7.x                                |
 | 7.0.0         | 6.8, 7.x                           |
 | 6.0.0         | 5.x, 6.x                           |
 | 5.x           | 5.x, limited support for 1.x & 2.x |
@@ -365,18 +361,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:
@@ -602,7 +586,7 @@ Imagine that you reset your index in a zero-downtime manner (to separate index),
 
 ### Types access
 
-You can access index-defined types with the following API:
+You can access index-defined type with the following API:
 
 ```ruby
 UsersIndex::User # => UsersIndex::User
@@ -630,11 +614,10 @@ UsersIndex::User.import # import with 0 arguments process all the data specified
 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::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 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.import # same as UsersIndex::User.import
+UsersIndex.import user: User.where('rating > 100') # import only specified users
 UsersIndex.reset! # purges index and imports default data for all types
 ```
 
@@ -923,19 +906,25 @@ Quick introduction.
 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:
 
 ```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'}) # or
+CitiesIndex::City.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
 
 ```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,7 +932,7 @@ 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.
@@ -969,8 +958,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::Type` 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 +967,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 +984,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,8 +1000,8 @@ 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`
@@ -1024,8 +1013,8 @@ Unlike `reset` or `upgrade` tasks, it is possible to pass type references to upd
 ```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#city] # updates UsersIndex and CitiesIndex (if City type is defined on CitiesIndex)
+rake chewy:update[-users,cities#city] # updates every index in the application except UsersIndex and CitiesIndex::City
 ```
 
 #### `chewy:sync`
@@ -1039,8 +1028,8 @@ See [Chewy::Type::Syncer](lib/chewy/type/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#city] # synchronizes UsersIndex and CitiesIndex (if City type is defined on CitiesIndex)
+rake chewy:sync[-users,cities#city] # synchronizes every index in the application except except UsersIndex and CitiesIndex::City
 ```
 
 #### `chewy:deploy`
@@ -1064,7 +1053,7 @@ 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#city]
 rake chewy:parallel:sync[4,-users]
 rake chewy:parallel:deploy[4] # performs parallel upgrade and parallel sync afterwards
 ```

data/lib/chewy/fields/root.rb

@@ -29,8 +29,7 @@ module Chewy
           mappings[name][:dynamic_templates].concat dynamic_templates
         end
 
-        mappings[name][:_parent] = parent.is_a?(Hash) ? parent : {type: parent} if parent
-        mappings
+        mappings[name]
       end
 
       def dynamic_template(*args)

data/lib/chewy/index.rb

@@ -152,23 +152,12 @@ module Chewy
         self.type_hash = type_hash.merge(type_class.type_name => type_class)
       end
 
-      # Types method has double usage.
-      # If no arguments are passed - it returns array of defined types:
+      # Returns defined type:
       #
-      #   UsersIndex.types # => [UsersIndex::Admin, UsersIndex::Manager, UsersIndex::User]
+      #   UsersIndex.types # => [UsersIndex::User]
       #
-      # If arguments are passed it treats like a part of chainable query DSL and
-      # adds types array for index to select.
-      #
-      #   UsersIndex.filters { name =~ 'ro' }.types(:admin, :manager)
-      #   UsersIndex.types(:admin, :manager).filters { name =~ 'ro' } # the same as the first example
-      #
-      def types(*args)
-        if args.present?
-          all.types(*args)
-        else
-          type_hash.values
-        end
+      def types
+        type_hash.values
       end
 
       # Returns defined types names:

data/lib/chewy/index/actions.rb

@@ -59,9 +59,7 @@ module Chewy
 
           body = specification_hash
           body[:aliases] = {general_name => {}} if options[:alias] && suffixed_name != general_name
-          args = {index: suffixed_name, body: body}
-          args[:include_type_name] = true if Runtime.version >= '6.7.0'
-          result = client.indices.create(**args)
+          result = client.indices.create(index: suffixed_name, body: body)
 
           Chewy.wait_for_status if result
           result

data/lib/chewy/index/aliases.rb

@@ -5,9 +5,7 @@ module Chewy
 
       module ClassMethods
         def indexes
-          get_args = {index: index_name}
-          get_args[:include_type_name] = true if Runtime.version >= '6.7.0'
-          indexes = empty_if_not_found { client.indices.get(**get_args).keys }
+          indexes = empty_if_not_found { client.indices.get(index: index_name).keys }
           indexes += empty_if_not_found { client.indices.get_alias(name: index_name).keys }
           indexes.compact.uniq
         end

data/lib/chewy/railtie.rb

@@ -22,17 +22,6 @@ module Chewy
     end
 
     module MigrationStrategy
-      extend ActiveSupport::Concern
-      included do
-        alias_method_chain :migrate, :chewy
-      end
-
-      def migrate_with_chewy(*args)
-        Chewy.strategy(:bypass) { migrate_without_chewy(*args) }
-      end
-    end
-
-    module Rails5MigrationStrategy
       def migrate(*args)
         Chewy.strategy(:bypass) { super }
       end
@@ -57,13 +46,8 @@ module Chewy
 
     initializer 'chewy.migration_strategy' do
       ActiveSupport.on_load(:active_record) do
-        if Rails::VERSION::MAJOR >= 5
-          ActiveRecord::Migration.prepend(Rails5MigrationStrategy)
-          ActiveRecord::Migrator.prepend(Rails5MigrationStrategy) if defined? ActiveRecord::Migrator
-        else
-          ActiveRecord::Migration.send(:include, MigrationStrategy)
-          ActiveRecord::Migrator.send(:include, MigrationStrategy) if defined? ActiveRecord::Migrator
-        end
+        ActiveRecord::Migration.prepend(MigrationStrategy)
+        ActiveRecord::Migrator.prepend(MigrationStrategy) if defined? ActiveRecord::Migrator
       end
     end
 

data/lib/chewy/search/loader.rb

@@ -9,14 +9,10 @@ module Chewy
     # @see Chewy::Search::Scrolling#scroll_objects
     class Loader
       # @param indexes [Array<Chewy::Index>] list of indexes to lookup types
-      # @param only [Array<String, Symbol>] list of selected type names to load
-      # @param except [Array<String, Symbol>] list of type names which will not be loaded
       # @param options [Hash] adapter-specific load options
       # @see Chewy::Type::Adapter::Base#load
-      def initialize(indexes: [], only: [], except: [], **options)
+      def initialize(indexes: [], **options)
         @indexes = indexes
-        @only = Array.wrap(only).map(&:to_s)
-        @except = Array.wrap(except).map(&:to_s)
         @options = options
       end
 
@@ -31,7 +27,7 @@ module Chewy
         (@derive_type ||= {})[[index, type]] ||= begin
           index_class = derive_index(index)
           raise Chewy::UnderivableType, "Can not find index named `#{index}`" unless index_class
-          index_class.type_hash[type] or raise Chewy::UnderivableType, "Index `#{index}` doesn`t have type named `#{type}`"
+          index_class.type_hash.values.first
         end
       end
 
@@ -48,8 +44,6 @@ module Chewy
       def load(hits)
         hit_groups = hits.group_by { |hit| [hit['_index'], hit['_type']] }
         loaded_objects = hit_groups.each_with_object({}) do |((index_name, type_name), hit_group), result|
-          next if skip_type?(type_name)
-
           type = derive_type(index_name, type_name)
           ids = hit_group.map { |hit| hit['_id'] }
           loaded = type.adapter.load(ids, **@options.merge(_type: type))
@@ -74,10 +68,6 @@ module Chewy
       def indexes_hash
         @indexes_hash ||= @indexes.index_by(&:index_name)
       end
-
-      def skip_type?(type_name)
-        @except.include?(type_name) || @only.present? && !@only.include?(type_name)
-      end
     end
   end
 end

data/lib/chewy/search/parameters/indices.rb

@@ -3,70 +3,48 @@ require 'chewy/search/parameters/storage'
 module Chewy
   module Search
     class Parameters
-      # Stores indices and/or types to query.
+      # Stores indices to query.
       # Renders it to lists of string accepted by ElasticSearch
       # API.
       #
-      # The semantics behind it can be described in the
-      # following statements:
-      # 1. If index is added to the storage, no matter, a class
+      # If index is added to the storage, no matter, a class
       # or a string/symbol, it gets appended to the list.
-      # 2. If type is added to the storage, it filters out types
-      # assigned via indices.
-      # 3. But when a type class with non-existing index is added,
-      # this index got also added to the list if indices.
-      # 4. In cases when of an index identifier added, type
-      # indetifiers also got appended instead of filtering.
       class Indices < Storage
         # Two index storages are equal if they produce the
         # same output on render.
         #
         # @see Chewy::Search::Parameters::Storage#==
         # @param other [Chewy::Search::Parameters::Storage] any storage instance
-        # @return [true, false] the result of comparision
+        # @return [true, false] the result of comparison
         def ==(other)
           super || other.class == self.class && other.render == render
         end
 
-        # Just adds types to types and indices to indices.
+        # Just adds indices to indices.
         #
         # @see Chewy::Search::Parameters::Storage#update!
-        # @param other_value [{Symbol => Array<Chewy::Index, Chewy::Type, String, Symbol>}] any acceptable storage value
-        # @return [{Symbol => Array<Chewy::Index, Chewy::Type, String, Symbol>}] updated value
+        # @param other_value [{Symbol => Array<Chewy::Index, String, Symbol>}] any acceptable storage value
+        # @return [{Symbol => Array<Chewy::Index, String, Symbol>}] updated value
         def update!(other_value)
           new_value = normalize(other_value)
 
-          @value = {
-            indices: value[:indices] | new_value[:indices],
-            types: value[:types] | new_value[:types]
-          }
+          @value = {indices: value[:indices] | new_value[:indices]}
         end
 
-        # Returns desired index and type names.
+        # Returns desired index names.
         #
         # @see Chewy::Search::Parameters::Storage#render
         # @return [{Symbol => Array<String>}] rendered value with the parameter name
         def render
-          {
-            index: index_names.uniq.sort,
-            type: type_names.uniq.sort
-          }.reject { |_, v| v.blank? }
+          {index: index_names.uniq.sort}.reject { |_, v| v.blank? }
         end
 
         # Returns index classes used for the request.
-        # No strings/symbos included.
+        # No strings/symbols included.
         #
         # @return [Array<Chewy::Index>] a list of index classes
         def indices
-          index_classes | type_classes.map(&:index)
-        end
-
-        # Returns type classes used for the request.
-        # No strings/symbos included.
-        #
-        # @return [Array<Chewy::Type>] a list of types classes
-        def types
-          type_classes | (index_classes - type_classes.map(&:index)).flat_map(&:types)
+          index_classes
         end
 
       private
@@ -78,10 +56,7 @@ module Chewy
         def normalize(value)
           value ||= {}
 
-          {
-            indices: Array.wrap(value[:indices]).flatten.compact,
-            types: Array.wrap(value[:types]).flatten.compact
-          }
+          {indices: Array.wrap(value[:indices]).flatten.compact}
         end
 
         def index_classes
@@ -97,26 +72,6 @@ module Chewy
         def index_names
           indices.map(&:index_name) | index_identifiers.map(&:to_s)
         end
-
-        def type_classes
-          value[:types].select do |klass|
-            klass.is_a?(Class) && klass < Chewy::Type
-          end
-        end
-
-        def type_identifiers
-          value[:types] - type_classes
-        end
-
-        def type_names
-          type_names = types.map(&:type_name)
-
-          if index_identifiers.blank? && type_identifiers.present?
-            (type_names & type_identifiers.map(&:to_s)).presence || type_names
-          else
-            type_names | type_identifiers.map(&:to_s)
-          end
-        end
       end
     end
   end