chewy 0.9.0 → 0.10.0

data/lib/chewy/type/witchcraft.rb

@@ -35,17 +35,20 @@ module Chewy
           !!_witchcraft
         end
 
-        def cauldron
-          @cauldron ||= Cauldron.new(self)
+        def cauldron(**options)
+          (@cauldron ||= {})[options] ||= Cauldron.new(self, **options)
         end
       end
 
       class Cauldron
         attr_reader :locals
 
-        def initialize(type)
+        # @param type [Chewy::Type] type for composition
+        # @param fields [Array<Symbol>] restricts the fields for composition
+        def initialize(type, fields: [])
           @type = type
           @locals = []
+          @fields = fields
         end
 
         def brew(object, crutches = nil)
@@ -91,7 +94,7 @@ module Chewy
         end
 
         def non_proc_values(field, nesting)
-          non_proc_fields = non_proc_fields_for(field)
+          non_proc_fields = non_proc_fields_for(field, nesting)
           object = "object#{nesting}"
 
           if non_proc_fields.present?
@@ -100,13 +103,13 @@ module Chewy
                 {
                   #{non_proc_fields.map do |f|
                     fetcher = "#{object}.has_key?(:#{f.name}) ? #{object}[:#{f.name}] : #{object}['#{f.name}']"
-                    "#{f.name}: #{composed_value(f, fetcher, nesting)}"
+                    "'#{f.name}'.freeze => #{composed_value(f, fetcher, nesting)}"
                   end.join(', ')}
                 }
               else
                 {
                   #{non_proc_fields.map do |f|
-                    "#{f.name}: #{composed_value(f, "#{object}.#{f.name}", nesting)}"
+                    "'#{f.name}'.freeze => #{composed_value(f, "#{object}.#{f.name}", nesting)}"
                   end.join(', ')}
                 }
               end)
@@ -117,13 +120,13 @@ module Chewy
         end
 
         def proc_values(field, nesting)
-          proc_fields = proc_fields_for(field)
+          proc_fields = proc_fields_for(field, nesting)
 
           if proc_fields.present?
             <<-RUBY
               {
                 #{proc_fields.map do |f|
-                  "#{f.name}: (#{composed_value(f, source_for(f.value, nesting), nesting)})"
+                  "'#{f.name}'.freeze => (#{composed_value(f, source_for(f.value, nesting), nesting)})"
                 end.join(', ')}
               }
             RUBY
@@ -132,14 +135,26 @@ module Chewy
           end
         end
 
-        def non_proc_fields_for(parent)
+        def non_proc_fields_for(parent, nesting)
           return [] unless parent
-          (parent.children || []).select { |field| !(field.value && field.value.is_a?(Proc)) }
+          fields = (parent.children || []).reject { |field| field.value && field.value.is_a?(Proc) }
+
+          if nesting.zero? && @fields.present?
+            fields.select { |f| @fields.include?(f.name) }
+          else
+            fields
+          end
         end
 
-        def proc_fields_for(parent)
+        def proc_fields_for(parent, nesting)
           return [] unless parent
-          (parent.children || []).select { |field| field.value && field.value.is_a?(Proc) }
+          fields = (parent.children || []).select { |field| field.value && field.value.is_a?(Proc) }
+
+          if nesting.zero? && @fields.present?
+            fields.select { |f| @fields.include?(f.name) }
+          else
+            fields
+          end
         end
 
         def source_for(proc, nesting)
@@ -166,7 +181,6 @@ module Chewy
               locals.push(proc.binding.eval(variable.to_s))
               source = replace_local(source, variable, locals.size - 1)
             end
-
           end
 
           Unparser.unparse(source)

data/lib/chewy/type/wrapper.rb

@@ -3,22 +3,48 @@ module Chewy
     module Wrapper
       extend ActiveSupport::Concern
 
-      attr_accessor :attributes, :_data, :_object
+      included do
+        attr_accessor :_data, :_object
+        attr_reader :attributes
+      end
+
+      module ClassMethods
+        def build(hit)
+          attributes = (hit['_source'] || {})
+            .reverse_merge(id: hit['_id'])
+            .merge!(_score: hit['_score'])
+            .merge!(_explanation: hit['_explanation'])
+
+          wrapper = new(attributes)
+          wrapper._data = hit
+          wrapper
+        end
+      end
 
       def initialize(attributes = {})
         @attributes = attributes.stringify_keys
       end
 
       def ==(other)
