chewy 7.1.0 → 7.2.0

data/spec/chewy/{type → index}/adapter/active_record_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe Chewy::Type::Adapter::ActiveRecord, :active_record do
+describe Chewy::Index::Adapter::ActiveRecord, :active_record do
   before do
     stub_model(:city)
     stub_model(:country)
@@ -381,11 +381,21 @@ describe Chewy::Type::Adapter::ActiveRecord, :active_record do
       context 'objects' do
         specify { expect(subject.import(cities + deleted) { |_data| true }).to eq(true) }
         specify { expect(subject.import(cities + deleted) { |_data| false }).to eq(false) }
-        specify { expect(subject.import(cities + deleted, batch_size: 1, &data_comparer.curry[cities[0].id])).to eq(false) }
-        specify { expect(subject.import(cities + deleted, batch_size: 1, &data_comparer.curry[cities[1].id])).to eq(false) }
-        specify { expect(subject.import(cities + deleted, batch_size: 1, &data_comparer.curry[cities[2].id])).to eq(false) }
-        specify { expect(subject.import(cities + deleted, batch_size: 1, &data_comparer.curry[deleted[0].id])).to eq(false) }
-        specify { expect(subject.import(cities + deleted, batch_size: 1, &data_comparer.curry[deleted[1].id])).to eq(false) }
+        specify do
+          expect(subject.import(cities + deleted, batch_size: 1, &data_comparer.curry[cities[0].id])).to eq(false)
+        end
+        specify do
+          expect(subject.import(cities + deleted, batch_size: 1, &data_comparer.curry[cities[1].id])).to eq(false)
+        end
+        specify do
+          expect(subject.import(cities + deleted, batch_size: 1, &data_comparer.curry[cities[2].id])).to eq(false)
+        end
+        specify do
+          expect(subject.import(cities + deleted, batch_size: 1, &data_comparer.curry[deleted[0].id])).to eq(false)
+        end
+        specify do
+          expect(subject.import(cities + deleted, batch_size: 1, &data_comparer.curry[deleted[1].id])).to eq(false)
+        end
       end
 
       context 'ids' do
@@ -427,7 +437,10 @@ describe Chewy::Type::Adapter::ActiveRecord, :active_record do
         subject { described_class.new(Country.joins(:cities)) }
 
         specify { expect(subject.import_fields(Country.where('rating < 2'))).to match([contain_exactly(1, 2)]) }
-        specify { expect(subject.import_fields(Country.where('rating < 2'), fields: [:rating])).to match([contain_exactly([1, 0], [2, 1])]) }
+        specify do
+          expect(subject.import_fields(Country.where('rating < 2'), fields: [:rating]))
+            .to match([contain_exactly([1, 0], [2, 1])])
+        end
       end
     end
 
@@ -436,21 +449,36 @@ describe Chewy::Type::Adapter::ActiveRecord, :active_record do
       specify { expect(subject.import_fields(1, 2, fields: [:rating])).to match([contain_exactly([1, 0], [2, 1])]) }
 
       specify { expect(subject.import_fields(countries.first(2))).to match([contain_exactly(1, 2)]) }
-      specify { expect(subject.import_fields(countries.first(2), fields: [:rating])).to match([contain_exactly([1, 0], [2, 1])]) }
+      specify do
+        expect(subject.import_fields(countries.first(2), fields: [:rating]))
+          .to match([contain_exactly([1, 0], [2, 1])])
+      end
     end
 
     context 'batch_size' do
       specify { expect(subject.import_fields(batch_size: 2)).to match([contain_exactly(1, 2), [3]]) }
-      specify { expect(subject.import_fields(batch_size: 2, fields: [:rating])).to match([contain_exactly([1, 0], [2, 1]), [[3, 2]]]) }
+      specify do
+        expect(subject.import_fields(batch_size: 2, fields: [:rating]))
+          .to match([contain_exactly([1, 0], [2, 1]), [[3, 2]]])
+      end
 
-      specify { expect(subject.import_fields(Country.where('rating < 2'), batch_size: 2)).to match([contain_exactly(1, 2)]) }
-      specify { expect(subject.import_fields(Country.where('rating < 2'), batch_size: 2, fields: [:rating])).to match([contain_exactly([1, 0], [2, 1])]) }
+      specify do
+        expect(subject.import_fields(Country.where('rating < 2'), batch_size: 2))
+          .to match([contain_exactly(1, 2)])
+      end
+      specify do
+        expect(subject.import_fields(Country.where('rating < 2'), batch_size: 2, fields: [:rating]))
+          .to match([contain_exactly([1, 0], [2, 1])])
+      end
 
       specify { expect(subject.import_fields(1, 2, batch_size: 1)).to match([[1], [2]]) }
       specify { expect(subject.import_fields(1, 2, batch_size: 1, fields: [:rating])).to match([[[1, 0]], [[2, 1]]]) }
 
       specify { expect(subject.import_fields(countries.first(2), batch_size: 1)).to match([[1], [2]]) }
