algolia 2.0.0 → 2.3.2

data/lib/algolia/insights_client.rb

@@ -13,7 +13,7 @@ module Algolia
       def initialize(insights_config, opts = {})
         @config      = insights_config
         adapter      = opts[:adapter] || Defaults::ADAPTER
-        logger       = opts[:logger] || LoggerHelper.create('debug.log')
+        logger       = opts[:logger] || LoggerHelper.create
         requester    = opts[:http_requester] || Defaults::REQUESTER_CLASS.new(adapter, logger)
         @transporter = Transport::Transport.new(@config, requester)
       end

data/lib/algolia/logger_helper.rb

@@ -5,7 +5,7 @@ module Algolia
     # @param debug_file [nil|String] file used to output the logs
     #
     def self.create(debug_file = nil)
-      file              = debug_file || File.new('debug.log')
+      file              = debug_file || (ENV['ALGOLIA_DEBUG'] ? File.new('debug.log') : $stderr)
       instance          = ::Logger.new file
       instance.progname = 'algolia'
       instance

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
+        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
+        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/add_api_key_response.rb

@@ -28,7 +28,7 @@ module Algolia
           end
           retries_count    += 1
           time_before_retry = retries_count * Defaults::WAIT_TASK_DEFAULT_TIME_BEFORE_RETRY
-          sleep(time_before_retry / 1000)
+          sleep(time_before_retry.to_f / 1000)
         end
       end
 

data/lib/algolia/responses/delete_api_key_response.rb

@@ -29,7 +29,7 @@ module Algolia
           unless @done
             retries_count    += 1
             time_before_retry = retries_count * Defaults::WAIT_TASK_DEFAULT_TIME_BEFORE_RETRY
-            sleep(time_before_retry / 1000)
+            sleep(time_before_retry.to_f / 1000)
           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/responses/restore_api_key_response.rb

@@ -26,7 +26,7 @@ module Algolia
           end
           retries_count    += 1
           time_before_retry = retries_count * Defaults::WAIT_TASK_DEFAULT_TIME_BEFORE_RETRY
-          sleep(time_before_retry / 1000)
+          sleep(time_before_retry.to_f / 1000)
         end
       end
 

data/lib/algolia/responses/update_api_key_response.rb

@@ -29,7 +29,7 @@ module Algolia
           raise e unless e.code == 404
           retries_count    += 1
           time_before_retry = retries_count * Defaults::WAIT_TASK_DEFAULT_TIME_BEFORE_RETRY
-          sleep(time_before_retry / 1000)
+          sleep(time_before_retry.to_f / 1000)
         end
       end
 

data/lib/algolia/search_client.rb

@@ -19,8 +19,8 @@ module Algolia
       def initialize(search_config, opts = {})
         @config      = search_config
         adapter      = opts[:adapter] || Defaults::ADAPTER
-        logger       = opts[:logger] || LoggerHelper.create('debug.log')
-        requester    = opts[:http_requester] || Defaults::REQUESTER_CLASS.new(adapter, logger)
+        @logger      = opts[:logger] || LoggerHelper.create
+        requester    = opts[:http_requester] || Defaults::REQUESTER_CLASS.new(adapter, @logger)
         @transporter = Transport::Transport.new(@config, requester)
       end
 
@@ -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, @logger)
       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
@@ -478,8 +478,12 @@ module Algolia
       # @return [Hash]
       #
       def multiple_queries(queries, opts = {})
+        queries.each do |q|
+          q[:params] = to_query_string(q[:params]) unless q[:params].nil? || q[:params].is_a?(String)
+        end
         @transporter.read(:POST, '/1/indexes/*/queries', { requests: queries }, opts)
       end
+      alias_method :search, :multiple_queries
 
       # # # # # # # # # # # # # # # # # # # # #
       # MCM METHODS
@@ -594,12 +598,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 = {})