+        return true if super
+
         if other.is_a?(Chewy::Type)
           self.class == other.class && (respond_to?(:id) ? id == other.id : attributes == other.attributes)
         elsif other.respond_to?(:id)
-          id.to_s == other.id.to_s
+          self.class.adapter.target.is_a?(Class) &&
+            other.is_a?(self.class.adapter.target) &&
+            id.to_s == other.id.to_s
         else
           false
         end
       end
 
+      %w[_id _type _index].each do |name|
+        define_method name do
+          data[name]
+        end
+      end
+
       def method_missing(method, *args, &block)
         m = method.to_s
         if (name = highlight_name(m))

data/lib/chewy/version.rb

@@ -1,3 +1,3 @@
 module Chewy
-  VERSION = '0.9.0'.freeze
+  VERSION = '0.10.0'.freeze
 end

data/lib/tasks/chewy.rake

@@ -1,34 +1,96 @@
 require 'chewy/rake_helper'
 
+def parse_classes(args)
+  if args.present? && args.first.tr!('-', '')
+    {except: args}
+  else
+    {only: args}
+  end
+end
+
+def parse_parallel_args(args)
+  options = {}
+  options[:parallel] = args.first =~ /\A\d+\z/ ? Integer(args.shift) : true
+  options.merge!(parse_classes(args))
+end
+
+def parse_journal_args(args)
+  options = {}
+  options[:time] = Time.parse(args.shift) if args.first =~ /\A\d+/
+  options.merge!(parse_classes(args))
+end
+
 namespace :chewy do
-  desc 'Destroy, recreate and import data to specified index'
+  desc 'Destroys, recreates and imports data for the specified indexes or all of them'
   task reset: :environment do |_task, args|
-    Chewy::RakeHelper.subscribed_task_stats do
-      indexes = args.extras
+    Chewy::RakeHelper.reset(parse_classes(args.extras))
+  end
 
-      if indexes.empty? || indexes.first.tr!('-', '')
-        Chewy::RakeHelper.reset_all(indexes)
-      else
-        Chewy::RakeHelper.reset_index(indexes)
-      end
-    end
+  desc 'Resets data for the specified indexes or all of them only if the index specification is changed'
+  task upgrade: :environment do |_task, args|
+    Chewy::RakeHelper.upgrade(parse_classes(args.extras))
   end
 
-  desc 'Updates data specified index'
+  desc 'Updates data for the specified indexes/types or all of them'
   task update: :environment do |_task, args|
-    Chewy::RakeHelper.subscribed_task_stats do
-      indexes = args.extras
+    Chewy::RakeHelper.update(parse_classes(args.extras))
+  end
 
-      if indexes.empty? || indexes.first.tr!('-', '')
-        Chewy::RakeHelper.update_all(indexes)
-      else
-        Chewy::RakeHelper.update_index(indexes)
-      end
+  desc 'Synchronizes data for the specified indexes/types or all of them'
+  task sync: :environment do |_task, args|
+    Chewy::RakeHelper.sync(parse_classes(args.extras))
+  end
+
+  desc 'Resets all the indexes with the specification changed and synchronizes the rest of them'
+  task deploy: :environment do
+    processed = Chewy::RakeHelper.upgrade
+    Chewy::RakeHelper.sync(except: processed)
+  end
+
+  namespace :parallel do
+    desc 'Parallel version of `rake chewy:reset`'
+    task reset: :environment do |_task, args|
+      Chewy::RakeHelper.reset(parse_parallel_args(args.extras))
+    end
+
+    desc 'Parallel version of `rake chewy:upgrade`'
+    task upgrade: :environment do |_task, args|
+      Chewy::RakeHelper.upgrade(parse_parallel_args(args.extras))
+    end
+
+    desc 'Parallel version of `rake chewy:update`'
+    task update: :environment do |_task, args|
+      Chewy::RakeHelper.update(parse_parallel_args(args.extras))
+    end
+
+    desc 'Parallel version of `rake chewy:sync`'
+    task sync: :environment do |_task, args|
+      Chewy::RakeHelper.sync(parse_parallel_args(args.extras))
+    end
+
+    desc 'Parallel version of `rake chewy:deploy`'
+    task deploy: :environment do |_task, args|
+      parallel = args.extras.first =~ /\A\d+\z/ ? Integer(args.extras.first) : true
+      processed = Chewy::RakeHelper.upgrade(parallel: parallel)
+      Chewy::RakeHelper.sync(except: processed, parallel: parallel)
+    end
+  end
+
+  namespace :journal do
+    desc 'Applies changes that were done after the specified time for the specified indexes/types or all of them'
+    task apply: :environment do |_task, args|
+      Chewy::RakeHelper.journal_apply(parse_journal_args(args.extras))
+    end
+
+    desc 'Removes journal records created before the specified timestamp for the specified indexes/types or all of them'
+    task clean: :environment do |_task, args|
+      Chewy::RakeHelper.journal_clean(parse_journal_args(args.extras))
     end
   end
 