-      specify { expect(subject.import_fields(countries.first(2), batch_size: 1, fields: [:rating])).to match([[[1, 0]], [[2, 1]]]) }
+      specify do
+        expect(subject.import_fields(countries.first(2), batch_size: 1, fields: [:rating]))
+          .to match([[[1, 0]], [[2, 1]]])
+      end
     end
 
     context 'typecast' do
@@ -481,31 +509,29 @@ describe Chewy::Type::Adapter::ActiveRecord, :active_record do
       let(:city_ids) { cities.map(&:id) }
       let(:deleted_ids) { deleted.map(&:id) }
 
-      let(:type) { double(type_name: 'user') }
-
       subject { described_class.new(City) }
 
-      specify { expect(subject.load(city_ids, _type: type)).to eq(cities) }
-      specify { expect(subject.load(city_ids.reverse, _type: type)).to eq(cities.reverse) }
-      specify { expect(subject.load(deleted_ids, _type: type)).to eq([nil, nil]) }
-      specify { expect(subject.load(city_ids + deleted_ids, _type: type)).to eq([*cities, nil, nil]) }
+      specify { expect(subject.load(city_ids, _index: 'users')).to eq(cities) }
+      specify { expect(subject.load(city_ids.reverse, _index: 'users')).to eq(cities.reverse) }
+      specify { expect(subject.load(deleted_ids, _index: 'users')).to eq([nil, nil]) }
+      specify { expect(subject.load(city_ids + deleted_ids, _index: 'users')).to eq([*cities, nil, nil]) }
       specify do
-        expect(subject.load(city_ids, _type: type, scope: -> { where(rating: 0) }))
+        expect(subject.load(city_ids, _index: 'users', scope: -> { where(rating: 0) }))
           .to eq(cities.first(2) + [nil])
       end
       specify do
-        expect(subject.load(city_ids,
-          _type: type, scope: -> { where(rating: 0) }, user: {scope: -> { where(rating: 1) }}))
-          .to eq([nil, nil] + cities.last(1))
+        expect(
+          subject.load(city_ids, _index: 'users', scope: -> { where(rating: 0) }, users: {scope: -> { where(rating: 1) }})
+        ).to eq([nil, nil] + cities.last(1))
       end
       specify do
-        expect(subject.load(city_ids, _type: type, scope: City.where(rating: 1)))
+        expect(subject.load(city_ids, _index: 'users', scope: City.where(rating: 1)))
           .to eq([nil, nil] + cities.last(1))
       end
       specify do
-        expect(subject.load(city_ids,
-          _type: type, scope: City.where(rating: 1), user: {scope: -> { where(rating: 0) }}))
-          .to eq(cities.first(2) + [nil])
+        expect(
+          subject.load(city_ids, _index: 'users', scope: City.where(rating: 1), users: {scope: -> { where(rating: 0) }})
+        ).to eq(cities.first(2) + [nil])
       end
     end
 
@@ -516,31 +542,33 @@ describe Chewy::Type::Adapter::ActiveRecord, :active_record do
       let(:city_ids) { cities.map(&:rating) }
       let(:deleted_ids) { deleted.map(&:rating) }
 
-      let(:type) { double(type_name: 'user') }
-
       subject { described_class.new(City) }
 
-      specify { expect(subject.load(city_ids, _type: type)).to eq(cities) }
-      specify { expect(subject.load(city_ids.reverse, _type: type)).to eq(cities.reverse) }
-      specify { expect(subject.load(deleted_ids, _type: type)).to eq([nil, nil]) }
-      specify { expect(subject.load(city_ids + deleted_ids, _type: type)).to eq([*cities, nil, nil]) }
+      specify { expect(subject.load(city_ids, _index: 'users')).to eq(cities) }
+      specify { expect(subject.load(city_ids.reverse, _index: 'users')).to eq(cities.reverse) }
+      specify { expect(subject.load(deleted_ids, _index: 'users')).to eq([nil, nil]) }
+      specify { expect(subject.load(city_ids + deleted_ids, _index: 'users')).to eq([*cities, nil, nil]) }
       specify do
-        expect(subject.load(city_ids, _type: type, scope: -> { where(country_id: 0) }))
+        expect(subject.load(city_ids, _index: 'users', scope: -> { where(country_id: 0) }))
           .to eq(cities.first(2) + [nil])
       end
       specify do
-        expect(subject.load(city_ids,
-          _type: type, scope: -> { where(country_id: 0) }, user: {scope: -> { where(country_id: 1) }}))
-          .to eq([nil, nil] + cities.last(1))
+        expect(
+          subject.load(
+            city_ids, _index: 'users', scope: -> { where(country_id: 0) }, users: {scope: -> { where(country_id: 1) }}
+          )
+        ).to eq([nil, nil] + cities.last(1))
       end
       specify do
-        expect(subject.load(city_ids, _type: type, scope: City.where(country_id: 1)))
+        expect(subject.load(city_ids, _index: 'users', scope: City.where(country_id: 1)))
           .to eq([nil, nil] + cities.last(1))
       end
       specify do
-        expect(subject.load(city_ids,
-          _type: type, scope: City.where(country_id: 1), user: {scope: -> { where(country_id: 0) }}))
-          .to eq(cities.first(2) + [nil])
+        expect(
+          subject.load(
+            city_ids, _index: 'users', scope: City.where(country_id: 1), users: {scope: -> { where(country_id: 0) }}
+          )
+        ).to eq(cities.first(2) + [nil])
       end
     end
   end

data/spec/chewy/{type → index}/adapter/object_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe Chewy::Type::Adapter::Object do
+describe Chewy::Index::Adapter::Object do
   before { stub_class(:product) }
   subject { described_class.new(:product) }
 
@@ -104,7 +104,13 @@ describe Chewy::Type::Adapter::Object do
     end
 
     context 'error handling' do
-      let(:products) { Array.new(3) { |i| double.tap { |product| allow(product).to receive_messages(rating: i.next) } } }
+      let(:products) do
+        Array.new(3) do |i|
+          double.tap do |product|
+            allow(product).to receive_messages(rating: i.next)
+          end
+        end
+      end
       let(:deleted) { Array.new(2) { |i| double(destroyed?: true, rating: i + 4) } }
       subject { described_class.new('product') }
 
@@ -135,13 +141,18 @@ describe Chewy::Type::Adapter::Object do
     context do
       subject { described_class.new(-> { objects }) }
       specify { expect(subject.import_fields(batch_size: 2)).to match([[1, 2], [3]]) }
-      specify { expect(subject.import_fields(fields: [:name], batch_size: 2)).to match([[[1, 'Name0'], [2, 'Name1']], [[3, 'Name2']]]) }
+      specify do
+        expect(subject.import_fields(fields: [:name], batch_size: 2))
+          .to match([[[1, 'Name0'], [2, 'Name1']], [[3, 'Name2']]])
+      end
     end
 
     context do
       subject { described_class.new(-> { objects }) }
       specify { expect(subject.import_fields(objects.first(2))).to match([[1, 2]]) }
-      specify { expect(subject.import_fields(objects.first(2), fields: [:name])).to match([[[1, 'Name0'], [2, 'Name1']]]) }
+      specify do
+        expect(subject.import_fields(objects.first(2), fields: [:name])).to match([[[1, 'Name0'], [2, 'Name1']]])
+      end
     end
 
     context do
@@ -178,7 +189,9 @@ describe Chewy::Type::Adapter::Object do
       context do
         subject { described_class.new(Product) }
         specify { expect(subject.import_fields(objects.first(2))).to match([[1, 2]]) }
-        specify { expect(subject.import_fields(objects.first(2), fields: [:name])).to match([[[1, 'Name0'], [2, 'Name1']]]) }
+        specify do
+          expect(subject.import_fields(objects.first(2), fields: [:name])).to match([[[1, 'Name0'], [2, 'Name1']]])
+        end
       end
 
       context 'batch_size' do
@@ -196,7 +209,9 @@ describe Chewy::Type::Adapter::Object do
     specify { expect(subject.import_references).to match([objects]) }
     specify { expect(subject.import_references(batch_size: 2)).to match([objects.first(2), objects.last(1)]) }
     specify { expect(subject.import_references(objects.first(2))).to match([objects.first(2)]) }
-    specify { expect(subject.import_references(objects.first(2), batch_size: 1)).to match([objects.first(1), [objects[1]]]) }
+    specify do
+      expect(subject.import_references(objects.first(2), batch_size: 1)).to match([objects.first(1), [objects[1]]])
+    end
   end
 
   describe '#load' do

