meilisearch 0.17.0 → 0.18.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c6e2e138205c88de9e5a82459a9a9648c1170380eb977ca839b8ed25aa238a8f
-  data.tar.gz: 642d60688d0000f6ae2d6f2ea64de47236eff9af6b34d71ec5bde38a2e76cc83
+  metadata.gz: df541b398ac4b031ec615d5e20c6a19cd7c370cdeaf83dcf63d789374827f012
+  data.tar.gz: 9277554fe2d6f388491d506cbfda456e71a1cc90b1945d933cfa72a2147ee52c
 SHA512:
-  metadata.gz: 76f796decd057670599f0cbd8e3c921f73457717b0e49e4a58ee9a7faabbefeae5819ba701c59aff27b4bd22fe449d60623b68e7be47e99d70379caa140097c1
-  data.tar.gz: 43734101c23e8fd5ab2fcf1b8044b5005b4e809f9947e16519e0f099e82491e75cce33499329faffb73fec91a589bf5de776566498b2c53054c793cbee7f0891
+  metadata.gz: bc0446c08444d6bf48d796c62c9b92e5f008835463b08c916e52f0ac9ce81156bcb835cd645fd78c31b98907a06230cf60fe2dbcfdcf0102b9c3fe8f9dfc2732
+  data.tar.gz: ac4f2136062699556c365e296db97fe54c6085a228c2b6831b963a72557918c100b83f7e5241183b5d9d173927e127b1e2ad402045dc64ec71056c7b57663fb2

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2019-2021 Meili
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,222 @@
+<p align="center">
+  <img src="https://res.cloudinary.com/meilisearch/image/upload/v1587402338/SDKs/meilisearch_ruby.svg" alt="MeiliSearch-Ruby" width="200" height="200" />
+</p>
+
+<h1 align="center">MeiliSearch Ruby</h1>
+
+<h4 align="center">
+  <a href="https://github.com/meilisearch/MeiliSearch">MeiliSearch</a> |
+  <a href="https://docs.meilisearch.com">Documentation</a> |
+  <a href="https://slack.meilisearch.com">Slack</a> |
+  <a href="https://roadmap.meilisearch.com/tabs/1-under-consideration">Roadmap</a> |
+  <a href="https://www.meilisearch.com">Website</a> |
+  <a href="https://docs.meilisearch.com/faq">FAQ</a>
+</h4>
+
+<p align="center">
+  <a href="https://badge.fury.io/rb/meilisearch"><img src="https://badge.fury.io/rb/meilisearch.svg" alt="Latest Stable Version"></a>
+  <a href="https://github.com/meilisearch/meilisearch-ruby/actions"><img src="https://github.com/meilisearch/meilisearch-ruby/workflows/Tests/badge.svg" alt="Test"></a>
+  <a href="https://github.com/meilisearch/meilisearch-ruby/blob/main/LICENSE"><img src="https://img.shields.io/badge/license-MIT-informational" alt="License"></a>
+  <a href="https://ms-bors.herokuapp.com/repositories/6"><img src="https://bors.tech/images/badge_small.svg" alt="Bors enabled"></a>
+</p>
+
+<p align="center">⚡ The MeiliSearch API client written for Ruby 💎</p>
+
+**MeiliSearch Ruby** is the MeiliSearch API client for Ruby developers.
+
+**MeiliSearch** is an open-source search engine. [Discover what MeiliSearch is!](https://github.com/meilisearch/MeiliSearch)
+
+## Table of Contents <!-- omit in toc -->
+
+- [📖 Documentation](#-documentation)
+- [🔧 Installation](#-installation)
+- [🚀 Getting Started](#-getting-started)
+- [🤖 Compatibility with MeiliSearch](#-compatibility-with-meilisearch)
+- [💡 Learn More](#-learn-more)
+- [⚙️ Development Workflow and Contributing](#️-development-workflow-and-contributing)
+
+## 📖 Documentation
+
+See our [Documentation](https://docs.meilisearch.com/learn/tutorials/getting_started.html) or our [API References](https://docs.meilisearch.com/reference/api/).
+
+## 🔧 Installation
+
+This package requires Ruby version 2.6.0 or later.
+
+With `gem` in command line:
+```bash
+gem install meilisearch
+```
+
+In your `Gemfile` with [bundler](https://bundler.io/):
+```ruby
+source 'https://rubygems.org'
+
+gem 'meilisearch'
+```
+
+### Run MeiliSearch <!-- omit in toc -->
+
+There are many easy ways to [download and run a MeiliSearch instance](https://docs.meilisearch.com/reference/features/installation.html#download-and-launch).
+
+For example, using the `curl` command in your [Terminal](https://itconnect.uw.edu/learn/workshops/online-tutorials/web-publishing/what-is-a-terminal/):
+
+```sh
+#Install MeiliSearch
+curl -L https://install.meilisearch.com | sh
+
+# Launch MeiliSearch
+./meilisearch --master-key=masterKey
+```
+
+NB: you can also download MeiliSearch from **Homebrew** or **APT** or even run it using **Docker**.
+
+## 🚀 Getting Started
+
+#### Add documents <!-- omit in toc -->
+
+```ruby
+require 'meilisearch'
+
+client = MeiliSearch::Client.new('http://127.0.0.1:7700', 'masterKey')
+
+# An index is where the documents are stored.
+index = client.index('movies')
+
+documents = [
+  { id: 1, title: 'Carol', genres: ['Romance', 'Drama'] },
+  { id: 2, title: 'Wonder Woman', genres: ['Action', 'Adventure'] },
+  { id: 3, title: 'Life of Pi', genres: ['Adventure', 'Drama'] },
+  { id: 4, title: 'Mad Max: Fury Road', genres: ['Adventure', 'Science Fiction'] },
+  { id: 5, title: 'Moana', genres: ['Fantasy', 'Action']},
+  { id: 6, title: 'Philadelphia', genres: ['Drama'] },
+]
+# If the index 'movies' does not exist, MeiliSearch creates it when you first add the documents.
+index.add_documents(documents) # => { "uid": 0 }
+```
+
+With the `uid`, you can check the status (`enqueued`, `processing`, `succeeded` or `failed`) of your documents addition using the [task](https://docs.meilisearch.com/reference/api/tasks.html#get-task).
+
+💡 To customize the `Client`, for example, increasing the default timeout, please check out [this section](https://github.com/meilisearch/meilisearch-ruby/wiki/Client-Options) of the Wiki.
+
+#### Basic Search <!-- omit in toc -->
+
+``` ruby
+# MeiliSearch is typo-tolerant:
+puts index.search('carlo')
+```
+Output:
+
+```ruby
+{
+  "hits" => [{
+    "id" => 1,
+    "title" => "Carol"
+  }],
+  "offset" => 0,
+  "limit" => 20,
+  "processingTimeMs" => 1,
+  "query" => "carlo"
+}
+```
+
+#### Custom search <!-- omit in toc -->
+
+All the supported options are described in the [search parameters](https://docs.meilisearch.com/reference/features/search_parameters.html) section of the documentation.
+
+```ruby
+index.search(
+  'wonder',
+  attributes_to_highlight: ['*']
+)
+```
+
+JSON output:
+
+```json
+{
+    "hits": [
+        {
+            "id": 2,
+            "title": "Wonder Woman",
+            "_formatted": {
+                "id": 2,
+                "title": "<em>Wonder</em> Woman"
+            }
+        }
+    ],
+    "offset": 0,
+    "limit": 20,
+    "processingTimeMs": 0,
+    "query": "wonder"
+}
+```
+
+#### Custom Search With Filters <!-- omit in toc -->
+
+If you want to enable filtering, you must add your attributes to the `filterableAttributes` index setting.
+
+```ruby
+index.update_filterable_attributes([
+  'id',
+  'genres'
+])
+```
+
+You only need to perform this operation once.
+
+Note that MeiliSearch will rebuild your index whenever you update `filterableAttributes`. Depending on the size of your dataset, this might take time. You can track the process using the [tasks](https://docs.meilisearch.com/reference/api/tasks.html#get-task)).
+
+Then, you can perform the search:
+
+```ruby
+index.search('wonder', { filter: ['id > 1 AND genres = Action'] })
+```
+
+JSON output:
+
+```json
+{
+  "hits": [
+    {
+      "id": 2,
+      "title": "Wonder Woman",
+      "genres": [
+        "Action",
+        "Adventure"
+      ]
+    }
+  ],
+  "nbHits": 1,
+  "exhaustiveNbHits": false,
+  "query": "wonder",
+  "limit": 20,
+  "offset": 0,
+  "processingTimeMs": 0
+}
+```
+
+## 🤖 Compatibility with MeiliSearch
+
+This package only guarantees the compatibility with the [version v0.25.0 of MeiliSearch](https://github.com/meilisearch/MeiliSearch/releases/tag/v0.25.0).
+
+## 💡 Learn More
+
+The following sections may interest you:
+
+- **Manipulate documents**: see the [API references](https://docs.meilisearch.com/reference/api/documents.html) or read more about [documents](https://docs.meilisearch.com/learn/core_concepts/documents.html).
+- **Search**: see the [API references](https://docs.meilisearch.com/reference/api/search.html) or follow our guide on [search parameters](https://docs.meilisearch.com/reference/features/search_parameters.html).
+- **Manage the indexes**: see the [API references](https://docs.meilisearch.com/reference/api/indexes.html) or read more about [indexes](https://docs.meilisearch.com/learn/core_concepts/indexes.html).
+- **Configure the index settings**: see the [API references](https://docs.meilisearch.com/reference/api/settings.html) or follow our guide on [settings parameters](https://docs.meilisearch.com/reference/features/settings.html).
+
+📖 Also, check out the [Wiki](https://github.com/meilisearch/meilisearch-ruby/wiki) of this repository to know what this SDK provdes!
+
+## ⚙️ Development Workflow and Contributing
+
+Any new contribution is more than welcome in this project!
+
+If you want to know more about the development workflow or want to contribute, please visit our [contributing guidelines](/CONTRIBUTING.md) for detailed instructions!
+
+<hr>
+
+**MeiliSearch** provides and maintains many **SDKs and Integration tools** like this one. We want to provide everyone with an **amazing search experience for any kind of project**. If you want to contribute, make suggestions, or just know what's going on right now, visit us in the [integration-guides](https://github.com/meilisearch/integration-guides) repository.

data/lib/meilisearch/client.rb

@@ -20,37 +20,22 @@ module MeiliSearch
     # client.create_index('indexUID')
     # client.create_index('indexUID', primaryKey: 'id')
     def create_index(index_uid, options = {})
-      body = options.merge(uid: index_uid)
-      index_hash = http_post '/indexes', body
-      index_object(index_hash['uid'], index_hash['primaryKey'])
-    end
+      body = Utils.transform_attributes(options.merge(uid: index_uid))
 
-    def get_or_create_index(index_uid, options = {})
-      begin
-        index_instance = fetch_index(index_uid)
-      rescue ApiError => e
-        raise e unless e.code == 'index_not_found'
+      http_post '/indexes', body
+    end
 
-        index_instance = create_index(index_uid, options)
-      end
-      index_instance
+    # 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['uid'])
     end
 
     def delete_index(index_uid)
       index_object(index_uid).delete
     end
 
-    # Usage:
-    # client.delete_index_if_exists('indexUID')
-    def delete_index_if_exists(index_uid)
-      index_object(index_uid).delete
-      true
-    rescue ApiError => e
-      raise e if e.code != 'index_not_found'
-
-      false
-    end
-
     # Usage:
     # client.index('indexUID')
     def index(index_uid)
@@ -70,7 +55,26 @@ module MeiliSearch
     def keys
       http_get '/keys'
     end
-    alias get_keys keys
+
+    def key(key_uid)
+      http_get "/keys/#{key_uid}"
+    end
+
+    def create_key(key_options)
+      body = Utils.transform_attributes(key_options)
+
+      http_post '/keys', body
+    end
+
+    def update_key(key_uid, key_options)
+      body = Utils.transform_attributes(key_options)
+
+      http_patch "/keys/#{key_uid}", body
+    end
+
+    def delete_key(key_uid)
+      http_delete "/keys/#{key_uid}"
+    end
 
     ### HEALTH
 
@@ -106,10 +110,28 @@ module MeiliSearch
     end
     alias get_dump_status dump_status
 
+    ### TASKS
+
+    def tasks
+      task_endpoint.task_list
+    end
+
+    def task(task_uid)
+      task_endpoint.task(task_uid)
+    end
+
+    def wait_for_task(task_uid, timeout_in_ms = 5000, interval_in_ms = 50)
+      task_endpoint.wait_for_task(task_uid, timeout_in_ms, interval_in_ms)
+    end
+
     private
 
     def index_object(uid, primary_key = nil)
       Index.new(uid, @base_url, @api_key, primary_key, @options)
     end
+
+    def task_endpoint
+      @task_endpoint ||= Task.new(@base_url, @api_key, @options)
+    end
   end
 end

data/lib/meilisearch/http_request.rb

@@ -12,14 +12,12 @@ module MeiliSearch
     def initialize(url, api_key = nil, options = {})
       @base_url = url
       @api_key = api_key
-      @options = options
-      @headers = {
-        'Content-Type' => 'application/json',
-        'X-Meili-API-Key' => api_key
-      }.compact
-      @headers_no_body = {
-        'X-Meili-API-Key' => api_key
-      }.compact
+      @options = merge_options({
+                                 timeout: 1,
+                                 max_retries: 0,
+                                 headers: build_default_options_headers(api_key),
+                                 convert_body?: true
+                               }, options)
     end
 
     def http_get(relative_path = '', query_params = {})
@@ -27,17 +25,17 @@ module MeiliSearch
         proc { |path, config| self.class.get(path, config) },
         relative_path,
         query_params: query_params,
-        headers: @headers_no_body
+        options: remove_options_header(@options, 'Content-Type')
       )
     end
 
-    def http_post(relative_path = '', body = nil, query_params = nil)
+    def http_post(relative_path = '', body = nil, query_params = nil, options = {})
       send_request(
         proc { |path, config| self.class.post(path, config) },
         relative_path,
         query_params: query_params,
         body: body,
-        headers: @headers
+        options: merge_options(@options, options)
       )
     end
 
@@ -47,7 +45,17 @@ module MeiliSearch
         relative_path,
         query_params: query_params,
         body: body,
-        headers: @headers
+        options: @options
+      )
+    end
+
+    def http_patch(relative_path = '', body = nil, query_params = nil)
+      send_request(
+        proc { |path, config| self.class.patch(path, config) },
+        relative_path,
+        query_params: query_params,
+        body: body,
+        options: @options
       )
     end
 
@@ -55,16 +63,41 @@ module MeiliSearch
       send_request(
         proc { |path, config| self.class.delete(path, config) },
         relative_path,
-        headers: @headers_no_body
+        options: remove_options_header(@options, 'Content-Type')
       )
     end
 
     private
 
-    SNAKE_CASE = /[^a-zA-Z0-9]+(.)/.freeze
+    def build_default_options_headers(api_key = nil)
+      header = {
+        'Content-Type' => 'application/json'
+      }
+      header = header.merge('Authorization' => "Bearer #{api_key}") unless api_key.nil?
+      header
+    end
 
-    def send_request(http_method, relative_path, query_params: nil, body: nil, headers: nil)
-      config = http_config(query_params, body, headers)
+    def merge_options(default_options, added_options = {})
+      default_cloned_headers = default_options[:headers].clone
+      merged_options = default_options.merge(added_options)
+      merged_options[:headers] = default_cloned_headers.merge(added_options[:headers]) if added_options.key?(:headers)
+      merged_options
+    end
+
+    def remove_options_header(options, key)
+      cloned_options = clone_options(options)
+      cloned_options[:headers].tap { |headers| headers.delete(key) }
+      cloned_options
+    end
+
+    def clone_options(options)
+      cloned_options = options.clone
+      cloned_options[:headers] = options[:headers].clone
+      cloned_options
+    end
+
+    def send_request(http_method, relative_path, query_params: nil, body: nil, options: {})
+      config = http_config(query_params, body, options)
       begin
         response = http_method.call(@base_url + relative_path, config)
       rescue Errno::ECONNREFUSED => e
@@ -73,36 +106,17 @@ module MeiliSearch
       validate(response)
     end
 
-    def http_config(query_params, body, headers)
-      body = transform_attributes(body).to_json
+    def http_config(query_params, body, options)
+      body = body.to_json if options[:convert_body?] == true
       {
-        headers: headers,
+        headers: options[:headers],
         query: query_params,
         body: body,
-        timeout: @options[:timeout] || 1,
-        max_retries: @options[:max_retries] || 0
+        timeout: options[:timeout],
+        max_retries: options[:max_retries]
       }.compact
     end
 
-    def transform_attributes(body)
-      case body
-      when Array
-        body.map { |item| transform_attributes(item) }
-      when Hash
-        parse(body)
-      else
-        body
-      end
-    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
-
     def validate(response)
       raise ApiError.new(response.code, response.message, response.body) unless response.success?
 

data/lib/meilisearch/index.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require 'meilisearch/http_request'
-require 'timeout'
 
 module MeiliSearch
   class Index < HTTPRequest
@@ -31,9 +30,7 @@ module MeiliSearch
     end
 
     def update(body)
-      index_hash = http_put indexes_path(id: @uid), body
-      set_base_properties index_hash
-      self
+      http_put indexes_path(id: @uid), Utils.transform_attributes(body)
     end
 
     alias update_index update
@@ -65,7 +62,7 @@ module MeiliSearch
     alias get_one_document document
 
     def documents(options = {})
-      http_get "/indexes/#{@uid}/documents", options
+      http_get "/indexes/#{@uid}/documents", Utils.transform_attributes(options)
     end
     alias get_documents documents
 
@@ -77,12 +74,33 @@ module MeiliSearch
     alias add_or_replace_documents add_documents
 
     def add_documents!(documents, primary_key = nil)
-      update = add_documents(documents, primary_key)
-      wait_for_pending_update(update['updateId'])
+      task = add_documents(documents, primary_key)
+      wait_for_task(task['uid'])
     end
     alias replace_documents! add_documents!
     alias add_or_replace_documents! add_documents!
 
+    def add_documents_json(documents, primary_key = nil)
+      options = { headers: { 'Content-Type' => 'application/json' }, convert_body?: false }
+      http_post "/indexes/#{@uid}/documents", documents, { primaryKey: primary_key }.compact, options
+    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
+    end
+    alias replace_documents_ndjson add_documents_ndjson
+    alias add_or_replace_documents_ndjson add_documents_ndjson
+
+    def add_documents_csv(documents, primary_key = nil)
+      options = { headers: { 'Content-Type' => 'text/csv' }, convert_body?: false }
+      http_post "/indexes/#{@uid}/documents", documents, { primaryKey: primary_key }.compact, options
+    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
@@ -90,41 +108,41 @@ module MeiliSearch
     alias add_or_update_documents update_documents
 
     def update_documents!(documents, primary_key = nil)
-      update = update_documents(documents, primary_key)
-      wait_for_pending_update(update['updateId'])
+      task = update_documents(documents, primary_key)
+      wait_for_task(task['uid'])
     end
     alias add_or_update_documents! update_documents!
 
     def add_documents_in_batches(documents, batch_size = 1000, primary_key = nil)
-      update_ids = []
+      tasks = []
       documents.each_slice(batch_size) do |batch|
-        update_ids.append(add_documents(batch, primary_key))
+        tasks.append(add_documents(batch, primary_key))
       end
-      update_ids
+      tasks
     end
 
     def add_documents_in_batches!(documents, batch_size = 1000, primary_key = nil)
-      update_ids = add_documents_in_batches(documents, batch_size, primary_key)
+      tasks = add_documents_in_batches(documents, batch_size, primary_key)
       responses = []
-      update_ids.each do |update_object|
-        responses.append(wait_for_pending_update(update_object['updateId']))
+      tasks.each do |task_obj|
+        responses.append(wait_for_task(task_obj['uid']))
       end
       responses
     end
 
     def update_documents_in_batches(documents, batch_size = 1000, primary_key = nil)
-      update_ids = []
+      tasks = []
       documents.each_slice(batch_size) do |batch|
-        update_ids.append(update_documents(batch, primary_key))
+        tasks.append(update_documents(batch, primary_key))
       end
-      update_ids
+      tasks
     end
 
     def update_documents_in_batches!(documents, batch_size = 1000, primary_key = nil)
-      update_ids = update_documents_in_batches(documents, batch_size, primary_key)
+      tasks = update_documents_in_batches(documents, batch_size, primary_key)
       responses = []
-      update_ids.each do |update_object|
-        responses.append(wait_for_pending_update(update_object['updateId']))
+      tasks.each do |task_obj|
+        responses.append(wait_for_task(task_obj['uid']))
       end
       responses
     end
@@ -139,8 +157,8 @@ module MeiliSearch
     alias delete_multiple_documents delete_documents
 
     def delete_documents!(documents_ids)
-      update = delete_documents(documents_ids)
-      wait_for_pending_update(update['updateId'])
+      task = delete_documents(documents_ids)
+      wait_for_task(task['uid'])
     end
     alias delete_multiple_documents! delete_documents!
 
@@ -151,8 +169,8 @@ module MeiliSearch
     alias delete_one_document delete_document
 
     def delete_document!(document_id)
-      update = delete_document(document_id)
-      wait_for_pending_update(update['updateId'])
+      task = delete_document(document_id)
+      wait_for_task(task['uid'])
     end
     alias delete_one_document! delete_document!
 
@@ -161,42 +179,35 @@ module MeiliSearch
     end
 
     def delete_all_documents!
-      update = delete_all_documents
-      wait_for_pending_update(update['updateId'])
+      task = delete_all_documents
+      wait_for_task(task['uid'])
     end
 
     ### SEARCH
 
     def search(query, options = {})
-      parsed_options = options.compact
-      http_post "/indexes/#{@uid}/search", { q: query.to_s }.merge(parsed_options)
+      parsed_options = Utils.transform_attributes({ q: query.to_s }.merge(options.compact))
+
+      http_post "/indexes/#{@uid}/search", parsed_options
     end
 
-    ### UPDATES
+    ### TASKS
 
-    def get_update_status(update_id)
-      http_get "/indexes/#{@uid}/updates/#{update_id}"
+    def task_endpoint
+      @task_endpoint ||= Task.new(@base_url, @api_key, @options)
     end
+    private :task_endpoint
 
-    def get_all_update_status
-      http_get "/indexes/#{@uid}/updates"
+    def task(task_uid)
+      task_endpoint.index_task(@uid, task_uid)
     end
 
-    def achieved_upate?(update)
-      update['status'] != 'enqueued' && update['status'] != 'processing'
+    def tasks
+      task_endpoint.index_tasks(@uid)
     end
 
-    def wait_for_pending_update(update_id, timeout_in_ms = 5000, interval_in_ms = 50)
-      Timeout.timeout(timeout_in_ms.to_f / 1000) do
-        loop do
-          get_update = get_update_status(update_id)
-          return get_update if achieved_upate?(get_update)
-
-          sleep interval_in_ms.to_f / 1000
-        end
-      end
-    rescue Timeout::Error
-      raise MeiliSearch::TimeoutError
+    def wait_for_task(task_uid, timeout_in_ms = 5000, interval_in_ms = 50)
+      task_endpoint.wait_for_task(task_uid, timeout_in_ms, interval_in_ms)
     end
 
     ### STATS
@@ -213,10 +224,6 @@ module MeiliSearch
       stats['isIndexing']
     end
 
-    def last_update
-      stats['lastUpdate']
-    end
-
     def field_distribution
       stats['fieldDistribution']
     end
@@ -229,7 +236,7 @@ module MeiliSearch
     alias get_settings settings
 
     def update_settings(settings)
-      http_post "/indexes/#{@uid}/settings", settings
+      http_post "/indexes/#{@uid}/settings", Utils.transform_attributes(settings)
     end
     alias settings= update_settings
 

data/lib/meilisearch/task.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require 'meilisearch/http_request'
+require 'timeout'
+
+module MeiliSearch
+  class Task < HTTPRequest
+    def task_list
+      http_get '/tasks/'
+    end
+
+    def task(task_uid)
+      http_get "/tasks/#{task_uid}"
+    end
+
+    def index_tasks(index_uid)
+      http_get "/indexes/#{index_uid}/tasks"
+    end
+
+    def index_task(index_uid, task_uid)
+      http_get "/indexes/#{index_uid}/tasks/#{task_uid}"
+    end
+
+    def wait_for_task(task_uid, timeout_in_ms = 5000, interval_in_ms = 50)
+      Timeout.timeout(timeout_in_ms.to_f / 1000) do
+        loop do
+          task = task(task_uid)
+          return task if achieved_task?(task)
+
+          sleep interval_in_ms.to_f / 1000
+        end
+      end
+    rescue Timeout::Error
+      raise MeiliSearch::TimeoutError
+    end
+
+    private
+
+    def achieved_task?(task)
+      task['status'] != 'enqueued' && task['status'] != 'processing'
+    end
+  end
+end

data/lib/meilisearch/utils.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module MeiliSearch
+  module Utils
+    SNAKE_CASE = /[^a-zA-Z0-9]+(.)/.freeze
+
+    def self.transform_attributes(body)
+      case body
+      when Array
+        body.map { |item| transform_attributes(item) }
+      when Hash
+        parse(body)
+      else
+        body
+      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
+        end
+    end
+
+    private_class_method :parse
+  end
+end

data/lib/meilisearch/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module MeiliSearch
-  VERSION = '0.17.0'
+  VERSION = '0.18.0'
 end

data/lib/meilisearch.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 
 require 'meilisearch/version'
+require 'meilisearch/utils'
+require 'meilisearch/task'
 require 'meilisearch/client'
 require 'meilisearch/index'
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: meilisearch
 version: !ruby/object:Gem::Version
-  version: 0.17.0
+  version: 0.18.0
 platform: ruby
 authors:
 - Meili
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-11-17 00:00:00.000000000 Z
+date: 2022-01-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: httparty
@@ -36,11 +36,15 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- LICENSE
+- README.md
 - lib/meilisearch.rb
 - lib/meilisearch/client.rb
 - lib/meilisearch/error.rb
 - lib/meilisearch/http_request.rb
 - lib/meilisearch/index.rb
+- lib/meilisearch/task.rb
+- lib/meilisearch/utils.rb
 - lib/meilisearch/version.rb
 homepage: https://github.com/meilisearch/meilisearch-ruby
 licenses: