algolia 2.0.0 → 2.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 555e432d41a84d3031f58dc7c74acf5297df48fe693fadf977c6b15547a82d6b
-  data.tar.gz: a3fbbc9ba6552b0b432a20e34cd5cf7a311f339c2df7f7a3c549ced84f409ba0
+  metadata.gz: dc743bd03ca6ebc94d2ae61eec22670ccbaa3531d2a9b66c44858280c644a938
+  data.tar.gz: 9e5fb85f9d474d266de360c25b7ef3efafa0fe0b78765aa1cae32b402a0865ac
 SHA512:
-  metadata.gz: 757d57c2723f3f036bfb7faa38615fd751311e99b0a3f5e1b3c13087c53a9010af88c99a5412e31bb3e6d3cdb9201478d7100c71080b3fe948004170a870f875
-  data.tar.gz: ede51228b6bc2498b65434102f8b25b17d7db74ae74cd2b50a1ec7184f42692e4b24d94de8c621ec91a8192c924e71ac1067bfdde038a03936407f12147b6175
+  metadata.gz: b343a5a32c22f73fd18b33235e9dfd4adcc4c6f3236bac881ad37160dce5af9a7b79e836643ba126e3c0f2943d0187ffb804fe1688fdd6f9599966d39950fa48
+  data.tar.gz: 98fea72cc28767839cead8d54d75f9d2ac262999bb92b5ba446d81abfb9d43ef7986c99bccc523c892916df6cf605b3e5fcf305935161bf9bdf371ab24e44196

data/.circleci/config.yml

@@ -23,6 +23,13 @@ aliases:
     name: Run linting tool
     command: bundle exec rake rubocop
 
+  - &credentials
+    name: Retrieve temporary Algolia credentials if needed
+    command: |
+      if [ "$CIRCLE_PR_REPONAME" ]; then
+        curl -s https://algoliasearch-client-keygen.herokuapp.com | sh >> $BASH_ENV
+      fi
+
   - &run_tests
      name: Run unit and integration tests
      command: |
@@ -73,6 +80,7 @@ jobs:
       - restore_cache: *restore_cache
       - run: *install_bundler
       - save_cache: *save_cache
+      - run: *credentials
       - run: *run_tests
 
   test_jruby:
@@ -88,6 +96,7 @@ jobs:
       - restore_cache: *restore_cache
       - run: *install_bundler
       - save_cache: *save_cache
+      - run: *credentials
       - run: *run_tests
 
   release:

data/.dockerignore

@@ -0,0 +1,38 @@
+# rspec failure tracking
+.rspec_status
+
+## MAC OS
+.DS_Store
+.idea/
+
+## TEXTMATE
+*.tmproj
+tmtags
+
+## EMACS
+*~
+\#*
+.\#*
+
+## VIM
+*.swp
+
+## PROJECT::GENERAL
+coverage
+rdoc
+pkg
+.rvmrc
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+
+## PROJECT::SPECIFIC
+spec/integration_spec_conf.rb
+data.sqlite3
+
+debug.log

data/.gitignore

@@ -37,3 +37,4 @@ spec/integration_spec_conf.rb
 data.sqlite3
 
 debug.log
+.ruby-version

data/CHANGELOG.md

@@ -1,6 +1,40 @@
 # ChangeLog
 
