Rename collection option to scope

Author: ellnix

README.md

@@ -265,14 +265,14 @@ Use `#each_result` to loop through pairs of your provided keys and the results:
 </ul>
 ```
 
-Records are loaded when the keys are models, or when `:collection` option is passed:
+Records are loaded when the keys are models, or when `:scope` option is passed:
 
 ```ruby
 multi_search_results = Meilisearch::Rails.multi_search(
-  # Collection may be a relation
-  'books' => { q: 'Harry', collection: Book.all },
+  # scope may be a relation
+  'books' => { q: 'Harry', scope: Book.all },
   # or a model
-  'mangas' => { q: 'Attack', collection: Manga }
+  'mangas' => { q: 'Attack', scope: Manga }
 )
 ```
 
@@ -282,8 +282,8 @@ The index to search is inferred from the model if the key is a model, if the key
 
 ```ruby
 multi_search_results = Meilisearch::Rails.multi_search(
-  'western' => { q: 'Harry', collection: Book, index_uid: 'books_production' },
-  'japanese' => { q: 'Attack', collection: Manga, index_uid: 'mangas_production' }
+  'western' => { q: 'Harry', scope: Book, index_uid: 'books_production' },
+  'japanese' => { q: 'Attack', scope: Manga, index_uid: 'mangas_production' }
 )
 ```
 
@@ -295,9 +295,9 @@ You can search the same index multiple times by specifying `:index_uid`:
 query = 'hero'
 
 multi_search_results = Meilisearch::Rails.multi_search(
-  'Isekai Manga' => { q: query, collection: Manga, filters: 'genre:isekai', index_uid: 'mangas_production' }
-  'Shounen Manga' => { q: query, collection: Manga, filters: 'genre:shounen', index_uid: 'mangas_production' }
-  'Steampunk Manga' => { q: query, collection: Manga, filters: 'genre:steampunk', index_uid: 'mangas_production' }
+  'Isekai Manga' => { q: query, scope: Manga, filters: 'genre:isekai', index_uid: 'mangas_production' }
+  'Shounen Manga' => { q: query, scope: Manga, filters: 'genre:shounen', index_uid: 'mangas_production' }
+  'Steampunk Manga' => { q: query, scope: Manga, filters: 'genre:steampunk', index_uid: 'mangas_production' }
 )
 ```
 

lib/meilisearch/rails/multi_search.rb

@@ -5,8 +5,8 @@ module Rails
     class << self
       def multi_search(searches)
         search_parameters = searches.map do |(index_target, options)|
-          collection_class = options[:collection].respond_to?(:model) ? options[:collection].model : options[:collection]
-          index_target = options.delete(:index_uid) || collection_class || index_target
+          model_class = options[:scope].respond_to?(:model) ? options[:scope].model : options[:scope]
+          index_target = options.delete(:index_uid) || model_class || index_target
 
           paginate(options) if pagination_enabled?
           normalize(options, index_target)
@@ -19,7 +19,7 @@ def multi_search(searches)
 
       def normalize(options, index_target)
         options
-          .except(:class_name, :collection)
+          .except(:class_name, :scope)
           .merge!(index_uid: index_uid_from_target(index_target))
       end
 

lib/meilisearch/rails/multi_search/result.rb

@@ -10,17 +10,17 @@ def initialize(searches, raw_results)
         searches.zip(raw_results['results']).each do |(target, search_options), result|
           results_class = if search_options[:class_name]
                             Meilisearch::Rails.logger.warn(
-                              '[meilisearch-rails] The :class_name option in multi search is deprecated, please use :collection instead.'
+                              '[meilisearch-rails] The :class_name option in multi search is deprecated, please use :scope instead.'
                             )
 
                             search_options[:class_name].constantize
                           elsif target.instance_of?(Class)
                             target
-                          elsif search_options[:collection]
-                            search_options[:collection]
+                          elsif search_options[:scope]
+                            search_options[:scope]
                           end
 
-          @results[target] = results_class ? load_results(results_class, result, collection: search_options[:collection]) : result['hits']
+          @results[target] = results_class ? load_results(results_class, result, scope: search_options[:scope]) : result['hits']
 
           @metadata[target] = result.except('hits')
         end
@@ -75,8 +75,8 @@ def to_h
 
       private
 
-      def load_results(klass, result, collection:)
-        collection ||= klass
+      def load_results(klass, result, scope:)
+        scope ||= klass
 
         pk_method = klass.ms_primary_key_method
         pk_method = pk_method.in if Utilities.mongo_model?(klass)
@@ -86,7 +86,7 @@ def load_results(klass, result, collection:)
         hits_by_id =
           result['hits'].index_by { |hit| hit[condition_key.to_s] }
 
-        records = collection.where(condition_key => hits_by_id.keys)
+        records = scope.where(condition_key => hits_by_id.keys)
 
         if records.respond_to? :in_order_of
           records.in_order_of(condition_key, hits_by_id.keys).each do |record|

spec/multi_search_spec.rb

@@ -164,7 +164,7 @@ def reset_indexes
     it 'returns a mixture of ORM records and hashes' do
       results = Meilisearch::Rails.multi_search(
         Book => { q: 'Steve' },
-        Product.index.uid => { q: 'palm', limit: 1, collection: Product },
+        Product.index.uid => { q: 'palm', limit: 1, scope: Product },
         Color.index.uid => { q: 'bl' }
       )
 
@@ -195,11 +195,11 @@ def reset_indexes
     end
   end
 
-  context 'with collections' do
-    it 'fetches items from the given collection' do
+  context 'with scopes' do
+    it 'fetches items from the given scope' do
       results = Meilisearch::Rails.multi_search(
-        Product => { q: 'palm', collection: Product.where('tags LIKE "%terrible%"') },
-        Color => { q: 'bl', collection: Color.where(short_name: 'bla') }
+        Product => { q: 'palm', scope: Product.where('tags LIKE "%terrible%"') },
+        Color => { q: 'bl', scope: Color.where(short_name: 'bla') }
       )
 
       expect(results).to contain_exactly(
@@ -209,15 +209,15 @@ def reset_indexes
 
     it 'infers the model' do
       results = Meilisearch::Rails.multi_search(
-        'colors' => { q: 'bl', collection: Color.all, index_uid: Color.index.uid }
+        'colors' => { q: 'bl', scope: Color.all, index_uid: Color.index.uid }
       )
 
       expect(results.to_h['colors']).to contain_exactly(blue, black)
     end
 
     it 'infers the index as well as the model' do
       results = Meilisearch::Rails.multi_search(
-        'colors' => { q: 'bl', collection: Color }
+        'colors' => { q: 'bl', scope: Color }
       )
 
       expect(results.to_h['colors']).to contain_exactly(blue, black)