-  desc 'Applies changes that were done from specified moment (as a timestamp)'
   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
 
@@ -37,18 +99,14 @@ namespace :chewy do
       else
         timestamp, retries = params
         time = Time.at(timestamp.to_i)
-        Chewy::Journal::Apply.since(time, retries: (retries.to_i if retries))
+        Chewy::Journal.new.apply(time, retries: (retries.to_i if retries))
       end
     end
   end
 
-  desc 'Cleans journal index. It accepts timestamp until which journal will be cleaned'
   task clean_journal: :environment do |_task, args|
-    timestamp = args.extras.first
-    if timestamp
-      Chewy::Journal::Clean.until(Time.at(timestamp.to_i))
-    else
-      Chewy::Journal.delete!
-    end
+    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/spec/chewy/config_spec.rb

@@ -13,6 +13,10 @@ describe Chewy::Config do
   its(:request_strategy) { should == :atomic }
   its(:use_after_commit_callbacks) { should == true }
   its(:indices_path) { should == 'app/chewy' }
+  its(:reset_disable_refresh_interval) { should == false }
+  its(:reset_no_replicas) { should == false }
+  its(:disable_refresh_async) { should == false }
+  its(:search_class) { should be < Chewy::Search::Request }
 
   describe '#transport_logger=' do
     let(:logger) { Logger.new('/dev/null') }
@@ -50,8 +54,85 @@ describe Chewy::Config do
     end
   end
 
+  describe '#search_class=' do
+    specify do
+      expect { subject.search_class = Chewy::Query }
+        .to change { subject.search_class }
+        .from(be < Chewy::Search::Request)
+        .to(be < Chewy::Query)
+    end
+
+    context do
+      before { hide_const('Kaminari') }
+
+      specify do
+        expect(subject.search_class.included_modules)
+          .to include(Chewy::Search::Pagination::WillPaginate)
+      end
+    end
+  end
+
+  describe '#search_class' 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
+
   describe '#configuration' do
-    before { subject.settings = { indices_path: 'app/custom_indices_path' } }
+    before { subject.settings = {indices_path: 'app/custom_indices_path'} }
 
     specify do
       expect(subject.configuration).to include(indices_path: 'app/custom_indices_path')

data/spec/chewy/fields/base_spec.rb

@@ -8,7 +8,7 @@ describe Chewy::Fields::Base do
     let(:field) { described_class.new(:name, value: ->(o) { o.value }) }
 
     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(field.compose(double(value: %w[hello world]))).to eq(name: %w[hello world]) }
 
     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) }
@@ -24,23 +24,24 @@ describe Chewy::Fields::Base do
 
       specify do
         expect(field.compose(double(value: double(subvalue1: 'hello', subvalue2: 'value', subname3: 'world'))))