-## Unreleased
+## [Unreleased](https://github.com/algolia/algoliasearch-client-ruby/compare/2.1.1..master)
+
+## [2.1.1](https://github.com/algolia/algoliasearch-client-ruby/compare/2.1.0...2.1.1) (2021-05-27)
+
+### Fix
+- Bug with read/write nodes caching ([`#455`](https://github.com/algolia/algoliasearch-client-ruby/pull/455))
+
+## [2.1.0](https://github.com/algolia/algoliasearch-client-ruby/compare/2.0.4...2.1.0) (2021-03-30)
+
+### Feat
+- Custom dictionaries methods
+
+### Fix
+- The parameter `forwardToReplicas` should be handled independently in the `set_settings` method
+
+## [2.0.4](https://github.com/algolia/algoliasearch-client-ruby/compare/2.0.3...2.0.4) (2021-01-05)
+
+### Fix
+- `app_api_key`: send opts with waitable method
+
+## [2.0.3](https://github.com/algolia/algoliasearch-client-ruby/compare/2.0.2...2.0.3) (2020-11-24)
+
+### Chore
+- Containerize the repo
+
+## [2.0.2](https://github.com/algolia/algoliasearch-client-ruby/compare/2.0.1...2.0.2) (2020-11-09)
+
+### Fix
+- Don't mutate index name on stripping
+
+## [2.0.1](https://github.com/algolia/algoliasearch-client-ruby/compare/2.0.0...2.0.1) (2020-11-02)
+
+### Fix
+- Simplify merge of headers in `Transport` class
+- `deserialize_settings` function to take into account `symbolize_keys` parameter
 
 ## [2.0.0](https://github.com/algolia/algoliasearch-client-ruby/releases/tag/2.0.0) (2020-10-27)
 

data/CONTRIBUTING.MD

@@ -0,0 +1,184 @@
+<p align="center">
+  <a href="https://www.algolia.com">
+      <img alt="Algolia for Ruby" src="https://raw.githubusercontent.com/algolia/algoliasearch-client-common/master/banners/ruby.png" >
+    </a>
+</p>
+
+Hello and welcome to the contributing guide for algolia gem. Thanks for considering participating in our project 🙇
+
+If this guide does not contain what you are looking for and thus prevents you from contributing, don't hesitate to leave a message on the [community forum](https://discourse.algolia.com/) or to [open an issue](https://github.com/algolia/algoliasearch-client-ruby/issues).
+
+<!-- DON'T EDIT THIS SECTION, INSTEAD RE-RUN TocDown TO UPDATE -->
+<!-- TocDown Begin -->
+* [Reporting an issue](#reporting-an-issue)
+* [The code contribution process](#the-code-contribution-process)
+* [Commit conventions](#commit-conventions)
+* [Branch organization](#branch-organization)
+* [Requirements](#requirements)
+* [Code structure](#code-structure)
+  * [The source algolia folder](#the-source-algolia-folder)
+* [Tests](#tests)
+* [Linting](#linting)
+<!-- TocDown End -->
+
+## Reporting an issue
+
+Opening an issue is very effective way to contribute because other users might also be impacted. We'll make sure to fix it quickly if it's technically feasible and doesn't have important side effects for other users.
+
+Before reporting an issue, first check that there is not an already open issue for the same topic using the [issues page](https://github.com/algolia/algoliasearch-client-ruby/issues). Don't hesitate to thumb up an issue that corresponds to the problem you have.
+
+It would be very helpful if you're able to add a test case that reproduces the issue. This could help us solve the issue faster.
+
+## The code contribution process
+
+The algolia gem is developed in Ruby ≥ 2.2.
+
+For any code contribution, you need to:
+
+- Fork and clone the project
+- Create a new branch for what you want to solve (fix/_issue-number_, feat/_name-of-the-feature_)
+- Make your changes
+- Open a pull request
+
+Depending on what you're working on, you might consider different [base branches](#branch-organization).
+
+Then:
+
+- Peer review of the pull request (by at least one of the core contributors)
+- Automatic checks ([tests](#tests), [commits](#commit-conventions), [linters](#linting))
+- When everything is green, one of the core contributors will merge your contribution 🚀
+
+## Commit conventions
+
+This project follows the [conventional changelog](https://conventionalcommits.org/) approach. This means that all commit messages should be formatted using the following scheme:
+
+```
+type(scope): description
+```
+
+In most cases, we use the following types:
+
+- `fix`: for any resolution of an issue (identified or not)
+- `feat`: for any new feature
+- `refactor`: for any code change that neither adds a feature nor fixes an issue
+- `docs`: for any documentation change or addition
+- `chore`: for anything that is not related to the library itself (doc, tooling)
+
+Even though the scope is optional, we try to fill it in as it helps us better understand the impact of a change. We either use the name of the widget/connector/component impacted or we use impact topic (e.g. `docs`, `tooling`, `deps`, `ci`).
+
+Finally, if your work is based on an issue on GitHub, please fill in the dedicated line in the PR template (read "[Closing issues using keywords](https://help.github.com/en/articles/closing-issues-using-keywords)").
+
+Some examples of valid commit messages (used as first lines):
+
+> - feat(account-client): add method XXX
+> - chore(deps): update dependency XXX to v3.0.7
+> - fix(search_user_ids): rename parameter clusterName
+> - chore: reword contributions guides
+
+## Branch organization
+
+The project is based on the classic GitHub flow:
+
+- `master` for the current version being worked on – Pull requests for bugs and feature related to the current major version should be created against this branch
+- `vX` for each major version (`X` being a number) – Pull requests for critical bug fixes should be created against this branch
+
+Most of the time, your pull requests should target the `master` branch.
+
+_Note that no new features will be developed or backported for the `vX` branches._
+
+## Requirements
+
+To run this project, you will need:
+
+- Ruby ≥ 2.2
+- [Bundler](https://bundler.io/)
+
+## Use the Dockerfile
+
+If you want to contribute to this project without installing all its dependencies, you can use our Docker image. 
+Please check our [dedicated guide](DOCKER_README.MD) to learn more.
+
+## Code structure
+
+Here are the main files and folders of the project
+
+```
+▸ lib/algolia/              << standalone clients and helpers classes
+▸ lib/test/                 << gathers the unit and integration tests
+  .rubocop.yml              << contains the rule used for the linter
+  algolia.gemspec           << gemspec file
+  CHANGELOG.md              << changelog file
+  CONTRIBUTING.md           << this file
+  Gemfile                   << dependencies needed to run the project locally
+  Rakefile                  << defines the different tasks to lint/test the project
+  README.md                 << the introduction of the project
+```
+
+### The lib/algolia folder
+
+```
+▸ lib/algolia/
+    ▸ config/       << the configurations associated with each clients 
+    ▸ enums/        << enumerables used accross the lib
+    ▸ http/         << the http layer logic
+    ▸ iterators/    << the iterators used for the browsing methods
+    ▸ responses/    << the waitable responses
+    ▸ transport/    << the transport layer logic
+```
+
+## Tests
+
+Our unit and integration tests are written with [Minitest](https://github.com/seattlerb/minitest), in the `test` syntax.
+
+To run all the tests at once:
+
+```sh
+bundle exec rake test:all
+```
+
+To run only the unit tests:
+
+```sh
+bundle exec rake test:unit
+```
+
+To run only the integration tests:
+
+```sh
+bundle exec rake test:integration
+```
+
+We ask that for each fix or feature submitted, you add at least one test demonstrating its behaviour. As you will need to use your own Algolia credentials to run them, we advise you to keep them short and use a small dataset, as well as using a mock requester anytime it's possible. If you encounter huge data overload because of testing, please reach out to [our support team](support@algolia.com).
+
+## Linting
+
+Linters help us maintain a consistent code base.
+
+If your editor support them, then you will see the errors directly there. You can also run them using your command line:
+
+```sh
+rake rubocop
+```
+
+However, we recommend that you use in your workflow pre-commit hooks, to avoid submitting code that might not pass the linting task setup in the CI. To use them,
+first download the gem `git-precommit`
+
+```sh
+gem install git-precommit
+```
+
+Then copy-paste the following content in a file called `pre-commit` in `.git/hooks/` 
+
+```sh
+#!/usr/bin/env sh
+
+function unstaged_changes {
+    ! git diff --quiet
+}
+
+if unstaged_changes; then
+    git stash save --keep-index "Performing partial commit against `git rev-parse HEAD`"
+fi
+
+exec time bundle exec rake precommit
+```

data/DOCKER_README.MD

@@ -0,0 +1,89 @@
+In this page you will find our recommended way of installing Docker on your machine. 
+This guide is made for OSX users.
+
+## Install docker
+
+First install Docker using [Homebrew](https://brew.sh/)
+```
+$ brew install docker
+```
+
+You can then install [Docker Desktop](https://docs.docker.com/get-docker/) if you wish, or use `docker-machine`. As we prefer the second option, we will only document this one.
+
+## Setup your docker
+
+Install `docker-machine`
+```
+$ brew install docker-machine
+```
+
+Then install [VirtualBox](https://www.virtualbox.org/) with [Homebrew Cask](https://github.com/Homebrew/homebrew-cask) to get a driver for your Docker machine
+```
+$ brew cask install virtualbox
+```
+
+You may need to enter your password and authorize the application in your `System Settings` > `Security & Privacy`.
+
+Create now a new machine, set it up as default and connect your shell to it (here we use zsh. The commands should anyway be displayed in each steps' output)
+
+```
+$ docker-machine create --driver virtualbox default
+$ docker-machine env default
+$ eval "$(docker-machine env default)"
+```
+
+Now you're all setup to use our provided Docker image!
+
+## Build the image
+
+```bash
+docker build -t algolia-ruby .
+```
+
+## Run the image
+
+You need to provide few environment variables at runtime to be able to run the [Common Test Suite](https://github.com/algolia/algoliasearch-client-specs/tree/master/common-test-suite).
+You can set them up directly in the command:
+
+```bash
+docker run -it --rm --env ALGOLIA_APP_ID=XXXXXX [...] -v $PWD:/app -w /app algolia-ruby bash
+```
+
+However, we advise you to export them in your `.bashrc` or `.zshrc`. That way, you can use [Docker's shorten syntax](https://docs.docker.com/engine/reference/commandline/run/#set-environment-variables--e---env---env-file) to set your variables.
+
+```bash
+### For external contributors, only the following env variables should be enough
+docker run -it --rm --env ALGOLIA_APPLICATION_ID_1 \
+                    --env ALGOLIA_ADMIN_KEY_1 \
+                    --env ALGOLIA_SEARCH_KEY_1 \
+-v $PWD:/app -w /app algolia-ruby bash
+
+### This is needed only to run the full test suite
+docker run -it --rm --env ALGOLIA_APPLICATION_ID_1 \
+                    --env ALGOLIA_ADMIN_KEY_1 \
+                    --env ALGOLIA_SEARCH_KEY_1 \
+                    --env ALGOLIA_APPLICATION_ID_2 \
+                    --env ALGOLIA_ADMIN_KEY_2 \
+                    --env ALGOLIA_APPLICATION_ID_MCM \
+                    --env ALGOLIA_ADMIN_KEY_MCM \
+-v $PWD:/app -w /app algolia-ruby bash
+```
+
+Once your container is running, any changes you make in your IDE are directly reflected in the container.
+
+To launch the tests, you can use one of the following commands
+```shell script
+# run only the unit tests
+bundle exec rake test:unit
+
+# run only the integration tests
+bundle exec rake test:integration
+
+# run the whole test suite
+bundle exec rake test:all
+
+# run a single test
+bundle exec rake test TEST=/full/path/to/test.rb TESTOPTS="--name=test_name"
+```
+
+Feel free to contact us if you have any questions.

data/Dockerfile

@@ -0,0 +1,7 @@
+FROM ruby:2.6.3
+
+RUN gem install bundler
+
+WORKDIR /app
+COPY . /app/
+RUN bundle install

data/README.md

@@ -6,8 +6,8 @@
   <h4 align="center">The perfect starting point to integrate <a href="https://algolia.com" target="_blank">Algolia</a> within your Ruby project</h4>
 
   <p align="center">
-    <a href="https://circleci.com/gh/algolia/algoliasearch-client-ruby"><img src="https://circleci.com/gh/algolia/algoliasearch-client-ruby/tree/release%2Fv2.svg?style=shield" alt="CircleCI" /></a>
-    <a href="https://rubygems.org/gems/algolia"><img src="https://badge.fury.io/rb/algoliasearch.svg" alt="Gem Version"></a>
+    <a href="https://circleci.com/gh/algolia/algoliasearch-client-ruby"><img src="https://circleci.com/gh/algolia/algoliasearch-client-ruby.svg?style=shield" alt="CircleCI" /></a>
+    <a href="https://rubygems.org/gems/algolia"><img src="https://badge.fury.io/rb/algolia.svg" alt="Gem Version"></a>
     <a href="https://rubygems.org/gems/algolia"><img src="https://img.shields.io/badge/licence-MIT-blue.svg" alt="License"></a>
   </p>
 </p>

data/algolia.gemspec

@@ -35,7 +35,7 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency 'rake'
   spec.add_development_dependency 'rubocop', '<= 0.82.0'
 
-  spec.add_dependency 'faraday', '~> 0.15'
+  spec.add_dependency 'faraday', ['>= 0.15', '< 2.0']
   spec.add_dependency 'multi_json', '~> 1.0'
   spec.add_dependency 'net-http-persistent'
 

data/lib/algolia.rb

@@ -20,6 +20,7 @@ require 'algolia/responses/indexing_response'
 require 'algolia/responses/add_api_key_response'
 require 'algolia/responses/update_api_key_response'
 require 'algolia/responses/delete_api_key_response'
+require 'algolia/responses/dictionary_response'
 require 'algolia/responses/restore_api_key_response'
 require 'algolia/responses/multiple_batch_indexing_response'
 require 'algolia/responses/multiple_response'

data/lib/algolia/helpers.rb

@@ -53,7 +53,7 @@ module Helpers
   # Support to convert old settings to their new names
   #
   def deserialize_settings(data, symbolize_keys)
-    settings = symbolize_hash(data)
+    settings = data
     keys     = {
       attributesToIndex: 'searchableAttributes',
       numericAttributesToIndex: 'numericAttributesForFiltering',
@@ -61,6 +61,7 @@ module Helpers
     }
 
     keys.each do |deprecated_key, current_key|
+      deprecated_key = symbolize_keys ? deprecated_key : deprecated_key.to_s
       if settings.has_key?(deprecated_key)
         key           = symbolize_keys ? current_key.to_sym : current_key.to_s
         settings[key] = settings.delete(deprecated_key)
@@ -81,4 +82,53 @@ module Helpers
     end
     res
   end
+
+  # Check the passed object to determine if it's an array
+  #
+  # @param object [Object]
+  #
+  def check_array(object)
+    raise Algolia::AlgoliaError, 'argument must be an array of objects' unless object.is_a?(Array)
+  end
+
+  # Check the passed object
+  #
+  # @param object [Object]
+  # @param in_array [Boolean] whether the object is an array or not
+  #
+  def check_object(object, in_array = false)
+    case object
+    when Array
+      raise Algolia::AlgoliaError, in_array ? 'argument must be an array of objects' : 'argument must not be an array'
+    when String, Integer, Float, TrueClass, FalseClass, NilClass
+      raise Algolia::AlgoliaError, "argument must be an #{'array of' if in_array} object, got: #{object.inspect}"
+    end
+  end
+
+  # Check if passed object has a objectID
+  #
+  # @param object [Object]
+  # @param object_id [String]
+  #
+  def get_object_id(object, object_id = nil)
+    check_object(object)
+    object_id ||= object[:objectID] || object['objectID']
+    raise Algolia::AlgoliaError, "Missing 'objectID'" if object_id.nil?
+    object_id
+  end
+
+  # Build a batch request
+  #
+  # @param action [String] action to perform on the engine
+  # @param objects [Array] objects on which build the action
+  # @param with_object_id [Boolean] if set to true, check if each object has an objectID set
+  #
+  def chunk(action, objects, with_object_id = false)
+    objects.map do |object|
+      check_object(object, true)
+      request            = { action: action, body: object }
+      request[:objectID] = get_object_id(object).to_s if with_object_id
+      request
+    end
+  end
 end

data/lib/algolia/http/http_requester.rb

@@ -9,9 +9,9 @@ module Algolia
       # @param logger [Object] logger used to log requests. Defaults to Algolia::LoggerHelper
       #
       def initialize(adapter, logger)
-        @adapter    = adapter
-        @logger     = logger
-        @connection = nil
+        @adapter     = adapter
+        @logger      = logger
+        @connections = {}
       end
 
       # Sends request to the engine
@@ -65,7 +65,7 @@ module Algolia
       # @return [Faraday::Connection]
       #
       def connection(host)
-        @connection ||= Faraday.new(build_url(host)) do |f|
+        @connections[host.accept] ||= Faraday.new(build_url(host)) do |f|
           f.adapter @adapter.to_sym
         end
       end

data/lib/algolia/responses/dictionary_response.rb

@@ -0,0 +1,33 @@
+module Algolia
+  class DictionaryResponse < BaseResponse
+    include CallType
+
+    attr_reader :raw_response
+
+    # @param client [Search::Client] Algolia Search Client used for verification
+    # @param response [Hash] Raw response from the client
+    #
+    def initialize(client, response)
+      @client       = client
+      @raw_response = response
+      @done         = false
+    end
+
+    # Wait for the task to complete
+    #
+    # @param opts [Hash] contains extra parameters to send with your query
+    #
+    def wait(_opts = {})
+      until @done
+        res    = @client.custom_request({}, path_encode('/1/task/%s', @raw_response[:taskID]), :GET, READ)
+        status = get_option(res, 'status')
+        if status == 'published'
+          @done = true
+        end
+        sleep(Defaults::WAIT_TASK_DEFAULT_TIME_BEFORE_RETRY / 1000)
+      end
+
+      self
+    end
+  end
+end

data/lib/algolia/search_client.rb

@@ -80,7 +80,7 @@ module Algolia
       end
 
       # # # # # # # # # # # # # # # # # # # # #
-      # MISC
+      # INDEX METHODS
       # # # # # # # # # # # # # # # # # # # # #
 
       # Initialize an index with a given name
@@ -90,11 +90,11 @@ module Algolia
       # @return [Index] new Index instance
       #
       def init_index(index_name)
-        index_name.strip!
-        if index_name.empty?
+        stripped_index_name = index_name.strip
+        if stripped_index_name.empty?
           raise AlgoliaError, 'Please provide a valid index name'
         end
-        Index.new(index_name, @transporter, @config)
+        Index.new(stripped_index_name, @transporter, @config)
       end
 
       # List all indexes of the client
@@ -300,7 +300,7 @@ module Algolia
       # @return [AddApiKeyResponse]
       #
       def add_api_key!(acl, opts = {})
-        response = add_api_key(acl)
+        response = add_api_key(acl, opts)
 
         response.wait(opts)
       end
@@ -594,12 +594,185 @@ module Algolia
         @transporter.read(:GET, '/1/clusters/mapping/pending' + handle_params({ getClusters: retrieve_mappings }), {}, request_options)
       end
 
-      #
       # Aliases the pending_mappings? method
       #
       alias_method :has_pending_mappings, :pending_mappings?
 
+      # # # # # # # # # # # # # # # # # # # # #
+      # CUSTOM DICTIONARIES METHODS
+      # # # # # # # # # # # # # # # # # # # # #
+
+      # Save entries for a given dictionary
+      #
+      # @param dictionary [String] dictionary name. Can be either 'stopwords', 'plurals' or 'compounds'
+      # @param dictionary_entries [Array<Hash>] array of dictionary entries
+      # @param opts [Hash] contains extra parameters to send with your query
+      #
+      # @return DictionaryResponse
+      #
+      def save_dictionary_entries(dictionary, dictionary_entries, opts = {})
+        response = @transporter.write(
+          :POST,
+          path_encode('/1/dictionaries/%s/batch', dictionary),
+          { clearExistingDictionaryEntries: false, requests: chunk('addEntry', dictionary_entries) },
+          opts
+        )
+
+        DictionaryResponse.new(self, response)
+      end
+
+      # Save entries for a given dictionary and wait for the task to finish
+      #
+      # @param dictionary [String] dictionary name. Can be either 'stopwords', 'plurals' or 'compounds'
+      # @param dictionary_entries [Array<Hash>] array of dictionary entries
+      # @param opts [Hash] contains extra parameters to send with your query
+      #
+      def save_dictionary_entries!(dictionary, dictionary_entries, opts = {})
+        response = save_dictionary_entries(dictionary, dictionary_entries, opts)
+
+        response.wait(opts)
+      end
+
+      # Replace entries for a given dictionary
+      #
+      # @param dictionary [String] dictionary name. Can be either 'stopwords', 'plurals' or 'compounds'
+      # @param dictionary_entries [Array<Hash>] array of dictionary entries
+      # @param opts [Hash] contains extra parameters to send with your query
+      #
+      # @return DictionaryResponse
+      #
+      def replace_dictionary_entries(dictionary, dictionary_entries, opts = {})
+        response = @transporter.write(
+          :POST,
+          path_encode('/1/dictionaries/%s/batch', dictionary),
+          { clearExistingDictionaryEntries: true, requests: chunk('addEntry', dictionary_entries) },
+          opts
+        )
+
+        DictionaryResponse.new(self, response)
+      end
+
+      # Replace entries for a given dictionary and wait for the task to finish
+      #
+      # @param dictionary [String] dictionary name. Can be either 'stopwords', 'plurals' or 'compounds'
+      # @param dictionary_entries [Array<Hash>] array of dictionary entries
+      # @param opts [Hash] contains extra parameters to send with your query
+      #
+      def replace_dictionary_entries!(dictionary, dictionary_entries, opts = {})
+        response = replace_dictionary_entries(dictionary, dictionary_entries, opts)
+
+        response.wait(opts)
+      end
+
+      # Delete entries for a given dictionary
+      #
+      # @param dictionary [String] dictionary name. Can be either 'stopwords', 'plurals' or 'compounds'
+      # @param object_ids [Array<Hash>] array of object ids
+      # @param opts [Hash] contains extra parameters to send with your query
+      #
+      # @return DictionaryResponse
+      #
+      def delete_dictionary_entries(dictionary, object_ids, opts = {})
+        request  = object_ids.map do |object_id|
+          { objectID: object_id }
+        end
+        response = @transporter.write(
+          :POST,
+          path_encode('/1/dictionaries/%s/batch', dictionary),
+          { clearExistingDictionaryEntries: false, requests: chunk('deleteEntry', request) },
+          opts
+        )
+
+        DictionaryResponse.new(self, response)
+      end
+
+      # Delete entries for a given dictionary and wait for the task to finish
+      #
+      # @param dictionary [String] dictionary name. Can be either 'stopwords', 'plurals' or 'compounds'
+      # @param object_ids [Array<Hash>] array of object ids
+      # @param opts [Hash] contains extra parameters to send with your query
       #
+      def delete_dictionary_entries!(dictionary, object_ids, opts = {})
+        response = delete_dictionary_entries(dictionary, object_ids, opts)
+
+        response.wait(opts)
+      end
+
+      # Clear all entries for a given dictionary
+      #
+      # @param dictionary [String] dictionary name. Can be either 'stopwords', 'plurals' or 'compounds'
+      # @param opts [Hash] contains extra parameters to send with your query
+      #
+      # @return DictionaryResponse
+      #
+      def clear_dictionary_entries(dictionary, opts = {})
+        replace_dictionary_entries(dictionary, [], opts)
+      end
+
+      # Clear all entries for a given dictionary and wait for the task to finish
+      #
+      # @param dictionary [String] dictionary name. Can be either 'stopwords', 'plurals' or 'compounds'
+      # @param opts [Hash] contains extra parameters to send with your query
+      #
+      def clear_dictionary_entries!(dictionary, opts = {})
+        response = replace_dictionary_entries(dictionary, [], opts)
+
+        response.wait(opts)
+      end
+
+      # Search entries for a given dictionary
+      #
+      # @param dictionary [String] dictionary name. Can be either 'stopwords', 'plurals' or 'compounds'
+      # @param query [String] query to send
+      # @param opts [Hash] contains extra parameters to send with your query
+      #
+      def search_dictionary_entries(dictionary, query, opts = {})
+        @transporter.read(
+          :POST,
+          path_encode('/1/dictionaries/%s/search', dictionary),
+          { query: query },
+          opts
+        )
+      end
+
+      # Set settings for all the dictionaries
+      #
+      # @param dictionary_settings [Hash]
+      # @param opts [Hash] contains extra parameters to send with your query
+      #
+      # @return DictionaryResponse
+      #
+      def set_dictionary_settings(dictionary_settings, opts = {})
+        response = @transporter.write(:PUT, '/1/dictionaries/*/settings', dictionary_settings, opts)
+
+        DictionaryResponse.new(self, response)
+      end
+
+      # Set settings for all the dictionaries and wait for the task to finish
+      #
+      # @param dictionary_settings [Hash]
+      # @param opts [Hash] contains extra parameters to send with your query
+      #
+      # @return DictionaryResponse
+      #
+      def set_dictionary_settings!(dictionary_settings, opts = {})
+        response = set_dictionary_settings(dictionary_settings, opts)
+
+        response.wait(opts)
+      end
+
+      # Retrieve settings for all the dictionaries
+      #
+      # @param opts [Hash] contains extra parameters to send with your query
+      #
+      def get_dictionary_settings(opts = {})
+        @transporter.read(:GET, '/1/dictionaries/*/settings', {}, opts)
+      end
+
+      # # # # # # # # # # # # # # # # # # # # #
+      # MISC METHODS
+      # # # # # # # # # # # # # # # # # # # # #
+
       # Method available to make custom requests to the API
       #
       def custom_request(data, uri, method, call_type, opts = {})

data/lib/algolia/search_index.rb

@@ -987,7 +987,15 @@ module Algolia
       # @return [IndexingResponse]
       #
       def set_settings(settings, opts = {})
-        response = @transporter.write(:PUT, path_encode('/1/indexes/%s/settings', @name), settings, opts)
+        request_options      = symbolize_hash(opts)
+        forward_to_replicas  = request_options.delete(:forwardToReplicas) || false
+
+        response = @transporter.write(
+          :PUT,
+          path_encode('/1/indexes/%s/settings', @name) + handle_params({ forwardToReplicas: forward_to_replicas }),
+          settings,
+          request_options
+        )
 
         IndexingResponse.new(self, response)
       end
@@ -1037,55 +1045,6 @@ module Algolia
 
       private
 
-      # Check the passed object to determine if it's an array
-      #
-      # @param object [Object]
-      #
-      def check_array(object)
-        raise AlgoliaError, 'argument must be an array of objects' unless object.is_a?(Array)
-      end
-
-      # Check the passed object
-      #
-      # @param object [Object]
-      # @param in_array [Boolean] whether the object is an array or not
-      #
-      def check_object(object, in_array = false)
-        case object
-        when Array
-          raise AlgoliaError, in_array ? 'argument must be an array of objects' : 'argument must not be an array'
-        when String, Integer, Float, TrueClass, FalseClass, NilClass
-          raise AlgoliaError, "argument must be an #{'array of' if in_array} object, got: #{object.inspect}"
-        end
-      end
-
-      # Check if passed object has a objectID
-      #
-      # @param object [Object]
-      # @param object_id [String]
-      #
-      def get_object_id(object, object_id = nil)
-        check_object(object)
-        object_id ||= object[:objectID] || object['objectID']
-        raise AlgoliaError, "Missing 'objectID'" if object_id.nil?
-        object_id
-      end
-
-      # Build a batch request
-      #
-      # @param action [String] action to perform on the engine
-      # @param objects [Array] objects on which build the action
-      # @param with_object_id [Boolean] if set to true, check if each object has an objectID set
-      #
-      def chunk(action, objects, with_object_id = false)
-        objects.map do |object|
-            check_object(object, true)
-            request            = { action: action, body: object }
-            request[:objectID] = get_object_id(object).to_s if with_object_id
-            request
-        end
-      end
-
       def raw_batch(requests, opts)
         @transporter.write(:POST, path_encode('/1/indexes/%s/batch', @name), { requests: requests }, opts)
       end

data/lib/algolia/transport/request_options.rb

@@ -34,7 +34,7 @@ module Algolia
       def add_headers(opts = {})
         unless opts[:headers].nil?
           opts[:headers].each do |opt, value|
-            @headers[opt.to_sym] = value
+            @headers[opt.to_s] = value
           end
           opts.delete(:headers)
         end

data/lib/algolia/transport/transport.rb

@@ -127,15 +127,12 @@ module Algolia
 
       # Generates headers from config headers and optional parameters
       #
-      # @option options [String] :headers
+      # @param request_options [RequestOptions]
       #
       # @return [Hash] merged headers
       #
       def generate_headers(request_options = {})
-        headers                                             = {}
-        extra_headers                                       = request_options.headers || {}
-        @config.headers.each { |key, val| headers[key.to_s] = val }
-        extra_headers.each { |key, val| headers[key.to_s]   = val }
+        headers = @config.headers.merge(request_options.headers)
         if request_options.compression_type == Defaults::GZIP_ENCODING
           headers['Accept-Encoding']  = Defaults::GZIP_ENCODING
         end

data/lib/algolia/version.rb

@@ -1,3 +1,3 @@
 module Algolia
-  VERSION = '2.0.0'.freeze
+  VERSION = '2.1.1'.freeze
 end

data/test/algolia/integration/analytics_client_test.rb

@@ -23,7 +23,9 @@ class AnalyticsClientTest < BaseTest
         endAt: tomorrow.strftime('%Y-%m-%dT%H:%M:%SZ')
       }
 
-      response   = client.add_ab_test(ab_test)
+      response   = retry_test do
+        client.add_ab_test(ab_test)
+      end
       ab_test_id = response[:abTestID]
 
       index1.wait_task(response[:taskID])
@@ -86,7 +88,9 @@ class AnalyticsClientTest < BaseTest
         endAt: tomorrow.strftime('%Y-%m-%dT%H:%M:%SZ')
       }
 
-      response   = client.add_ab_test(ab_test)
+      response   = retry_test do
+        client.add_ab_test(ab_test)
+      end
       ab_test_id = response[:abTestID]
 
       index.wait_task(response[:taskID])

data/test/algolia/integration/search_client_test.rb

@@ -1,3 +1,4 @@
+require 'securerandom'
 require_relative 'base_test'
 
 class SearchClientTest < BaseTest
@@ -215,6 +216,7 @@ class SearchClientTest < BaseTest
 
     def test_api_keys
       assert_equal ['search'], @api_key[:acl]
+      assert_equal 'A description', @api_key[:description]
 
       api_keys = @@search_client.list_api_keys[:keys].map do |key|
         key[:value]
@@ -222,7 +224,9 @@ class SearchClientTest < BaseTest
       assert_includes api_keys, @api_key[:value]
 
       @@search_client.update_api_key!(@api_key[:value], { maxHitsPerQuery: 42 })
-      updated_api_key = @@search_client.get_api_key(@api_key[:value])
+      updated_api_key = retry_test do
+        @@search_client.get_api_key(@api_key[:value], test: 'test')
+      end
       assert_equal 42, updated_api_key[:maxHitsPerQuery]
 
       @@search_client.delete_api_key!(@api_key[:value])
@@ -233,18 +237,13 @@ class SearchClientTest < BaseTest
 
       assert_equal 'Key does not exist', exception.message
 
-      loop do
-        begin
-          @@search_client.restore_api_key!(@api_key[:value])
-          break
-        rescue Algolia::AlgoliaHttpError => e
-          if e.code != 404
-            raise StandardError
-          end
-        end
+      retry_test do
+        @@search_client.restore_api_key!(@api_key[:value])
       end
 
-      restored_key = @@search_client.get_api_key(@api_key[:value])
+      restored_key = retry_test do
+        @@search_client.get_api_key(@api_key[:value])
+      end
 
       refute_nil restored_key
     end
@@ -333,7 +332,12 @@ class SearchClientTest < BaseTest
         secured_index1 = secured_client.init_index(@index1.name)
         secured_index2 = secured_client.init_index(@index2.name)
 
-        secured_index1.search('')
+        res = retry_test do
+          secured_index1.search('')
+        end
+
+        assert_equal 1, res[:hits].length
+
         exception = assert_raises Algolia::AlgoliaHttpError do
           secured_index2.search('')
         end
@@ -366,5 +370,96 @@ class SearchClientTest < BaseTest
         assert_equal 'The SecuredAPIKey doesn\'t have a validUntil parameter.', exception.message
       end
     end
+
+    describe 'Custom Dictionaries' do
+      def before_all
+        @client = Algolia::Search::Client.create(APPLICATION_ID_2, ADMIN_KEY_2)
+      end
+
+      def test_stopwords_dictionaries
+        entry_id = SecureRandom.hex
+        assert_equal 0, @client.search_dictionary_entries('stopwords', entry_id)[:nbHits]
+
+        entry = {
+          objectID: entry_id,
+          language: 'en',
+          word: 'down'
+        }
+        @client.save_dictionary_entries!('stopwords', [entry])
+
+        stopwords = @client.search_dictionary_entries('stopwords', entry_id)
+        assert_equal 1, stopwords[:nbHits]
+        assert_equal stopwords[:hits][0][:objectID], entry[:objectID]
+        assert_equal stopwords[:hits][0][:word], entry[:word]
+
+        @client.delete_dictionary_entries!('stopwords', [entry_id])
+        assert_equal 0, @client.search_dictionary_entries('stopwords', entry_id)[:nbHits]
+
+        old_dictionary_state   = @client.search_dictionary_entries('stopwords', '')
+        old_dictionary_entries = old_dictionary_state[:hits].map do |hit|
+          hit.reject { |key| key == :type }
+        end
+
+        @client.save_dictionary_entries!('stopwords', [entry])
+        assert_equal 1, @client.search_dictionary_entries('stopwords', entry_id)[:nbHits]
+
+        @client.replace_dictionary_entries!('stopwords', old_dictionary_entries)
+        assert_equal 0, @client.search_dictionary_entries('stopwords', entry_id)[:nbHits]
+
+        stopwords_settings = {
+          disableStandardEntries: {
+            stopwords: {
+              en: true
+            }
+          }
+        }
+
+        @client.set_dictionary_settings!(stopwords_settings)
+
+        assert_equal @client.get_dictionary_settings, stopwords_settings
+      end
+
+      def test_plurals_dictionaries
+        entry_id = SecureRandom.hex
+        assert_equal 0, @client.search_dictionary_entries('plurals', entry_id)[:nbHits]
+
+        entry = {
+          objectID: entry_id,
+          language: 'fr',
+          words: %w(cheval chevaux)
+        }
+        @client.save_dictionary_entries!('plurals', [entry])
+
+        plurals = @client.search_dictionary_entries('plurals', entry_id)
+        assert_equal 1, plurals[:nbHits]
+        assert_equal plurals[:hits][0][:objectID], entry[:objectID]
+        assert_equal plurals[:hits][0][:words], entry[:words]
+
+        @client.delete_dictionary_entries!('plurals', [entry_id])
+        assert_equal 0, @client.search_dictionary_entries('plurals', entry_id)[:nbHits]
+      end
+
+      def test_compounds_dictionaries
+        entry_id = SecureRandom.hex
+        assert_equal 0, @client.search_dictionary_entries('compounds', entry_id)[:nbHits]
+
+        entry = {
+          objectID: entry_id,
+          language: 'de',
+          word: 'kopfschmerztablette',
+          decomposition: %w(kopf schmerz tablette)
+        }
+        @client.save_dictionary_entries!('compounds', [entry])
+
+        compounds = @client.search_dictionary_entries('compounds', entry_id)
+        assert_equal 1, compounds[:nbHits]
+        assert_equal compounds[:hits][0][:objectID], entry[:objectID]
+        assert_equal compounds[:hits][0][:word], entry[:word]
+        assert_equal compounds[:hits][0][:decomposition], entry[:decomposition]
+
+        @client.delete_dictionary_entries!('compounds', [entry_id])
+        assert_equal 0, @client.search_dictionary_entries('compounds', entry_id)[:nbHits]
+      end
+    end
   end
 end

data/test/algolia/integration/search_index_test.rb

@@ -274,6 +274,9 @@ class SearchIndexTest < BaseTest
       @index.set_settings!(settings)
 
       assert_equal @index.get_settings, settings
+
+      # check that the forwardToReplicas parameter is passed correctly
+      assert @index.set_settings!(settings, { forwardToReplicas: true })
     end
   end
 

data/test/algolia/unit/helpers_test.rb

@@ -26,13 +26,15 @@ class HelpersTest
       old_settings = {
         'attributesToIndex' => %w(attr1 attr2),
         'numericAttributesToIndex' => %w(attr1 attr2),
-        'slaves' => %w(index1 index2)
+        'slaves' => %w(index1 index2),
+        'minWordSizefor1Typo' => 1
       }
 
       new_settings = {
         'searchableAttributes' => %w(attr1 attr2),
         'numericAttributesForFiltering' => %w(attr1 attr2),
-        'replicas' => %w(index1 index2)
+        'replicas' => %w(index1 index2),
+        'minWordSizefor1Typo' => 1
       }
 
       deserialized_settings = deserialize_settings(old_settings, false)

data/test/test_helper.rb

@@ -87,3 +87,15 @@ def rule_without_metadata(rule)
   rule.delete(:_metadata)
   rule
 end
+
+def retry_test(delay = 0.1, max_retries = 30)
+  (1...max_retries).each do |i|
+    begin
+      return yield
+    rescue Algolia::AlgoliaHttpError
+      sleep delay * i
+    end
+  end
+
+  raise StandardError, 'reached the maximum number of retries'
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: algolia
 version: !ruby/object:Gem::Version
-  version: 2.0.0
+  version: 2.1.1
 platform: ruby
 authors:
 - Algolia
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2020-10-27 00:00:00.000000000 Z
+date: 2021-05-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -56,16 +56,22 @@ dependencies:
   name: faraday
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0.15'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '2.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0.15'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '2.0'
 - !ruby/object:Gem::Dependency
   name: multi_json
   requirement: !ruby/object:Gem::Requirement
@@ -186,6 +192,7 @@ extensions: []
 extra_rdoc_files: []
 files:
 - ".circleci/config.yml"
+- ".dockerignore"
 - ".github/ISSUE_TEMPLATE.md"
 - ".github/PULL_REQUEST_TEMPLATE.md"
 - ".gitignore"
@@ -193,6 +200,9 @@ files:
 - ".rubocop_todo.yml"
 - CHANGELOG.md
 - CODE_OF_CONDUCT.md
+- CONTRIBUTING.MD
+- DOCKER_README.MD
+- Dockerfile
 - Gemfile
 - LICENSE
 - README.md
@@ -228,6 +238,7 @@ files:
 - lib/algolia/responses/add_api_key_response.rb
 - lib/algolia/responses/base_response.rb
 - lib/algolia/responses/delete_api_key_response.rb
+- lib/algolia/responses/dictionary_response.rb
 - lib/algolia/responses/indexing_response.rb
 - lib/algolia/responses/multiple_batch_indexing_response.rb
 - lib/algolia/responses/multiple_response.rb
@@ -294,7 +305,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
+rubygems_version: 3.0.6
 signing_key:
 specification_version: 4
 summary: A simple Ruby client for the algolia.com REST API