algoliasearch 1.2.9 → 1.2.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3c2d37bc8e01bf59c2a23fd08ec86229e6b37f95
-  data.tar.gz: f2890ed7e2c1103ca6004ac91792c4c0ac3d62ac
+  metadata.gz: df5a732fe0627231c87d9015404183714d411ca8
+  data.tar.gz: 3c90c3e9c12cafa3cb37d254acf723c3a210f48b
 SHA512:
-  metadata.gz: a83669bc6eedf16e80419534844ad6a654a9e8fb675800e5f68393689c205a77187a2c00fd1c82755d9ef68d4147be666a6c5a0fa97bafea9c0fbddc7b0de161
-  data.tar.gz: dee9c83ce0c9246f667663f1e683efda2f3e5c81476c61f3e75760438ccd6af3ab3fd77814a8149a5f1f9034f8fc59f467d9e3eefe0a7ebb015d11f62888a74d
+  metadata.gz: c3a164a8ca1699b0f34801431985fd475a1440ca04de278cf81fe7640b5bebd44a5ee86b92a0e60a967f0e777f51e06afac3a689381581a9aa71d0cd5f101f50
+  data.tar.gz: e51c1cd7aef502ee8ea4d6eecff24e22be7ef957590d008df148225590857eb797ec27de59b8c4741798adcd0fe90897c5535c0c870836ad0e705616f64195c7

data/.travis.yml

@@ -9,7 +9,9 @@ rvm:
 - 1.9.3
 - jruby
 - rbx-2
+install:
+- bundle install
 env:
   global:
-  - secure: lBLtTjQyeJW7+TWgGmf1mmsXgUzsTnq3/KHvCk+BvOGwoHXTBR1Y6yiczWWHEP4/wBeXXm31xUQC+VoYc/7Ev/2NNB/mqlXAgGw+D0nwQriNXjYt1WV6lQvyoiaUzQ+w+7VahWdx0LuKvSYI+khe8M8BfHQqYacu0VlpAUnjb2I=
-  - secure: mtXQd2Tre01/I2e2MtD0Nu0nocKL9bLozN3v0qZdACpwSwAE1lr8EmAGIZUJp/FbqISOXcjMTmnjvhqp+gw6SE7pdO7vzzzuoJUVi50IrasoBFV97S+lX091n4D4/BDnP906qeA+/1apcIFwk4+8SNgrsIUcZui2eMjP3YunM4g=
+  - secure: OFKp0J81VrKXfpQZWkwSfsG/knN4tr45yDAGekFy4FKcA6Ra6EqDUzcY1MVrkKq9YRUgLJRfjgqF3Ei0cm2qMo1dy5XUG/fY8upTVdQK2Nm1qfbjnh70+vnYpHidHg9pEI8QROwsM7n19QoT16j1af4UinGFE/HBiJpuXcABuLw=
+  - secure: Jkc/DnS1knCf0fO3qUxaExoEPEEuTFcmJGP/DkOZ5tnMSro8pjgzXIIzMaQSoRO4B7Hv0o7NzNTqNV6/KgB3jLlsj4dQtjkTnZ21Uk0sah5wZpWyC6QhtuIv1yA2utIsNLygU9WDoyD+V9EwuYrLNone1zSGIclAjlPO4xCYo6E=

data/ChangeLog

@@ -1,7 +1,12 @@
 CHANGELOG
 
-2014-07-08  1.2.9
+2014-08-22  1.2.10
 
+      * Using Digest to remove "Digest::Digest is deprecated; Use Digest" warning (author: @dglancy)
+
+2014-07-10  1.2.9
+
+      * Expose connect_timeout, receive_timeout and send_timeout
       * Add new 'delete_by_query' method to delete all objects matching a specific query
       * Add new 'get_objects' method to retrieve a list of objects from a single API call
       * Add a helper to perform disjunctive faceting

data/README.md

@@ -3,8 +3,6 @@ Algolia Search API Client for Ruby
 
 
 