-          .to eq(name: { subname1: 'hello', subname2: 'value', subname3: 'world' })
+          .to eq(name: {subname1: 'hello', subname2: 'value', subname3: 'world'})
       end
       specify do
         expect(field.compose(double(value: [
           double(subvalue1: 'hello1', subvalue2: 'value1', subname3: 'world1'),
           double(subvalue1: 'hello2', subvalue2: 'value2', subname3: 'world2')
         ]))).to eq(name: [
-          { subname1: 'hello1', subname2: 'value1', subname3: 'world1' },
-          { subname1: 'hello2', subname2: 'value2', subname3: 'world2' }
+          {subname1: 'hello1', subname2: 'value1', subname3: 'world1'},
+          {subname1: 'hello2', subname2: 'value2', subname3: 'world2'}
         ])
       end
     end
 
     context 'parent objects' do
-      let!(:country) { described_class.new(:name, value: ->(country) { country.cities }) }
-      let!(:city) { described_class.new(:name, value: ->(city, country) { city.districts.map { |district| [district, country.name] } }) }
-      let!(:district) { described_class.new(:name, value: ->(district, city, country) { [district, city.name, country.name] }) }
+      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(:crutches) { double(suffix: 'suffix', city_name: 'Bangkok') }
 
       before do
         country.children.push(city)
@@ -49,12 +50,12 @@ describe Chewy::Fields::Base do
 
       specify do
         expect(country.compose(double(name: 'Thailand', cities: [
-          double(name: 'Bangkok', districts: %w(First Second))
-        ]))).to eq(name: [
-          { name: [
-            { name: [%w(First Thailand), 'Bangkok', 'Thailand'] },
-            { name: [%w(Second Thailand), 'Bangkok', 'Thailand'] }
-          ] }
+          double(districts: %w[First Second])
+        ]), crutches)).to eq(name: [
+          {name: [
+            {name: [%w[First Thailand suffix], 'Bangkok', 'Thailand', crutches]},
+            {name: [%w[Second Thailand suffix], 'Bangkok', 'Thailand', crutches]}
+          ]}
         ])
       end
     end
@@ -71,14 +72,14 @@ describe Chewy::Fields::Base do
 
     context 'hash values' do
       let(:field) { described_class.new(:name, type: 'object') }
-      let(:object) { double(name: { key1: 'value1', key2: 'value2' }) }
+      let(:object) { double(name: {key1: 'value1', key2: 'value2'}) }
 
       before do
         field.children.push(described_class.new(:key1, value: ->(h) { h[:key1] }))
         field.children.push(described_class.new(:key2, value: ->(h) { h[:key2] }))
       end
 
-      specify { expect(field.compose(object)).to eq(name: { key1: 'value1', key2: 'value2' }) }
+      specify { expect(field.compose(object)).to eq(name: {key1: 'value1', key2: 'value2'}) }
     end
   end
 
@@ -92,11 +93,11 @@ describe Chewy::Fields::Base do
     end
 
     specify do
-      expect(field.mappings_hash).to eq(name: { type: :object, properties: {
-                                          name1: { type: 'string1', fields: {
-                                            name3: { type: 'string3' }, name4: { type: 'string4' }
-                                          } }, name2: { type: 'string2' }
-                                        } })
+      expect(field.mappings_hash).to eq(name: {type: :object, properties: {
+        name1: {type: 'string1', fields: {
+          name3: {type: 'string3'}, name4: {type: 'string4'}
+        }}, name2: {type: 'string2'}
+      }})
     end
 
     context do
@@ -104,11 +105,11 @@ describe Chewy::Fields::Base do
       let(:fields1) { Array.new(2) { |i| described_class.new("name#{i + 1}") } }
 
       specify do
-        expect(field.mappings_hash).to eq(name: { type: :string, fields: {
-                                            name1: { type: 'object', properties: {
-                                              name3: { type: 'string3' }, name4: { type: 'string4' }
-                                            } }, name2: { type: 'string' }
-                                          } })
+        expect(field.mappings_hash).to eq(name: {type: :string, fields: {
+          name1: {type: 'object', properties: {
+            name3: {type: 'string3'}, name4: {type: 'string4'}
+          }}, name2: {type: 'string'}
+        }})
       end
     end
   end
