meilisearch 0.27.0 → 0.27.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 41cfeec247ef2cdaef19f6ddade5d32b7dcc80cbc69fe500c9310f7dab87e5a4
-  data.tar.gz: af889a896d762a38fbb1af56aba3b462cf73f35e4fe97048ef09bbaad44ffa53
+  metadata.gz: cc7926e5e9f849ba9fb7377e4d1fe416abdba271c6518e511311da9750e209dc
+  data.tar.gz: 4dbb041794de52a349af301d713958de08fd4ceb4ac2afc0baa176e980d52f1c
 SHA512:
-  metadata.gz: 6ce24688fe857e840d07efda981cc00d0f8a60982aea1d487646b21a82117693eaa61fbe9dc778512b00b7d2363001c68dca0387f7b7a550a00eee022133c046
-  data.tar.gz: fda38ae00c08ba533e76dc0ce9a101331b23fb47e6c9554478a6027f1524b92141c6ecc764dce974402e66db67b9e6d85a96ff74893eb3419d0a9f02865b1cec
+  metadata.gz: 65b4e041307fa52c979bae5efb07428fbb2db6d67564bf00f151c8d45aa636e83eb1b6c87716a5cab92802f734073f919912ea97f6efc88acfaa9866375a9ea4
+  data.tar.gz: 054ed5ae299c6cce0e8a183ef828e233b634dfef5fee89c9dc213062171071455120957596b169dd7ce1b23b6027e1829725290d70c303532bb87fb96e6d287b

data/README.md

