algoliasearch 1.5.1 → 1.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7f8a8ea00f71415bf0e2840c750d9122d14a0b14
-  data.tar.gz: 20f3cdce74f9bf324414263d8fb50e90f0ca933a
+  metadata.gz: 511e4c42adb37f4b590e19d4db50e168207206cf
+  data.tar.gz: 26b545014c375f33eb5cb5ecee8b1f2c9a2dfa8e
 SHA512:
-  metadata.gz: bdf0fb25764237fc16479a5d2f1faebf5f469cb979eaf9e3571b9fe70c3151ca8b40f24b7eee4a94b1bffe5f196d006becdc0ca8654e438567ec12e973623dd3
-  data.tar.gz: c94357b18b72c01a06ef07af02f45e5f4a01d16cb780af9c555a83321504719689563460691fc738dcafb5b0aa462c73b23cf408c7d2bb056c3368c241615cb9
+  metadata.gz: bd5b41f2dd31727913a7cf6d043aa6d95d7736258a6996a3ebdb16efbef6176b0c24f554b1406258c933c6a62abb8b45a8c8db1ed5a78c69e74e2dc3bf92da43
+  data.tar.gz: 185d83cf55c8a9778a15e17d1e5dece6ad317c973f7b1e912d4dcc22dbcead51e510d7045add8b2f6bb69ccefd72412965472fe4acc15c72defff99f415b076d

data/.travis.yml

@@ -6,13 +6,8 @@ rvm:
 - 1.8.7
 - 1.9.3
 - 2.0.0
-- 2.1.0
-- 2.1.1
-- 2.1.2
-- 2.1.3
-- 2.1.4
 - 2.1.5
-- 2.2.0
+- 2.2.2
 - jruby
 - rbx-2
 install:

data/ChangeLog

@@ -1,5 +1,8 @@
 CHANGELOG
 
+2015-07-19 1.6.0
+      * Ability to instantiate multiple API clients in the same process (was using a class variable before).
+
 2015-07-14 1.5.1
       * Ability to retrieve a single page from a cursor with `browse_from`
 

data/lib/algolia/client.rb

@@ -19,6 +19,8 @@ module Algolia
     DEFAULT_SEARCH_TIMEOUT  = 5
 
     def initialize(data = {})
+      raise ArgumentError.new("No APPLICATION_ID provided, please set :application_id") if data[:application_id].nil?
+
       @ssl             = data[:ssl].nil? ? true : data[:ssl]
       @ssl_version     = data[:ssl_version].nil? ? nil : data[:ssl_version]
       @application_id  = data[:application_id]
@@ -38,6 +40,278 @@ module Algolia
       }
     end
 
