algoliasearch 1.11.0 → 1.12.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2a37e65bca2bf7c296add2c0f0187ab5bd33eedb
-  data.tar.gz: 7889a0cce2a6470260c3616ca71fda9022084792
+  metadata.gz: 47343e37f75fab97f3f03b5077d1422376a0995f
+  data.tar.gz: d0c473b3587f99c0b64410fea213dd73f4e83ae9
 SHA512:
-  metadata.gz: db44fe908876413039e4efb0a447f9fbf7b95a3cbd11e0401d1bb53500e13d4d6b133772bb7b589c96b4de08f178a50443f101285df47a8e917c6b21c8a8d79a
-  data.tar.gz: 04f539db59d6de73e6d088b19b80a2182d1f931c5649e0c6af5fc4e968bd4fc698e4a9797c88a1041e1b0dc843a0a9c599892441893645330a605a07c7bdf230
+  metadata.gz: 2c853a919b2dc0a269b28890fa431576dd55424776c77a784dab5bf4e0c536456f9ad1fb67e3a0378ba6f45c3c832f5b018e104866ec5ee731010550c5ffc347
+  data.tar.gz: 5e12669bdc370347f622652079fe882ed836ae6726fe123cc8d2ddfc8b80c6a1a395525dc5ae96fc33a55f4896fc37f0e0f746d1b550773979c5480cf44c4d28

data/.travis.yml

@@ -11,6 +11,9 @@ rvm:
 - 2.3.1
 - jruby
 - rbx-2
+matrix:
+  allow_failures:
+  - rvm: rbx-2
 cache: bundler
 env:
   global:

data/ChangeLog

@@ -1,5 +1,8 @@
 CHANGELOG
 
+2016-10-31 1.12.0
+      * Add `search_facet`
+
 2016-08-21 1.11.0
       * Upgraded to httpclient 2.8.1 to avoid reseting the keep-alive while changing timeouts
 

data/Gemfile

@@ -1,6 +1,6 @@
 source 'https://rubygems.org'
 
-gem 'httpclient', '~> 2.8.2'
+gem 'httpclient', '~> 2.8.2.4'
 gem 'json', '>= 1.5.1'
 gem 'rubysl', '~> 2.0', :platform => :rbx
 

data/Gemfile.lock

@@ -31,7 +31,7 @@ GEM
       net-http-persistent (>= 2.7)
       net-http-pipeline
     highline (1.6.21)
-    httpclient (2.8.2.2)
+    httpclient (2.8.2.4)
     json (1.8.3)
     json (1.8.3-java)
     launchy (2.4.3)
@@ -311,7 +311,7 @@ PLATFORMS
 DEPENDENCIES
   coveralls
   highline (< 1.7.0)
-  httpclient (~> 2.8.2)
+  httpclient (~> 2.8.2.4)
   json (>= 1.5.1)
   mime-types (< 2.0)
   rake
@@ -323,6 +323,3 @@ DEPENDENCIES
   simplecov
   travis
   webmock
-
-BUNDLED WITH
-   1.11.2

data/README.md