@@ -251,8 +251,6 @@ JSON output:
 }
 ```
 
-You can enable it by querying PATCH /experimental-features with { "scoreDetails": true }
-
 This feature is only available with Meilisearch v1.3 and newer (optional).
 
 #### Custom Search With attributes on at search time  <!-- omit in toc -->

data/lib/meilisearch/client.rb

@@ -16,7 +16,8 @@ module MeiliSearch
     def swap_indexes(*options)
       mapped_array = options.map { |arr| { indexes: arr } }
 
-      http_post '/swap-indexes', mapped_array
+      response = http_post '/swap-indexes', mapped_array
+      Models::Task.new(response, task_endpoint)
     end
 
     def indexes(options = {})
@@ -35,14 +36,20 @@ module MeiliSearch
     def create_index(index_uid, options = {})
       body = Utils.transform_attributes(options.merge(uid: index_uid))
 
-      http_post '/indexes', body
+      response = http_post '/indexes', body
+
+      Models::Task.new(response, task_endpoint)
     end
 
     # Synchronous version of create_index.
     # Waits for the task to be achieved, be careful when using it.
     def create_index!(index_uid, options = {})
-      task = create_index(index_uid, options)
-      wait_for_task(task['taskUid'])
+      Utils.soft_deprecate(
+        'Client#create_index!',
+        "client.create_index('#{index_uid}').await"
+      )
+
+      create_index(index_uid, options).await
     end
 
     def delete_index(index_uid)
@@ -118,7 +125,8 @@ module MeiliSearch
     ### DUMPS
 
     def create_dump
-      http_post '/dumps'
+      response = http_post '/dumps'
+      Models::Task.new(response, task_endpoint)
     end
 
     ### SNAPSHOTS

data/lib/meilisearch/index.rb

@@ -30,13 +30,15 @@ module MeiliSearch
     end
 
     def update(body)
-      http_patch indexes_path(id: @uid), Utils.transform_attributes(body)
+      response = http_patch indexes_path(id: @uid), Utils.transform_attributes(body)
+      Models::Task.new(response, task_endpoint)
     end
 
     alias update_index update
 
     def delete
-      http_delete indexes_path(id: @uid)
+      response = http_delete indexes_path(id: @uid)
+      Models::Task.new(response, task_endpoint)
     end
     alias delete_index delete
 
@@ -86,28 +88,38 @@ module MeiliSearch
 
     def add_documents(documents, primary_key = nil)
       documents = [documents] if documents.is_a?(Hash)
-      http_post "/indexes/#{@uid}/documents", documents, { primaryKey: primary_key }.compact
+      response = http_post "/indexes/#{@uid}/documents", documents, { primaryKey: primary_key }.compact
+
+      Models::Task.new(response, task_endpoint)
     end
     alias replace_documents add_documents
     alias add_or_replace_documents add_documents
 
     def add_documents!(documents, primary_key = nil)
-      task = add_documents(documents, primary_key)
-      wait_for_task(task['taskUid'])
+      Utils.soft_deprecate(
+        'Index#add_documents!',
+        'index.add_documents(...).await'
+      )
+
+      add_documents(documents, primary_key).await
     end
     alias replace_documents! add_documents!
     alias add_or_replace_documents! add_documents!
 
     def add_documents_json(documents, primary_key = nil)
       options = { convert_body?: false }
-      http_post "/indexes/#{@uid}/documents", documents, { primaryKey: primary_key }.compact, options
+      response = http_post "/indexes/#{@uid}/documents", documents, { primaryKey: primary_key }.compact, options
+
+      Models::Task.new(response, task_endpoint)
     end
     alias replace_documents_json add_documents_json
     alias add_or_replace_documents_json add_documents_json
 
     def add_documents_ndjson(documents, primary_key = nil)
       options = { headers: { 'Content-Type' => 'application/x-ndjson' }, convert_body?: false }
-      http_post "/indexes/#{@uid}/documents", documents, { primaryKey: primary_key }.compact, options
+      response = http_post "/indexes/#{@uid}/documents", documents, { primaryKey: primary_key }.compact, options
+
+      Models::Task.new(response, task_endpoint)
     end
     alias replace_documents_ndjson add_documents_ndjson
     alias add_or_replace_documents_ndjson add_documents_ndjson
@@ -115,58 +127,62 @@ module MeiliSearch
     def add_documents_csv(documents, primary_key = nil, delimiter = nil)
       options = { headers: { 'Content-Type' => 'text/csv' }, convert_body?: false }
 
-      http_post "/indexes/#{@uid}/documents", documents, {
+      response = http_post "/indexes/#{@uid}/documents", documents, {
         primaryKey: primary_key,
         csvDelimiter: delimiter
       }.compact, options
+
+      Models::Task.new(response, task_endpoint)
     end
     alias replace_documents_csv add_documents_csv
     alias add_or_replace_documents_csv add_documents_csv
 
     def update_documents(documents, primary_key = nil)
       documents = [documents] if documents.is_a?(Hash)
-      http_put "/indexes/#{@uid}/documents", documents, { primaryKey: primary_key }.compact
+      response = http_put "/indexes/#{@uid}/documents", documents, { primaryKey: primary_key }.compact
+
+      Models::Task.new(response, task_endpoint)
     end
     alias add_or_update_documents update_documents
 
     def update_documents!(documents, primary_key = nil)
-      task = update_documents(documents, primary_key)
-      wait_for_task(task['taskUid'])
+      Utils.soft_deprecate(
+        'Index#update_documents!',
+        'index.update_documents(...).await'
+      )
+
+      update_documents(documents, primary_key).await
     end
     alias add_or_update_documents! update_documents!
 
     def add_documents_in_batches(documents, batch_size = 1000, primary_key = nil)
-      tasks = []
-      documents.each_slice(batch_size) do |batch|
-        tasks.append(add_documents(batch, primary_key))
+      documents.each_slice(batch_size).map do |batch|
+        add_documents(batch, primary_key)
       end
-      tasks
     end
 
     def add_documents_in_batches!(documents, batch_size = 1000, primary_key = nil)
-      tasks = add_documents_in_batches(documents, batch_size, primary_key)
-      responses = []
-      tasks.each do |task_obj|
-        responses.append(wait_for_task(task_obj['taskUid']))
-      end
-      responses
+      Utils.soft_deprecate(
+        'Index#add_documents_in_batches!',
+        'index.add_documents_in_batches(...).each(&:await)'
+      )
+
+      add_documents_in_batches(documents, batch_size, primary_key).each(&:await)
     end
 
     def update_documents_in_batches(documents, batch_size = 1000, primary_key = nil)
-      tasks = []
-      documents.each_slice(batch_size) do |batch|
-        tasks.append(update_documents(batch, primary_key))
+      documents.each_slice(batch_size).map do |batch|
+        update_documents(batch, primary_key)
       end
-      tasks
     end
 
     def update_documents_in_batches!(documents, batch_size = 1000, primary_key = nil)
-      tasks = update_documents_in_batches(documents, batch_size, primary_key)
-      responses = []
-      tasks.each do |task_obj|
-        responses.append(wait_for_task(task_obj['taskUid']))
-      end
-      responses
+      Utils.soft_deprecate(
+        'Index#update_documents_in_batches!',
+        'index.update_documents_in_batches(...).each(&:await)'
+      )
+
+      update_documents_in_batches(documents, batch_size, primary_key).each(&:await)
     end
 
     # Public: Delete documents from an index
@@ -178,44 +194,61 @@ module MeiliSearch
     # Returns a Task object.
     def delete_documents(options = {})
       Utils.version_error_handler(__method__) do
-        if options.is_a?(Hash) && options.key?(:filter)
-          http_post "/indexes/#{@uid}/documents/delete", options
-        else
-          # backwards compatibility:
-          # expect to be a array or/number/string to send alongside as documents_ids.
-          options = [options] unless options.is_a?(Array)
+        response = if options.is_a?(Hash) && options.key?(:filter)
+                     http_post "/indexes/#{@uid}/documents/delete", options
+                   else
+                     # backwards compatibility:
+                     # expect to be a array or/number/string to send alongside as documents_ids.
+                     options = [options] unless options.is_a?(Array)
 
-          http_post "/indexes/#{@uid}/documents/delete-batch", options
-        end
+                     http_post "/indexes/#{@uid}/documents/delete-batch", options
+                   end
+
+        Models::Task.new(response, task_endpoint)
       end
     end
     alias delete_multiple_documents delete_documents
 
     def delete_documents!(documents_ids)
-      task = delete_documents(documents_ids)
-      wait_for_task(task['taskUid'])
+      Utils.soft_deprecate(
+        'Index#delete_documents!',
+        'index.delete_documents(...).await'
+      )
+
+      delete_documents(documents_ids).await
     end
     alias delete_multiple_documents! delete_documents!
 
     def delete_document(document_id)
       encode_document = URI.encode_www_form_component(document_id)
-      http_delete "/indexes/#{@uid}/documents/#{encode_document}"
+      response = http_delete "/indexes/#{@uid}/documents/#{encode_document}"
+
+      Models::Task.new(response, task_endpoint)
     end
     alias delete_one_document delete_document
 
     def delete_document!(document_id)
-      task = delete_document(document_id)
-      wait_for_task(task['taskUid'])
+      Utils.soft_deprecate(
+        'Index#delete_document!',
+        'index.delete_document(...).await'
+      )
+
+      delete_document(document_id).await
     end
     alias delete_one_document! delete_document!
 
     def delete_all_documents
-      http_delete "/indexes/#{@uid}/documents"
+      response = http_delete "/indexes/#{@uid}/documents"
+      Models::Task.new(response, task_endpoint)
     end
 
     def delete_all_documents!
-      task = delete_all_documents
-      wait_for_task(task['taskUid'])
+      Utils.soft_deprecate(
+        'Index#delete_all_documents!',
+        'index.delete_all_documents(...).await'
+      )
+
+      delete_all_documents.await
     end
 
     ### SEARCH
@@ -288,12 +321,14 @@ module MeiliSearch
     alias get_settings settings
 
     def update_settings(settings)
-      http_patch "/indexes/#{@uid}/settings", Utils.transform_attributes(settings)
+      response = http_patch "/indexes/#{@uid}/settings", Utils.transform_attributes(settings)
+      Models::Task.new(response, task_endpoint)
     end
     alias settings= update_settings
 
     def reset_settings
-      http_delete "/indexes/#{@uid}/settings"
+      response = http_delete "/indexes/#{@uid}/settings"
+      Models::Task.new(response, task_endpoint)
     end
 
     ### SETTINGS - RANKING RULES
@@ -304,12 +339,14 @@ module MeiliSearch
     alias get_ranking_rules ranking_rules
 
     def update_ranking_rules(ranking_rules)
-      http_put "/indexes/#{@uid}/settings/ranking-rules", ranking_rules
+      response = http_put "/indexes/#{@uid}/settings/ranking-rules", ranking_rules
+      Models::Task.new(response, task_endpoint)
     end
     alias ranking_rules= update_ranking_rules
 
     def reset_ranking_rules
-      http_delete "/indexes/#{@uid}/settings/ranking-rules"
+      response = http_delete "/indexes/#{@uid}/settings/ranking-rules"
+      Models::Task.new(response, task_endpoint)
     end
 
     ### SETTINGS - SYNONYMS
@@ -320,12 +357,14 @@ module MeiliSearch
     alias get_synonyms synonyms
 
     def update_synonyms(synonyms)
-      http_put "/indexes/#{@uid}/settings/synonyms", synonyms
+      response = http_put "/indexes/#{@uid}/settings/synonyms", synonyms
+      Models::Task.new(response, task_endpoint)
     end
     alias synonyms= update_synonyms
 
     def reset_synonyms
-      http_delete "/indexes/#{@uid}/settings/synonyms"
+      response = http_delete "/indexes/#{@uid}/settings/synonyms"
+      Models::Task.new(response, task_endpoint)
     end
 
     ### SETTINGS - STOP-WORDS
@@ -337,12 +376,14 @@ module MeiliSearch
 
     def update_stop_words(stop_words)
       body = stop_words.nil? || stop_words.is_a?(Array) ? stop_words : [stop_words]
-      http_put "/indexes/#{@uid}/settings/stop-words", body
+      response = http_put "/indexes/#{@uid}/settings/stop-words", body
+      Models::Task.new(response, task_endpoint)
     end
     alias stop_words= update_stop_words
 
     def reset_stop_words
-      http_delete "/indexes/#{@uid}/settings/stop-words"
+      response = http_delete "/indexes/#{@uid}/settings/stop-words"
+      Models::Task.new(response, task_endpoint)
     end
 
     ### SETTINGS - DINSTINCT ATTRIBUTE
@@ -353,12 +394,14 @@ module MeiliSearch
     alias get_distinct_attribute distinct_attribute
 
     def update_distinct_attribute(distinct_attribute)
-      http_put "/indexes/#{@uid}/settings/distinct-attribute", distinct_attribute
+      response = http_put "/indexes/#{@uid}/settings/distinct-attribute", distinct_attribute
+      Models::Task.new(response, task_endpoint)
     end
     alias distinct_attribute= update_distinct_attribute
 
     def reset_distinct_attribute
-      http_delete "/indexes/#{@uid}/settings/distinct-attribute"
+      response = http_delete "/indexes/#{@uid}/settings/distinct-attribute"
+      Models::Task.new(response, task_endpoint)
     end
 
     ### SETTINGS - SEARCHABLE ATTRIBUTES
@@ -369,12 +412,14 @@ module MeiliSearch
     alias get_searchable_attributes searchable_attributes
 
     def update_searchable_attributes(searchable_attributes)
-      http_put "/indexes/#{@uid}/settings/searchable-attributes", searchable_attributes
+      response = http_put "/indexes/#{@uid}/settings/searchable-attributes", searchable_attributes
+      Models::Task.new(response, task_endpoint)
     end
     alias searchable_attributes= update_searchable_attributes
 
     def reset_searchable_attributes
-      http_delete "/indexes/#{@uid}/settings/searchable-attributes"
+      response = http_delete "/indexes/#{@uid}/settings/searchable-attributes"
+      Models::Task.new(response, task_endpoint)
     end
 
     ### SETTINGS - DISPLAYED ATTRIBUTES
@@ -385,12 +430,14 @@ module MeiliSearch
     alias get_displayed_attributes displayed_attributes
 
     def update_displayed_attributes(displayed_attributes)
-      http_put "/indexes/#{@uid}/settings/displayed-attributes", displayed_attributes
+      response = http_put "/indexes/#{@uid}/settings/displayed-attributes", displayed_attributes
+      Models::Task.new(response, task_endpoint)
     end
     alias displayed_attributes= update_displayed_attributes
 
     def reset_displayed_attributes
-      http_delete "/indexes/#{@uid}/settings/displayed-attributes"
+      response = http_delete "/indexes/#{@uid}/settings/displayed-attributes"
+      Models::Task.new(response, task_endpoint)
     end
 
     ### SETTINGS - FILTERABLE ATTRIBUTES
@@ -401,12 +448,14 @@ module MeiliSearch
     alias get_filterable_attributes filterable_attributes
 
     def update_filterable_attributes(filterable_attributes)
-      http_put "/indexes/#{@uid}/settings/filterable-attributes", filterable_attributes
+      response = http_put "/indexes/#{@uid}/settings/filterable-attributes", filterable_attributes
+      Models::Task.new(response, task_endpoint)
     end
     alias filterable_attributes= update_filterable_attributes
 
     def reset_filterable_attributes
-      http_delete "/indexes/#{@uid}/settings/filterable-attributes"
+      response = http_delete "/indexes/#{@uid}/settings/filterable-attributes"
+      Models::Task.new(response, task_endpoint)
     end
 
     ### SETTINGS - SORTABLE ATTRIBUTES
@@ -417,12 +466,14 @@ module MeiliSearch
     alias get_sortable_attributes sortable_attributes
 
     def update_sortable_attributes(sortable_attributes)
-      http_put "/indexes/#{@uid}/settings/sortable-attributes", sortable_attributes
+      response = http_put "/indexes/#{@uid}/settings/sortable-attributes", sortable_attributes
+      Models::Task.new(response, task_endpoint)
     end
     alias sortable_attributes= update_sortable_attributes
 
     def reset_sortable_attributes
-      http_delete "/indexes/#{@uid}/settings/sortable-attributes"
+      response = http_delete "/indexes/#{@uid}/settings/sortable-attributes"
+      Models::Task.new(response, task_endpoint)
     end
 
     ### SETTINGS - PAGINATION
@@ -433,12 +484,14 @@ module MeiliSearch
     alias get_pagination pagination
 
     def update_pagination(pagination)
-      http_patch "/indexes/#{@uid}/settings/pagination", pagination
+      response = http_patch "/indexes/#{@uid}/settings/pagination", pagination
+      Models::Task.new(response, task_endpoint)
     end
     alias pagination= update_sortable_attributes
 
     def reset_pagination
-      http_delete "/indexes/#{@uid}/settings/pagination"
+      response = http_delete "/indexes/#{@uid}/settings/pagination"
+      Models::Task.new(response, task_endpoint)
     end
 
     def typo_tolerance
@@ -448,12 +501,14 @@ module MeiliSearch
 
     def update_typo_tolerance(typo_tolerance_attributes)
       attributes = Utils.transform_attributes(typo_tolerance_attributes)
-      http_patch("/indexes/#{@uid}/settings/typo-tolerance", attributes)
+      response = http_patch("/indexes/#{@uid}/settings/typo-tolerance", attributes)
+      Models::Task.new(response, task_endpoint)
     end
     alias typo_tolerance= update_typo_tolerance
 
     def reset_typo_tolerance
-      http_delete("/indexes/#{@uid}/settings/typo-tolerance")
+      response = http_delete("/indexes/#{@uid}/settings/typo-tolerance")
+      Models::Task.new(response, task_endpoint)
     end
 
     def faceting
@@ -463,12 +518,14 @@ module MeiliSearch
 
     def update_faceting(faceting_attributes)
       attributes = Utils.transform_attributes(faceting_attributes)
-      http_patch("/indexes/#{@uid}/settings/faceting", attributes)
+      response = http_patch("/indexes/#{@uid}/settings/faceting", attributes)
+      Models::Task.new(response, task_endpoint)
     end
     alias faceting= update_faceting
 
     def reset_faceting
-      http_delete("/indexes/#{@uid}/settings/faceting")
+      response = http_delete("/indexes/#{@uid}/settings/faceting")
+      Models::Task.new(response, task_endpoint)
     end
 
     ### SETTINGS - DICTIONARY
@@ -479,11 +536,13 @@ module MeiliSearch
 
     def update_dictionary(dictionary_attributes)
       attributes = Utils.transform_attributes(dictionary_attributes)
-      http_put("/indexes/#{@uid}/settings/dictionary", attributes)
+      response = http_put("/indexes/#{@uid}/settings/dictionary", attributes)
+      Models::Task.new(response, task_endpoint)
     end
 
     def reset_dictionary
-      http_delete("/indexes/#{@uid}/settings/dictionary")
+      response = http_delete("/indexes/#{@uid}/settings/dictionary")
+      Models::Task.new(response, task_endpoint)
     end
     ### SETTINGS - SEPARATOR TOKENS
 
@@ -493,11 +552,13 @@ module MeiliSearch
 
     def update_separator_tokens(separator_tokens_attributes)
       attributes = Utils.transform_attributes(separator_tokens_attributes)
-      http_put("/indexes/#{@uid}/settings/separator-tokens", attributes)
+      response = http_put("/indexes/#{@uid}/settings/separator-tokens", attributes)
+      Models::Task.new(response, task_endpoint)
     end
 
     def reset_separator_tokens
-      http_delete("/indexes/#{@uid}/settings/separator-tokens")
+      response = http_delete("/indexes/#{@uid}/settings/separator-tokens")
+      Models::Task.new(response, task_endpoint)
     end
 
     ### SETTINGS - NON SEPARATOR TOKENS
@@ -508,11 +569,13 @@ module MeiliSearch
 
     def update_non_separator_tokens(non_separator_tokens_attributes)
       attributes = Utils.transform_attributes(non_separator_tokens_attributes)
-      http_put("/indexes/#{@uid}/settings/non-separator-tokens", attributes)
+      response = http_put("/indexes/#{@uid}/settings/non-separator-tokens", attributes)
+      Models::Task.new(response, task_endpoint)
     end
 
     def reset_non_separator_tokens
-      http_delete("/indexes/#{@uid}/settings/non-separator-tokens")
+      response = http_delete("/indexes/#{@uid}/settings/non-separator-tokens")
+      Models::Task.new(response, task_endpoint)
     end
 
     ### SETTINGS - PROXIMITY PRECISION

data/lib/meilisearch/models/task.rb

@@ -0,0 +1,160 @@
+# frozen_string_literal: true
+
+require 'forwardable'
+
+module MeiliSearch
+  module Models
+    class Task
+      extend Forwardable
+
+      # Maintain backwards compatibility with task hash return type
+      def_delegators :metadata, :[], :dig, :keys, :key?, :has_key?
+
+      attr_reader :metadata
+
+      def initialize(metadata_hash, task_endpoint)
+        self.metadata = metadata_hash
+        validate_required_fields! metadata
+
+        @task_endpoint = task_endpoint
+      end
+
+      def uid
+        @metadata['taskUid']
+      end
+
+      def type
+        @metadata['type']
+      end
+
+      def status
+        @metadata['status']
+      end
+
+      def enqueued?
+        refresh if status_enqueued?
+
+        status_enqueued?
+      end
+
+      def processing?
+        refresh if status_processing? || status_enqueued?
+
+        status_processing?
+      end
+
+      def unfinished?
+        refresh if status_processing? || status_enqueued?
+
+        status_processing? || status_enqueued?
+      end
+      alias waiting? unfinished?
+
+      def finished?
+        !unfinished?
+      end
+
+      def succeeded?
+        Utils.warn_on_unfinished_task(self) if unfinished?
+
+        status == 'succeeded'
+      end
+      alias has_succeeded? succeeded?
+
+      def failed?
+        Utils.warn_on_unfinished_task(self) if unfinished?
+
+        status == 'failed'
+      end
+      alias has_failed? failed?
+
+      def cancelled?
+        Utils.warn_on_unfinished_task(self) if unfinished?
+
+        status_cancelled?
+      end
+
+      def deleted?
+        refresh unless @deleted
+
+        !!@deleted
+      end
+
+      def error
+        @metadata['error']
+      end
+
+      def refresh(with: nil)
+        self.metadata = with || @task_endpoint.task(uid)
+
+        self
+      rescue MeiliSearch::ApiError => e
+        raise e unless e.http_code == 404
+
+        @deleted = true
+
+        self
+      end
+
+      def await(timeout_in_ms = 5000, interval_in_ms = 50)
+        refresh with: @task_endpoint.wait_for_task(uid, timeout_in_ms, interval_in_ms) unless finished?
+
+        self
+      end
+
+      def cancel
+        return true if status_cancelled?
+        return false if status_finished?
+
+        @task_endpoint.cancel_tasks(uids: [uid]).await
+
+        cancelled?
+      end
+
+      def delete
+        return false unless status_finished?
+
+        @task_endpoint.delete_tasks(uids: [uid]).await
+
+        deleted?
+      end
+
+      def to_h
+        @metadata
+      end
+      alias to_hash to_h
+
+      private
+
+      def validate_required_fields!(task_hash)
+        raise ArgumentError, 'Cannot instantiate a task without an ID'    unless task_hash['taskUid']
+        raise ArgumentError, 'Cannot instantiate a task without a type'   unless task_hash['type']
+        raise ArgumentError, 'Cannot instantiate a task without a status' unless task_hash['status']
+      end
+
+      def status_enqueued?
+        status == 'enqueued'
+      end
+
+      def status_processing?
+        status == 'processing'
+      end
+
+      def status_finished?
+        ['succeeded', 'failed', 'cancelled'].include? status
+      end
+
+      def status_cancelled?
+        status == 'cancelled'
+      end
+
+      def metadata=(metadata)
+        @metadata = metadata
+
+        uid = @metadata['taskUid'] || @metadata['uid']
+        @metadata['uid'] = uid
+        @metadata['taskUid'] = uid
+      end
+    end
+  end
+end

data/lib/meilisearch/utils.rb

@@ -1,73 +1,98 @@
 # frozen_string_literal: true
 
+require 'logger'
+
 module MeiliSearch
   module Utils
     SNAKE_CASE = /[^a-zA-Z0-9]+(.)/
 
-    def self.transform_attributes(body)
-      case body
-      when Array
-        body.map { |item| transform_attributes(item) }
-      when Hash
-        warn_on_non_conforming_attribute_names(body)
-        parse(body)
-      else
-        body
+    class << self
+      attr_writer :logger
+
+      def logger
+        @logger ||= Logger.new($stdout)
+      end
+
+      def soft_deprecate(subject, replacement)
+        logger.warn("[meilisearch-ruby] #{subject} is DEPRECATED, please use #{replacement} instead.")
       end
-    end
 
-    def self.parse(body)
-      body
-        .transform_keys(&:to_s)
-        .transform_keys do |key|
-          key.include?('_') ? key.downcase.gsub(SNAKE_CASE, &:upcase).gsub('_', '') : key
+      def warn_on_unfinished_task(task_uid)
+        message = <<~UNFINISHED_TASK_WARNING
+          [meilisearch-ruby] Task #{task_uid}'s finished state (succeeded?/failed?/cancelled?) is being checked before finishing.
+          [meilisearch-ruby] Tasks in meilisearch are processed in the background asynchronously.
+          [meilisearch-ruby] Please use the #finished? method to check if the task is finished or the #await method to wait for the task to finish.
+        UNFINISHED_TASK_WARNING
+
+        message.lines.each do |line|
+          logger.warn(line)
         end
-    end
+      end
 
-    def self.filter(original_options, allowed_params = [])
-      original_options.transform_keys(&:to_sym).slice(*allowed_params)
-    end
+      def transform_attributes(body)
+        case body
+        when Array
+          body.map { |item| transform_attributes(item) }
+        when Hash
+          warn_on_non_conforming_attribute_names(body)
+          parse(body)
+        else
+          body
+        end
+      end
 
-    def self.parse_query(original_options, allowed_params = [])
-      only_allowed_params = filter(original_options, allowed_params)
+      def filter(original_options, allowed_params = [])
+        original_options.transform_keys(&:to_sym).slice(*allowed_params)
+      end
+
+      def parse_query(original_options, allowed_params = [])
+        only_allowed_params = filter(original_options, allowed_params)
 
-      Utils.transform_attributes(only_allowed_params).then do |body|
-        body.transform_values do |v|
-          v.respond_to?(:join) ? v.join(',') : v.to_s
+        Utils.transform_attributes(only_allowed_params).then do |body|
+          body.transform_values do |v|
+            v.respond_to?(:join) ? v.join(',') : v.to_s
+          end
         end
       end
-    end
 
-    def self.message_builder(current_message, method_name)
-      "#{current_message}\nHint: It might not be working because maybe you're not up " \
-        "to date with the Meilisearch version that `#{method_name}` call requires."
-    end
+      def version_error_handler(method_name)
+        yield if block_given?
+      rescue MeiliSearch::ApiError => e
+        message = message_builder(e.http_message, method_name)
 