@@ -132,85 +133,115 @@ describe Chewy::Fields::Base do
 
       specify do
         expect(EventsIndex::Event.mappings_hash).to eq(event: {
-                                                         properties: {
-                                                           id: { type: 'string' },
-                                                           category: {
-                                                             type: 'object',
-                                                             properties: {
-                                                               id: { type: 'string' },
-                                                               licenses: {
-                                                                 type: 'object',
-                                                                 properties: {
-                                                                   id: { type: 'string' },
-                                                                   name: { type: 'string' }
-                                                                 }
-                                                               }
-                                                             }
-                                                           }
-                                                         }
-                                                       })
+          properties: {
+            id: {type: 'string'},
+            category: {
+              type: 'object',
+              properties: {
+                id: {type: 'string'},
+                licenses: {
+                  type: 'object',
+                  properties: {
+                    id: {type: 'string'},
+                    name: {type: 'string'}
+                  }
+                }
+              }
+            }
+          }
+        })
+      end
+
+      context 'default field type' do
+        around do |example|
+          previous_type = Chewy.default_field_type
+          Chewy.default_field_type = 'text'
+          example.run
+          Chewy.default_field_type = previous_type
+        end
+
+        specify do
+          expect(EventsIndex::Event.mappings_hash).to eq(event: {
+            properties: {
+              id: {type: 'text'},
+              category: {
+                type: 'object',
+                properties: {
+                  id: {type: 'text'},
+                  licenses: {
+                    type: 'object',
+                    properties: {
+                      id: {type: 'text'},
+                      name: {type: 'text'}
+                    }
+                  }
+                }
+              }
+            }
+          })
+        end
       end
 
       specify do
         expect(EventsIndex::Event.root_object.compose(
-                 id: 1, category: { id: 2, licenses: { id: 3, name: 'Name' } }
-        )).to eq('event' => { 'id' => 1, 'category' => { 'id' => 2, 'licenses' => { 'id' => 3, 'name' => 'Name' } } })
+                 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_object.compose(id: 1, category: [
-          { id: 2, 'licenses' => { id: 3, name: 'Name1' } },
-          { id: 4, licenses: nil }
-        ])).to eq('event' => { 'id' => 1, 'category' => [
-          { 'id' => 2, 'licenses' => { 'id' => 3, 'name' => 'Name1' } },
-          { 'id' => 4, 'licenses' => nil.as_json }
-        ] })
+          {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_object.compose('id' => 1, category: { id: 2, licenses: [
-          { id: 3, name: 'Name1' }, { id: 4, name: 'Name2' }
-        ] })).to eq('event' => { 'id' => 1, 'category' => { 'id' => 2, 'licenses' => [
-          { 'id' => 3, 'name' => 'Name1' }, { 'id' => 4, 'name' => 'Name2' }
-        ] } })
+        expect(EventsIndex::Event.root_object.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_object.compose(id: 1, category: [
-          { id: 2, licenses: [
-            { id: 3, 'name' => 'Name1' }, { id: 4, name: 'Name2' }
-          ] },
-          { id: 5, licenses: [] }
-        ])).to eq('event' => { 'id' => 1, 'category' => [
-          { 'id' => 2, 'licenses' => [
-            { 'id' => 3, 'name' => 'Name1' }, { 'id' => 4, 'name' => 'Name2' }
-          ] },
-          { 'id' => 5, 'licenses' => [] }
-        ] })
+          {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
 
       specify do
         expect(EventsIndex::Event.root_object.compose(
                  double(id: 1, category: double(id: 2, licenses: double(id: 3, name: 'Name')))
-        )).to eq('event' => { '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_object.compose(double(id: 1, category: [
           double(id: 2, licenses: double(id: 3, name: 'Name1')),
           double(id: 4, licenses: nil)
-        ]))).to eq('event' => { 'id' => 1, 'category' => [
-          { 'id' => 2, 'licenses' => { 'id' => 3, 'name' => 'Name1' } },
-          { 'id' => 4, 'licenses' => nil.as_json }
-        ] })
+        ]))).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_object.compose(double(id: 1, category: double(id: 2, licenses: [
           double(id: 3, name: 'Name1'), double(id: 4, name: 'Name2')
-        ])))).to eq('event' => { '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
@@ -219,12 +250,12 @@ describe Chewy::Fields::Base do
             double(id: 3, name: 'Name1'), double(id: 4, name: 'Name2')
           ]),
           double(id: 5, licenses: [])
