algoliasearch 1.4.1 → 1.4.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d9df8ced9c8a5da4e7e677c2643b24891b84a406
-  data.tar.gz: ea2d150a9d5171f5e4da18a6a5c7758137d31aa5
+  metadata.gz: f84aa6b108332e6d8c8e967371efe01ededbeff9
+  data.tar.gz: 89e4300df60f82e9a392f1179bdbcd0521e80cd0
 SHA512:
-  metadata.gz: 04a47d4b5227e7e97db5d33fb1759a3c053e0e34a94fb6d7eb380c97a4ae4dbfc097df30755afa2524f41cc93400d19c2b3db5d70676cd9a5469ba68cadab3e4
-  data.tar.gz: 088ba592a94f6e31dd3d0f07f5668b53bb63932fd8680e84c03da0dc7a0add25aaa8a8bfca3f8c9b43ec797d0288391611ec441f89d0bfa77a188de3ffbfdbd8
+  metadata.gz: 57b4c7a292ff76a4686da1e74f42c5f51be1ee96bf98bcd9dfb2725570cb4b5edee355f44a0f6ad0861226ed6df906e5c9ac0a645b77754c98b6c01e78b46caa
+  data.tar.gz: 6b40a8311c4037fe9b00a6e8242146dcab7e2be3bc605a311206b2613f3c045d46ad9dd2df0d473b58a4c49ca7a37c18a158f194a71c075058e9e8e4122f5c94

data/ChangeLog

@@ -1,5 +1,11 @@
 CHANGELOG
 
+2015-05-04 1.4.2
+      * Add new methods to add/update api key
+      * Add batch method to target multiple indices
+      * Add strategy parameter for the multipleQueries
+      * Add new method to generate secured api key from query parameters
+
 2015-04-10  1.4.1
       * Force the default connect/read/write/search/batch timeouts to Algolia-specific values
 

data/README.md

@@ -2,6 +2,7 @@
 
 
 