data/spec/chewy/{type → index}/import/bulk_builder_spec.rb

@@ -1,11 +1,11 @@
 require 'spec_helper'
 
-describe Chewy::Type::Import::BulkBuilder do
+describe Chewy::Index::Import::BulkBuilder do
   before { Chewy.massacre }
 
-  subject { described_class.new(type, index: index, delete: delete, fields: fields) }
-  let(:type) { CitiesIndex::City }
-  let(:index) { [] }
+  subject { described_class.new(index, to_index: to_index, delete: delete, fields: fields) }
+  let(:index) { CitiesIndex }
+  let(:to_index) { [] }
   let(:delete) { [] }
   let(:fields) { [] }
 
@@ -14,9 +14,8 @@ describe Chewy::Type::Import::BulkBuilder do
       before do
         stub_model(:city)
         stub_index(:cities) do
-          define_type City do
-            field :name, :rating
-          end
+          index_scope City
+          field :name, :rating
         end
       end
       let(:cities) { Array.new(3) { |i| City.create!(id: i + 1, name: "City#{i + 17}", rating: 42) } }
@@ -24,7 +23,7 @@ describe Chewy::Type::Import::BulkBuilder do
       specify { expect(subject.bulk_body).to eq([]) }
 
       context do
-        let(:index) { cities }
+        let(:to_index) { cities }
         specify do
           expect(subject.bulk_body).to eq([
             {index: {_id: 1, data: {'name' => 'City17', 'rating' => 42}}},
@@ -44,7 +43,7 @@ describe Chewy::Type::Import::BulkBuilder do
       end
 
       context do
-        let(:index) { cities.first(2) }
+        let(:to_index) { cities.first(2) }
         let(:delete) { [cities.last] }
         specify do
           expect(subject.bulk_body).to eq([
@@ -74,10 +73,9 @@ describe Chewy::Type::Import::BulkBuilder do
 
       before do
         stub_index(:cities) do
-          define_type City do
-            root id: -> { name } do
-              field :rating
-            end
+          index_scope City
+          root id: -> { name } do
+            field :rating
           end
         end
       end
@@ -90,7 +88,7 @@ describe Chewy::Type::Import::BulkBuilder do
       end
 
       context 'indexing' do
-        let(:index) { [london] }
+        let(:to_index) { [london] }
 
         specify do
           expect(subject.bulk_body).to eq([
@@ -113,17 +111,15 @@ describe Chewy::Type::Import::BulkBuilder do
     context 'crutches' do
       before do
         stub_index(:cities) do
-          define_type :city do
-            crutch :names do |collection|
-              collection.map { |item| [item.id, "Name#{item.id}"] }.to_h
-            end
-
-            field :name, value: ->(o, c) { c.names[o.id] }
+          crutch :names do |collection|
+            collection.map { |item| [item.id, "Name#{item.id}"] }.to_h
           end
+
+          field :name, value: ->(o, c) { c.names[o.id] }
         end
       end
 
-      let(:index) { [double(id: 42)] }
+      let(:to_index) { [double(id: 42)] }
 
       specify do
         expect(subject.bulk_body).to eq([
@@ -132,7 +128,7 @@ describe Chewy::Type::Import::BulkBuilder do
       end
 
       context 'witchcraft' do
-        before { CitiesIndex::City.witchcraft! }
+        before { CitiesIndex.witchcraft! }
         specify do
           expect(subject.bulk_body).to eq([
             {index: {_id: 42, data: {'name' => 'Name42'}}}
@@ -144,13 +140,11 @@ describe Chewy::Type::Import::BulkBuilder do
     context 'empty ids' do
       before do
         stub_index(:cities) do
-          define_type :city do
-            field :name
-          end
+          field :name
         end
       end
 
-      let(:index) { [{id: 1, name: 'Name0'}, double(id: '', name: 'Name1'), double(name: 'Name2')] }
+      let(:to_index) { [{id: 1, name: 'Name0'}, double(id: '', name: 'Name1'), double(name: 'Name2')] }
       let(:delete) { [double(id: '', name: 'Name3'), {name: 'Name4'}, '', 2] }
 
       specify do
@@ -180,15 +174,13 @@ describe Chewy::Type::Import::BulkBuilder do
   describe '#index_objects_by_id' do
     before do
       stub_index(:cities) do
-        define_type :city do
-          field :name
-        end
+        field :name
       end
     end
 
-    let(:index) { [double(id: 1), double(id: 2), double(id: ''), double] }
+    let(:to_index) { [double(id: 1), double(id: 2), double(id: ''), double] }
     let(:delete) { [double(id: 3)] }
 
-    specify { expect(subject.index_objects_by_id).to eq('1' => index.first, '2' => index.second) }
+    specify { expect(subject.index_objects_by_id).to eq('1' => to_index.first, '2' => to_index.second) }
   end
 end

data/spec/chewy/{type → index}/import/bulk_request_spec.rb

@@ -1,13 +1,13 @@
 require 'spec_helper'
 
-describe Chewy::Type::Import::BulkRequest do
+describe Chewy::Index::Import::BulkRequest do
   before { Chewy.massacre }
 
-  subject { described_class.new(type, suffix: suffix, bulk_size: bulk_size, **bulk_options) }
+  subject { described_class.new(index, suffix: suffix, bulk_size: bulk_size, **bulk_options) }
   let(:suffix) {}
   let(:bulk_size) {}
   let(:bulk_options) { {} }
-  let(:type) { PlacesIndex::City }
+  let(:index) { PlacesIndex }
 
   describe '#initialize' do
     specify { expect { described_class.new(nil, bulk_size: 100) }.to raise_error(ArgumentError) }
@@ -18,9 +18,8 @@ describe Chewy::Type::Import::BulkRequest do
     before do
       stub_model(:city)
       stub_index(:places) do
-        define_type City do
-          field :name
-        end
+        index_scope City
+        field :name
       end
     end
 

data/spec/chewy/{type → index}/import/journal_builder_spec.rb

@@ -1,13 +1,11 @@
 require 'spec_helper'
 
-describe Chewy::Type::Import::JournalBuilder, :orm do
+describe Chewy::Index::Import::JournalBuilder, :orm do
   before do
     stub_model(:country)
-    stub_index 'namespace/cities' do
-      define_type :city
-    end
+    stub_index 'namespace/cities'
     stub_index 'namespace/countries' do
-      define_type Country
+      index_scope Country
     end
     Timecop.freeze(time)
   end
@@ -15,23 +13,22 @@ describe Chewy::Type::Import::JournalBuilder, :orm do
 
   let(:time) { Time.parse('2017-07-14 12:00Z') }
 
-  let(:type) { Namespace::CitiesIndex::City }
-  let(:index) { [] }
+  let(:index) { Namespace::CitiesIndex }
+  let(:to_index) { [] }
   let(:delete) { [] }
-  subject { described_class.new(type, index: index, delete: delete) }
+  subject { described_class.new(index, to_index: to_index, delete: delete) }
 
   describe '#bulk_body' do
     specify { expect(subject.bulk_body).to eq([]) }
 
     context do
-      let(:index) { [{id: 1, name: 'City'}] }
+      let(:to_index) { [{id: 1, name: 'City'}] }
       specify do
         expect(subject.bulk_body).to eq([{
           index: {
             _index: 'chewy_journal',
             data: {
               'index_name' => 'namespace/cities',
-              'type_name' => 'city',
               'action' => 'index',
               'references' => [Base64.encode64('{"id":1,"name":"City"}')],
               'created_at' => time.as_json
@@ -49,7 +46,6 @@ describe Chewy::Type::Import::JournalBuilder, :orm do
             _index: 'chewy_journal',
             data: {
               'index_name' => 'namespace/cities',
-              'type_name' => 'city',
               'action' => 'delete',
               'references' => [Base64.encode64('{"id":1,"name":"City"}')],
               'created_at' => time.as_json
@@ -60,8 +56,8 @@ describe Chewy::Type::Import::JournalBuilder, :orm do
     end
 
     context do
-      let(:type) { Namespace::CountriesIndex::Country }
-      let(:index) { [Country.new(id: 1, name: 'City')] }
+      let(:index) { Namespace::CountriesIndex }
+      let(:to_index) { [Country.new(id: 1, name: 'City')] }
       let(:delete) { [Country.new(id: 2, name: 'City')] }
       specify do
         expect(subject.bulk_body).to eq([{
@@ -69,7 +65,6 @@ describe Chewy::Type::Import::JournalBuilder, :orm do
             _index: 'chewy_journal',
             data: {
               'index_name' => 'namespace/countries',
-              'type_name' => 'country',
               'action' => 'index',
               'references' => [Base64.encode64('1')],
               'created_at' => time.as_json
@@ -80,7 +75,6 @@ describe Chewy::Type::Import::JournalBuilder, :orm do
             _index: 'chewy_journal',
             data: {
               'index_name' => 'namespace/countries',
-              'type_name' => 'country',
               'action' => 'delete',
               'references' => [Base64.encode64('2')],
               'created_at' => time.as_json