-
-
 [Algolia Search](http://www.algolia.com) is a search API that provides hosted full-text, numerical and faceted search.
 Algolia’s Search API makes it easy to deliver a great search experience in your apps & websites providing:
 
@@ -19,18 +17,18 @@ Algolia’s Search API makes it easy to deliver a great search experience in you
 
 This Ruby client let you easily use the Algolia Search API from your backend. It wraps [Algolia's REST API](http://www.algolia.com/doc/rest_api).
 
-
 [![Build Status](https://travis-ci.org/algolia/algoliasearch-client-ruby.png?branch=master)](https://travis-ci.org/algolia/algoliasearch-client-ruby) [![Gem Version](https://badge.fury.io/rb/algoliasearch.png)](http://badge.fury.io/rb/algoliasearch) [![Code Climate](https://codeclimate.com/github/algolia/algoliasearch-client-ruby.png)](https://codeclimate.com/github/algolia/algoliasearch-client-ruby) [![Coverage Status](https://coveralls.io/repos/algolia/algoliasearch-client-ruby/badge.png)](https://coveralls.io/r/algolia/algoliasearch-client-ruby)
 
 
 
 Table of Content
--------------
+================
 **Get started**
 
 1. [Setup](#setup)
 1. [Quick Start](#quick-start)
-1. [Online documentation](#online-documentation)
+1. [Online documentation](#documentation)
+1. [Tutorials](#tutorials)
 
 **Commands reference**
 
@@ -39,8 +37,9 @@ Table of Content
 1. [Search](#search)
 1. [Get an object](#get-an-object)
 1. [Delete an object](#delete-an-object)
+1. [Delete by query](#delete-by-query)
 1. [Index settings](#index-settings)
-1. [List indexes](#list-indexes)
+1. [List indices](#list-indices)
 1. [Delete an index](#delete-an-index)
 1. [Clear an index](#clear-an-index)
 1. [Wait indexing](#wait-indexing)
@@ -74,6 +73,10 @@ Algolia.init :application_id => "YourApplicationID",
 
 
 
+
+
+
+
 Quick Start
 -------------
 
@@ -116,27 +119,63 @@ puts index.search('jim').to_json
 ```
 
 
+**Notes:** If you are building a web application, you may be more interested in using our [JavaScript client](https://github.com/algolia/algoliasearch-client-js) to perform queries. It brings two benefits:
+  * your users get a better response time by avoiding to go through your servers,
+  * it will offload your servers of unnecessary tasks.
+
+```html
+<script type="text/javascript" src="//path/to/algoliasearch.min.js"></script>
+<script type="text/javascript">
+  var client = new AlgoliaSearch("YourApplicationID", "YourSearchOnlyAPIKey");
+  var index = client.initIndex('YourIndexName');
 
+  function searchCallback(success, content) {
+    if (success) {
+      console.log(content);
+    }
+  }
 
-Online Documentation
-----------------
+  // perform query "jim"
+  index.search("jim", searchCallback);
 
-Check our [online documentation](http://www.algolia.com/doc):
- * [Initial Import](http://www.algolia.com/doc#InitialImport)
- * [Ranking &amp; Relevance](http://www.algolia.com/doc#RankingRelevance)
- * [Settings](http://www.algolia.com/doc#Settings)
- * [Search](http://www.algolia.com/doc#Search)
- * [Incremental Updates](http://www.algolia.com/doc#IncrementalUpdates)
- * [Reindexing](http://www.algolia.com/doc#Reindexing)
- * [Numeric-Search](http://www.algolia.com/doc#Numeric-Search)
- * [Category-Search](http://www.algolia.com/doc#Category-Search)
- * [Faceting](http://www.algolia.com/doc#Faceting)
- * [Geo-Search](http://www.algolia.com/doc#Geo-Search)
- * [Security](http://www.algolia.com/doc#Security)
- * [Indexing Several Types](http://www.algolia.com/doc#IndexingSeveralTypes)
+  // the last optional argument can be used to add search parameters
+  index.search("jim", searchCallback, { hitsPerPage: 5, facets: '*', maxValuesPerFacet: 10 });
+</script>
+```
+
+
+
+
+
+
+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)
+ * [Indexing](http://www.algolia.com/doc/guides/ruby#Indexing)
+ * [Search](http://www.algolia.com/doc/guides/ruby#Search)
+ * [Sorting](http://www.algolia.com/doc/guides/ruby#Sorting)
+ * [Filtering](http://www.algolia.com/doc/guides/ruby#Filtering)
+ * [Faceting](http://www.algolia.com/doc/guides/ruby#Faceting)
+ * [Geo-Search](http://www.algolia.com/doc/guides/ruby#Geo-Search)
+ * [Security](http://www.algolia.com/doc/guides/ruby#Security)
  * [REST API](http://www.algolia.com/doc/rest)
 
 
+Tutorials
+================
+
+Check our [tutorials](http://www.algolia.com/doc/tutorials):
+ * [Searchbar with auto-completion](http://www.algolia.com/doc/tutorials/auto-complete)
+ * [Searchbar with multi-categories auto-completion](http://www.algolia.com/doc/tutorials/multi-auto-complete)
+ * [Instant-search](http://www.algolia.com/doc/tutorials/instant-search)
+
+
+
+Commands reference
+==================
 
 
 
@@ -197,7 +236,11 @@ index.partial_update_object({"city" => "San Francisco",
 
 Search
 -------------
- **Opening note:** If you are building a web application, you may be more interested in using our [javascript client](https://github.com/algolia/algoliasearch-client-js) to send queries. It brings two benefits: (i) your users get a better response time by avoiding to go through your servers, and (ii) it will offload your servers of unnecessary tasks.
+
+**Opening note:** If you are building a web application, you may be more interested in using our [javascript client](https://github.com/algolia/algoliasearch-client-js) to send queries. It brings two benefits:
+  * your users get a better response time by avoiding to go through your servers,
+  * and it will offload your servers of unnecessary tasks.
+
 
 To perform a search, you just need to initialize the index and perform a call to the search function.
 
@@ -212,10 +255,15 @@ You can use the following optional arguments:
   * **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.
+ * **removeWordsIfNoResult**: This option to select a strategy to avoid having an empty result page. There is three different option:
+  * **LastWords**: when a query does not return any result, the final word will be removed until there is results,
+  * **FirstWords**: when a query does not return any result, the first word will be removed until there is results,
+  * **None**: No specific processing is done when a query does not return any result (default behavior).
  * **typoTolerance**: if set to false, disable the typo-tolerance. Defaults to true.
  * **minWordSizefor1Typo**: the minimum number of characters in a query word to accept one typo in this word.<br/>Defaults to 3.
  * **minWordSizefor2Typos**: the minimum number of characters in a query word to accept two typos in this word.<br/>Defaults to 7.
  * **allowTyposOnNumericTokens**: if set to false, disable typo-tolerance on numeric tokens (numbers). Default to true.
+ * **restrictSearchableAttributes** List of attributes you want to use for textual search (must be a subset of the `attributesToIndex` index setting). Attributes are separated with a comma (for example `"name,address"`), you can also use a JSON string array encoding (for example encodeURIComponent("[\"name\",\"address\"]")). By default, all attributes specified in `attributesToIndex` settings are used to search.
  * **advancedSyntax**: Enable the advanced query syntax. Defaults to 0 (false).
     * **Phrase query**: a phrase query defines a particular sequence of terms. A phrase query is build by Algolia's query parser for words surrounded by `"`. For example, `"search engine"` will retrieve records having `search` next to `engine` only. Typo-tolerance is _disabled_ on phrase queries.
     * **Prohibit operator**: The prohibit operator excludes records that contain the term after the `-` symbol. For example `search -engine` will retrieve records containing `search` but not `engine`.
@@ -232,6 +280,10 @@ You can use the following optional arguments:
 #### Geo-search parameters
 
  * **aroundLatLng**: search for entries around a given latitude/longitude (specified as two floats separated by a comma).<br/>For example `aroundLatLng=47.316669,5.016670`).<br/>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).<br/>At indexing, you should specify geoloc of an object with the `_geoloc` attribute (in the form `{"_geoloc":{"lat":48.853409, "lng":2.348800}}`)
+
+ * **aroundLatLngViaIP**: search for entries around a given latitude/longitude (automatically computed from user IP address).<br/>For example `aroundLatLng=47.316669,5.016670`).<br/>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).<br/>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).<br/>For example `insideBoundingBox=47.3165,4.9665,47.3424,5.0201`).<br/>At indexing, you should specify geoloc of an object with the _geoloc attribute (in the form `{"_geoloc":{"lat":48.853409, "lng":2.348800}}`)
 
 #### Parameters to control results content
@@ -246,7 +298,7 @@ You can use the following optional arguments:
  
 
 #### Numeric search parameters
- * **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 `>=`. 
+ * **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 easily perform range queries via the `:` operator (equivalent to combining a `>=` and `<=` operand), for example `numericFilters=price:10 to 1000`.
 
@@ -255,7 +307,7 @@ You can also mix OR and AND operators. The OR operator is defined with a parenth
 You can also use a string array encoding (for example `numericFilters: ["price>100","price<1000"]`).
 
 #### Category search parameters
- * **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)*.<br/>At indexing, tags should be added in the **_tags** attribute of objects (for example `{"_tags":["tag1","tag2"]}`). 
+ * **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)*.<br/>At indexing, tags should be added in the **_tags** attribute of objects (for example `{"_tags":["tag1","tag2"]}`).
 
 #### Faceting parameters
  * **facetFilters**: filter the query by a list of facets. Facets are separated by commas and each facet is encoded as `attributeName:value`. To OR facets, you must add parentheses. For example: `facetFilters=(category:Book,category:Movie),author:John%20Doe`. You can also use a string array encoding (for example `[["category:Book","category:Movie"],"author:John%20Doe"]`).
@@ -308,6 +360,24 @@ The server response will look like:
 ```
 
 
+Multi-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, "tagFilters" => "promotion"}
+  , {:index_name => "products", "query" => my_query_string, "hitsPerPage" => 10}])
+
+puts res["results"]
+```
+
+
+
 
 
 
@@ -325,6 +395,12 @@ res = index.get_object("myID", "firstname,lastname")
 res = index.get_object("myID", "fistname")
 ```
 
+You can also retrieve a set of objects:
+
+```ruby
+res = index.get_objects(["myID", "myID2"])
+```
+
 Delete an object
 -------------
 
@@ -334,6 +410,18 @@ You can delete an object using its `objectID`:
 index.delete_object("myID")
 ```
 
+
+Delete by query
+-------------
+
+You can delete all objects matching a single query with the following code. Internally, the API client performs the query, delete all matching hits, wait until the deletions have been applied and so on.
+
+```ruby
+params = {}
+index.delete_by_query("John", params)
+```
+
+
 Index Settings
 -------------
 
@@ -344,27 +432,29 @@ 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, but you should 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 comma as 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"]`
  * **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 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. **Note**: This feature is disabled if the query string is empty and there isn't any `tagFilters`, nor any `facetFilters`, nor any `numericFilters` parameters.
- * **ranking**: (array of strings) controls the way results are sorted.<br/>We have nine available criteria: 
+ * **ranking**: (array of strings) controls the way results are sorted.<br/>We have nine available criteria:
   * **typo**: sort according to number of typos,
   * **geo**: sort according to decreassing 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 `optionalWords` query parameter to have results with the most matched words first.
   * **proximity**: sort according to the proximity of query words in hits,
   * **attribute**: sort according to the order of attributes defined by attributesToIndex,
-  * **exact**: 
+  * **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.
   * **asc(attributeName)**: sort according to a numeric attribute by ascending order. **attributeName** can be the name of any numeric attribute of your records (integer, a double or boolean).
   * **desc(attributeName)**: sort according to a numeric attribute by descending order. **attributeName** can be the name of any numeric attribute of your records (integer, a double or boolean). <br/>The standard order is ["typo", "geo", "words", "proximity", "attribute", "exact", "custom"]
  * **customRanking**: (array of strings) lets you specify part of the ranking.<br/>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),
   * **prefixNone**: no query word is interpreted as a prefix. This option is not recommended.
- * **slaves**: The list of indexes on which you want to replicate all write operations. In order to get response times in milliseconds, we pre-compute part of the ranking during indexing. 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 to automatically update slave indexes with the same operations.
+ * **slaves**: The list of indices on which you want to replicate all write operations. In order to get response times in milliseconds, we pre-compute part of the ranking during indexing. 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 to automatically update slave indices with the same operations.
 
 #### Query expansion
  * **synonyms**: (array of array of words considered as equals). For example, you may want to retrieve your **black ipad** record when your users are searching for **dark ipad**, even if the **dark** word is not part of the record: so you need to configure **black** as a synonym of **dark**. For example `"synomyms": [ [ "black", "dark" ], [ "small", "little", "mini" ], ... ]`.
@@ -401,9 +491,9 @@ puts settings.to_json
 index.set_settings({"customRanking" => ["desc(followers)"]})
 ```
 
-List indexes
+List indices
 -------------
-You can list all your indexes with their associated information (number of entries, disk size, etc.) with the `list_indexes` method:
+You can list all your indices with their associated information (number of entries, disk size, etc.) with the `list_indexes` method:
 
 ```ruby
 Algolia.list_indexes
@@ -429,7 +519,7 @@ index.clear_index
 Wait indexing
 -------------
 
-All write operations return a `taskID` when the job is securely stored on our infrastructure but not when the job is published in your index. Even if it's extremely fast, you can easily ensure indexing is complete using  the same method with a `!`. 
+All write operations return a `taskID` when the job is securely stored on our infrastructure but not when the job is published in your index. Even if it's extremely fast, you can easily ensure indexing is complete using  the same method with a `!`.
 
 For example, to wait for indexing of a new object:
 ```ruby
@@ -486,8 +576,8 @@ res = index.partial_update_objects([{"firstname" => "Jimmie",
 Security / User API Keys
 -------------
 
-The admin API key provides full control of all your indexes. 
-You can also generate user API keys to control security. 
+The admin API key provides full control of all your indices.
+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.
 
 To list existing keys, you can use `list_user_keys` method:
@@ -526,7 +616,7 @@ You can also create an API Key with advanced restrictions:
   Note: If you are sending the query through your servers, you must use the `Algolia.with_rate_limits("EndUserIP", "APIKeyWithRateLimit") do ... end` block to enable rate-limit.
 
  * 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 content by massively querying the index.
- * Specify the list of targeted indexes. Defaults to all indexes if empty of blank.
+ * Specify the list of targeted indices, you can target all indices starting by a prefix or finishing by a suffix with the '*' character (for example "dev_*" matches all indices starting by "dev_" and "*_dev" matches all indices finishing by "_dev"). Defaults to all indices if empty of blank.
 
 ```ruby
 # Creates a new global API key that is valid for 300 seconds
@@ -629,7 +719,7 @@ puts Algolia.move_index("MyNewIndex", "MyIndex")
 Backup / Retrieve all index content
 -------------
 
-You can retrieve all index content for backup purpose or for analytics using the browse method. 
+You can retrieve all index content for backup purpose or for analytics using the browse method.
 This method retrieve 1000 objects by API call and support pagination.
 
 ```ruby
@@ -642,7 +732,7 @@ puts index.browse(1)
 Logs
 -------------
 
-You can retrieve the last logs via this API. Each log entry contains: 
+You can retrieve the last logs via this API. Each log entry contains:
  * Timestamp in ISO-8601 format
  * Client IP
  * Request Headers (API-Key is obfuscated)

data/algoliasearch.gemspec

@@ -6,12 +6,12 @@
 
 Gem::Specification.new do |s|
   s.name = "algoliasearch"
-  s.version = "1.2.9"
+  s.version = "1.2.10"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.require_paths = ["lib"]
   s.authors = ["Algolia"]
-  s.date = "2014-07-08"
+  s.date = "2014-08-22"
   s.description = "A simple Ruby client for the algolia.com REST API"
   s.email = "contact@algolia.com"
   s.extra_rdoc_files = [

data/lib/algolia/client.rb

@@ -10,7 +10,7 @@ module Algolia
   # A class which encapsulates the HTTPS communication with the Algolia
   # API server. Uses the HTTPClient library for low-level HTTP communication.
   class Client
-    attr_reader :ssl, :hosts, :application_id, :api_key, :headers, :connect_timeout, :send_timeout, :receive_timeout
+    attr_reader :ssl, :hosts, :application_id, :api_key, :headers, :connect_timeout, :send_timeout, :receive_timeout, :search_timeout
 
 
     def initialize(data = {})
@@ -21,6 +21,7 @@ module Algolia
       @connect_timeout = data[:connect_timeout]
       @send_timeout    = data[:send_timeout]
       @receive_timeout = data[:receive_timeout]
+      @search_timeout  = data[:search_timeout]
       @headers = {
         Protocol::HEADER_API_KEY => api_key,
         Protocol::HEADER_APP_ID  => application_id,
@@ -33,11 +34,11 @@ module Algolia
     # with common basic response handling. Will raise a
     # AlgoliaProtocolError if the response has an error status code,
     # and will return the parsed JSON body on success, if there is one.
-    def request(uri, method, data = nil)
+    def request(uri, method, data = nil, timeout = nil)
       exceptions = []
       thread_local_hosts.each do |host|
         begin
-          return perform_request(host[:session], host[:base_url] + uri, method, data)
+          return perform_request(host[:session], host[:base_url] + uri, method, data, timeout)
         rescue AlgoliaProtocolError => e
           raise if e.code != Protocol::ERROR_TIMEOUT and e.code != Protocol::ERROR_UNAVAILABLE
           exceptions << e
@@ -48,19 +49,19 @@ module Algolia
       raise AlgoliaProtocolError.new(0, "Cannot reach any host: #{exceptions.map { |e| e.to_s }.join(', ')}")
     end
 
-    def get(uri)
-      request(uri, :GET)
+    def get(uri, timeout = nil)
+      request(uri, :GET, nil, timeout)
     end
 
-    def post(uri, body = {})
-      request(uri, :POST, body)
+    def post(uri, body = {}, timeout = nil)
+      request(uri, :POST, body, timeout)
     end
 
-    def put(uri, body = {})
+    def put(uri, body = {}, timeout = nil)
       request(uri, :PUT, body)
     end
 
-    def delete(uri)
+    def delete(uri, timeout = nil)
       request(uri, :DELETE)
     end
 
@@ -83,21 +84,29 @@ module Algolia
     end
 
     private
-    def perform_request(session, url, method, data)
-      response = case method
-      when :GET
-        session.get(url, { :header => @headers })
-      when :POST
-        session.post(url, { :body => data, :header => @headers })
-      when :PUT
-        session.put(url, { :body => data, :header => @headers })
-      when :DELETE
-        session.delete(url, { :header => @headers })
-      end
-      if response.code >= 400 || response.code < 200
-        raise AlgoliaProtocolError.new(response.code, "Cannot #{method} to #{url}: #{response.content} (#{response.code})")
+    def perform_request(session, url, method, data, timeout)
+      original_send_timeout = session.send_timeout
+      original_receive_timeout = session.receive_timeout
+      begin
+        session.send_timeout = session.receive_timeout = timeout if timeout
+        response = case method
+        when :GET
+          session.get(url, { :header => @headers })
+        when :POST
+          session.post(url, { :body => data, :header => @headers })
+        when :PUT
+          session.put(url, { :body => data, :header => @headers })
+        when :DELETE
+          session.delete(url, { :header => @headers })
+        end
+        if response.code >= 400 || response.code < 200
+          raise AlgoliaProtocolError.new(response.code, "Cannot #{method} to #{url}: #{response.content} (#{response.code})")
+        end
+        return JSON.parse(response.content)
+      ensure
+        session.send_timeout = original_send_timeout
+        session.receive_timeout = original_receive_timeout
       end
-      return JSON.parse(response.content)
     end
 
   end
@@ -170,7 +179,7 @@ module Algolia
       tag_filters = tag_filters.map { |t| t.is_a?(Array) ? "(#{t.join(',')})" : t }.join(',')
     end
     raise ArgumentError.new('Attribute "tag_filters" must be a list of tags') if !tag_filters.is_a?(String)
-    OpenSSL::HMAC.hexdigest(OpenSSL::Digest::Digest.new('sha256'), private_api_key, "#{tag_filters}#{user_token.to_s}")
+    OpenSSL::HMAC.hexdigest(OpenSSL::Digest.new('sha256'), private_api_key, "#{tag_filters}#{user_token.to_s}")
   end
 
   #
@@ -187,7 +196,7 @@ module Algolia
         { :indexName => indexName, :params => Protocol.to_query(encoded_params) }
       end
     }
-    Algolia.client.post(Protocol.multiple_queries_uri, requests.to_json)
+    Algolia.client.post(Protocol.multiple_queries_uri, requests.to_json, Algolia.client.search_timeout)
   end
 
   #

data/lib/algolia/index.rb

@@ -136,7 +136,7 @@ module Algolia
     #   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))
+      Algolia.client.get(Protocol.search_uri(name, query, encoded_params), Algolia.client.search_timeout)
     end
 
     #

data/lib/algolia/version.rb

@@ -1,3 +1,3 @@
 module Algolia
-  VERSION = "1.2.9"
+  VERSION = "1.2.10"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: algoliasearch
 version: !ruby/object:Gem::Version
-  version: 1.2.9
+  version: 1.2.10
 platform: ruby
 authors:
 - Algolia
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-07-08 00:00:00.000000000 Z
+date: 2014-08-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: httpclient
@@ -131,7 +131,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.1.11
+rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
 summary: A simple Ruby client for the algolia.com REST API