@@ -48,7 +48,7 @@ Indexing
 
 1. [Add objects](#add-objects---add_objects)
 1. [Update objects](#update-objects---save_objects)
-1. [Partial update](#partial-update---partial_update_objects)
+1. [Partial update objects](#partial-update-objects---partial_update_objects)
 1. [Delete objects](#delete-objects---delete_objects)
 
 Settings
@@ -196,7 +196,7 @@ index.set_settings({"customRanking" => ["desc(followers)"]})
 You can also configure the list of attributes you want to index by order of importance (first = most important):
 
 ```ruby
-index.set_settings({"attributesToIndex" => ["lastname", "firstname", "company", 
+index.set_settings({"searchableAttributes" => ["lastname", "firstname", "company", 
                                             "email", "city", "address"]})
 ```
 
@@ -358,17 +358,17 @@ The server response will look like:
 
 - `nbHits` (integer): Number of hits that the search query matched.
 
-- `page` (integer): Index of the current page (zero-based). See the [`page`](#page) search parameter.
+- `page` (integer): Index of the current page (zero-based). See the [`page`](#page) search parameter. *Note: Not returned if you use `offset`/`length` for pagination.*
 
-- `hitsPerPage` (integer): Maximum number of hits returned per page. See the [`hitsPerPage`](#hitsperpage) search parameter.
+- `hitsPerPage` (integer): Maximum number of hits returned per page. See the [`hitsPerPage`](#hitsperpage) search parameter. *Note: Not returned if you use `offset`/`length` for pagination.*
 
-- `nbPages` (integer): Number of pages corresponding to the number of hits. Basically, `ceil(nbHits / hitsPerPage)`.
+- `nbPages` (integer): Number of pages corresponding to the number of hits. Basically, `ceil(nbHits / hitsPerPage)`. *Note: Not returned if you use `offset`/`length` for pagination.*
 
 - `processingTimeMS` (integer): Time that the server took to process the request, in milliseconds. *Note: This does not include network time.*
 
 - `query` (string): An echo of the query text. See the [`query`](#query) search parameter.
 
-- `queryAfterRemoval` (string, optional): *Note: Only returned when [`removeWordsIfNoResults`](#removewordsifnoresults) is set.* A markup text indicating which parts of the original query have been removed in order to retrieve a non-empty result set. The removed parts are surrounded by `<em>` tags.
+- `queryAfterRemoval` (string, optional): *Note: Only returned when [`removeWordsIfNoResults`](#removewordsifnoresults) is set to `lastWords` or `firstWords`.* A markup text indicating which parts of the original query have been removed in order to retrieve a non-empty result set. The removed parts are surrounded by `<em>` tags.
 
 - `params` (string, URL-encoded): An echo of all search parameters.
 
@@ -382,7 +382,7 @@ When [`getRankingInfo`](#getrankinginfo) is set to `true`, the following additio
 
 - `serverUsed` (string): Actual host name of the server that processed the request. (Our DNS supports automatic failover and load balancing, so this may differ from the host name used in the request.)
 
-- `parsedQuery` (string): The query string that will be searched, after normalization.
+- `parsedQuery` (string): The query string that will be searched, after normalization. Normalization includes removing stop words (if [removeStopWords](#removestopwords) is enabled), and transforming portions of the query string into phrase queries (see [advancedSyntax](#advancedsyntax)).
 
 - `timeoutCounts` (boolean): Whether a timeout was hit when computing the facet counts. When `true`, the counts will be interpolated (i.e. approximate). See also `exhaustiveFacetsCount`.
 
@@ -426,6 +426,7 @@ Parameters that can also be used in a setSettings also have the `indexing` [scop
 **Attributes**
 
 - [attributesToRetrieve](#attributestoretrieve) `settings`, `search`
+- [restrictSearchableAttributes](#restrictsearchableattributes) `search`
 
 **Filtering / Faceting**
 
@@ -440,11 +441,14 @@ Parameters that can also be used in a setSettings also have the `indexing` [scop
 - [highlightPreTag](#highlightpretag) `settings`, `search`
 - [highlightPostTag](#highlightposttag) `settings`, `search`
 - [snippetEllipsisText](#snippetellipsistext) `settings`, `search`
+- [restrictHighlightAndSnippetArrays](#restricthighlightandsnippetarrays) `settings`, `search`
 
 **Pagination**
 
 - [page](#page) `search`
 - [hitsPerPage](#hitsperpage) `settings`, `search`
+- [offset](#offset) `search`
+- [length](#length) `search`
 
 **Typos**
 
@@ -472,6 +476,7 @@ Parameters that can also be used in a setSettings also have the `indexing` [scop
 - [advancedSyntax](#advancedsyntax) `settings`, `search`
 - [optionalWords](#optionalwords) `settings`, `search`
 - [removeStopWords](#removestopwords) `settings`, `search`
+- [disableExactOnAttributes](#disableexactonattributes) `settings`, `search`
 - [exactOnSingleWordQuery](#exactonsinglewordquery) `settings`, `search`
 - [alternativesAsExact](#alternativesasexact) `settings`, `search`
 
@@ -483,9 +488,47 @@ Parameters that can also be used in a setSettings also have the `indexing` [scop
 - [tagFilters (deprecated)](#tagfilters-deprecated) `search`
 - [facetFilters (deprecated)](#facetfilters-deprecated) `search`
 - [analytics](#analytics) `search`
+- [analyticsTags](#analyticstags) `search`
+- [synonyms](#synonyms) `search`
+- [replaceSynonymsInHighlight](#replacesynonymsinhighlight) `search`, `settings`
+- [minProximity](#minproximity) `search`, `settings`
 
 <!--/PARAMETERS_LINK-->
 
+### Multiple queries - `multiple_queries`
+
+You can send multiple queries with a single API call using a batch of queries:
+
+```ruby
+# perform 3 queries in a single API call:
+# - 1st query targets index `categories`
+# - 2nd and 3rd queries target index `products`
+res = Algolia.multiple_queries([{:index_name => "categories", "query" => my_query_string, "hitsPerPage" => 3}
+  , {:index_name => "products", "query" => my_query_string, "hitsPerPage" => 3, "filters" => "_tags:promotion"}
+  , {:index_name => "products", "query" => my_query_string, "hitsPerPage" => 10}])
+
+puts res["results"]
+```
+
+You can specify a `strategy` parameter 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.
+
+#### Response
+
+The resulting JSON contains the following fields:
+
+- `results` (array): The results for each request, in the order they were submitted. The contents are the same as in [Search in an index](#search-in-an-index---search).
+
+    Each result also includes the following additional fields:
+
+    - `index` (string): The name of the targeted index.
+
+    - `processed` (boolean, optional): *Note: Only returned when `strategy` is `stopIfEnoughmatches`.* Whether the query was processed.
+
+
+
 ### Find by IDs - `get_objects`
 
 You can easily retrieve an object using its `objectID` and optionally specify a comma separated list of attributes you want:
@@ -516,21 +559,33 @@ res = index.get_objects(["myID", "myID2"])
 
 Each entry in an index has a unique identifier called `objectID`. There are two ways to add an entry to the index:
 
- 1. Using automatic `objectID` assignment. You will be able to access it in the answer.
- 2. Supplying your own `objectID`.
+ 1. Supplying your own `objectID`.
+ 2. Using automatic `objectID` assignment. You will be able to access it in the answer.
 
 You don't need to explicitly create an index, it will be automatically created the first time you add an object.
 Objects are schema less so you don't need any configuration to start indexing. If you wish to configure things, the settings section provides details about advanced settings.
 
-Example with automatic `objectID` assignment:
+Example with automatic `objectID` assignments:
 
 ```ruby
-res = index.add_object({"firstname" => "Jimmie", 
-                        "lastname" => "Barninger"})
-puts "ObjectID=" + res["objectID"]
+res = index.add_objects([{"firstname" => "Jimmie", 
+                          "lastname" => "Barninger"},
+                         {"firstname" => "Warren", 
+                          "lastname" => "Speach"}])
 ```
 
-Example with manual `objectID` assignment:
+Example with manual `objectID` assignments:
+
+```ruby
+res = index.add_objects([{"objectID" => "1",
+                          "firstname" => "Jimmie",
+                          "lastname" => "Barninger"},
+                         {"objectID" => "2",
+                          "firstname" => "Warren",
+                          "lastname" => "Speach"}])
+```
+
+To add a single object, use the `[Add object](#add-object---add_object)` method:
 
 ```ruby
 res = index.add_object({"firstname" => "Jimmie", 
@@ -538,7 +593,6 @@ res = index.add_object({"firstname" => "Jimmie",
 puts "ObjectID=" + res["objectID"]
 ```
 
-
 ### Update objects - `save_objects`
 
 You have three options when updating an existing object:
@@ -547,7 +601,18 @@ You have three options when updating an existing object:
  2. Replace only some attributes.
  3. Apply an operation to some attributes.
 
-Example on how to replace all attributes of an existing object:
+Example on how to replace all attributes existing objects:
+
+```ruby
+res = index.save_objects([{"firstname" => "Jimmie", 
+                          "lastname" => "Barninger",
+                           "objectID" => "myID1"},
+                          {"firstname" => "Warren", 
+                          "lastname" => "Speach",
+                           "objectID" => "myID2"}])
+```
+
+To update a single object, you can use the `[Update object](#update-object---save_object) method:
 
 ```ruby
 index.save_object({"firstname" => "Jimmie", 
@@ -556,7 +621,8 @@ index.save_object({"firstname" => "Jimmie",
                    "objectID" => "myID"})
 ```
 
-### Partial update - `partial_update_objects`
+
+### Partial update objects - `partial_update_objects`
 
 You have many ways to update an object's attributes:
 
@@ -615,10 +681,25 @@ index.partial_update_object({"price" => {"value" => 42, "_operation" => "Decreme
 Note: Here we are decrementing the value by `42`. To decrement just by one, put
 `value:1`.
 
+To partial update multiple objects using one API call, you can use the `[Partial update objects](#partial-update-objects---partial_update_objects)` method:
+
+```ruby
+res = index.partial_update_objects([{"firstname" => "Jimmie", 
+                                     "objectID" => "SFO"},
+                                    {"firstname" => "Warren", 
+                                     "objectID" => "myID2"}])
+```
+
 
 ### Delete objects - `delete_objects`
 
-You can delete an object using its `objectID`:
+You can delete objects using their `objectID`:
+
+```ruby
+res = index.delete_objects(["myID1", "myID2"])
+```
+
+To delete a single object, you can use the `[Delete object](#delete-object---delete_object)` method:
 
 ```ruby
 index.delete_object("myID")
@@ -668,7 +749,7 @@ the biggest `taskID` with `wait_task`.
 You can retrieve settings:
 
 ```ruby
-res = index.get_settings
+settings = index.get_settings
 puts settings.to_json
 ```
 
@@ -682,12 +763,12 @@ index.set_settings({"customRanking" => ["desc(followers)"]})
 
 Performance wise, it's better to do a `set_settings` before pushing the data
 
-#### Slave settings
+#### Replica settings
 
-You can forward all settings updates to the slaves of an index by using the `forwardToSlaves` option:
+You can forward all settings updates to the replicas of an index by using the `forwardToReplicas` option:
 
 ```ruby
-index.set_settings({"customRanking" => ["desc(followers)"]}, {"forwardToSlave" => true})
+index.set_settings({"customRanking" => ["desc(followers)"]}, {"forwardToReplicas" => true})
 ```
 
 
@@ -696,14 +777,14 @@ index.set_settings({"customRanking" => ["desc(followers)"]}, {"forwardToSlave" =
 
 <!--PARAMETERS_LINK-->
 
-Here is the list of parameters you can use with the set settings method (`indexing` [scope](#scope))
+Here is the list of parameters you can use with the set settings method (`settings` [scope](#scope)).
 
 
-Parameters that can be overridden at search time also have the `search` [scope](#scope)
+Parameters that can be overridden at search time also have the `search` [scope](#scope).
 
 **Attributes**
 
-- [attributesToIndex](#attributestoindex) `settings`
+- [searchableAttributes](#searchableattributes) `settings`
 - [attributesForFaceting](#attributesforfaceting) `settings`
 - [attributesToRetrieve](#attributestoretrieve) `settings`, `search`
 - [unretrievableAttributes](#unretrievableattributes) `settings`
@@ -712,7 +793,7 @@ Parameters that can be overridden at search time also have the `search` [scope](
 
 - [ranking](#ranking) `settings`
 - [customRanking](#customranking) `settings`
-- [slaves](#slaves) `settings`
+- [replicas](#replicas) `settings`
 
 **Filtering / Faceting**
 
@@ -756,7 +837,7 @@ Parameters that can be overridden at search time also have the `search` [scope](
 
 - [attributeForDistinct](#attributefordistinct) `settings`
 - [distinct](#distinct) `settings`, `search`
-- [numericAttributesToIndex](#numericattributestoindex) `settings`
+- [numericAttributesForFiltering](#numericattributesforfiltering) `settings`
 - [allowCompressionOfIntegerArray](#allowcompressionofintegerarray) `settings`
 - [altCorrections](#altcorrections) `settings`
 - [placeholders](#placeholders) `settings`
@@ -788,17 +869,17 @@ They are three scopes:
 
 **Attributes**
 
+- [searchableAttributes](#searchableattributes) `settings`
 - [attributesForFaceting](#attributesforfaceting) `settings`
-- [attributesToIndex](#attributestoindex) `settings`
-- [attributesToRetrieve](#attributestoretrieve) `settings`, `search`
 - [unretrievableAttributes](#unretrievableattributes) `settings`
-
+- [attributesToRetrieve](#attributestoretrieve) `settings`, `search`
+- [restrictSearchableAttributes](#restrictsearchableattributes) `search`
 
 **Ranking**
 
 - [ranking](#ranking) `settings`
 - [customRanking](#customranking) `settings`
-- [slaves](#slaves) `settings`
+- [replicas](#replicas) `settings`
 
 **Filtering / Faceting**
 
@@ -819,6 +900,8 @@ They are three scopes:
 
 - [page](#page) `search`
 - [hitsPerPage](#hitsperpage) `settings`, `search`
+- [offset](#offset) `search`
+- [length](#length) `search`
 
 **Typos**
 
@@ -857,14 +940,18 @@ They are three scopes:
 - [attributeForDistinct](#attributefordistinct) `settings`
 - [distinct](#distinct) `settings`, `search`
 - [getRankingInfo](#getrankinginfo) `search`
-- [numericAttributesToIndex](#numericattributestoindex) `settings`
+- [numericAttributesForFiltering](#numericattributesforfiltering) `settings`
 - [allowCompressionOfIntegerArray](#allowcompressionofintegerarray) `settings`
 - [numericFilters (deprecated)](#numericfilters-deprecated) `search`
 - [tagFilters (deprecated)](#tagfilters-deprecated) `search`
 - [facetFilters (deprecated)](#facetfilters-deprecated) `search`
 - [analytics](#analytics) `search`
-- [altCorrections](#altcorrections) `settings`
+- [analyticsTags](#analyticstags) `search`
+- [synonyms](#synonyms) `search`
+- [replaceSynonymsInHighlight](#replacesynonymsinhighlight) `search`, `settings`
 - [placeholders](#placeholders) `settings`
+- [altCorrections](#altcorrections) `settings`
+- [minProximity](#minproximity) `search`, `settings`
 
 ### Search
 
@@ -879,11 +966,12 @@ The instant search query string, used to set the string you want to search in yo
 
 ### Attributes
 
-#### attributesToIndex
+#### searchableAttributes
 
 - scope: `settings`
 - type: `array of strings`
 - default: `*`
+- formerly known as: `attributesToIndex`
 
 
 The list of attributes you want index (i.e. to make searchable).
@@ -895,7 +983,7 @@ This parameter has two important uses:
 
 1. **Limit the attributes to index.** For example, if you store the URL of a picture, you want to store it and be able to retrieve it, but you probably don't want to search in the URL.
 
-2. **Control part of the ranking.** The contents of the `attributesToIndex` parameter impacts ranking in two complementary ways:
+2. **Control part of the ranking.** The contents of the `searchableAttributes` parameter impacts ranking in two complementary ways:
 
     First, the order in which attributes are listed defines their ranking priority: matches in attributes at the beginning of the list will be considered more important than matches in attributes further down the list. To assign the same priority to several attributes, pass them within the same string, separated by commas. For example, by specifying `["title,"alternative_title", "text"]`, `title` and `alternative_title` will have the same priority, but a higher priority than `text`.
 
@@ -950,13 +1038,13 @@ You can also use `*` to retrieve all values when an **attributesToRetrieve** set
 
 - scope: `search`
 - type: `array of strings`
-- default: `attributesToIndex`
+- default: `searchableAttributes`
 
 
-List of attributes you want to use for textual search (must be a subset of the `attributesToIndex` index setting).
+List of attributes you want to use for textual search (must be a subset of the `searchableAttributes` index setting).
 Attributes are separated with a comma such as `"name,address"`.
 You can also use JSON string array encoding such as `encodeURIComponent("[\"name\",\"address\"]")`.
-By default, all attributes specified in the `attributesToIndex` settings are used to search.
+By default, all attributes specified in the `searchableAttributes` settings are used to search.
 
 
 ### Ranking
@@ -976,7 +1064,7 @@ We have nine available criterion:
 * `geo`: Sort according to decreasing distance when performing a geo location based search.
 * `words`: Sort according to the number of query words matched by decreasing order. This parameter is useful when you use the `optionalWords` query parameter to have results with the most matched words first.
 * `proximity`: Sort according to the proximity of the query words in hits.
-* `attribute`: Sort according to the order of attributes defined by attributesToIndex.
+* `attribute`: Sort according to the order of attributes defined by searchableAttributes.
 * `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 TV show "V", you want to find it with the "V" query and avoid getting all popular TV shows starting by the letter V before it.
   * If the user query contains multiple words: sort according to the number of words that matched exactly (not as a prefix).
@@ -1004,11 +1092,12 @@ For example, `"customRanking" => ["desc(population)", "asc(name)"]`.
 To get a full description of how the Custom Ranking works,
 you can have a look at our [Ranking guide](https://www.algolia.com/doc/guides/relevance/ranking).
 
-#### slaves
+#### replicas
 
 - scope: `settings`
 - type: `array of strings`
 - default: `[]`
+- formerly known as: `slaves`
 
 
 The list of indices on which you want to replicate all write operations.
@@ -1019,7 +1108,7 @@ If you want to use different ranking configurations depending of the use case,
 you need to create one index per ranking configuration.
 
 This option enables you to perform write operations only on this index and automatically
-update slave indices with the same operations.
+update replica indices with the same operations.
 
 ### Filtering / Faceting
 
@@ -1105,6 +1194,10 @@ Limit the number of facet values returned for each facet.
 
 For example, `maxValuesPerFacet=10` will retrieve a maximum of 10 values per facet.
 
+**Warnings**
+
+- The engine has a hard limit on the `maxValuesPerFacet` of `1000`. Any value above that will be interpreted by the engine as being `1000`.
+
 ### Highlighting / Snippeting
 
 #### attributesToHighlight
@@ -1204,6 +1297,28 @@ Pagination parameter used to select the page to retrieve.
 
 Pagination parameter used to select the number of hits per page.
 
+#### offset
+
+- scope: `search`
+- type: `integer`
+- default: `null`
+
+
+Offset of the first hit to return (zero-based).
+
+**Warning:** In most cases, `page`/`hitsPerPage` is the recommended method for pagination; `offset`/`length` is reserved for advanced use.
+
+#### length
+
+- scope: `search`
+- type: `integer`
+- default: `null`
+
+
+Number of hits to return.
+
+**Warning:** In most cases, `page`/`hitsPerPage` is the recommended method for pagination; `offset`/`length` is reserved for advanced use.
+
 ### Typos
 
 #### minWordSizefor1Typo
@@ -1265,7 +1380,7 @@ If set to true, plural won't be considered as a typo. For example, car and cars,
 
 
 List of attributes on which you want to disable typo tolerance
-(must be a subset of the `attributesToIndex` index setting).
+(must be a subset of the `searchableAttributes` index setting).
 
 Attributes are separated with a comma such as `"name,address"`.
 You can also use JSON string array encoding such as `encodeURIComponent("[\"name\",\"address\"]")`.
@@ -1523,7 +1638,7 @@ For most use cases, it is better to not use this feature as people search by key
 
 
 List of attributes on which you want to disable prefix matching
-(must be a subset of the `attributesToIndex` index setting).
+(must be a subset of the `searchableAttributes` index setting).
 
 This setting is useful on attributes that contain string that should not be matched as a prefix
 (for example a product SKU).
@@ -1537,7 +1652,7 @@ This setting is useful on attributes that contain string that should not be matc
 
 
 List of attributes on which you want to disable the computation of `exact` criteria
-(must be a subset of the `attributesToIndex` index setting).
+(must be a subset of the `searchableAttributes` index setting).
 
 #### exactOnSingleWordQuery
 
@@ -1617,11 +1732,12 @@ you can have a look at our [guide on distinct](https://www.algolia.com/doc/searc
 If set to true,
 the result hits will contain ranking information in the **_rankingInfo** attribute.
 
-#### numericAttributesToIndex
+#### numericAttributesForFiltering
 
 - scope: `settings`
 - type: `array of strings`
 - default: ``
+- formerly known as: `numericAttributesToIndex`
 
 
 All numerical attributes are automatically indexed as numerical filters
@@ -1727,6 +1843,33 @@ For example, `[["category:Book","category:Movie"],"author:John%20Doe"]`.
 
 If set to false, this query will not be taken into account in the analytics feature.
 
+#### analyticsTags
+
+- scope: `search`
+- type: `array of strings`
+- default: `null`
+
+
+If set, tag your query with the specified identifiers. Tags can then be used in the Analytics to analyze a subset of searches only.
+
+#### synonyms
+
+- scope: `search`
+- type: `boolean`
+- default: `true`
+
+
+If set to `false`, the search will not use the synonyms defined for the targeted index.
+
+#### replaceSynonymsInHighlight
+
+- scope: `search`, `settings`
+- type: `boolean`
+- default: `true`
+
+
+If set to `false`, words matched via synonym expansion will not be replaced by the matched synonym in the highlighted result.
+
 #### placeholders
 
 - scope: `settings`
@@ -1774,6 +1917,19 @@ For example:
 ]
 ```
 
+#### minProximity
+
+- scope: `search`, `settings`
+- type: `integer`
+- default: `1`
+
+
+Configure the precision of the `proximity` ranking criterion. By default, the minimum (and best) proximity value distance between 2 matching words is 1. Setting it to 2 (or 3) would allow 1 (or 2) words to be found between the matching words without degrading the proximity ranking value.
+
+Considering the query *“javascript framework”*, if you set `minProximity=2`, the records *“JavaScript framework”* and *“JavaScript charting framework”* will get the same proximity score, even if the second contains a word between the two matching words.
+
+**Note:** the maximum `minProximity` that can be set is 7. Any higher value will disable the `proximity` criterion from the ranking formula.
+
 
 ## Manage Indices
 
@@ -1845,7 +2001,7 @@ The move_index method will overwrite the destination index, and delete the tempo
 **Warning**
 
 The move_index operation will override all settings of the destination,
-There is one exception for the [slaves](#slaves) parameter which is not impacted.
+There is one exception for the [replicas](#replicas) parameter which is not impacted.
 
 For example, if you want to fully update your index `MyIndex` every night, we recommend the following process:
 
@@ -1853,13 +2009,13 @@ For example, if you want to fully update your index `MyIndex` every night, we re
   and [Get synonym](#get-synonym---get_synonym).
  1. Apply settings and synonyms to the temporary index `MyTmpIndex`, (this will create the `MyTmpIndex` index)
   using [Set settings](#set-settings---set_settings) and [Batch synonyms](#batch-synonyms---batch_synonyms)
-  (make sure to remove the [slaves](#slaves) parameter from the settings if it exists).
+  (make sure to remove the [replicas](#replicas) parameter from the settings if it exists).
  1. Import your records into a new index using [Add objects](#add-objects---add_objects).
  1. Atomically replace the index `MyIndex` with the content and settings of the index `MyTmpIndex`
  using the [Move index](#move-index---move_index) method.
  This will automatically override the old index without any downtime on the search.
  1. You'll end up with only one index called `MyIndex`, that contains the records and settings pushed to `MyTmpIndex`
- and the slave-indices that were initially attached to `MyIndex` will be in sync with the new data.
+ and the replica-indices that were initially attached to `MyIndex` will be in sync with the new data.
 
 
 
@@ -1868,22 +2024,57 @@ For example, if you want to fully update your index `MyIndex` every night, we re
 
 ## Api Keys
 
-The **admin** API key provides full control of all your indices. *The admin API key should always be kept secure; do NOT use it from outside your back-end.*
+### Overview
+
+When creating your Algolia Account, you'll notice there are 3 different API Keys:
+
+- **Admin API Key** - it provides full control of all your indices.
+*The admin API key should always be kept secure;
+do NOT give it to anybody; do NOT use it from outside your back-end as it will
+allow the person who has it to query/change/delete data*
+
+- **Search-Only API Key** - It allows you to search on every indices.
+
+- **Monitoring API Key** - It allows you to access the [Monitoring API](https://www.algolia.com/doc/rest-api/monitoring)
+
+#### Other types of API keys
+
+The *Admin API Key* and *Search-Only API Key* both have really large scope and sometimes you want to give a key to
+someone that have restricted permissions, can it be an index, a rate limit, a validity limit, ...
+
+To address those use-cases we have two differents type of keys:
 
-You can also generate user API keys to control security.
-These API keys can be restricted to a set of operations or/and restricted to a given index.
+- **Secured API Keys**
+
+When you need to restrict the scope of the *Search Key*, we recommend to use *Secured API Key*.
+You can generate them on the fly (without any call to the API)
+from the *Search Only API Key* or any search *User Key* using the [Generate key](#generate-key---generate_secured_api_key) method
+
+- **User API Keys**
+
+If *Secured API Keys* does not meet your requirements, you can make use of *User keys*.
+Managing and especially creating those keys requires a call to the API.
+
+We have several methods to manage them:
+- [Add user key](#add-user-key---add_user_key)
+- [Update user key](#update-user-key---update_user_key)
+- [Delete user key](#delete-user-key---delete_user_key)
+- [List api keys](#list-api-keys---list_api_keys)
+- [Get key permissions](#get-key-permissions---get_user_key_acl)
 
 ### Generate key - `generate_secured_api_key`
 
-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:
+When you need to restrict the scope of the *Search Key*, we recommend to use *Secured API Key*.
+You can generate a *Secured API Key* from the *Search Only API Key* or any search *User API Key*
 
-```ruby
-# generate a public API key for user 42. Here, records are tagged with:
-#  - 'user_XXXX' if they are visible by user XXXX
-public_key = Algolia.generate_secured_api_key 'YourSearchOnlyApiKey', {'filters'=> '_tags:user_42'}
-```
+There is a few things to know about about *Secured API Keys*
+- They always need to be generated **on your backend** using one of our API Client 
+- You can generate them on the fly (without any call to the API)
+- They will not appear on the dashboard as they are generated without any call to the API
+- The key you use to generate it **needs to become private** and you should not use it in your frontend.
+- The generated secured API key **will inherit any restriction from the search key it has been generated from**
 
-This public API key can then be used in your JavaScript code as follow:
+You can then use the key in your frontend code
 
 ```js
 var client = algoliasearch('YourApplicationID', '<%= public_api_key %>');
@@ -1900,29 +2091,84 @@ index.search('something', function(err, content) {
 });
 ```
 
-You can mix rate limits and secured API keys by setting a `userToken` query parameter at API key generation 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.
+#### Filters
+
+Every filter set in the API key will always be applied. On top of that [filters](#filters) can be applied
+in the query parameters.
 
 ```ruby
 # generate a public API key for user 42. Here, records are tagged with:
 #  - 'user_XXXX' if they are visible by user XXXX
-public_key = Algolia.generate_secured_api_key 'YourSearchOnlyApiKey', {'filters'=> '_tags:user_42', 'userToken'=> 'user_42'}
+public_key = Algolia.generate_secured_api_key 'YourSearchOnlyApiKey', {'filters'=> '_tags:user_42'}
 ```
 
-This public API key can then be used in your JavaScript code as follow:
+**Warning**:
 
-```js
-var client = algoliasearch('YourApplicationID', '<%= public_api_key %>');
+If you set filters in the key `groups:admin`, and `groups:press OR groups:visitors` in the query parameters,
+this will be equivalent to `groups:admin AND (groups:press OR groups:visitors)`
 
-var index = client.initIndex('indexName')
+##### Having one API Key per User
 
-index.search('another query', function(err, content) {
-  if (err) {
-    console.error(err);
-    return;
-  }
+One of the usage of secured API keys, is to have allow users to see only part of an index, when this index
+contains the data of all users.
+In that case, you can tag all records with their associated `user_id` in order to add a `user_id=42` filter when
+generating the *Secured API Key* to retrieve only what a user is tagged in.
 
-  console.log(content);
-});
+**Warning**
+If you're generating *Secured API Keys* using the [JavaScript client](http://github.com/algolia/algoliasearch-client-js) in your frontend,
+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.
+
+#### Valid Until
+
+You can set a Unix timestamp used to define the expiration date of the API key
+
+```ruby
+# generate a public API key that is valid for 1 hour:
+valid_until = Time.now.to_i + 3600
+public_key = Algolia.generate_secured_api_key 'YourSearchOnlyApiKey', {'validUntil'=> valid_until}
+```
+
+#### Index Restriction
+
+You can restrict the key to a list of index names allowed for the secured API key
+
+```ruby
+# generate a public API key that is restricted to 'index1' and 'index2':
+public_key = Algolia.generate_secured_api_key 'YourSearchOnlyApiKey', {'restrictIndices'=> 'index1,index2'}
+```
+
+#### Rate Limiting
+
+If you want to rate limit a secured API Key, the API key you generate the secured api key from need to be rate-limited.
+You can do that either via the dashboard or via the API using the
+[Add user key](#add-user-key---add_user_key) or [Update user key](#update-user-key---update_user_key) method
+
+##### User Rate Limiting
+
+By default the rate limits will only use the `IP`.
+
+This can be an issue when several of your end users are using the same IP.
+To avoid that, you can set a `userToken` query parameter when generating the key.
+
+When set, a unique user will be identified by his `IP + user_token` instead of only by his `IP`.
+
+This allows you to restrict a single user to performing a maximum of `N` API calls per hour,
+even if he shares his `IP` with another user.
+
+```ruby
+# generate a public API key for user 42. Here, records are tagged with:
+#  - 'user_XXXX' if they are visible by user XXXX
+public_key = Algolia.generate_secured_api_key 'YourSearchOnlyApiKey', {'filters'=> '_tags:user_42', 'userToken'=> 'user_42'}
+```
+
+#### Network restriction
+
+For more protection against API key leaking and reuse you can restrict the key to be valid only from specific IPv4 networks
+
+```ruby
+# generate a public API key that is restricted to '192.168.1.0/24':
+public_key = Algolia.generate_secured_api_key 'YourSearchOnlyApiKey', {'restrictSources'=> '192.168.1.0/24'}
 ```
 
 
@@ -1935,7 +2181,7 @@ index.search('another query', function(err, content) {
 
 This method saves a single synonym record into the index.
 
-In this example, we specify true to forward the creation to slave indices.
+In this example, we specify true to forward the creation to replica indices.
 By default the behavior is to save only on the specified index.
 
 ```ruby
@@ -1949,7 +2195,7 @@ index.save_synonym('a-unique-identifier', {
 ### Batch synonyms - `batch_synonyms`
 
 Use the batch method to create a large number of synonyms at once,
-forward them to slave indices if desired,
+forward them to replica indices if desired,
 and optionally replace all existing synonyms
 on the index with the content of the batch using the replaceExistingSynonyms parameter.
 
@@ -1958,7 +2204,7 @@ on a production index. This is the only way to ensure the index always
 has a full list of synonyms to use during the indexing of the new list.
 
 ```ruby
-# Batch synonyms, with slave forwarding and atomic replacement of existing synonyms
+# Batch synonyms, with replica forwarding and atomic replacement of existing synonyms
 index.batch_synonyms([{
   :objectID => 'a-unique-identifier',
   :type => 'synonym',
@@ -1985,10 +2231,10 @@ in the batch update.
 
 Use the normal index delete method to delete synonyms,
 specifying the objectID of the synonym record you want to delete.
-Forward the deletion to slave indices by setting the forwardToSlaves parameter to true.
+Forward the deletion to replica indices by setting the forwardToReplicas parameter to true.
 
 ```ruby
-# Delete and forward to slaves
+# Delete and forward to replicas
 index.delete_synonym('a-unique-identifier', true)
 ```
 
@@ -2003,7 +2249,7 @@ To atomically replace all synonyms of an index,
 use the batch method with the replaceExistingSynonyms parameter set to true.
 
 ```ruby
-# Clear synonyms and forward to slaves
+# Clear synonyms and forward to replicas
 index.clear_synonyms(true)
 ```
 
@@ -2042,47 +2288,6 @@ results = index.search_synonyms('street', {
 ### Custom batch - `batch`
 
 You may want to perform multiple operations with one API call to reduce latency.
-We expose four methods to perform batch operations:
-
-* Add objects - `add_objects`: Add an array of objects using automatic `objectID` assignment.
-* Update objects - `save_objects`: Add or update an array of objects that contains an `objectID` attribute.
-* Delete objects - `delete_objects`: Delete an array of objectIDs.
-* Partial update - `partial_update_objects`: Partially update an array of objects that contain an `objectID` attribute (only specified attributes will be updated).
-
-Example using automatic `objectID` assignment:
-
-```ruby
-res = index.add_objects([{"firstname" => "Jimmie", 
-                          "lastname" => "Barninger"},
-                         {"firstname" => "Warren", 
-                          "lastname" => "Speach"}])
-```
-
-Example with user defined `objectID` (add or update):
-
-```ruby
-res = index.save_objects([{"firstname" => "Jimmie", 
-                          "lastname" => "Barninger",
-                           "objectID" => "myID1"},
-                          {"firstname" => "Warren", 
-                          "lastname" => "Speach",
-                           "objectID" => "myID2"}])
-```
-
-Example that deletes a set of records:
-
-```ruby
-res = index.delete_objects(["myID1", "myID2"])
-```
-
-Example that updates only the `firstname` attribute:
-
-```ruby
-res = index.partial_update_objects([{"firstname" => "Jimmie", 
-                                     "objectID" => "SFO"},
-                                    {"firstname" => "Warren", 
-                                     "objectID" => "myID2"}])
-```
 
 
 
@@ -2400,41 +2605,6 @@ Algolia.get_user_key("f420238212c54dcfad07ea0aa6d5c45f")
 index.get_user_key("71671c38001bf3ac857bc82052485107")
 ```
 
-### Multiple queries - `multiple_queries`
-
-You can send multiple queries with a single API call using a batch of queries:
-
-```ruby
-# perform 3 queries in a single API call:
-# - 1st query targets index `categories`
-# - 2nd and 3rd queries target index `products`
-res = Algolia.multiple_queries([{:index_name => "categories", "query" => my_query_string, "hitsPerPage" => 3}
-  , {:index_name => "products", "query" => my_query_string, "hitsPerPage" => 3, "filters" => "_tags:promotion"}
-  , {:index_name => "products", "query" => my_query_string, "hitsPerPage" => 10}])
-
-puts res["results"]
-```
-
-You can specify a `strategy` parameter 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.
-
-#### Response
-
-The resulting JSON contains the following fields:
-
-- `results` (array): The results for each request, in the order they were submitted. The contents are the same as in [Search in an index](#search-in-an-index---search).
-
-    Each result also includes the following additional fields:
-
-    - `index` (string): The name of the targeted index.
-
-    - `processed` (boolean, optional): *Note: Only returned when `strategy` is `stopIfEnoughmatches`.* Whether the query was processed.
-
-
-
-
 ### Get Logs - `get_logs`
 
 You can retrieve the latest logs via this API. Each log entry contains:

data/algoliasearch.gemspec

@@ -50,17 +50,17 @@ Gem::Specification.new do |s|
     s.specification_version = 4
 
     if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
-      s.add_runtime_dependency(%q<httpclient>, ["~> 2.8.2"])
+      s.add_runtime_dependency(%q<httpclient>, ["~> 2.8.2.4"])
       s.add_runtime_dependency(%q<json>, [">= 1.5.1"])
       s.add_development_dependency "travis"
       s.add_development_dependency "rake"
       s.add_development_dependency "rdoc"
     else
-      s.add_dependency(%q<httpclient>, ["~> 2.8.2"])
+      s.add_dependency(%q<httpclient>, ["~> 2.8.2.4"])
       s.add_dependency(%q<json>, [">= 1.5.1"])
     end
   else
-    s.add_dependency(%q<httpclient>, ["~> 2.8.2"])
+    s.add_dependency(%q<httpclient>, ["~> 2.8.2.4"])
     s.add_dependency(%q<json>, [">= 1.5.1"])
   end
 end

data/lib/algolia/client.rb

@@ -349,6 +349,7 @@ module Algolia
         rescue => e
           exceptions << e
         end
+        host[:session].reset_all
       end
       raise AlgoliaProtocolError.new(0, "Cannot reach any host: #{exceptions.map { |e| e.to_s }.join(', ')}")
     end

data/lib/algolia/index.rb

@@ -208,9 +208,10 @@ module Algolia
     # 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 ","
+    # @param attributesToRetrieve (optional) if set, contains the list of attributes to retrieve as an array of strings of a string separated by ","
     #
     def get_object(objectID, attributesToRetrieve = nil)
+      attributesToRetrieve = attributesToRetrieve.join(',') if attributesToRetrieve.is_a?(Array)
       if attributesToRetrieve.nil?
         client.get(Protocol.object_uri(name, objectID, nil), :read)
       else
@@ -222,9 +223,16 @@ module Algolia
     # Get a list of objects from this index
     #
     # @param objectIDs the array of unique identifier of the objects to retrieve
-    #
-    def get_objects(objectIDs)
-      client.post(Protocol.objects_uri, { :requests => objectIDs.map { |objectID| { :indexName => name, :objectID => objectID } } }.to_json, :read)['results']
+    # @param attributesToRetrieve (optional) if set, contains the list of attributes to retrieve as an array of strings of a string separated by ","
+    #
+    def get_objects(objectIDs, attributesToRetrieve = nil)
+      attributesToRetrieve = attributesToRetrieve.join(',') if attributesToRetrieve.is_a?(Array)
+      requests = objectIDs.map do |objectID|
+        req = {:indexName => name, :objectID => objectID.to_s}
+        req[:attributesToRetrieve] = attributesToRetrieve unless attributesToRetrieve.nil?
+        req
+      end
+      client.post(Protocol.objects_uri, { :requests => requests }.to_json, :read)['results']
     end
 
     # Wait the publication of a task on the server.
@@ -555,6 +563,20 @@ module Algolia
       res
     end
 
+    # Search in facets
+    #
+    # @param facet Name of the facet to search. It must have been declared in the
+    #       index's`attributesForFaceting` setting with the `searchable()` modifier.
+    # @param text Text to search for in the facet's values
+    # @param query An optional query to take extra search parameters into account.
+    #       These parameters apply to index objects like in a regular search query.
+    #       Only facet values contained in the matched objects will be returned.
+    def search_facet(facet, text, query = {})
+      params = query.clone
+      params['facetQuery'] = text
+      client.post(Protocol.search_facet_uri(name, facet), params.to_json)
+    end
+
     # Perform a search with disjunctive facets generating as many queries as number of disjunctive facets
     #
     # @param query the query
@@ -675,17 +697,17 @@ module Algolia
     # Delete a synonym
     #
     # @param objectID the synonym objectID
-    # @param forward_to_slaves should we forward the delete to slave indices
-    def delete_synonym(objectID, forward_to_slaves = false)
-      client.delete("#{Protocol.synonym_uri(name, objectID)}?forwardToSlaves=#{forward_to_slaves}", :write)
+    # @param forward_to_replicas should we forward the delete to replica indices
+    def delete_synonym(objectID, forward_to_replicas = false)
+      client.delete("#{Protocol.synonym_uri(name, objectID)}?forwardToReplicas=#{forward_to_replicas}", :write)
     end
 
     # Delete a synonym and wait the end of indexing
     #
     # @param objectID the synonym objectID
-    # @param forward_to_slaves should we forward the delete to slave indices
-    def delete_synonym!(objectID, forward_to_slaves = false)
-      res = delete_synonym(objectID, forward_to_slaves)
+    # @param forward_to_replicas should we forward the delete to replica indices
+    def delete_synonym!(objectID, forward_to_replicas = false)
+      res = delete_synonym(objectID, forward_to_replicas)
       wait_task(res["taskID"])
       return res
     end
@@ -694,34 +716,34 @@ module Algolia
     #
     # @param objectID the synonym objectID
     # @param synonym the synonym
-    # @param forward_to_slaves should we forward the delete to slave indices
-    def save_synonym(objectID, synonym, forward_to_slaves = false)
-      client.put("#{Protocol.synonym_uri(name, objectID)}?forwardToSlaves=#{forward_to_slaves}", synonym.to_json, :write)
+    # @param forward_to_replicas should we forward the delete to replica indices
+    def save_synonym(objectID, synonym, forward_to_replicas = false)
+      client.put("#{Protocol.synonym_uri(name, objectID)}?forwardToReplicas=#{forward_to_replicas}", synonym.to_json, :write)
     end
 
     # Save a synonym and wait the end of indexing
     #
     # @param objectID the synonym objectID
     # @param synonym the synonym
-    # @param forward_to_slaves should we forward the delete to slave indices
-    def save_synonym!(objectID, synonym, forward_to_slaves = false)
-      res = save_synonym(objectID, synonym, forward_to_slaves)
+    # @param forward_to_replicas should we forward the delete to replica indices
+    def save_synonym!(objectID, synonym, forward_to_replicas = false)
+      res = save_synonym(objectID, synonym, forward_to_replicas)
       wait_task(res["taskID"])
       return res
     end
 
     # Clear all synonyms
     #
-    # @param forward_to_slaves should we forward the delete to slave indices
-    def clear_synonyms(forward_to_slaves = false)
-      client.post("#{Protocol.clear_synonyms_uri(name)}?forwardToSlaves=#{forward_to_slaves}", :write)
+    # @param forward_to_replicas should we forward the delete to replica indices
+    def clear_synonyms(forward_to_replicas = false)
+      client.post("#{Protocol.clear_synonyms_uri(name)}?forwardToReplicas=#{forward_to_replicas}", :write)
     end
 
     # Clear all synonyms and wait the end of indexing
     #
-    # @param forward_to_slaves should we forward the delete to slave indices
-    def clear_synonyms!(forward_to_slaves = false)
-      res = clear_synonyms(forward_to_slaves)
+    # @param forward_to_replicas should we forward the delete to replica indices
+    def clear_synonyms!(forward_to_replicas = false)
+      res = clear_synonyms(forward_to_replicas)
       wait_task(res["taskID"])
       return res
     end
@@ -729,19 +751,19 @@ module Algolia
     # Add/Update an array of synonyms
     #
     # @param synonyms the array of synonyms to add/update
-    # @param forward_to_slaves should we forward the delete to slave indices
+    # @param forward_to_replicas should we forward the delete to replica indices
     # @param replace_existing_synonyms should we replace the existing synonyms before adding the new ones
-    def batch_synonyms(synonyms, forward_to_slaves = false, replace_existing_synonyms = false)
-      client.post("#{Protocol.batch_synonyms_uri(name)}?forwardToSlaves=#{forward_to_slaves}&replaceExistingSynonyms=#{replace_existing_synonyms}", synonyms.to_json, :batch)
+    def batch_synonyms(synonyms, forward_to_replicas = false, replace_existing_synonyms = false)
+      client.post("#{Protocol.batch_synonyms_uri(name)}?forwardToReplicas=#{forward_to_replicas}&replaceExistingSynonyms=#{replace_existing_synonyms}", synonyms.to_json, :batch)
     end
 
     # Add/Update an array of synonyms and wait the end of indexing
     #
     # @param synonyms the array of synonyms to add/update
-    # @param forward_to_slaves should we forward the delete to slave indices
+    # @param forward_to_replicas should we forward the delete to replica indices
     # @param replace_existing_synonyms should we replace the existing synonyms before adding the new ones
-    def batch_synonyms!(synonyms, forward_to_slaves = false, replace_existing_synonyms = false)
-      res = batch_synonyms(synonyms, forward_to_slaves, replace_existing_synonyms)
+    def batch_synonyms!(synonyms, forward_to_replicas = false, replace_existing_synonyms = false)
+      res = batch_synonyms(synonyms, forward_to_replicas, replace_existing_synonyms)
       wait_task(res["taskID"])
       return res
     end

data/lib/algolia/protocol.rb

@@ -83,6 +83,10 @@ module Algolia
       "#{index_uri(index)}/browse#{params}"
     end
 
+    def Protocol.search_facet_uri(index, facet)
+      "#{index_uri(index)}/facets/#{facet}/query"
+    end
+
     def Protocol.partial_object_uri(index, object_id, create_if_not_exits = true)
       params = create_if_not_exits ? "" : "?createIfNotExists=false"
       "#{index_uri(index)}/#{CGI.escape(object_id)}/partial#{params}"

data/lib/algolia/version.rb

@@ -1,3 +1,3 @@
 module Algolia
-  VERSION = "1.11.0"
+  VERSION = "1.12.0"
 end

data/spec/client_spec.rb

@@ -187,6 +187,26 @@ describe 'Client' do
     objects.size.should eq(2)
   end
 
+  it "should restrict attributesToRetrieve" do
+    @index.clear_index
+    @index.add_object({:firstname => "Robert", :lastname => "foo", :objectID => 1})
+    @index.add_object!({:firstname => "Robert2", :lastname => "bar", :objectID => 2})
+    objects = @index.get_objects([1, 2], ['firstname'])
+    objects.size.should eq(2)
+    objects[0].should eq({"firstname"=>"Robert", "objectID"=>"1"})
+    objects[1].should eq({"firstname"=>"Robert2", "objectID"=>"2"})
+
+    objects = @index.get_objects([1, 2], [:firstname])
+    objects.size.should eq(2)
+    objects[0].should eq({"firstname"=>"Robert", "objectID"=>"1"})
+    objects[1].should eq({"firstname"=>"Robert2", "objectID"=>"2"})
+
+    objects = @index.get_objects(["1", "2"], 'firstname,lastname')
+    objects.size.should eq(2)
+    objects[0].should eq({"firstname"=>"Robert", "lastname"=>"foo", "objectID"=>"1"})
+    objects[1].should eq({"firstname"=>"Robert2", "lastname"=>"bar", "objectID"=>"2"})
+  end
+
   it "should delete the object" do
     @index.clear
     @index.add_object!({:firstname => "Robert"})
@@ -769,6 +789,64 @@ describe 'Client' do
     res['results'][0]['params'].should be_a(String)
   end
 
+  it 'should handle facet search' do
+    objects = {
+      :snoopy => {
+        :objectID => '1',
+        'name' => 'Snoopy',
+        :kind => ['dog', 'animal'],
+        :born => 1950,
+        :series => 'Peanuts'
+      },
+      :woodstock => {
+        :objectID => '2',
+        :name => 'Woodstock',
+        :kind => ['bird', 'animal'],
+        :born => 1960,
+        :series => 'Peanuts'
+      },
+      :charlie => {
+        :objectID => '3',
+        :name => 'Charlie Brown',
+        :kind => ['human'],
+        :born => 1950,
+        :series => 'Peanuts'
+      },
+      :hobbes => {
+        :objectID => '4',
+        :name => 'Hobbes',
+        :kind => ['tiger', 'animal', 'teddy'],
+        :born => 1985,
+        :series => 'Calvin & Hobbes'
+      },
+      :calvin => {
+        :objectID => '5',
+        :name => 'Calvin',
+        :kind => ['human'],
+        :born => 1985,
+        :series => 'Calvin & Hobbes'
+      }
+    }
+
+    index = Algolia::Index.new(safe_index_name('test_facet_search'))
+    index.set_settings({
+      :attributesForFaceting => [
+        'searchable(series)',
+        'kind'
+      ]
+    })
+    index.add_objects! objects.values
+
+    query = {
+      :facetFilters => ['kind:animal'],
+      :numericFilters => ['born >= 1955']
+    }
+    answer = index.search_facet 'series', 'Peanutz', query
+    expect(answer['facetHits'].size).to eq(1)
+    expect(answer['facetHits'].first['value']).to eq('Peanuts')
+    expect(answer['facetHits'].first['count']).to eq(1)
+  end
+
   it 'should handle disjunctive faceting' do
     index = Algolia::Index.new(safe_index_name("test_hotels"))
     index.set_settings :attributesForFacetting => ['city', 'stars', 'facilities']

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: algoliasearch
 version: !ruby/object:Gem::Version
-  version: 1.11.0
+  version: 1.12.0
 platform: ruby
 authors:
 - Algolia
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-08-21 00:00:00.000000000 Z
+date: 2016-10-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: httpclient
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.8.2
+        version: 2.8.2.4
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.8.2
+        version: 2.8.2.4
 - !ruby/object:Gem::Dependency
   name: json
   requirement: !ruby/object:Gem::Requirement