algolia 2.0.4 → 2.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e2ba367e6308158bc455c60a0d0a5c16fbb1ed4565aaa3a6b8d4cca3e16f0c0d
-  data.tar.gz: af53995633ba454c929265d5d81d311c67a99fcdd76e8eeec51f98aa8e89f778
+  metadata.gz: 5c2f4626569fa71c66f1801a6608a0d66bdd7afc5d2d42342856d8083281d0ee
+  data.tar.gz: bbc716503ac0354dd80a1e5d1196cfc8ff5e8d80c3c166c196bd1ec5e227a446
 SHA512:
-  metadata.gz: 896b3821ad99f02449f652090c6b4249a932d454bd03e58879c2fad030d6179480b208c36bd07003dd3c58f96cd7630e28aa1afa026cc83f907a3bcf015f2f02
-  data.tar.gz: bdc286d0c8df062b33fc6d25fd6d3d4348dc82cce74703d26a12d8374a91c5e378e3d7f03ff2d617a76beab88828a8004d3457997394df2a9832277ca308f411
+  metadata.gz: bd82583938e41074786a9f6e3518256af5f54c6946e8224a9e2ecc40952f211475dbec10ba5d054058764bdccbdceff80a9147c195a8c3f62a5ab4f033c11757
+  data.tar.gz: 25971344a9f64260d29f8c1a7878605a2e408369de05b4e4add74e828697cefde461bb83ed5564dbd6f94de3844844e6e357568e830de53a3d77253a27151e33

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:
@@ -122,7 +131,7 @@ workflows:
       - test_ruby:
           matrix:
             parameters:
-              version: ['2.2', '2.3', '2.4', '2.5', '2.6', '2.7']
+              version: ['2.2', '2.3', '2.4', '2.5', '2.6', '2.7', '3.0']
           filters:
             tags:
               only: /.*/

data/CHANGELOG.md

@@ -1,6 +1,32 @@
 # ChangeLog
 