-        ]))).to eq('event' => { '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
     end
 
@@ -247,7 +278,7 @@ describe Chewy::Fields::Base do
       specify do
         expect(EventsIndex::Event.root_object.compose(
                  double(id: 1, categories: double(id: 2, license: double(id: 3, name: 'Name')))
-        )).to eq('event' => { 'id' => 1, 'category' => { 'id' => 2, 'licenses' => { 'id' => 3, 'name' => 'Name' } } })
+        )).to eq('id' => 1, 'category' => {'id' => 2, 'licenses' => {'id' => 3, 'name' => 'Name'}})
       end
     end
 
@@ -266,43 +297,43 @@ describe Chewy::Fields::Base do
 
       specify do
         expect(EventsIndex::Event.mappings_hash).to eq(event: {
-                                                         properties: {
-                                                           id: { type: 'string' },
-                                                           name: {
-                                                             type: 'string',
-                                                             fields: {
-                                                               raw: { analyzer: 'my_own', type: 'string' }
-                                                             }
-                                                           },
-                                                           category: { type: 'object' }
-                                                         }
-                                                       })
+          properties: {
+            id: {type: 'string'},
+            name: {
+              type: 'string',
+              fields: {
+                raw: {analyzer: 'my_own', type: 'string'}
+              }
+            },
+            category: {type: 'object'}
+          }
+        })
       end
 
       specify do
         expect(EventsIndex::Event.root_object.compose(
-                 double(id: 1, name: 'Jonny', category: double(id: 2, as_json: { 'name' => 'Borogoves' }))
-        )).to eq('event' => {
-                   'id' => 1,
-                   'name' => 'Jonny',
-                   'category' => { 'name' => 'Borogoves' }
-                 })
+                 double(id: 1, name: 'Jonny', category: double(id: 2, as_json: {'name' => 'Borogoves'}))
+        )).to eq(
+          'id' => 1,
+          'name' => 'Jonny',
+          'category' => {'name' => 'Borogoves'}
+        )
       end
 
       specify do
         expect(EventsIndex::Event.root_object.compose(
                  double(id: 1, name: 'Jonny', category: [
-                   double(id: 2, as_json: { 'name' => 'Borogoves1' }),
-                   double(id: 3, as_json: { 'name' => 'Borogoves2' })
+                   double(id: 2, as_json: {'name' => 'Borogoves1'}),
+                   double(id: 3, as_json: {'name' => 'Borogoves2'})
                  ])
-        )).to eq('event' => {
-                   'id' => 1,
-                   'name' => 'Jonny',
-                   'category' => [
-                     { 'name' => 'Borogoves1' },
-                     { 'name' => 'Borogoves2' }
-                   ]
-                 })
+        )).to eq(
+          'id' => 1,
+          'name' => 'Jonny',
+          'category' => [
+            {'name' => 'Borogoves1'},
+            {'name' => 'Borogoves2'}
+          ]
+        )
       end
     end
 
@@ -320,7 +351,11 @@ describe Chewy::Fields::Base do
             Country.has_many :cities, order: :id
           end
         when :mongoid
-          City.belongs_to :country
+          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
@@ -351,9 +386,9 @@ describe Chewy::Fields::Base do
       end
 
       specify do
-        expect(CountriesIndex::Country.root_object.compose(country_with_cities)).to eq('country' => { 'id' => 1, 'cities' => [
-          { 'id' => 1, 'name' => 'City1' }, { 'id' => 2, 'name' => 'City2' }
-        ] })
+        expect(CountriesIndex::Country.root_object.compose(country_with_cities)).to eq('id' => 1, 'cities' => [
+          {'id' => 1, 'name' => 'City1'}, {'id' => 2, 'name' => 'City2'}
+        ])
       end
 
       context 'nested object' do
@@ -372,7 +407,7 @@ describe Chewy::Fields::Base do
         specify do
           expect(CitiesIndex::City.root_object.compose(
                    City.create!(id: 1, country: Country.create!(id: 1, name: 'Country'))
-          )).to eq('city' => { 'id' => 1, 'country' => { 'id' => 1, 'name' => 'Country' } })
+          )).to eq('id' => 1, 'country' => {'id' => 1, 'name' => 'Country'})
         end
       end
     end