+    #
+    # Initialize a new index
+    #
+    def init_index(name)
+      Index.new(name, self)
+    end
+
+    #
+    # Allow to set custom headers
+    #
+    def set_extra_header(key, value)
+      headers[key] = value
+    end
+
+    #
+    # Allow to use IP rate limit when you have a proxy between end-user and Algolia.
+    # This option will set the X-Forwarded-For HTTP header with the client IP and the X-Forwarded-API-Key with the API Key having rate limits.
+    # @param admin_api_key the admin API Key you can find in your dashboard
+    # @param end_user_ip the end user IP (you can use both IPV4 or IPV6 syntax)
+    # @param rate_limit_api_key the API key on which you have a rate limit
+    #
+    def enable_rate_limit_forward(admin_api_key, end_user_ip, rate_limit_api_key)
+      headers[Protocol::HEADER_API_KEY] = admin_api_key
+      headers[Protocol::HEADER_FORWARDED_IP] = end_user_ip
+      headers[Protocol::HEADER_FORWARDED_API_KEY] = rate_limit_api_key
+    end
+
+    #
+    # Disable IP rate limit enabled with enableRateLimitForward() function
+    #
+    def disable_rate_limit_forward
+      headers[Protocol::HEADER_API_KEY] = Algolia.client.api_key
+      headers.delete(Protocol::HEADER_FORWARDED_IP)
+      headers.delete(Protocol::HEADER_FORWARDED_API_KEY)
+    end
+
+    #
+    # Convenience method thats wraps enable_rate_limit_forward/disable_rate_limit_forward
+    #
+    def with_rate_limits(end_user_ip, rate_limit_api_key, &block)
+      enable_rate_limit_forward(Algolia.client.api_key, end_user_ip, rate_limit_api_key)
+      begin
+        yield
+      ensure
+        disable_rate_limit_forward
+      end
+    end
+
+    #
+    # This method allows to query multiple indexes with one API call
+    # 
+    # @param queries the array of hash representing the query and associated index name
+    # @param index_name_key the name of the key used to fetch the index_name (:index_name by default)
+    # @param strategy define the strategy applied on the sequential searches (none by default)
+    #
+    def multiple_queries(queries, index_name_key = :index_name, strategy = "none")
+      requests = {
+        :requests => queries.map do |query|
+          indexName = query.delete(index_name_key) || query.delete(index_name_key.to_s)
+          encoded_params = Hash[query.map { |k,v| [k.to_s, v.is_a?(Array) ? v.to_json : v] }]
+          { :indexName => indexName, :params => Protocol.to_query(encoded_params) }
+        end
+      }
+      post(Protocol.multiple_queries_uri(strategy), requests.to_json, :search)
+    end
+
+    #
+    # List all existing indexes
+    # return an Answer object with answer in the form 
+    #     {"items": [{ "name": "contacts", "createdAt": "2013-01-18T15:33:13.556Z"},
+    #                {"name": "notes", "createdAt": "2013-01-18T15:33:13.556Z"}]}
+    #
+    def list_indexes
+      get(Protocol.indexes_uri, :read)
+    end
+
+    #
+    # Move an existing index.
+    # @param src_index the name of index to copy.
+    # @param dst_index the new index name that will contains a copy of srcIndexName (destination will be overriten if it already exist).
+    #
+    def move_index(src_index, dst_index)
+      request = {"operation" => "move", "destination" => dst_index};
+      post(Protocol.index_operation_uri(src_index), request.to_json)
+    end
+
+    #
+    # Move an existing index and wait until the move has been processed
+    # @param src_index the name of index to copy.
+    # @param dst_index the new index name that will contains a copy of srcIndexName (destination will be overriten if it already exist).
+    #
+    def move_index!(src_index, dst_index)
+      res = Algolia.move_index(src_index, dst_index)
+      init_index(dst_index).wait_task(res['taskID'])
+      res
+    end
+
+    #
+    # Copy an existing index.
+    # @param src_index the name of index to copy.
+    # @param dst_index the new index name that will contains a copy of srcIndexName (destination will be overriten if it already exist).
+    #
+    def copy_index(src_index, dst_index)
+      request = {"operation" => "copy", "destination" => dst_index};
+      Algolia.client.post(Protocol.index_operation_uri(src_index), request.to_json)
+    end
+
+    #
+    # Copy an existing index and wait until the copy has been processed.
+    # @param src_index the name of index to copy.
+    # @param dst_index the new index name that will contains a copy of srcIndexName (destination will be overriten if it already exist).
+    #
+    def copy_index!(src_index, dst_index)
+      res = Algolia.copy_index(src_index, dst_index)
+      init_index(dst_index).wait_task(res['taskID'])
+      res
+    end
+
+    # Delete an index
+    #
+    def delete_index(name)
+      init_index(name).delete
+    end
+
+    # Delete an index and wait until the deletion has been processed.
+    #
+    def delete_index!(name)
+      init_index(name).delete!
+    end
+
+    #
+    # Return last logs entries.
+    #
+    # @param offset Specify the first entry to retrieve (0-based, 0 is the most recent log entry).
+    # @param length Specify the maximum number of entries to retrieve starting at offset. Maximum allowed value: 1000.
+    #
+    def get_logs(offset = 0, length = 10, type = "all")
+      if (type.is_a?(true.class))
+        if (type)
+          type = "error"
+        else
+          type = "all"
+        end
+      end
+      get(Protocol.logs(offset, length, type))
+    end
+
+    # List all existing user keys with their associated ACLs
+    def list_user_keys
+      get(Protocol.keys_uri, :read)
+    end
+
+    # Get ACL of a user key
+    def get_user_key(key)
+      get(Protocol.key_uri(key), :read)
+    end
+
+    #
+    #  Create a new user key
+    #
+    #  @param obj can be two different parameters:
+    #        The list of parameters for this key. Defined by a NSDictionary that
+    #        can contains the following values:
+    #          - acl: array of string
+    #          - indices: array of string
+    #          - validity: int
+    #          - referers: array of string
+    #          - description: string
+    #          - maxHitsPerQuery: integer
+    #          - queryParameters: string
+    #          - maxQueriesPerIPPerHour: integer
+    #        Or the list of ACL for this key. Defined by an array of NSString that
+    #        can contains the following values:
+    #          - search: allow to search (https and http)
+    #          - addObject: allows to add/update an object in the index (https only)
+    #          - deleteObject : allows to delete an existing object (https only)
+    #          - deleteIndex : allows to delete index content (https only)
+    #          - settings : allows to get index settings (https only)
+    #          - editSettings : allows to change index settings (https only)
+    #  @param validity the number of seconds after which the key will be automatically removed (0 means no time limit for this key)
+    #  @param maxQueriesPerIPPerHour the maximum number of API calls allowed from an IP address per hour (0 means unlimited)
+    #  @param maxHitsPerQuery  the maximum number of hits this API key can retrieve in one call (0 means unlimited)
+    #  @param indexes the optional list of targeted indexes
+    #
+    def add_user_key(obj, validity = 0, maxQueriesPerIPPerHour = 0, maxHitsPerQuery = 0, indexes = nil)
+      if obj.instance_of? Array
+        params = {
+          :acl => obj
+        }
+      else
+        params = obj
+      end
+      if validity != 0
+        params["validity"] = validity.to_i
+      end
+      if maxQueriesPerIPPerHour != 0
+        params["maxQueriesPerIPPerHour"] = maxQueriesPerIPPerHour.to_i
+      end
+      if maxHitsPerQuery != 0
+        params["maxHitsPerQuery"] = maxHitsPerQuery.to_i
+      end
+      params[:indexes] = indexes if indexes
+      post(Protocol.keys_uri, params.to_json)
+    end
+
+    #
+    #  Update a user key
+    #
+    #  @param obj can be two different parameters:
+    #        The list of parameters for this key. Defined by a NSDictionary that
+    #        can contains the following values:
+    #          - acl: array of string
+    #          - indices: array of string
+    #          - validity: int
+    #          - referers: array of string
+    #          - description: string
+    #          - maxHitsPerQuery: integer
+    #          - queryParameters: string
+    #          - maxQueriesPerIPPerHour: integer
+    #        Or the list of ACL for this key. Defined by an array of NSString that
+    #        can contains the following values:
+    #          - search: allow to search (https and http)
+    #          - addObject: allows to add/update an object in the index (https only)
+    #          - deleteObject : allows to delete an existing object (https only)
+    #          - deleteIndex : allows to delete index content (https only)
+    #          - settings : allows to get index settings (https only)
+    #          - editSettings : allows to change index settings (https only)
+    #  @param validity the number of seconds after which the key will be automatically removed (0 means no time limit for this key)
+    #  @param maxQueriesPerIPPerHour the maximum number of API calls allowed from an IP address per hour (0 means unlimited)
+    #  @param maxHitsPerQuery  the maximum number of hits this API key can retrieve in one call (0 means unlimited)
+    #  @param indexes the optional list of targeted indexes
+    #
+    def update_user_key(key, obj, validity = 0, maxQueriesPerIPPerHour = 0, maxHitsPerQuery = 0, indexes = nil)
+      if obj.instance_of? Array
+        params = {
+          :acl => obj
+        }
+      else
+        params = obj
+      end
+      if validity != 0
+        params["validity"] = validity.to_i
+      end
+      if maxQueriesPerIPPerHour != 0
+        params["maxQueriesPerIPPerHour"] = maxQueriesPerIPPerHour.to_i
+      end
+      if maxHitsPerQuery != 0
+        params["maxHitsPerQuery"] = maxHitsPerQuery.to_i
+      end
+      params[:indexes] = indexes if indexes
+      put(Protocol.key_uri(key), params.to_json)
+    end
+
+
+    # Delete an existing user key
+    def delete_user_key(key)
+      delete(Protocol.key_uri(key))
+    end
+
+    # Send a batch request targeting multiple indices
+    def batch(requests)
+      post(Protocol.batch_uri, {"requests" => requests}.to_json, :batch)
+    end
+
+    # Send a batch request targeting multiple indices and wait the end of the indexing
+    def batch!(requests)
+      res = batch(requests)
+      res['taskID'].each do |index, taskID|
+        init_index(index).wait_task(taskID)
+      end
+    end
+
     # Perform an HTTP request for the given uri and method
     # with common basic response handling. Will raise a
     # AlgoliaProtocolError if the response has an error status code,