-## [Unreleased](https://github.com/algolia/algoliasearch-client-ruby/compare/2.0.4...master)
+## [Unreleased](https://github.com/algolia/algoliasearch-client-ruby/compare/2.2.2..master)
+
+## [2.2.1](https://github.com/algolia/algoliasearch-client-ruby/compare/2.2.1...2.2.2) (2021-12-08)
+### Fixed
+- Added a `status` field to the `MockRequester` ([`#467`](https://github.com/algolia/algoliasearch-client-ruby/pull/467))
+
+## [2.2.1](https://github.com/algolia/algoliasearch-client-ruby/compare/2.2.0...2.2.1) (2021-11-12)
+### Chore
+- Deprecated `RecommendationClient` in favor of `PersonalizationClient` ([`#461`](https://github.com/algolia/algoliasearch-client-ruby/pull/461))
+
+## [2.2.0](https://github.com/algolia/algoliasearch-client-ruby/compare/2.1.1...2.2.0) (2021-11-08)
+### Added
+- Added RecommendClient ([`#466`](https://github.com/algolia/algoliasearch-client-ruby/pull/466))
+- Added `search` alias for `multiple_queries` ([`#457`](https://github.com/algolia/algoliasearch-client-ruby/pull/457))
+
+## [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)
 

data/README.md

@@ -41,7 +41,7 @@ Then, create objects on your index:
 client = Algolia::Search::Client.create('YourApplicationID', 'YourAPIKey')
 index = client.init_index('your_index_name')
 
-index.save_objects([objectID: 1, name: 'Foo'])
+index.save_objects([{objectID: 1, name: 'Foo'}])
 ```
 
 Finally, you may begin searching a object using the `search` method:

data/lib/algolia/config/personalization_config.rb

@@ -0,0 +1,20 @@
+module Algolia
+  module Personalization
+    class Config < BaseConfig
+      attr_accessor :region, :default_hosts
+
+      # Initialize a config
+      #
+      # @option options [String] :application_id
+      # @option options [String] :api_key
+      # @option options [String] :region
+      #
+      def initialize(opts = {})
+        super(opts)
+
+        @region        = opts[:region] || 'us'
+        @default_hosts = [Transport::StatefulHost.new("personalization.#{region}.algolia.com")]
+      end
+    end
+  end
+end

data/lib/algolia/config/recommend_config.rb

@@ -0,0 +1,6 @@
+module Algolia
+  module Recommend
+    class Config < Algolia::Search::Config
+    end
+  end
+end

data/lib/algolia/config/recommendation_config.rb

@@ -1,20 +1,7 @@
 module Algolia
   module Recommendation
-    class Config < BaseConfig
-      attr_accessor :region, :default_hosts
-
-      # Initialize a config
-      #
-      # @option options [String] :application_id
-      # @option options [String] :api_key
-      # @option options [String] :region
-      #
-      def initialize(opts = {})
-        super(opts)
-
-        @region        = opts[:region] || 'us'
-        @default_hosts = [Transport::StatefulHost.new("recommendation.#{region}.algolia.com")]
-      end
+    # <b>DEPRECATED:</b> Please use <tt>Algolia::Personalization::Config</tt> instead.
+    class Config < Algolia::Personalization::Config
     end
   end
 end

data/lib/algolia/helpers.rb

@@ -82,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/personalization_client.rb

@@ -0,0 +1,60 @@
+module Algolia
+  module Personalization
+    class Client
+      # Initializes the Personalization client
+      #
+      # @param personalization_config [Personalization::Config] a Personalization::Config object which contains your APP_ID and API_KEY
+      # @option adapter [Object] adapter object used for the connection
+      # @option logger [Object]
+      # @option http_requester [Object] http_requester object used for the connection
+      #
+      def initialize(personalization_config, opts = {})
+        @config      = personalization_config
+        adapter      = opts[:adapter] || Defaults::ADAPTER
+        logger       = opts[:logger] || LoggerHelper.create('debug.log')
+        requester    = opts[:http_requester] || Defaults::REQUESTER_CLASS.new(adapter, logger)
+        @transporter = Transport::Transport.new(@config, requester)
+      end
+
+      # Create a new client providing only app ID and API key
+      #
+      # @param app_id [String] Algolia application ID
+      # @param api_key [String] Algolia API key
+      #
+      # @return self
+      #
+      def self.create(app_id, api_key)
+        config = Personalization::Config.new(application_id: app_id, api_key: api_key)
+        create_with_config(config)
+      end
+
+      # Create a new client providing only an Personalization::Config object
+      #
+      # @param config [Personalization::Config]
+      #
+      # @return self
+      #
+      def self.create_with_config(config)
+        new(config)
+      end
+
+      # Set the personalization strategy.
+      #
+      # @param personalization_strategy [Hash] A strategy object.
+      #
+      # @return [Hash]
+      #
+      def set_personalization_strategy(personalization_strategy, opts = {})
+        @transporter.write(:POST, '1/strategies/personalization', personalization_strategy, opts)
+      end
+
+      # Get the personalization strategy.
+      #
+      # @return [Hash]
+      #
+      def get_personalization_strategy(opts = {})
+        @transporter.read(:GET, '1/strategies/personalization', {}, opts)
+      end
+    end
+  end
+end

data/lib/algolia/recommend_client.rb

@@ -0,0 +1,134 @@
+module Algolia
+  module Recommend
+    class Model
+      BOUGHT_TOGETHER  = 'bought-together'
+      RELATED_PRODUCTS = 'related-products'
+    end
+
+    class Client
+      include Helpers
+
+      # Initializes the Recommend client
+      #
+      # @param recommend_config [Recommend::Config] a Recommend::Config object which contains your APP_ID and API_KEY
+      # @option adapter [Object] adapter object used for the connection
+      # @option logger [Object]
+      # @option http_requester [Object] http_requester object used for the connection
+      #
+      def initialize(recommend_config, opts = {})
+        @config      = recommend_config
+        adapter      = opts[:adapter] || Defaults::ADAPTER
+        logger       = opts[:logger] || LoggerHelper.create('debug.log')
+        requester    = opts[:http_requester] || Defaults::REQUESTER_CLASS.new(adapter, logger)
+        @transporter = Transport::Transport.new(@config, requester)
+      end
+
+      # Create a new client providing only app ID and API key
+      #
+      # @param app_id [String] Algolia application ID
+      # @param api_key [String] Algolia API key
+      #
+      # @return self
+      #
+      def self.create(app_id, api_key)
+        config = Recommend::Config.new(application_id: app_id, api_key: api_key)
+        create_with_config(config)
+      end
+
+      # Create a new client providing only an Recommend::Config object
+      #
+      # @param config [Recommend::Config]
+      #
+      # @return self
+      #
+      def self.create_with_config(config)
+        new(config)
+      end
+
+      # Get recommendation for the given queries
+      #
+      # @param requests [Array<Hash>] the queries to retrieve recommendations for
+      # @param opts [Hash] extra parameters to send with your request
+      #
+      # @return [Hash]
+      #
+      def get_recommendations(requests, opts = {})
+        @transporter.write(
+          :POST,
+          '/1/indexes/*/recommendations',
+          { requests: format_recommendation_requests(symbolize_all(requests)) },
+          opts
+        )
+      end
+
+      # Get related products for the given requests
+      #
+      # @param requests [Array<Hash>] the requests to get related products for
+      # @param opts [Hash] extra parameters to send with your request
+      #
+      # @return [Hash]
+      #
+      def get_related_products(requests, opts = {})
+        get_recommendations(
+          set_request_models(symbolize_all(requests), Model::RELATED_PRODUCTS),
+          opts
+        )
+      end
+
+      # Get frequently bought together items for the given requests
+      #
+      # @param requests [Array<Hash>] the requests to get frequently bought together items for
+      # @param opts [Hash] extra parameters to send with your request
+      #
+      # @return [Hash]
+      #
+      def get_frequently_bought_together(requests, opts = {})
+        get_recommendations(
+          set_request_models(symbolize_all(requests), Model::BOUGHT_TOGETHER),
+          opts
+        )
+      end
+
+      private
+
+      # Symbolize all hashes in an array
+      #
+      # @param hash_array [Array<Hash<String|Symbol, any>>] the hashes to symbolize
+      #
+      # @return [Array<Hash<Symbol, any>>]
+      #
+      def symbolize_all(hash_array)
+        hash_array.map { |q| symbolize_hash(q) }
+      end
+
+      # Format the recommendation requests
+      #
+      # @param requests [Array<Hash>] the requests to retrieve recommendations for
+      #
+      # @return [Array<Hash>]
+      #
+      def format_recommendation_requests(requests)
+        requests.map do |request|
+          request[:threshold] = 0 unless request[:threshold].is_a? Numeric
+          request.delete(:fallbackParameters) if request[:model] == Model::BOUGHT_TOGETHER
+
+          request
+        end
+      end
+
+      # Force the requests to target a specific model
+      #
+      # @param requests [Array<Hash>] the requests to change
+      # @param model [String] the model to enforce
+      #
+      # @return [Array<Hash>]
+      #
+      def set_request_models(requests, model)
+        requests.map do |query|
+          query[:model] = model
+          query
+        end
+      end
+    end
+  end
+end

data/lib/algolia/recommendation_client.rb

@@ -1,60 +1,7 @@
 module Algolia
   module Recommendation
-    class Client
-      # Initializes the Recommendation client
-      #
-      # @param recommendation_config [Recommendation::Config] a Recommendation::Config object which contains your APP_ID and API_KEY
-      # @option adapter [Object] adapter object used for the connection
-      # @option logger [Object]
-      # @option http_requester [Object] http_requester object used for the connection
-      #
-      def initialize(recommendation_config, opts = {})
-        @config      = recommendation_config
-        adapter      = opts[:adapter] || Defaults::ADAPTER
-        logger       = opts[:logger] || LoggerHelper.create('debug.log')
-        requester    = opts[:http_requester] || Defaults::REQUESTER_CLASS.new(adapter, logger)
-        @transporter = Transport::Transport.new(@config, requester)
-      end
-
-      # Create a new client providing only app ID and API key
-      #
-      # @param app_id [String] Algolia application ID
-      # @param api_key [String] Algolia API key
-      #
-      # @return self
-      #
-      def self.create(app_id, api_key)
-        config = Recommendation::Config.new(application_id: app_id, api_key: api_key)
-        create_with_config(config)
-      end
-
-      # Create a new client providing only an Recommendation::Config object
-      #
-      # @param config [Recommendation::Config]
-      #
-      # @return self
-      #
-      def self.create_with_config(config)
-        new(config)
-      end
-
-      # Set the personalization strategy.
-      #
-      # @param personalization_strategy [Hash] A strategy object.
-      #
-      # @return [Hash]
-      #
-      def set_personalization_strategy(personalization_strategy, opts = {})
-        @transporter.write(:POST, '1/strategies/personalization', personalization_strategy, opts)
-      end
-
-      # Get the personalization strategy.
-      #
-      # @return [Hash]
-      #
-      def get_personalization_strategy(opts = {})
-        @transporter.read(:GET, '1/strategies/personalization', {}, opts)
-      end
+    # <b>DEPRECATED:</b> Please use <tt>Algolia::Personalization::Client</tt> instead.
+    class Client < Algolia::Personalization::Client
     end
   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
@@ -480,6 +480,7 @@ module Algolia
       def multiple_queries(queries, opts = {})
         @transporter.read(:POST, '/1/indexes/*/queries', { requests: queries }, opts)
       end
+      alias_method :search, :multiple_queries
 
       # # # # # # # # # # # # # # # # # # # # #
       # MCM METHODS
@@ -594,12 +595,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/version.rb

@@ -1,3 +1,3 @@
 module Algolia
-  VERSION = '2.0.4'.freeze
+  VERSION = '2.2.2'.freeze
 end

data/lib/algolia.rb

@@ -7,6 +7,8 @@ require 'algolia/config/base_config'
 require 'algolia/config/search_config'
 require 'algolia/config/analytics_config'
 require 'algolia/config/insights_config'
+require 'algolia/config/recommend_config'
+require 'algolia/config/personalization_config'
 require 'algolia/config/recommendation_config'
 require 'algolia/enums/call_type'
 require 'algolia/enums/retry_outcome_type'
@@ -20,6 +22,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'
@@ -32,6 +35,8 @@ require 'algolia/account_client'
 require 'algolia/search_client'
 require 'algolia/analytics_client'
 require 'algolia/insights_client'
+require 'algolia/recommend_client'
+require 'algolia/personalization_client'
 require 'algolia/recommendation_client'
 require 'algolia/error'
 require 'algolia/search_index'

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/mocks/mock_requester.rb

@@ -1,25 +1,27 @@
 class MockRequester
+  attr_accessor :requests
   def initialize
     @connection = nil
+    @requests   = []
   end
 
-  def send_request(host, method, path, _body, headers, _timeout, _connect_timeout)
-    connection = get_connection(host)
-    response   = {
-      connection: connection,
+  def send_request(host, method, path, body, headers, timeout, connect_timeout)
+    request = {
       host: host,
+      method: method,
       path: path,
+      body: body,
       headers: headers,
-      method: method,
-      status: 200,
-      body: '{"hits":[],"nbHits":0,"page":0,"nbPages":1,"hitsPerPage":20,"exhaustiveNbHits":true,"query":"test","params":"query=test","processingTimeMS":1}',
-      success: true
+      timeout: timeout,
+      connect_timeout: connect_timeout
     }
 
+    @requests.push(request)
+
     Algolia::Http::Response.new(
-      status: response[:status],
-      body: response[:body],
-      headers: response[:headers]
+      status: 200,
+      body: '{"hits": [], "status": "published"}',
+      headers: {}
     )
   end
 

data/test/algolia/integration/personalization_client_test.rb

@@ -0,0 +1,30 @@
+require_relative 'base_test'
+require 'date'
+
+class PersonalizationClientTest < BaseTest
+  describe 'Personalization client' do
+    def test_personalization_client
+      client                   = Algolia::Personalization::Client.create(APPLICATION_ID_1, ADMIN_KEY_1)
+      personalization_strategy = {
+        eventsScoring: [
+          { eventName: 'Add to cart', eventType: 'conversion', score: 50 },
+          { eventName: 'Purchase', eventType: 'conversion', score: 100 }
+        ],
+        facetsScoring: [
+          { facetName: 'brand', score: 100 },
+          { facetName: 'categories', score: 10 }
+        ],
+        personalizationImpact: 0
+      }
+
+      begin
+        client.set_personalization_strategy(personalization_strategy)
+      rescue Algolia::AlgoliaHttpError => e
+        raise e unless e.code == 429
+      end
+      response = client.get_personalization_strategy
+
+      assert_equal response, personalization_strategy
+    end
+  end
+end

data/test/algolia/integration/recommend_client_test.rb

@@ -0,0 +1,70 @@
+require 'securerandom'
+require_relative 'base_test'
+
+class RecommendClientTest < BaseTest
+  describe 'Recommendations' do
+    def test_get_recommendations
+      requester = MockRequester.new
+      client    = Algolia::Recommend::Client.new(@@search_config, http_requester: requester)
+
+      # It correctly formats queries using the 'bought-together' model
+      client.get_recommendations([{ indexName: 'products', objectID: 'B018APC4LE', model: Algolia::Recommend::Model::BOUGHT_TOGETHER }])
+
+      # It correctly formats queries using the 'related-products' model
+      client.get_recommendations([{ indexName: 'products', objectID: 'B018APC4LE', model: Algolia::Recommend::Model::RELATED_PRODUCTS }])
+
+      # It correctly formats multiple queries.
+      client.get_recommendations(
+        [
+          { indexName: 'products', objectID: 'B018APC4LE-1', model: Algolia::Recommend::Model::RELATED_PRODUCTS, threshold: 0 },
+          { indexName: 'products', objectID: 'B018APC4LE-2', model: Algolia::Recommend::Model::RELATED_PRODUCTS, threshold: 0 }
+        ]
+      )
+
+      # It resets the threshold to 0 if it's not numeric.
+      client.get_recommendations([{ indexName: 'products', objectID: 'B018APC4LE', model: Algolia::Recommend::Model::BOUGHT_TOGETHER, threshold: nil }])
+
+      # It passes the threshold correctly if it's numeric.
+      client.get_recommendations([{ indexName: 'products', objectID: 'B018APC4LE', model: Algolia::Recommend::Model::BOUGHT_TOGETHER, threshold: 42 }])
+
+      assert_requests(
+        requester,
+        [
+          { method: :post, path: '/1/indexes/*/recommendations', body: '{"requests":[{"indexName":"products","objectID":"B018APC4LE","model":"bought-together","threshold":0}]}' },
+          { method: :post, path: '/1/indexes/*/recommendations', body: '{"requests":[{"indexName":"products","objectID":"B018APC4LE","model":"related-products","threshold":0}]}' },
+          { method: :post, path: '/1/indexes/*/recommendations', body: '{"requests":[{"indexName":"products","objectID":"B018APC4LE-1","model":"related-products","threshold":0},{"indexName":"products","objectID":"B018APC4LE-2","model":"related-products","threshold":0}]}' },
+          { method: :post, path: '/1/indexes/*/recommendations', body: '{"requests":[{"indexName":"products","objectID":"B018APC4LE","model":"bought-together","threshold":0}]}' },
+          { method: :post, path: '/1/indexes/*/recommendations', body: '{"requests":[{"indexName":"products","objectID":"B018APC4LE","model":"bought-together","threshold":42}]}' }
+        ]
+      )
+    end
+
+    def test_get_related_products
+      requester = MockRequester.new
+      client    = Algolia::Recommend::Client.new(@@search_config, http_requester: requester)
+
+      client.get_related_products([{ indexName: 'products', objectID: 'B018APC4LE' }])
+
+      assert_requests(
+        requester,
+        [{ method: :post, path: '/1/indexes/*/recommendations', body: '{"requests":[{"indexName":"products","objectID":"B018APC4LE","model":"related-products","threshold":0}]}' }]
+      )
+    end
+
+    def test_get_frequently_bought_together
+      requester = MockRequester.new
+      client    = Algolia::Recommend::Client.new(@@search_config, http_requester: requester)
+
+      client.get_frequently_bought_together([{ indexName: 'products', objectID: 'B018APC4LE' }])
+      client.get_frequently_bought_together([{ indexName: 'products', objectID: 'B018APC4LE', fallbackParameters: {} }])
+
+      assert_requests(
+        requester,
+        [
+          { method: :post, path: '/1/indexes/*/recommendations', body: '{"requests":[{"indexName":"products","objectID":"B018APC4LE","model":"bought-together","threshold":0}]}' },
+          { method: :post, path: '/1/indexes/*/recommendations', body: '{"requests":[{"indexName":"products","objectID":"B018APC4LE","model":"bought-together","threshold":0}]}' }
+        ]
+      )
+    end
+  end
+end

data/test/algolia/integration/search_client_test.rb

@@ -1,3 +1,4 @@
+require 'securerandom'
 require_relative 'base_test'
 
 class SearchClientTest < BaseTest
@@ -223,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])
@@ -234,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
@@ -334,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
@@ -367,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/test_helper.rb

@@ -28,6 +28,22 @@ class Minitest::Test
   @@search_client = Algolia::Search::Client.new(@@search_config)
 end
 
+def assert_requests(requester, requests)
+  refute_empty requests
+  refute_nil requester
+
+  actual_requests = requester.requests
+  assert_equal requests.size, actual_requests.size
+
+  requests.each_with_index do |expected_request, i|
+    request = actual_requests[i]
+
+    assert_equal(expected_request[:body], request[:body])
+    assert_equal(expected_request[:method], request[:method])
+    assert_equal(expected_request[:path], request[:path])
+  end
+end
+
 def check_environment_variables
   raise Algolia::AlgoliaError, 'ALGOLIA_APPLICATION_ID_1 must be defined' if ENV['ALGOLIA_APPLICATION_ID_1'].to_s.strip.empty?
   raise Algolia::AlgoliaError, 'ALGOLIA_ADMIN_KEY_1 must be defined' if ENV['ALGOLIA_ADMIN_KEY_1'].to_s.strip.empty?
@@ -87,3 +103,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.4
+  version: 2.2.2
 platform: ruby
 authors:
 - Algolia
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-01-05 00:00:00.000000000 Z
+date: 2021-12-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -218,6 +218,8 @@ files:
 - lib/algolia/config/analytics_config.rb
 - lib/algolia/config/base_config.rb
 - lib/algolia/config/insights_config.rb
+- lib/algolia/config/personalization_config.rb
+- lib/algolia/config/recommend_config.rb
 - lib/algolia/config/recommendation_config.rb
 - lib/algolia/config/search_config.rb
 - lib/algolia/defaults.rb
@@ -234,10 +236,13 @@ files:
 - lib/algolia/iterators/rule_iterator.rb
 - lib/algolia/iterators/synonym_iterator.rb
 - lib/algolia/logger_helper.rb
+- lib/algolia/personalization_client.rb
+- lib/algolia/recommend_client.rb
 - lib/algolia/recommendation_client.rb
 - 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
@@ -273,6 +278,8 @@ files:
 - test/algolia/integration/base_test.rb
 - test/algolia/integration/insights_client_test.rb
 - test/algolia/integration/mocks/mock_requester.rb
+- test/algolia/integration/personalization_client_test.rb
+- test/algolia/integration/recommend_client_test.rb
 - test/algolia/integration/recommendation_client_test.rb
 - test/algolia/integration/search_client_test.rb
 - test/algolia/integration/search_index_test.rb
@@ -304,7 +311,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.4
+rubygems_version: 3.0.6
 signing_key:
 specification_version: 4
 summary: A simple Ruby client for the algolia.com REST API
@@ -314,6 +321,8 @@ test_files:
 - test/algolia/integration/base_test.rb
 - test/algolia/integration/insights_client_test.rb
 - test/algolia/integration/mocks/mock_requester.rb
+- test/algolia/integration/personalization_client_test.rb
+- test/algolia/integration/recommend_client_test.rb
 - test/algolia/integration/recommendation_client_test.rb
 - test/algolia/integration/search_client_test.rb
 - test/algolia/integration/search_index_test.rb