+
 [Algolia Search](http://www.algolia.com) is a hosted full-text, numerical, and faceted search engine capable of delivering realtime results from the first keystroke.
 
 Our Ruby client lets you easily use the [Algolia Search API](https://www.algolia.com/doc/rest_api) from your backend. It wraps the [Algolia Search REST API](http://www.algolia.com/doc/rest_api).
@@ -23,9 +24,10 @@ Table of Contents
 
 **Commands Reference**
 
-1. [Add a new object](#add-a-new-object-in-the-index)
+1. [Add a new object](#add-a-new-object-to-the-index)
 1. [Update an object](#update-an-existing-object-in-the-index)
 1. [Search](#search)
+1. [Multiple queries](#multiple-queries)
 1. [Get an object](#get-an-object)
 1. [Delete an object](#delete-an-object)
 1. [Delete by query](#delete-by-query)
@@ -37,13 +39,12 @@ Table of Contents
 1. [Batch writes](#batch-writes)
 1. [Security / User API Keys](#security--user-api-keys)
 1. [Copy or rename an index](#copy-or-rename-an-index)
-1. [Backup / Retrieve all index content](#backup--retrieve-all-index-content)
+1. [Backup / Retrieve all index content](#backup--retrieve-of-all-index-content)
 1. [Logs](#logs)
 1. [Mock](#mock)
 
 
 
-
 Setup
 -------------
 To setup your project, follow these steps:
@@ -68,15 +69,10 @@ If you're a Ruby on Rails user; you're probably looking for the [algoliasearch-r
 
 
 
-
-
-
-
-
-
 Quick Start
 -------------
 
+
 In 30 seconds, this quick start tutorial will show you how to index and search objects.
 
 Without any prior configuration, you can start indexing [500 contacts](https://github.com/algolia/algoliasearch-client-csharp/blob/master/contacts.json) in the ```contacts``` index using the following code:
@@ -123,7 +119,7 @@ puts index.search('jim').to_json
 ```html
 <script src="//cdn.jsdelivr.net/algoliasearch/3/algoliasearch.min.js"></script>
 <script>
-var client = algoliasearch('ApplicationID', 'Search-Only-API-Key');
+var client = algoliasearch('ApplicationID', 'apiKey');
 var index = client.initIndex('indexName');
 
 // perform query "jim"
@@ -153,13 +149,8 @@ function searchCallback(err, content) {
 
 
 
-
-
-
-
 Documentation
 ================
-
 Check our [online documentation](http://www.algolia.com/doc/guides/ruby):
  * [Initial Import](http://www.algolia.com/doc/guides/ruby#InitialImport)
  * [Ranking &amp; Relevance](http://www.algolia.com/doc/guides/ruby#RankingRelevance)
@@ -172,7 +163,6 @@ Check our [online documentation](http://www.algolia.com/doc/guides/ruby):
  * [Security](http://www.algolia.com/doc/guides/ruby#Security)
  * [REST API](http://www.algolia.com/doc/rest)
 
-
 Tutorials
 ================
 
@@ -188,8 +178,6 @@ Commands Reference
 
 
 
-
-
 Add a new object to the Index
 -------------
 
@@ -286,8 +274,6 @@ index.partial_update_object({"price" => {"value" => 42, "_operation": "Decrement
                              "objectID" => "myID"})
 ```
 
-
-
 Search
 -------------
 
@@ -437,6 +423,10 @@ res = Algolia.multiple_queries([{:index_name => "categories", "query" => my_quer
 puts res["results"]
 ```
 
+You can specify a strategy to optimize your multiple queries:
+- **none**: Execute the sequence of queries until the end.
+- **stopIfEnoughMatches**: Execute the sequence of queries until the number of hits is reached by the sum of hits.
+
 
 
 Get an object
@@ -455,16 +445,10 @@ res = index.get_object("myID", "fistname")
 
 You can also retrieve a set of objects:
 
-
 ```ruby
 res = index.get_objects(["myID", "myID2"])
 ```
 
-
-
-
-
-
 Delete an object
 -------------
 
@@ -496,8 +480,8 @@ You can retrieve all settings using the `get_settings` function. The result will
  * **attributesToIndex**: (array of strings) The list of fields you want to index.<br/>If set to null, all textual and numerical attributes of your objects are indexed. Be sure to update it to get optimal results.<br/>This parameter has two important uses:
   * *Limit the attributes to index*.<br/>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*.<br/>(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)"]`.
-**Notes**: All numerical attributes are automatically indexed as numerical filters. If you don't need filtering on some of your numerical attributes, please consider sending them as strings to speed up the indexing.<br/>
 You can decide to have the same priority for two attributes by passing them in the same string using a comma as a separator. For example `title` and `alternative_title` have the same priority in this example, which is different than text priority: `attributesToIndex:["title,alternative_title", "text"]`.
+* **numericAttributesToIndex**: (array of strings) All numerical attributes are automatically indexed as numerical filters. If you don't need filtering on some of your numerical attributes, you can specify this list to speed up the indexing.<br/> If you only need to filter on a numeric value with the operator '=', you can speed up the indexing by specifying the attribute with `equalOnly(AttributeName)`. The other operators will be disabled.
  * **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**: The attribute name used for the `Distinct` feature. This feature is similar to the SQL "distinct" keyword. When enabled in queries 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. **Note**: This feature is disabled if the query string is empty and there aren't any `tagFilters`, `facetFilters`, nor `numericFilters` parameters.
  * **ranking**: (array of strings) Controls the way results are sorted.<br/>We have nine available criteria:
@@ -523,7 +507,7 @@ You can decide to have the same priority for two attributes by passing them in t
  * **allowCompressionOfIntegerArray**: Allows compression of big integer arrays. We recommended enabling this feature and then storing the list of user IDs or rights as an integer array. When enabled, the integer array is reordered to reach a better compression ratio. Defaults to false.
 
 #### Query expansion
- * **synonyms**: (array of array of words considered as equals). For example, you may want to retrieve the **black ipad** record when your users are searching for **dark ipad**, even if the word **dark** is not part of the record. To do this, you need to configure **black** as a synonym of **dark**. For example, `"synomyms": [ [ "black", "dark" ], [ "small", "little", "mini" ], ... ]`.
+ * **synonyms**: (array of array of string considered as equals). For example, you may want to retrieve the **black ipad** record when your users are searching for **dark ipad**, even if the word **dark** is not part of the record. To do this, you need to configure **black** as a synonym of **dark**. For example, `"synomyms": [ [ "black", "dark" ], [ "small", "little", "mini" ], ... ]`. Synonym feature also supports multi-words expression like `"synonyms": [ ["NY", "New York"] ]`
  * **placeholders**: (hash of array of words). This is an advanced use case to define a token substitutable by a list of words without having the original token searchable. It is defined by a hash associating placeholders to lists of substitutable words. For example, `"placeholders": { "<streetnumber>": ["1", "2", "3", ..., "9999"]}` would allow it to be able to match all street numbers. We use the `< >` tag syntax to define placeholders in an attribute. For example:
   * Push a record with the placeholder: `{ "name" : "Apple Store", "address" : "&lt;streetnumber&gt; Opera street, Paris" }`.
   * Configure the placeholder in your index settings: `"placeholders": { "<streetnumber>" : ["1", "2", "3", "4", "5", ... ], ... }`.
@@ -639,6 +623,23 @@ res = index.partial_update_objects([{"firstname" => "Jimmie",
 
 
 
+If you have one index per user, you may want to perform a batch operations across severals indexes.
+We expose a method to perform this type of batch:
+```ruby
+res = index.batch([
+	{"action"=> "addObject", "indexName"=> "index1", "body": {"firstname" => "Jimmie", 
+                          "lastname" => "Barninger"}},
+    {"action"=> "addObject", "indexName"=> "index2", "body": {"firstname" => "Warren", 
+                          "lastname" => "Speach"}}])
+```
+
+The attribute **action** can have these values:
+- addObject
+- updateObject
+- partialUpdateObject
+- partialUpdateObjectNoCreate
+- deleteObject
+
 Security / User API Keys
 -------------
 
@@ -675,7 +676,7 @@ res = index.add_user_key(["search"])
 puts res['key']
 ```
 
-You can also create an API Key with advanced restrictions:
+You can also create an API Key with advanced settings:
 
  * Add a validity period. The key will be valid for a specific period of time (in seconds).
  * Specify the maximum number of API calls allowed from an IP address per hour. Each time an API call is performed with this key, a check is performed. If the IP at the source of the call did more than this number of calls in the last hour, a 403 code is returned. Defaults to 0 (no rate limit). This parameter can be used to protect you from attempts at retrieving your entire index contents by massively querying the index.
@@ -685,6 +686,10 @@ You can also create an API Key with advanced restrictions:
 
  * Specify the maximum number of hits this API key can retrieve in one call. Defaults to 0 (unlimited). This parameter can be used to protect you from attempts at retrieving your entire index contents by massively querying the index.
  * Specify the list of targeted indices. You can target all indices starting with a prefix or ending with a suffix using the '*' character. For example, "dev_*" matches all indices starting with "dev_" and "*_dev" matches all indices ending with "_dev". Defaults to all indices if empty or blank.
+ * Specify the list of referers. You can target all referers starting with a prefix or ending with a suffix using the '*' character. For example, "algolia.com/*" matches all referers starting with "algolia.com/" and "*.algolia.com" matches all referers ending with ".algolia.com". Defaults to all referers if empty or blank.
+ * Specify the list of query parameters. You can force the query parameters for a query using the url string format (param1=X&param2=Y...).
+ * Specify a description to describe where the key is used.
+
 
 ```ruby
 # Creates a new global API key that is valid for 300 seconds
@@ -695,7 +700,18 @@ puts res['key']
 #  - rate limit of 100 calls per hour per IP
 #  - maximum of 20 hits
 #  - valid on 'my_index1' and 'my_index2'
-res = index.add_user_key(["search"], 300, 100, 20, ['my_index1', 'my_index2'])
+
+params = {
+	:validity => 300,
+	:maxQueriesPerIPPerHour => 100,
+	:maxHitsPerQuery => 20,
+	:indexes => ['my_index1', 'my_index2'],
+	:referers => ['algolia.com/*'],
+	:queryParameters => 'typoTolerance=strict&ignorePlurals=false',
+	:description => 'Limited search only API key for algolia.com'
+}
+
+res = Algolia.add_user_key(params)
 puts res['key']
 ```
 
@@ -730,21 +746,19 @@ index.delete_user_key("71671c38001bf3ac857bc82052485107")
 
 
 
-You may have a single index containing per user data. In that case, all records should be tagged with their associated user_id in order to add a `tagFilters=(public,user_42)` filter at query time to retrieve only what a user has access to. If you're using the [JavaScript client](http://github.com/algolia/algoliasearch-client-js), it will result in a security breach since the user is able to modify the `tagFilters` you've set by modifying the code from the browser. To keep using the JavaScript client (recommended for optimal latency) and target secured records, you can generate a secured API key from your backend:
+You may have a single index containing per user data. In that case, all records should be tagged with their associated user_id in order to add a `tagFilters=user_42` filter at query time to retrieve only what a user has access to. If you're using the [JavaScript client](http://github.com/algolia/algoliasearch-client-js), it will result in a security breach since the user is able to modify the `tagFilters` you've set by modifying the code from the browser. To keep using the JavaScript client (recommended for optimal latency) and target secured records, you can generate a secured API key from your backend:
 
 ```ruby
 # generate a public API key for user 42. Here, records are tagged with:
-#  - 'public' if they are visible by all users
 #  - 'user_XXXX' if they are visible by user XXXX
-public_key = Algolia.generate_secured_api_key 'YourSearchOnlyApiKey', '(public,user_42)'
+public_key = Algolia.generate_secured_api_key 'YourSearchOnlyApiKey', 'tagFilters=user_42'
 ```
 
 This public API key can then be used in your JavaScript code as follow:
 
-```javascript
-<script type="text/javascript">
+```js
 var client = algoliasearch('YourApplicationID', '<%= public_api_key %>');
-client.setSecurityTags('(public,user_42)'); // must be same than those used at generation-time
+client.setExtraHeader('X-Algolia-QueryParameters', 'tagFilters=user_42'); // must be same than those used at generation-time
 
 var index = client.initIndex('indexName')
 
@@ -756,26 +770,23 @@ index.search('something', function(err, content) {
 
   console.log(content);
 });
-</script>
 ```
 
 You can mix rate limits and secured API keys by setting an extra `user_token` attribute both at API key generation time and query time. When set, a unique user will be identified by her `IP + user_token` instead of only by her `IP`. This allows you to restrict a single user to performing a maximum of `N` API calls per hour, even if she shares her `IP` with another user.
 
 ```ruby
 # generate a public API key for user 42. Here, records are tagged with:
-#  - 'public' if they are visible by all users
 #  - 'user_XXXX' if they are visible by user XXXX
-public_key = Algolia.generate_secured_api_key 'YourRateLimitedApiKey', '(public,user_42)', 'user_42'
+public_key = Algolia.generate_secured_api_key 'YourRateLimitedApiKey', 'tagFilters=user_42', 'user_42'
 ```
 
 This public API key can then be used in your JavaScript code as follow:
 
-```javascript
-<script type="text/javascript">
+```js
 var client = algoliasearch('YourApplicationID', '<%= public_api_key %>');
 
 // must be same than those used at generation-time
-client.setSecurityTags('(public,user_42)');
+client.setExtraHeader('X-Algolia-QueryParameters', 'tagFilters=user_42');
 
 // must be same than the one used at generation-time
 client.setUserToken('user_42');
@@ -790,7 +801,26 @@ index.search('another query', function(err, content) {
 
   console.log(content);
 });
-</script>
+```
+
+You can also generate secured API keys to limit the usage of a key to a referer. The generation use the same function than the Per user restriction. This public API key can be used in your JavaScript code as follow:
+
+```js
+var client = algoliasearch('YourApplicationID', '<%= public_api_key %>');
+
+// must be same than those used at generation-time
+client.setExtraHeader('X-Algolia-AllowedReferer', 'algolia.com/*');
+
+var index = client.initIndex('indexName')
+
+index.search('another query', function(err, content) {
+  if (err) {
+    console.error(err);
+    return;
+  }
+
+  console.log(content);
+});
 ```
 
 
@@ -892,4 +922,3 @@ end
 ```
 
 
-

data/lib/algolia/client.rb

@@ -65,7 +65,7 @@ module Algolia
         begin
           return perform_request(host[:session], host[:base_url] + uri, method, data)
         rescue AlgoliaProtocolError => e
-          raise if e.code == Protocol::ERROR_BAD_REQUEST or e.code == Protocol::ERROR_FORBIDDEN or e.code == Protocol::ERROR_NOT_FOUND
+          raise if e.code / 100 == 4
           exceptions << e
         rescue => e
           exceptions << e
@@ -129,7 +129,7 @@ module Algolia
       when :DELETE
         session.delete(url, { :header => @headers })
       end
-      if response.code >= 400 || response.code < 200
+      if response.code / 100 != 2
         raise AlgoliaProtocolError.new(response.code, "Cannot #{method} to #{url}: #{response.content} (#{response.code})")
       end
       return JSON.parse(response.content)
@@ -220,8 +220,9 @@ module Algolia
   # 
   # @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 Algolia.multiple_queries(queries, index_name_key = :index_name)
+  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)
@@ -229,7 +230,7 @@ module Algolia
         { :indexName => indexName, :params => Protocol.to_query(encoded_params) }
       end
     }
-    Algolia.client.post(Protocol.multiple_queries_uri, requests.to_json, :search)
+    Algolia.client.post(Protocol.multiple_queries_uri(strategy), requests.to_json, :search)
   end
 
   #
@@ -326,27 +327,47 @@ module Algolia
   #
   #  Create a new user key
   #
-  #  @param acls the list of ACL for this key. Defined by an array of strings that 
-  #         can contains the following values:
-  #           - search: allow to search (https and http)
-  #           - addObject: allows to add a new object in the index (https only)
-  #           - updateObject : allows to change content of an existing object (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 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 Algolia.add_user_key(acls, validity = 0, maxQueriesPerIPPerHour = 0, maxHitsPerQuery = 0, indexes = nil)
-    params = {
-      :acl => acls,
-      :validity => validity.to_i,
-      :maxQueriesPerIPPerHour => maxQueriesPerIPPerHour.to_i,
-      :maxHitsPerQuery => maxHitsPerQuery.to_i
-    }
+  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)
   end
@@ -354,27 +375,47 @@ module Algolia
   #
   #  Update a user key
   #
-  #  @param acls the list of ACL for this key. Defined by an array of strings that 
-  #         can contains the following values:
-  #           - search: allow to search (https and http)
-  #           - addObject: allows to add a new object in the index (https only)
-  #           - updateObject : allows to change content of an existing object (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 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 Algolia.update_user_key(key, acls, validity = 0, maxQueriesPerIPPerHour = 0, maxHitsPerQuery = 0, indexes = nil)
-    params = {
-      :acl => acls,
-      :validity => validity.to_i,
-      :maxQueriesPerIPPerHour => maxQueriesPerIPPerHour.to_i,
-      :maxHitsPerQuery => maxHitsPerQuery.to_i
-    }
+  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)
   end
@@ -385,6 +426,19 @@ module Algolia
       Algolia.client.delete(Protocol.key_uri(key))
   end
 
+  # Send a batch request targeting multiple indices
+  def Algolia.batch(requests)
+    Algolia.client.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 Algolia.batch!(requests)
+    res = batch(requests)
+    res['taskID'].each { |index, taskID|
+      Algolia::Index.new(index).wait_task(taskID)
+    }
+  end
+
   # Used mostly for testing. Lets you delete the api key global vars.
   def Algolia.destroy
     @@client = Thread.current[:algolia_hosts] = Thread.current[:algolia_search_hosts] = nil

data/lib/algolia/index.rb

@@ -432,37 +432,91 @@ module Algolia
     #
     #  Create a new user key
     #
-    #  @param acls the list of ACL for this key. Defined by an array of strings that 
-    #         can contains the following values:
-    #           - search: allow to search (https and http)
-    #           - addObject: allows to add a new object in the index (https only)
-    #           - updateObject : allows to change content of an existing object (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 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
+    #          - 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)
     #
-    def add_user_key(acls, validity = 0, maxQueriesPerIPPerHour = 0, maxHitsPerQuery = 0)
-      Algolia.client.post(Protocol.index_keys_uri(name), {:acl => acls, :validity => validity, :maxQueriesPerIPPerHour => maxQueriesPerIPPerHour.to_i, :maxHitsPerQuery => maxHitsPerQuery.to_i}.to_json)
+    def add_user_key(obj, validity = 0, maxQueriesPerIPPerHour = 0, maxHitsPerQuery = 0)
+      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
+      Algolia.client.post(Protocol.index_keys_uri(name), params.to_json)
     end
 
     #
     #  Update a user key
     #
-    #  @param acls the list of ACL for this key. Defined by an array of strings that 
-    #         can contains the following values:
-    #           - search: allow to search (https and http)
-    #           - addObject: allows to add a new object in the index (https only)
-    #           - updateObject : allows to change content of an existing object (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 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
+    #          - 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)
     #
-    def update_user_key(key, acls, validity = 0, maxQueriesPerIPPerHour = 0, maxHitsPerQuery = 0)
-      Algolia.client.put(Protocol.index_key_uri(name, key), {:acl => acls, :validity => validity, :maxQueriesPerIPPerHour => maxQueriesPerIPPerHour.to_i, :maxHitsPerQuery => maxHitsPerQuery.to_i}.to_json)
+    def update_user_key(key, obj, validity = 0, maxQueriesPerIPPerHour = 0, maxHitsPerQuery = 0)
+      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
+      Algolia.client.put(Protocol.index_key_uri(name, key), params.to_json)
     end
 
  

data/lib/algolia/protocol.rb

@@ -39,8 +39,8 @@ module Algolia
       "/#{VERSION}/indexes"
     end
 
-    def Protocol.multiple_queries_uri
-      "/#{VERSION}/indexes/*/queries"
+    def Protocol.multiple_queries_uri(strategy = "none")
+      "/#{VERSION}/indexes/*/queries?strategy=#{strategy}"
     end
 
     def Protocol.objects_uri
@@ -52,9 +52,9 @@ module Algolia
       "/#{VERSION}/indexes/#{CGI.escape(index)}"
     end
 
-    def Protocol.batch_uri(index)
-      "#{index_uri(index)}/batch"
-    end
+    def Protocol.batch_uri(index = nil)
+      "#{index.nil? ? "/#{VERSION}/indexes/*" : index_uri(index)}/batch"
+    end  
     
     def Protocol.index_operation_uri(index)
       "#{index_uri(index)}/operation"

data/lib/algolia/version.rb

@@ -1,3 +1,3 @@
 module Algolia
-  VERSION = "1.4.1"
+  VERSION = "1.4.2"
 end

data/spec/client_spec.rb

@@ -737,5 +737,17 @@ describe 'Client' do
       index.delete_index
     end
   end
+
+  
+
+  it "should send a custom batch" do
+    batch = [
+      {:action => "addObject", :indexName => @index.name, :body => { :objectID => "11", :email => "john@be.org" }},
+      {:action => "addObject", :indexName => @index.name, :body => { :objectID => "22", :email => "robert@be.org" }}
+    ]
+    Algolia.batch!(batch)
+    res = @index.search("@be.org")
+    res["hits"].length.should eq(2)
+  end
 end
 

metadata

@@ -1,83 +1,83 @@
 --- !ruby/object:Gem::Specification
 name: algoliasearch
 version: !ruby/object:Gem::Version
-  version: 1.4.1
+  version: 1.4.2
 platform: ruby
 authors:
 - Algolia
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-04-10 00:00:00.000000000 Z
+date: 2015-05-04 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,12 +121,12 @@ 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: []