@@ -101,7 +375,7 @@ module Algolia
     def thread_local_hosts(read, connect_timeout, send_timeout, receive_timeout)
       thread_local_var = read ? :algolia_search_hosts : :algolia_hosts
       Thread.current[thread_local_var] ||= {}
-      Thread.current[thread_local_var]["#{connect_timeout}-#{send_timeout}-#{receive_timeout}"] ||= (read ? search_hosts : hosts).map do |host|
+      Thread.current[thread_local_var]["#{self.hash}:#{connect_timeout}-#{send_timeout}-#{receive_timeout}"] ||= (read ? search_hosts : hosts).map do |host|
         client = HTTPClient.new
         client.ssl_config.ssl_version = @ssl_version if @ssl && @ssl_version
         hinfo = {
@@ -117,7 +391,6 @@ module Algolia
       end
     end
 
-    private
     def perform_request(session, url, method, data)
       response = case method
       when :GET
@@ -153,8 +426,6 @@ module Algolia
     defaulted = { :application_id => application_id, :api_key => api_key }
     defaulted.merge!(options)
 
-    raise ArgumentError.new("No APPLICATION_ID provided, please set :application_id") if defaulted[:application_id].nil?
-
     @@client = Client.new(defaulted)
   end
 
@@ -162,7 +433,7 @@ module Algolia
   # Allow to set custom headers
   #
   def Algolia.set_extra_header(key, value)
-    Algolia.client.headers[key] = value
+    Algolia.client.set_extra_header(key, value)
   end
 
   #
@@ -173,30 +444,21 @@ module Algolia
   # @param rate_limit_api_key the API key on which you have a rate limit
   #
   def Algolia.enable_rate_limit_forward(admin_api_key, end_user_ip, rate_limit_api_key)
-    Algolia.client.headers[Protocol::HEADER_API_KEY] = admin_api_key
-    Algolia.client.headers[Protocol::HEADER_FORWARDED_IP] = end_user_ip
-    Algolia.client.headers[Protocol::HEADER_FORWARDED_API_KEY] = rate_limit_api_key
+    Algolia.client.enable_rate_limit_forward(admin_api_key, end_user_ip, rate_limit_api_key)
   end
 
   #
   # Disable IP rate limit enabled with enableRateLimitForward() function
   #
   def Algolia.disable_rate_limit_forward
-    Algolia.client.headers[Protocol::HEADER_API_KEY] = Algolia.client.api_key
-    Algolia.client.headers.delete(Protocol::HEADER_FORWARDED_IP)
-    Algolia.client.headers.delete(Protocol::HEADER_FORWARDED_API_KEY)
+    Algolia.client.disable_rate_limit_forward
   end
 
   #
   # Convenience method thats wraps enable_rate_limit_forward/disable_rate_limit_forward
   #
   def Algolia.with_rate_limits(end_user_ip, rate_limit_api_key, &block)
-    Algolia.enable_rate_limit_forward(Algolia.client.api_key, end_user_ip, rate_limit_api_key)
-    begin
-      yield
-    ensure
-      Algolia.disable_rate_limit_forward
-    end
+    Algolia.client.with_rate_limits(end_user_ip, rate_limit_api_key, &block)
   end
 
   #
@@ -223,14 +485,7 @@ module Algolia
   # @param strategy define the strategy applied on the sequential searches (none by default)
   #
   def Algolia.multiple_queries(queries, index_name_key = :index_name, strategy = "none")
-    requests = {
-      :requests => queries.map do |query|
-        indexName = query.delete(index_name_key) || query.delete(index_name_key.to_s)
-        encoded_params = Hash[query.map { |k,v| [k.to_s, v.is_a?(Array) ? v.to_json : v] }]
-        { :indexName => indexName, :params => Protocol.to_query(encoded_params) }
-      end
-    }
-    Algolia.client.post(Protocol.multiple_queries_uri(strategy), requests.to_json, :search)
+    Algolia.client.multiple_queries(queries, index_name_key, strategy)
   end
 
   #
@@ -240,7 +495,7 @@ module Algolia
   #                {"name": "notes", "createdAt": "2013-01-18T15:33:13.556Z"}]}
   #
   def Algolia.list_indexes
-      Algolia.client.get(Protocol.indexes_uri, :read)
+    Algolia.client.list_indexes
   end
 
   #
@@ -249,8 +504,7 @@ module Algolia
   # @param dst_index the new index name that will contains a copy of srcIndexName (destination will be overriten if it already exist).
   #
   def Algolia.move_index(src_index, dst_index)
-      request = {"operation" => "move", "destination" => dst_index};
-      Algolia.client.post(Protocol.index_operation_uri(src_index), request.to_json)
+    Algolia.client.move_index(src_index, dst_index)
   end
 
   #
@@ -259,9 +513,7 @@ module Algolia
   # @param dst_index the new index name that will contains a copy of srcIndexName (destination will be overriten if it already exist).
   #
   def Algolia.move_index!(src_index, dst_index)
-      res = Algolia.move_index(src_index, dst_index)
-      Index.new(dst_index).wait_task(res['taskID'])
-      res
+    Algolia.client.move_index!(src_index, dst_index)
   end
 
   #
@@ -270,8 +522,7 @@ module Algolia
   # @param dst_index the new index name that will contains a copy of srcIndexName (destination will be overriten if it already exist).
   #
   def Algolia.copy_index(src_index, dst_index)
-      request = {"operation" => "copy", "destination" => dst_index};
-      Algolia.client.post(Protocol.index_operation_uri(src_index), request.to_json)
+    Algolia.client.copy_index(src_index, dst_index)
   end
 
   #
@@ -280,21 +531,19 @@ module Algolia
   # @param dst_index the new index name that will contains a copy of srcIndexName (destination will be overriten if it already exist).
   #
   def Algolia.copy_index!(src_index, dst_index)
-      res = Algolia.copy_index(src_index, dst_index)
-      Index.new(dst_index).wait_task(res['taskID'])
-      res
+    Algolia.client.copy_index!(src_index, dst_index)
   end
 
   # Delete an index
   #
-  def delete_index(name)
-    Index.new(name).delete
+  def Algolia.delete_index(name)
+    Algolia.client.delete_index(name)
   end
 
   # Delete an index and wait until the deletion has been processed.
   #
-  def delete_index!(name)
-    Index.new(name).delete!
+  def Algolia.delete_index!(name)
+    Algolia.client.delete_index!(name)
   end
 
   #
@@ -304,24 +553,17 @@ module Algolia
   # @param length Specify the maximum number of entries to retrieve starting at offset. Maximum allowed value: 1000.
   #
   def Algolia.get_logs(offset = 0, length = 10, type = "all")
-      if (type.is_a?(true.class))
-        if (type)
-          type = "error"
-        else
-          type = "all"
-        end
-      end
-      Algolia.client.get(Protocol.logs(offset, length, type))
+    Algolia.client.get_logs(offset, length, type)
   end
 
   # List all existing user keys with their associated ACLs
   def Algolia.list_user_keys
-      Algolia.client.get(Protocol.keys_uri, :read)
+    Algolia.client.list_user_keys
   end
 
   # Get ACL of a user key
   def Algolia.get_user_key(key)
-      Algolia.client.get(Protocol.key_uri(key), :read)
+    Algolia.client.get_user_key(key)
   end
 
   #
@@ -352,24 +594,7 @@ module Algolia
   #  @param indexes the optional list of targeted indexes
   #
   def Algolia.add_user_key(obj, validity = 0, maxQueriesPerIPPerHour = 0, maxHitsPerQuery = 0, indexes = nil)
-    if obj.instance_of? Array
-      params = {
-        :acl => obj
-      }
-    else
-      params = obj
-    end
-    if validity != 0
-      params["validity"] = validity.to_i
-    end
-    if maxQueriesPerIPPerHour != 0
-      params["maxQueriesPerIPPerHour"] = maxQueriesPerIPPerHour.to_i
-    end
-    if maxHitsPerQuery != 0
-      params["maxHitsPerQuery"] = maxHitsPerQuery.to_i
-    end
-    params[:indexes] = indexes if indexes
-    Algolia.client.post(Protocol.keys_uri, params.to_json)
+    Algolia.client.add_user_key(obj, validity, maxQueriesPerIPPerHour, maxHitsPerQuery, indexes)
   end
 
   #
@@ -400,43 +625,22 @@ module Algolia
   #  @param indexes the optional list of targeted indexes
   #
   def Algolia.update_user_key(key, obj, validity = 0, maxQueriesPerIPPerHour = 0, maxHitsPerQuery = 0, indexes = nil)
-    if obj.instance_of? Array
-      params = {
-        :acl => obj
-      }
-    else
-      params = obj
-    end
-    if validity != 0
-      params["validity"] = validity.to_i
-    end
-    if maxQueriesPerIPPerHour != 0
-      params["maxQueriesPerIPPerHour"] = maxQueriesPerIPPerHour.to_i
-    end
-    if maxHitsPerQuery != 0
-      params["maxHitsPerQuery"] = maxHitsPerQuery.to_i
-    end
-    params[:indexes] = indexes if indexes
-    Algolia.client.put(Protocol.key_uri(key), params.to_json)
+    Algolia.client.update_user_key(key, obj, validity, maxQueriesPerIPPerHour, maxHitsPerQuery, indexes)
   end
 
-
   # Delete an existing user key
   def Algolia.delete_user_key(key)
-      Algolia.client.delete(Protocol.key_uri(key))
+      Algolia.client.delete_user_key(key)
   end
 
   # Send a batch request targeting multiple indices
   def Algolia.batch(requests)
-    Algolia.client.post(Protocol.batch_uri, {"requests" => requests}.to_json, :batch)
+    Algolia.client.batch(requests)
   end
 
   # Send a batch request targeting multiple indices and wait the end of the indexing
   def Algolia.batch!(requests)
-    res = batch(requests)
-    res['taskID'].each { |index, taskID|
-      Algolia::Index.new(index).wait_task(taskID)
-    }
+    Algolia.client.batch!(requests)
   end
 
   # Used mostly for testing. Lets you delete the api key global vars.

data/lib/algolia/index.rb

@@ -2,19 +2,20 @@ require 'algolia/client'
 require 'algolia/error'
 
 module Algolia
-  
+
   class Index
-    attr_accessor :name
-    
-    def initialize(name)
+    attr_accessor :name, :client
+
+    def initialize(name, client = nil)
       self.name = name
+      self.client = client || Algolia.client
     end
-    
+
     # Delete an index
     #
     # return an hash of the form { "deletedAt" => "2013-01-18T15:33:13.556Z", "taskID" => "42" }
     def delete
-      Algolia.client.delete(Protocol.index_uri(name))
+      client.delete(Protocol.index_uri(name))
     end
     alias_method :delete_index, :delete
 
@@ -29,25 +30,25 @@ module Algolia
     alias_method :delete_index!, :delete!
 
     # Add an object in this index
-    # 
-    # @param obj the object to add to the index. 
+    #
+    # @param obj the object to add to the index.
     #  The object is represented by an associative array
-    # @param objectID (optional) an objectID you want to attribute to this object 
+    # @param objectID (optional) an objectID you want to attribute to this object
     #  (if the attribute already exist the old object will be overridden)
     def add_object(obj, objectID = nil)
       check_object obj
       if objectID.nil? || objectID.to_s.empty?
-        Algolia.client.post(Protocol.index_uri(name), obj.to_json)
+        client.post(Protocol.index_uri(name), obj.to_json)
       else
-        Algolia.client.put(Protocol.object_uri(name, objectID), obj.to_json)        
+        client.put(Protocol.object_uri(name, objectID), obj.to_json)
       end
     end
-    
+
     # Add an object in this index and wait end of indexing
-    # 
+    #
     # @param obj the object to add to the index.
     #  The object is represented by an associative array
-    # @param objectID (optional) an objectID you want to attribute to this object 
+    # @param objectID (optional) an objectID you want to attribute to this object
     #  (if the attribute already exist the old object will be overridden)
     def add_object!(obj, objectID = nil)
       res = add_object(obj, objectID)
@@ -56,16 +57,16 @@ module Algolia
     end
 
     # Add several objects in this index
-    # 
-    # @param objs the array of objects to add inside the index. 
+    #
+    # @param objs the array of objects to add inside the index.
     #  Each object is represented by an associative array
     def add_objects(objs)
       batch build_batch('addObject', objs, false)
     end
-    
+
     # Add several objects in this index and wait end of indexing
-    # 
-    # @param objs the array of objects to add inside the index. 
+    #
+    # @param objs the array of objects to add inside the index.
     #  Each object is represented by an associative array
     def add_objects!(obj)
       res = add_objects(obj)
@@ -82,65 +83,66 @@ module Algolia
     # - hitsPerPage: (integer) Pagination parameter used to select the number of hits per page. Defaults to 20.
     # - attributesToRetrieve: a string that contains the list of object attributes you want to retrieve (let you minimize the answer size).
     #   Attributes are separated with a comma (for example "name,address").
-    #   You can also use a string array encoding (for example ["name","address"]). 
+    #   You can also use a string array encoding (for example ["name","address"]).
     #   By default, all attributes are retrieved. You can also use '*' to retrieve all values when an attributesToRetrieve setting is specified for your index.
-    # - attributesToHighlight: a string that contains the list of attributes you want to highlight according to the query. 
-    #   Attributes are separated by a comma. You can also use a string array encoding (for example ["name","address"]). 
-    #   If an attribute has no match for the query, the raw value is returned. By default all indexed text attributes are highlighted. 
-    #   You can use `*` if you want to highlight all textual attributes. Numerical attributes are not highlighted. 
+    # - attributesToHighlight: a string that contains the list of attributes you want to highlight according to the query.
+    #   Attributes are separated by a comma. You can also use a string array encoding (for example ["name","address"]).
+    #   If an attribute has no match for the query, the raw value is returned. By default all indexed text attributes are highlighted.
+    #   You can use `*` if you want to highlight all textual attributes. Numerical attributes are not highlighted.
     #   A matchLevel is returned for each highlighted attribute and can contain:
     #      - full: if all the query terms were found in the attribute,
     #      - partial: if only some of the query terms were found,
     #      - none: if none of the query terms were found.
-    # - attributesToSnippet: a string that contains the list of attributes to snippet alongside the number of words to return (syntax is `attributeName:nbWords`). 
+    # - attributesToSnippet: a string that contains the list of attributes to snippet alongside the number of words to return (syntax is `attributeName:nbWords`).
     #    Attributes are separated by a comma (Example: attributesToSnippet=name:10,content:10).
     #    You can also use a string array encoding (Example: attributesToSnippet: ["name:10","content:10"]). By default no snippet is computed.
     # - minWordSizefor1Typo: the minimum number of characters in a query word to accept one typo in this word. Defaults to 3.
     # - minWordSizefor2Typos: the minimum number of characters in a query word to accept two typos in this word. Defaults to 7.
     # - getRankingInfo: if set to 1, the result hits will contain ranking information in _rankingInfo attribute.
     # - aroundLatLng: search for entries around a given latitude/longitude (specified as two floats separated by a comma).
-    #   For example aroundLatLng=47.316669,5.016670). 
+    #   For example aroundLatLng=47.316669,5.016670).
     #   You can specify the maximum distance in meters with the aroundRadius parameter (in meters) and the precision for ranking with aroundPrecision
     #   (for example if you set aroundPrecision=100, two objects that are distant of less than 100m will be considered as identical for "geo" ranking parameter).
     #   At indexing, you should specify geoloc of an object with the _geoloc attribute (in the form {"_geoloc":{"lat":48.853409, "lng":2.348800}})
     # - insideBoundingBox: search entries inside a given area defined by the two extreme points of a rectangle (defined by 4 floats: p1Lat,p1Lng,p2Lat,p2Lng).
     #   For example insideBoundingBox=47.3165,4.9665,47.3424,5.0201).
     #   At indexing, you should specify geoloc of an object with the _geoloc attribute (in the form {"_geoloc":{"lat":48.853409, "lng":2.348800}})
-    # - numericFilters: a string that contains the list of numeric filters you want to apply separated by a comma. 
-    #   The syntax of one filter is `attributeName` followed by `operand` followed by `value`. Supported operands are `<`, `<=`, `=`, `>` and `>=`. 
-    #   You can have multiple conditions on one attribute like for example numericFilters=price>100,price<1000. 
+    # - numericFilters: a string that contains the list of numeric filters you want to apply separated by a comma.
+    #   The syntax of one filter is `attributeName` followed by `operand` followed by `value`. Supported operands are `<`, `<=`, `=`, `>` and `>=`.
+    #   You can have multiple conditions on one attribute like for example numericFilters=price>100,price<1000.
     #   You can also use a string array encoding (for example numericFilters: ["price>100","price<1000"]).
-    # - tagFilters: filter the query by a set of tags. You can AND tags by separating them by commas. 
+    # - tagFilters: filter the query by a set of tags. You can AND tags by separating them by commas.
     #   To OR tags, you must add parentheses. For example, tags=tag1,(tag2,tag3) means tag1 AND (tag2 OR tag3).
     #   You can also use a string array encoding, for example tagFilters: ["tag1",["tag2","tag3"]] means tag1 AND (tag2 OR tag3).
-    #   At indexing, tags should be added in the _tags** attribute of objects (for example {"_tags":["tag1","tag2"]}). 
-    # - facetFilters: filter the query by a list of facets. 
-    #   Facets are separated by commas and each facet is encoded as `attributeName:value`. 
-    #   For example: `facetFilters=category:Book,author:John%20Doe`. 
+    #   At indexing, tags should be added in the _tags** attribute of objects (for example {"_tags":["tag1","tag2"]}).
+    # - facetFilters: filter the query by a list of facets.
+    #   Facets are separated by commas and each facet is encoded as `attributeName:value`.
+    #   For example: `facetFilters=category:Book,author:John%20Doe`.
     #   You can also use a string array encoding (for example `["category:Book","author:John%20Doe"]`).
-    # - facets: List of object attributes that you want to use for faceting. 
-    #   Attributes are separated with a comma (for example `"category,author"` ). 
+    # - facets: List of object attributes that you want to use for faceting.
+    #   Attributes are separated with a comma (for example `"category,author"` ).
     #   You can also use a JSON string array encoding (for example ["category","author"]).
-    #   Only attributes that have been added in **attributesForFaceting** index setting can be used in this parameter. 
+    #   Only attributes that have been added in **attributesForFaceting** index setting can be used in this parameter.
     #   You can also use `*` to perform faceting on all attributes specified in **attributesForFaceting**.
     # - queryType: select how the query words are interpreted, it can be one of the following value:
     #    - prefixAll: all query words are interpreted as prefixes,
     #    - prefixLast: only the last word is interpreted as a prefix (default behavior),
     #    - prefixNone: no query word is interpreted as a prefix. This option is not recommended.
-    # - optionalWords: a string that contains the list of words that should be considered as optional when found in the query. 
+    # - optionalWords: a string that contains the list of words that should be considered as optional when found in the query.
     #   The list of words is comma separated.
-    # - distinct: If set to 1, enable the distinct feature (disabled by default) if the attributeForDistinct index setting is set. 
-    #   This feature is similar to the SQL "distinct" keyword: when enabled in a query with the distinct=1 parameter, 
-    #   all hits containing a duplicate value for the attributeForDistinct attribute are removed from results. 
-    #   For example, if the chosen attribute is show_name and several hits have the same value for show_name, then only the best 
+    # - distinct: If set to 1, enable the distinct feature (disabled by default) if the attributeForDistinct index setting is set.
+    #   This feature is similar to the SQL "distinct" keyword: when enabled in a query with the distinct=1 parameter,
+    #   all hits containing a duplicate value for the attributeForDistinct attribute are removed from results.
+    #   For example, if the chosen attribute is show_name and several hits have the same value for show_name, then only the best
     #   one is kept and others are removed.
     def search(query, params = {})
       encoded_params = Hash[params.map { |k,v| [k.to_s, v.is_a?(Array) ? v.to_json : v] }]
-      Algolia.client.get(Protocol.search_uri(name, query, encoded_params), :search)
+      client.get(Protocol.search_uri(name, query, encoded_params), :search)
     end
 
     class IndexBrowser
-      def initialize(name, params)
+      def initialize(client, name, params)
+        @client = client
         @name = name
         @params = params
         @cursor = params[:cursor] || params['cursor'] || nil
@@ -148,7 +150,7 @@ module Algolia
 
       def browse(&block)
         loop do
-          answer = Algolia.client.get(Protocol.browse_uri(@name, @params.merge({ :cursor => @cursor })), :read)
+          answer = @client.get(Protocol.browse_uri(@name, @params.merge({ :cursor => @cursor })), :read)
           answer['hits'].each do |hit|
             if block.arity == 2
               yield hit, @cursor
@@ -185,11 +187,11 @@ module Algolia
         else
           params[:hitsPerPage] = hitsPerPage unless hitsPerPage.nil?
         end
-        IndexBrowser.new(name, params).browse(&block)
+        IndexBrowser.new(client, name, params).browse(&block)
       else
         page ||= 0
         hitsPerPage ||= 1000
-        Algolia.client.get(Protocol.browse_uri(name, {:page => page, :hitsPerPage => hitsPerPage}), :read)
+        client.get(Protocol.browse_uri(name, {:page => page, :hitsPerPage => hitsPerPage}), :read)
       end
     end
 
@@ -197,20 +199,20 @@ module Algolia
     # Browse a single page from a specific cursor
     #
     def browse_from(cursor, hitsPerPage = 1000)
-      Algolia.client.get(Protocol.browse_uri(name, { :cursor => cursor, :hitsPerPage => hitsPerPage }), :read)
+      client.get(Protocol.browse_uri(name, { :cursor => cursor, :hitsPerPage => hitsPerPage }), :read)
     end
 
     #
     # Get an object from this index
-    # 
+    #
     # @param objectID the unique identifier of the object to retrieve
     # @param attributesToRetrieve (optional) if set, contains the list of attributes to retrieve as a string separated by ","
     #
     def get_object(objectID, attributesToRetrieve = nil)
       if attributesToRetrieve.nil?
-        Algolia.client.get(Protocol.object_uri(name, objectID, nil), :read)
+        client.get(Protocol.object_uri(name, objectID, nil), :read)
       else
-        Algolia.client.get(Protocol.object_uri(name, objectID, {:attributes => attributesToRetrieve}), :read)
+        client.get(Protocol.object_uri(name, objectID, {:attributes => attributesToRetrieve}), :read)
       end
     end
 
@@ -220,18 +222,18 @@ module Algolia
     # @param objectIDs the array of unique identifier of the objects to retrieve
     #
     def get_objects(objectIDs)
-      Algolia.client.post(Protocol.objects_uri, { :requests => objectIDs.map { |objectID| { :indexName => name, :objectID => objectID } } }.to_json, :read)['results']
+      client.post(Protocol.objects_uri, { :requests => objectIDs.map { |objectID| { :indexName => name, :objectID => objectID } } }.to_json, :read)['results']
     end
 
-    # Wait the publication of a task on the server. 
+    # Wait the publication of a task on the server.
     # All server task are asynchronous and you can check with this method that the task is published.
     #
     # @param taskID the id of the task returned by server
     # @param timeBeforeRetry the time in milliseconds before retry (default = 100ms)
-    #    
+    #
     def wait_task(taskID, timeBeforeRetry = 100)
       loop do
-        status = Algolia.client.get(Protocol.task_uri(name, taskID), :read)["status"]
+        status = client.get(Protocol.task_uri(name, taskID), :read)["status"]
         if status == "published"
           return
         end
@@ -240,19 +242,19 @@ module Algolia
     end
 
     # Override the content of an object
-    # 
+    #
     # @param obj the object to save
     # @param objectID the associated objectID, if nil 'obj' must contain an 'objectID' key
     #
     def save_object(obj, objectID = nil)
-      Algolia.client.put(Protocol.object_uri(name, get_objectID(obj, objectID)), obj.to_json)
+      client.put(Protocol.object_uri(name, get_objectID(obj, objectID)), obj.to_json)
     end
 
     # Override the content of object and wait end of indexing
-    # 
+    #
     # @param obj the object to save
     # @param objectID the associated objectID, if nil 'obj' must contain an 'objectID' key
-    #    
+    #
     def save_object!(obj, objectID = nil)
       res = save_object(obj, objectID)
       wait_task(res["taskID"])
@@ -260,7 +262,7 @@ module Algolia
     end
 
     # Override the content of several objects
-    # 
+    #
     # @param objs the array of objects to save, each object must contain an 'objectID' key
     #
     def save_objects(objs)
@@ -268,9 +270,9 @@ module Algolia
     end
 
     # Override the content of several objects and wait end of indexing
-    # 
+    #
     # @param objs the array of objects to save, each object must contain an objectID attribute
-    #    
+    #
     def save_objects!(objs)
       res = save_objects(objs)
       wait_task(res["taskID"])
@@ -279,18 +281,18 @@ module Algolia
 
     #
     # Update partially an object (only update attributes passed in argument)
-    # 
+    #
     # @param obj the object attributes to override
     # @param objectID the associated objectID, if nil 'obj' must contain an 'objectID' key
     # @param create_if_not_exits a boolean, if true creates the object if this one doesn't exist
     #
     def partial_update_object(obj, objectID = nil, create_if_not_exits = true)
-      Algolia.client.post(Protocol.partial_object_uri(name, get_objectID(obj, objectID), create_if_not_exits), obj.to_json)
+      client.post(Protocol.partial_object_uri(name, get_objectID(obj, objectID), create_if_not_exits), obj.to_json)
     end
-    
+
     #
     # Partially Override the content of several objects
-    # 
+    #
     # @param objs an array of objects to update (each object must contains a objectID attribute)
     # @param create_if_not_exits a boolean, if true create the objects if they don't exist
     #
@@ -304,7 +306,7 @@ module Algolia
 
     #
     # Partially Override the content of several objects and wait end of indexing
-    # 
+    #
     # @param objs an array of objects to update (each object must contains a objectID attribute)
     # @param create_if_not_exits a boolean, if true create the objects if they don't exist
     #
@@ -316,7 +318,7 @@ module Algolia
 
     #
     # Update partially an object (only update attributes passed in argument) and wait indexing
-    # 
+    #
     # @param obj the attributes to override
     # @param objectID the associated objectID, if nil 'obj' must contain an 'objectID' key
     # @param create_if_not_exits a boolean, if true creates the object if this one doesn't exist
@@ -326,19 +328,19 @@ module Algolia
       wait_task(res["taskID"])
       return res
     end
-    
+
+    #
+    # Delete an object from the index
     #
-    # Delete an object from the index 
-    # 
     # @param objectID the unique identifier of object to delete
     #
     def delete_object(objectID)
-      Algolia.client.delete(Protocol.object_uri(name, objectID))
+      client.delete(Protocol.object_uri(name, objectID))
     end
-    
+
     #
     # Delete an object from the index and wait end of indexing
-    # 
+    #
     # @param objectID the unique identifier of object to delete
     #
     def delete_object!(objectID)
@@ -349,7 +351,7 @@ module Algolia
 
     #
     # Delete several objects
-    # 
+    #
     # @param objs an array of objectIDs
     #
     def delete_objects(objs)
@@ -359,7 +361,7 @@ module Algolia
 
     #
     # Delete several objects and wait end of indexing
-    # 
+    #
     # @param objs an array of objectIDs
     #
     def delete_objects!(objs)
@@ -392,13 +394,13 @@ module Algolia
 
     #
     # Delete the index content
-    # 
+    #
     #
     def clear
-      Algolia.client.post(Protocol.clear_uri(name))
+      client.post(Protocol.clear_uri(name))
     end
     alias_method :clear_index, :clear
-    
+
     #
     # Delete the index content and wait end of indexing
     #
@@ -408,50 +410,50 @@ module Algolia
       return res
     end
     alias_method :clear_index!, :clear!
-    
+
     #
     # Set settings for this index
-    # 
+    #
     # @param settigns the settings object that can contains :
     # - minWordSizefor1Typo: (integer) the minimum number of characters to accept one typo (default = 3).
     # - minWordSizefor2Typos: (integer) the minimum number of characters to accept two typos (default = 7).
     # - hitsPerPage: (integer) the number of hits per page (default = 10).
-    # - attributesToRetrieve: (array of strings) default list of attributes to retrieve in objects. 
+    # - attributesToRetrieve: (array of strings) default list of attributes to retrieve in objects.
     #   If set to null, all attributes are retrieved.
-    # - attributesToHighlight: (array of strings) default list of attributes to highlight. 
+    # - attributesToHighlight: (array of strings) default list of attributes to highlight.
     #   If set to null, all indexed attributes are highlighted.
     # - attributesToSnippet**: (array of strings) default list of attributes to snippet alongside the number of words to return (syntax is attributeName:nbWords).
     #   By default no snippet is computed. If set to null, no snippet is computed.
     # - attributesToIndex: (array of strings) the list of fields you want to index.
     #   If set to null, all textual and numerical attributes of your objects are indexed, but you should update it to get optimal results.
     #   This parameter has two important uses:
-    #     - Limit the attributes to index: For example if you store a binary image in base64, you want to store it and be able to 
+    #     - Limit the attributes to index: For example if you store a binary image in base64, you want to store it and be able to
     #       retrieve it but you don't want to search in the base64 string.
-    #     - Control part of the ranking*: (see the ranking parameter for full explanation) Matches in attributes at the beginning of 
-    #       the list will be considered more important than matches in attributes further down the list. 
-    #       In one attribute, matching text at the beginning of the attribute will be considered more important than text after, you can disable 
+    #     - Control part of the ranking*: (see the ranking parameter for full explanation) Matches in attributes at the beginning of
+    #       the list will be considered more important than matches in attributes further down the list.
+    #       In one attribute, matching text at the beginning of the attribute will be considered more important than text after, you can disable
     #       this behavior if you add your attribute inside `unordered(AttributeName)`, for example attributesToIndex: ["title", "unordered(text)"].
-    # - attributesForFaceting: (array of strings) The list of fields you want to use for faceting. 
+    # - attributesForFaceting: (array of strings) The list of fields you want to use for faceting.
     #   All strings in the attribute selected for faceting are extracted and added as a facet. If set to null, no attribute is used for faceting.
-    # - attributeForDistinct: (string) The attribute name used for the Distinct feature. This feature is similar to the SQL "distinct" keyword: when enabled 
-    #   in query with the distinct=1 parameter, all hits containing a duplicate value for this attribute are removed from results. 
+    # - attributeForDistinct: (string) The attribute name used for the Distinct feature. This feature is similar to the SQL "distinct" keyword: when enabled
+    #   in query with the distinct=1 parameter, all hits containing a duplicate value for this attribute are removed from results.
     #   For example, if the chosen attribute is show_name and several hits have the same value for show_name, then only the best one is kept and others are removed.
     # - ranking: (array of strings) controls the way results are sorted.
-    #   We have six available criteria: 
+    #   We have six available criteria:
     #    - typo: sort according to number of typos,
     #    - geo: sort according to decreassing distance when performing a geo-location based search,
     #    - proximity: sort according to the proximity of query words in hits,
     #    - attribute: sort according to the order of attributes defined by attributesToIndex,
-    #    - exact: 
-    #        - if the user query contains one word: sort objects having an attribute that is exactly the query word before others. 
-    #          For example if you search for the "V" TV show, you want to find it with the "V" query and avoid to have all popular TV 
+    #    - exact:
+    #        - if the user query contains one word: sort objects having an attribute that is exactly the query word before others.
+    #          For example if you search for the "V" TV show, you want to find it with the "V" query and avoid to have all popular TV
     #          show starting by the v letter before it.
     #        - if the user query contains multiple words: sort according to the number of words that matched exactly (and not as a prefix).
     #    - custom: sort according to a user defined formula set in **customRanking** attribute.
     #   The standard order is ["typo", "geo", "proximity", "attribute", "exact", "custom"]
     # - customRanking: (array of strings) lets you specify part of the ranking.
     #   The syntax of this condition is an array of strings containing attributes prefixed by asc (ascending order) or desc (descending order) operator.
-    #   For example `"customRanking" => ["desc(population)", "asc(name)"]`  
+    #   For example `"customRanking" => ["desc(population)", "asc(name)"]`
     # - queryType: Select how the query words are interpreted, it can be one of the following value:
     #   - prefixAll: all query words are interpreted as prefixes,
     #   - prefixLast: only the last word is interpreted as a prefix (default behavior),
@@ -461,24 +463,24 @@ module Algolia
     # - optionalWords: (array of strings) Specify a list of words that should be considered as optional when found in the query.
     #
     def set_settings(new_settings)
-      Algolia.client.put(Protocol.settings_uri(name), new_settings.to_json)
+      client.put(Protocol.settings_uri(name), new_settings.to_json)
     end
-    
+
     # Get settings of this index
     def get_settings
-      Algolia.client.get(Protocol.settings_uri(name), :read)
-    end 
+      client.get(Protocol.settings_uri(name), :read)
+    end
 
     # List all existing user keys with their associated ACLs
     def list_user_keys
-      Algolia.client.get(Protocol.index_keys_uri(name), :read)
+      client.get(Protocol.index_keys_uri(name), :read)
     end
- 
+
     # Get ACL of a user key
     def get_user_key(key)
-      Algolia.client.get(Protocol.index_key_uri(name, key), :read)
+      client.get(Protocol.index_key_uri(name, key), :read)
     end
- 
+
     #
     #  Create a new user key
     #
@@ -521,7 +523,7 @@ module Algolia
       if maxHitsPerQuery != 0
         params["maxHitsPerQuery"] = maxHitsPerQuery.to_i
       end
-      Algolia.client.post(Protocol.index_keys_uri(name), params.to_json)
+      client.post(Protocol.index_keys_uri(name), params.to_json)
     end
 
     #
@@ -566,18 +568,18 @@ module Algolia
       if maxHitsPerQuery != 0
         params["maxHitsPerQuery"] = maxHitsPerQuery.to_i
       end
-      Algolia.client.put(Protocol.index_key_uri(name, key), params.to_json)
+      client.put(Protocol.index_key_uri(name, key), params.to_json)
     end
 
- 
+
     # Delete an existing user key
     def delete_user_key(key)
-      Algolia.client.delete(Protocol.index_key_uri(name, key))
+      client.delete(Protocol.index_key_uri(name, key))
     end
 
     # Send a batch request
     def batch(request)
-      Algolia.client.post(Protocol.batch_uri(name), request.to_json, :batch)
+      client.post(Protocol.batch_uri(name), request.to_json, :batch)
     end
 
     # Send a batch request and wait the end of the indexing
@@ -648,7 +650,7 @@ module Algolia
           :analytics => false
         })
       end