-    def self.version_error_handler(method_name)
-      yield if block_given?
-    rescue MeiliSearch::ApiError => e
-      message = message_builder(e.http_message, method_name)
+        raise MeiliSearch::ApiError.new(e.http_code, message, e.http_body)
+      rescue StandardError => e
+        raise e.class, message_builder(e.message, method_name)
+      end
 
-      raise MeiliSearch::ApiError.new(e.http_code, message, e.http_body)
-    rescue StandardError => e
-      raise e.class, message_builder(e.message, method_name)
-    end
+      def warn_on_non_conforming_attribute_names(body)
+        return if body.nil?
 
-    def self.warn_on_non_conforming_attribute_names(body)
-      return if body.nil?
+        non_snake_case = body.keys.grep_v(/^[a-z0-9_]+$/)
+        return if non_snake_case.empty?
 
-      non_snake_case = body.keys.grep_v(/^[a-z0-9_]+$/)
-      return if non_snake_case.empty?
+        message = <<~MSG
+          [meilisearch-ruby] Attributes will be expected to be snake_case in future versions.
+          [meilisearch-ruby] Non-conforming attributes: #{non_snake_case.join(', ')}
+        MSG
 
-      message = <<~MSG
-        Attributes will be expected to be snake_case in future versions of Meilisearch Ruby.
+        logger.warn(message)
+      end
 
-        Non-conforming attributes: #{non_snake_case.join(', ')}
-      MSG
+      private
 
-      warn(message)
-    end
+      def parse(body)
+        body
+          .transform_keys(&:to_s)
+          .transform_keys do |key|
+            key.include?('_') ? key.downcase.gsub(SNAKE_CASE, &:upcase).gsub('_', '') : key
+          end
+      end
 
-    private_class_method :parse, :message_builder
+      def message_builder(current_message, method_name)
+        "#{current_message}\nHint: It might not be working because maybe you're not up " \
+          "to date with the Meilisearch version that `#{method_name}` call requires."
+      end
+    end
   end
 end

data/lib/meilisearch/version.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module MeiliSearch
-  VERSION = '0.27.0'
+  VERSION = '0.27.1'
 
   def self.qualified_version
     "Meilisearch Ruby (v#{VERSION})"

data/lib/meilisearch.rb

@@ -2,6 +2,7 @@
 
 require 'meilisearch/version'
 require 'meilisearch/utils'
+require 'meilisearch/models/task'
 require 'meilisearch/http_request'
 require 'meilisearch/multi_search'
 require 'meilisearch/tenant_token'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: meilisearch
 version: !ruby/object:Gem::Version
-  version: 0.27.0
+  version: 0.27.1
 platform: ruby
 authors:
 - Meili
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2024-02-14 00:00:00.000000000 Z
+date: 2024-03-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: httparty
@@ -43,6 +43,7 @@ files:
 - lib/meilisearch/error.rb
 - lib/meilisearch/http_request.rb
 - lib/meilisearch/index.rb
+- lib/meilisearch/models/task.rb
 - lib/meilisearch/multi_search.rb
 - lib/meilisearch/task.rb
 - lib/meilisearch/tenant_token.rb