-      answers = Algolia.multiple_queries(queries)
+      answers = client.multiple_queries(queries)
 
       # aggregate answers
       ## first answer stores the hits + regular facets

data/lib/algolia/version.rb

@@ -1,3 +1,3 @@
 module Algolia
-  VERSION = "1.5.1"
+  VERSION = "1.6.0"
 end

metadata

@@ -1,83 +1,83 @@
 --- !ruby/object:Gem::Specification
 name: algoliasearch
 version: !ruby/object:Gem::Version
-  version: 1.5.1
+  version: 1.6.0
 platform: ruby
 authors:
 - Algolia
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-07-14 00:00:00.000000000 Z
+date: 2015-07-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: httpclient
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '2.4'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '2.4'
 - !ruby/object:Gem::Dependency
   name: json
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: 1.5.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: 1.5.1
 - !ruby/object:Gem::Dependency
   name: travis
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: rdoc
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 description: A simple Ruby client for the algolia.com REST API
@@ -89,8 +89,8 @@ extra_rdoc_files:
 - LICENSE.txt
 - README.md
 files:
-- .rspec
-- .travis.yml
+- ".rspec"
+- ".travis.yml"
 - ChangeLog
 - Gemfile
 - Gemfile.lock
@@ -121,17 +121,17 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.0.14
+rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
 summary: A simple Ruby client for the algolia.com REST API