algoliasearch-rails 1.11.17 → 1.11.18

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 55fbc5ac8483cb4609a0102a438d0d988f14950e
-  data.tar.gz: 487ba5769e40b3dee94861d2478d4809ce018c7a
+  metadata.gz: b90eda1033e39094342631bc26f4356b2fb77723
+  data.tar.gz: b2b8a9acdc2814b526f69c30c7bb85de3998f039
 SHA512:
-  metadata.gz: 007e97d90dff45d6fecb0e769bfd36f87d5721d5d5861a9225dc4a3758a0be167244019380fc753e3208d4ed2be157188dc49b8d0789a93db1ed88d16a6f720f
-  data.tar.gz: 68dbf288873f169a4f135f7ad4634266a27cb6a8123ed4624cce3f0c890e5fa9e9936dd45afcec4645e0be92eef62e46d37ea670964666a87f8e70543365eb34
+  metadata.gz: fae998c2943cbaa65c7fd588a96aaee86fe7b5c8937dda84c3708e5c09fe6c94367361230a3e264023f4d6d585cc3b7641ac41b11b14a7e4b4cc689e23cfc7c3
+  data.tar.gz: d079747d3a7fcc582b4dce2ec76a225abf6c9c46dd8f340d893448e67e7d87d73a231ab2bb89b3c5631993f5dc9dc6964191fc9473f9cdac74b8382ba2104ef9

data/ChangeLog

@@ -1,5 +1,9 @@
 CHANGELOG
 
+2015-03-31 1.11.18
+
+      * Embed AlgoliaSearch JS API client v3 as well. Default is still the v2 to keep the backward compatibility.
+
 2015-03-08 1.11.17
 
       * Add missing index settings (including removeWordsIfNoResults, unretrievableAttributes and ignorePlurals)

data/README.md

@@ -14,6 +14,7 @@ Table of Content
 1. [Install](#install)
 1. [Setup](#setup)
 1. [Quick Start](#quick-start)
+1. [Ranking & Relevance](#ranking--relevance)
 1. [Options](#options)
 1. [Configuration example](#configuration-example)
 1. [Indexing](#indexing)
@@ -105,15 +106,56 @@ class Product < ActiveRecord::Base
 end
 ```
 
+#### Ranking & Relevance
+
+We provide many ways to configure your index allowing you to tune your overall index relevancy. The most important ones are the **searchable attributes** and the attributes reflecting **record popularity**.
+
+```ruby
+class Product < ActiveRecord::Base
+  include AlgoliaSearch
+
+  algoliasearch do
+    # list of attribute used to build an Algolia record
+    attributes :title, :subtitle, :description, :likes_count, :seller_name
+
+    # the attributesToIndex` setting defines the attributes
+    # you want to search in: here `title`, `subtitle` & `description`.
+    # You need to list them by order of importance. `description` is tagged as
+    # `unordered` to avoid taking the position of a match into account in that attribute.
+    attributesToIndex ['title', 'subtitle', 'unordered(description)']
+
+    # the `customRanking` setting defines the ranking criteria use to compare two matching
+    # records in case their text-relevance is equal. It should reflect your record popularity.
+    customRanking ['desc(likes_count)']
+  end
+
+end
+```
+
 #### Frontend Search (realtime experience)
 
+Traditional search implementations tend to have search logic and functionality on the backend. This made sense when the search experience consisted of a user entering a search query, executing that search, and then being redirected to a search result page.
+
+Implementing search on the backend is no longer necessary. In fact, in most cases it is harmful to performance because of added network and processing latency. We highly recommend the usage of our [JavaScript API Client](https://github.com/algolia/algoliasearch-client-js) issuing all search requests directly from the end user's browser, mobile device, or client. It will reduce the overall search latency while offloading your servers at the same time.
 
-We recommend the usage of our [JavaScript API Client](https://github.com/algolia/algoliasearch-client-js) to perform queries. The JS API client is part of the gem, just require ```algolia/algoliasearch.min``` somewhere in your JavaScript manifest, for example in ```application.js``` if you are using Rails 3.1+:
+The JS API client is part of the gem, just require ```algolia/v3/algoliasearch.min``` somewhere in your JavaScript manifest, for example in ```application.js``` if you are using Rails 3.1+:
 
 ```javascript
-//= require algolia/algoliasearch.min
+//= require algolia/v3/algoliasearch.min
 ```
 
+Then in your JavaScript code you can do:
+
+```js
+var client = new AlgoliaSearch('ApplicationID', 'Search-Only-API-Key');
+var index = client.initIndex('YourIndexName');
+index.search('something', function(success, hits) {
+  console.log(success, hits)
+}, { hitsPerPage: 10, page: 0 });
+```
+
+**We recently (March 2015) released a new version (V3) of our JavaScript client, if you were using our previous version (V2), [read the migration guide](https://github.com/algolia/algoliasearch-client-js/wiki/Migration-guide-from-2.x.x-to-3.x.x)**
+
 #### Backend Search
 
 A search returns ORM-compliant objects reloading them from your database.
@@ -393,7 +435,7 @@ class Item < ActiveRecord::Base
 
   algoliasearch per_environment: true do
     # the list of attributes sent to Algolia's API
-    attribute :created_at, :title, :url, :author, :points, :story_text, :comment_text, :author, :num_comments, :story_id, :story_title, :
+    attribute :created_at, :title, :url, :author, :points, :story_text, :comment_text, :author, :num_comments, :story_id, :story_title
 
     # integer version of the created_at datetime field, to use numerical filtering
     attribute :created_at_i do
@@ -703,10 +745,10 @@ At query time, specify <code>{ aroundLatLng: "37.33, -121.89", aroundRadius: 500
 Typeahead UI
 -------------
 
-Require ```algolia/algoliasearch.min``` (see [algoliasearch-client-js](https://github.com/algolia/algoliasearch-client-js)) and ```algolia/typeahead.jquery.js``` somewhere in your JavaScript manifest, for example in ```application.js``` if you are using Rails 3.1+:
+Require ```algolia/v3/algoliasearch.min``` (see [algoliasearch-client-js](https://github.com/algolia/algoliasearch-client-js)) and ```algolia/typeahead.jquery.js``` somewhere in your JavaScript manifest, for example in ```application.js``` if you are using Rails 3.1+:
 
 ```javascript
-//= require algolia/algoliasearch.min
+//= require algolia/v3/algoliasearch.min
 //= require algolia/typeahead.jquery
 ```
 
@@ -723,7 +765,7 @@ Turns any ```input[type="text"]``` element into a typeahead, for example:
 
 <script type="text/javascript">
   $(document).ready(function() {
-    var client = new AlgoliaSearch('YourApplicationID', 'SearchOnlyApplicationKey');
+    var client = algoliasearch('YourApplicationID', 'SearchOnlyApplicationKey');
     var template = Hogan.compile('{{{_highlightResult.email.value}}} ({{{_highlightResult.first_name.value}}} {{{_highlightResult.last_name.value}}})');
     $('input#user_email').typeahead(null, {
       source: client.initIndex('<%= Contact.index_name %>').ttAdapter(),

data/VERSION

@@ -1 +1 @@
-1.11.17
+1.11.18

data/algoliasearch-rails.gemspec

@@ -38,16 +38,32 @@ Gem::Specification.new do |s|
     "lib/algoliasearch/utilities.rb",
     "spec/spec_helper.rb",
     "spec/utilities_spec.rb",
-    "vendor/assets/javascripts/algolia/algoliasearch.js",
-    "vendor/assets/javascripts/algolia/algoliasearch.min.js",
-    "vendor/assets/javascripts/algolia/algoliasearch.jquery.js",
-    "vendor/assets/javascripts/algolia/algoliasearch.jquery.min.js",
     "vendor/assets/javascripts/algolia/algoliasearch.angular.js",
     "vendor/assets/javascripts/algolia/algoliasearch.angular.min.js",
-    "vendor/assets/javascripts/algolia/typeahead.jquery.js",
+    "vendor/assets/javascripts/algolia/algoliasearch.jquery.js",
+    "vendor/assets/javascripts/algolia/algoliasearch.jquery.min.js",
+    "vendor/assets/javascripts/algolia/algoliasearch.js",
+    "vendor/assets/javascripts/algolia/algoliasearch.min.js",
+    "vendor/assets/javascripts/algolia/bloodhound.js",
+    "vendor/assets/javascripts/algolia/bloodhound.min.js",
     "vendor/assets/javascripts/algolia/typeahead.bundle.js",
     "vendor/assets/javascripts/algolia/typeahead.bundle.min.js",
-    "vendor/assets/javascripts/algolia/bloodhound.js"
+    "vendor/assets/javascripts/algolia/typeahead.jquery.js",
+    "vendor/assets/javascripts/algolia/typeahead.jquery.min.js",
+    "vendor/assets/javascripts/algolia/v2",
+    "vendor/assets/javascripts/algolia/v2/algoliasearch.angular.js",
+    "vendor/assets/javascripts/algolia/v2/algoliasearch.angular.min.js",
+    "vendor/assets/javascripts/algolia/v2/algoliasearch.jquery.js",
+    "vendor/assets/javascripts/algolia/v2/algoliasearch.jquery.min.js",
+    "vendor/assets/javascripts/algolia/v2/algoliasearch.js",
+    "vendor/assets/javascripts/algolia/v2/algoliasearch.min.js",
+    "vendor/assets/javascripts/algolia/v3",
+    "vendor/assets/javascripts/algolia/v3/algoliasearch.angular.js",
+    "vendor/assets/javascripts/algolia/v3/algoliasearch.angular.min.js",
+    "vendor/assets/javascripts/algolia/v3/algoliasearch.jquery.js",
+    "vendor/assets/javascripts/algolia/v3/algoliasearch.jquery.min.js",
+    "vendor/assets/javascripts/algolia/v3/algoliasearch.js",
+    "vendor/assets/javascripts/algolia/v3/algoliasearch.min.js"
   ]
   s.homepage = "http://github.com/algolia/algoliasearch-rails"
   s.licenses = ["MIT"]

data/vendor/assets/javascripts/algolia/algoliasearch.angular.js

@@ -21,7 +21,7 @@
  * THE SOFTWARE.
  */
 
-var ALGOLIA_VERSION = '2.9.2';
+var ALGOLIA_VERSION = '2.9.4';
 
 /*
  * Copyright (c) 2013 Algolia
@@ -58,892 +58,959 @@ var ALGOLIA_VERSION = '2.9.2';
  *        - dsnHost (optional) override the automatic computation of dsn hostname
  */
 var AlgoliaSearch = function(applicationID, apiKey, methodOrOptions, resolveDNS, hosts) {
-    var self = this;
-    this.applicationID = applicationID;
-    this.apiKey = apiKey;
-    this.dsn = true;
-    this.dsnHost = null;
-    this.hosts = [];
-    this.currentHostIndex = 0;
-    this.requestTimeoutInMs = 2000;
-    this.extraHeaders = [];
-    this.jsonp = null;
-    this.options = {};
-
-    // make sure every client instance has it's own cache
-    this.cache = {};
-
-    var method;
-    var tld = 'net';
-    if (typeof methodOrOptions === 'string') { // Old initialization
-        method = methodOrOptions;
-    } else {
-        // Take all option from the hash
-        var options = methodOrOptions || {};
-        this.options = options;
-        if (!this._isUndefined(options.method)) {
-            method = options.method;
-        }
-        if (!this._isUndefined(options.tld)) {
-            tld = options.tld;
-        }
-        if (!this._isUndefined(options.dsn)) {
-            this.dsn = options.dsn;
-        }
-        if (!this._isUndefined(options.hosts)) {
-            hosts = options.hosts;
-        }
-        if (!this._isUndefined(options.dsnHost)) {
-            this.dsnHost = options.dsnHost;
-        }
-        if (!this._isUndefined(options.requestTimeoutInMs)) {
-            this.requestTimeoutInMs = +options.requestTimeoutInMs;
-        }
-        if (!this._isUndefined(options.jsonp)) {
-            this.jsonp = options.jsonp;
-        }
+  var self = this;
+  this.applicationID = applicationID;
+  this.apiKey = apiKey;
+  this.dsn = true;
+  this.dsnHost = null;
+  this.hosts = [];
+  this.currentHostIndex = 0;
+  this.requestTimeoutInMs = 2000;
+  this.extraHeaders = [];
+  this.jsonp = null;
+  this.options = {};
+
+  // make sure every client instance has it's own cache
+  this.cache = {};
+
+  var method;
+  var tld = 'net';
+  if (typeof methodOrOptions === 'string') { // Old initialization
+    method = methodOrOptions;
+  } else {
+    // Take all option from the hash
+    var options = methodOrOptions || {};
+    this.options = options;
+    if (!this._isUndefined(options.method)) {
+      method = options.method;
     }
-    // If hosts is undefined, initialize it with applicationID
-    if (this._isUndefined(hosts)) {
-        hosts = [
-            this.applicationID + '-1.algolia.' + tld,
-            this.applicationID + '-2.algolia.' + tld,
-            this.applicationID + '-3.algolia.' + tld
-        ];
-    }
-    // detect is we use http or https
-    this.host_protocol = 'http://';
-    if (this._isUndefined(method) || method === null) {
-        this.host_protocol = ('https:' == document.location.protocol ? 'https' : 'http') + '://';
-    } else if (method === 'https' || method === 'HTTPS') {
-        this.host_protocol = 'https://';
-    }
-    // Add hosts in random order
-    for (var i = 0; i < hosts.length; ++i) {
-        if (Math.random() > 0.5) {
-            this.hosts.reverse();
-        }
-        this.hosts.push(this.host_protocol + hosts[i]);
+    if (!this._isUndefined(options.tld)) {
+      tld = options.tld;
     }
-    if (Math.random() > 0.5) {
-        this.hosts.reverse();
+    if (!this._isUndefined(options.dsn)) {
+      this.dsn = options.dsn;
     }
-    // then add Distributed Search Network host if there is one
-    if (this.dsn || this.dsnHost != null) {
-        if (this.dsnHost) {
-            this.hosts.unshift(this.host_protocol + this.dsnHost);
-        } else {
-            this.hosts.unshift(this.host_protocol + this.applicationID + '-dsn.algolia.' + tld);
-        }
+    if (!this._isUndefined(options.hosts)) {
+      hosts = options.hosts;
+    }
+    if (!this._isUndefined(options.dsnHost)) {
+      this.dsnHost = options.dsnHost;
+    }
+    if (!this._isUndefined(options.requestTimeoutInMs)) {
+      this.requestTimeoutInMs = +options.requestTimeoutInMs;
+    }
+    if (!this._isUndefined(options.jsonp)) {
+      this.jsonp = options.jsonp;
     }
-    // angular dependencies injection
-    if (this.options.angular) {
-        this.options.angular.$injector.invoke(['$http', '$q', function ($http, $q) {
-            self.options.angular.$q = $q;
-            self.options.angular.$http = $http;
-        }]);
+  }
+  // If hosts is undefined, initialize it with applicationID
+  if (this._isUndefined(hosts)) {
+    hosts = [
+      this.applicationID + '-1.algolia.' + tld,
+      this.applicationID + '-2.algolia.' + tld,
+      this.applicationID + '-3.algolia.' + tld
+    ];
+  }
+  // detect is we use http or https
+  this.host_protocol = 'http://';
+  if (this._isUndefined(method) || method === null) {
+    this.host_protocol = ('https:' == document.location.protocol ? 'https' : 'http') + '://';
+  } else if (method === 'https' || method === 'HTTPS') {
+    this.host_protocol = 'https://';
+  }
+  // Add hosts in random order
+  for (var i = 0; i < hosts.length; ++i) {
+    if (Math.random() > 0.5) {
+      this.hosts.reverse();
+    }
+    this.hosts.push(this.host_protocol + hosts[i]);
+  }
+  if (Math.random() > 0.5) {
+    this.hosts.reverse();
+  }
+  // then add Distributed Search Network host if there is one
+  if (this.dsn || this.dsnHost != null) {
+    if (this.dsnHost) {
+      this.hosts.unshift(this.host_protocol + this.dsnHost);
+    } else {
+      this.hosts.unshift(this.host_protocol + this.applicationID + '-dsn.algolia.' + tld);
     }
+  }
+  // angular dependencies injection
+  if (this.options.angular) {
+    this.options.angular.$injector.invoke(['$http', '$q', function ($http, $q) {
+      self.options.angular.$q = $q;
+      self.options.angular.$http = $http;
+    }]);
+  }
 };
 
+// This holds the number of JSONP requests done accross clients
+// It's used as part of the ?callback=JSONP_$JSONPCounter when we do JSONP requests
+AlgoliaSearch.JSONPCounter = 0;
+
 function AlgoliaExplainResults(hit, titleAttribute, otherAttributes) {
 
-    function _getHitExplanationForOneAttr_recurse(obj, foundWords) {
+  function _getHitExplanationForOneAttr_recurse(obj, foundWords) {
+    var res = [];
+    if (typeof obj === 'object' && 'matchedWords' in obj && 'value' in obj) {
+      var match = false;
+      for (var j = 0; j < obj.matchedWords.length; ++j) {
+        var word = obj.matchedWords[j];
+        if (!(word in foundWords)) {
+          foundWords[word] = 1;
+          match = true;
+        }
+      }
+      if (match) {
+        res.push(obj.value);
+      }
+    } else if (Object.prototype.toString.call(obj) === '[object Array]') {
+      for (var i = 0; i < obj.length; ++i) {
+        var array = _getHitExplanationForOneAttr_recurse(obj[i], foundWords);
+        res = res.concat(array);
+      }
+    } else if (typeof obj === 'object') {
+      for (var prop in obj) {
+        if (obj.hasOwnProperty(prop)){
+          res = res.concat(_getHitExplanationForOneAttr_recurse(obj[prop], foundWords));
+        }
+      }
+    }
+    return res;
+  }
+
+  function _getHitExplanationForOneAttr(hit, foundWords, attr) {
+    var base = hit._highlightResult || hit;
+    if (attr.indexOf('.') === -1) {
+      if (attr in base) {
+        return _getHitExplanationForOneAttr_recurse(base[attr], foundWords);
+      }
+      return [];
+    }
+    var array = attr.split('.');
+    var obj = base;
+    for (var i = 0; i < array.length; ++i) {
+      if (Object.prototype.toString.call(obj) === '[object Array]') {
         var res = [];
-        if (typeof obj === 'object' && 'matchedWords' in obj && 'value' in obj) {
-            var match = false;
-            for (var j = 0; j < obj.matchedWords.length; ++j) {
-                var word = obj.matchedWords[j];
-                if (!(word in foundWords)) {
-                    foundWords[word] = 1;
-                    match = true;
-                }
-            }
-            if (match) {
-                res.push(obj.value);
-            }
-        } else if (Object.prototype.toString.call(obj) === '[object Array]') {
-            for (var i = 0; i < obj.length; ++i) {
-                var array = _getHitExplanationForOneAttr_recurse(obj[i], foundWords);
-                res = res.concat(array);
-            }
-        } else if (typeof obj === 'object') {
-            for (var prop in obj) {
-                if (obj.hasOwnProperty(prop)){
-                    res = res.concat(_getHitExplanationForOneAttr_recurse(obj[prop], foundWords));
-                }
-            }
+        for (var j = 0; j < obj.length; ++j) {
+          res = res.concat(_getHitExplanationForOneAttr(obj[j], foundWords, array.slice(i).join('.')));
         }
         return res;
+      }
+      if (array[i] in obj) {
+        obj = obj[array[i]];
+      } else {
+        return [];
+      }
+    }
+    return _getHitExplanationForOneAttr_recurse(obj, foundWords);
+  }
+
+  var res = {};
+  var foundWords = {};
+  var title = _getHitExplanationForOneAttr(hit, foundWords, titleAttribute);
+  res.title = (title.length > 0) ? title[0] : '';
+  res.subtitles = [];
+
+  if (typeof otherAttributes !== 'undefined') {
+    for (var i = 0; i < otherAttributes.length; ++i) {
+      var attr = _getHitExplanationForOneAttr(hit, foundWords, otherAttributes[i]);
+      for (var j = 0; j < attr.length; ++j) {
+        res.subtitles.push({ attr: otherAttributes[i], value: attr[j] });
+      }
     }
+  }
+  return res;
+}
 
-    function _getHitExplanationForOneAttr(hit, foundWords, attr) {
-        var base = hit._highlightResult || hit;
-        if (attr.indexOf('.') === -1) {
-            if (attr in base) {
-                return _getHitExplanationForOneAttr_recurse(base[attr], foundWords);
-            }
-            return [];
-        }
-        var array = attr.split('.');
-        var obj = base;
-        for (var i = 0; i < array.length; ++i) {
-            if (Object.prototype.toString.call(obj) === '[object Array]') {
-                var res = [];
-                for (var j = 0; j < obj.length; ++j) {
-                    res = res.concat(_getHitExplanationForOneAttr(obj[j], foundWords, array.slice(i).join('.')));
-                }
-                return res;
-            }
-            if (array[i] in obj) {
-                obj = obj[array[i]];
-            } else {
-                return [];
-            }
-        }
-        return _getHitExplanationForOneAttr_recurse(obj, foundWords);
+
+AlgoliaSearch.prototype = {
+  /*
+   * Delete an index
+   *
+   * @param indexName the name of index to delete
+   * @param callback the result callback with two arguments
+   *  success: boolean set to true if the request was successfull
+   *  content: the server answer that contains the task ID
+   */
+  deleteIndex: function(indexName, callback) {
+    return this._jsonRequest({ method: 'DELETE',
+              url: '/1/indexes/' + encodeURIComponent(indexName),
+              callback: callback });
+  },
+  /**
+   * Move an existing index.
+   * @param srcIndexName the name of index to copy.
+   * @param dstIndexName the new index name that will contains a copy of srcIndexName (destination will be overriten if it already exist).
+   * @param callback the result callback with two arguments
+   *  success: boolean set to true if the request was successfull
+   *  content: the server answer that contains the task ID
+   */
+  moveIndex: function(srcIndexName, dstIndexName, callback) {
+    var postObj = {operation: 'move', destination: dstIndexName};
+    return this._jsonRequest({ method: 'POST',
+              url: '/1/indexes/' + encodeURIComponent(srcIndexName) + '/operation',
+              body: postObj,
+              callback: callback });
+
+  },
+  /**
+   * Copy an existing index.
+   * @param srcIndexName the name of index to copy.
+   * @param dstIndexName the new index name that will contains a copy of srcIndexName (destination will be overriten if it already exist).
+   * @param callback the result callback with two arguments
+   *  success: boolean set to true if the request was successfull
+   *  content: the server answer that contains the task ID
+   */
+  copyIndex: function(srcIndexName, dstIndexName, callback) {
+    var postObj = {operation: 'copy', destination: dstIndexName};
+    return this._jsonRequest({ method: 'POST',
+              url: '/1/indexes/' + encodeURIComponent(srcIndexName) + '/operation',
+              body: postObj,
+              callback: callback });
+  },
+  /**
+   * Return last log entries.
+   * @param offset Specify the first entry to retrieve (0-based, 0 is the most recent log entry).
+   * @param length Specify the maximum number of entries to retrieve starting at offset. Maximum allowed value: 1000.
+   * @param callback the result callback with two arguments
+   *  success: boolean set to true if the request was successfull
+   *  content: the server answer that contains the task ID
+   */
+  getLogs: function(callback, offset, length) {
+    if (this._isUndefined(offset)) {
+      offset = 0;
+    }
+    if (this._isUndefined(length)) {
+      length = 10;
     }
 
-    var res = {};
-    var foundWords = {};
-    var title = _getHitExplanationForOneAttr(hit, foundWords, titleAttribute);
-    res.title = (title.length > 0) ? title[0] : '';
-    res.subtitles = [];
+    return this._jsonRequest({ method: 'GET',
+              url: '/1/logs?offset=' + offset + '&length=' + length,
+              callback: callback });
+  },
+  /*
+   * List all existing indexes (paginated)
+   *
+   * @param callback the result callback with two arguments
+   *  success: boolean set to true if the request was successfull
+   *  content: the server answer with index list or error description if success is false.
+   * @param page The page to retrieve, starting at 0.
+   */
+  listIndexes: function(callback, page) {
+    var params = typeof page !== 'undefined' ? '?page=' + page : '';
+    return this._jsonRequest({ method: 'GET',
+              url: '/1/indexes' + params,
+              callback: callback });
+  },
+
+  /*
+   * Get the index object initialized
+   *
+   * @param indexName the name of index
+   * @param callback the result callback with one argument (the Index instance)
+   */
+  initIndex: function(indexName) {
+    return new this.Index(this, indexName);
+  },
+  /*
+   * List all existing user keys with their associated ACLs
+   *
+   * @param callback the result callback with two arguments
+   *  success: boolean set to true if the request was successfull
+   *  content: the server answer with user keys list or error description if success is false.
+   */
+  listUserKeys: function(callback) {
+    return this._jsonRequest({ method: 'GET',
+              url: '/1/keys',
+              callback: callback });
+  },
+  /*
+   * Get ACL of a user key
+   *
+   * @param callback the result callback with two arguments
+   *  success: boolean set to true if the request was successfull
+   *  content: the server answer with user keys list or error description if success is false.
+   */
+  getUserKeyACL: function(key, callback) {
+    return this._jsonRequest({ method: 'GET',
+              url: '/1/keys/' + key,
+              callback: callback });
+  },
+  /*
+   * Delete an existing user key
+   *
+   * @param callback the result callback with two arguments
+   *  success: boolean set to true if the request was successfull
+   *  content: the server answer with user keys list or error description if success is false.
+   */
+  deleteUserKey: function(key, callback) {
+    return this._jsonRequest({ method: 'DELETE',
+              url: '/1/keys/' + key,
+              callback: callback });
+  },
+  /*
+   * Add an existing 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/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 callback the result callback with two arguments
+   *  success: boolean set to true if the request was successfull
+   *  content: the server answer with user keys list or error description if success is false.
+   */
+  addUserKey: function(acls, callback) {
+    return this.addUserKeyWithValidity(acls, 0, 0, 0, callback);
+  },
+  /*
+   * Add an existing 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/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 Specify the maximum number of API calls allowed from an IP address per hour.
+   * @param maxHitsPerQuery Specify the maximum number of hits this API key can retrieve in one call.
+   * @param callback the result callback with two arguments
+   *  success: boolean set to true if the request was successfull
+   *  content: the server answer with user keys list or error description if success is false.
+   */
+  addUserKeyWithValidity: function(acls, validity, maxQueriesPerIPPerHour, maxHitsPerQuery, callback) {
+    var aclsObject = {};
+    aclsObject.acl = acls;
+    aclsObject.validity = validity;
+    aclsObject.maxQueriesPerIPPerHour = maxQueriesPerIPPerHour;
+    aclsObject.maxHitsPerQuery = maxHitsPerQuery;
+    return this._jsonRequest({ method: 'POST',
+              url: '/1/keys',
+              body: aclsObject,
+              callback: callback });
+  },
 
-    if (typeof otherAttributes !== 'undefined') {
-        for (var i = 0; i < otherAttributes.length; ++i) {
-            var attr = _getHitExplanationForOneAttr(hit, foundWords, otherAttributes[i]);
-            for (var j = 0; j < attr.length; ++j) {
-                res.subtitles.push({ attr: otherAttributes[i], value: attr[j] });
-            }
+  /**
+   * Set the extra security tagFilters header
+   * @param {string|array} tags The list of tags defining the current security filters
+   */
+  setSecurityTags: function(tags) {
+    if (Object.prototype.toString.call(tags) === '[object Array]') {
+      var strTags = [];
+      for (var i = 0; i < tags.length; ++i) {
+        if (Object.prototype.toString.call(tags[i]) === '[object Array]') {
+          var oredTags = [];
+          for (var j = 0; j < tags[i].length; ++j) {
+            oredTags.push(tags[i][j]);
+          }
+          strTags.push('(' + oredTags.join(',') + ')');
+        } else {
+          strTags.push(tags[i]);
         }
+      }
+      tags = strTags.join(',');
     }
-    return res;
-}
+    this.tagFilters = tags;
+  },
 
+  /**
+   * Set the extra user token header
+   * @param {string} userToken The token identifying a uniq user (used to apply rate limits)
+   */
+  setUserToken: function(userToken) {
+    this.userToken = userToken;
+  },
 
-AlgoliaSearch.prototype = {
-    /*
-     * Delete an index
-     *
-     * @param indexName the name of index to delete
-     * @param callback the result callback with two arguments
-     *  success: boolean set to true if the request was successfull
-     *  content: the server answer that contains the task ID
-     */
-    deleteIndex: function(indexName, callback) {
-        return this._jsonRequest({ method: 'DELETE',
-                            url: '/1/indexes/' + encodeURIComponent(indexName),
-                            callback: callback });
-    },
-    /**
-     * Move an existing index.
-     * @param srcIndexName the name of index to copy.
-     * @param dstIndexName the new index name that will contains a copy of srcIndexName (destination will be overriten if it already exist).
-     * @param callback the result callback with two arguments
-     *  success: boolean set to true if the request was successfull
-     *  content: the server answer that contains the task ID
-     */
-    moveIndex: function(srcIndexName, dstIndexName, callback) {
-        var postObj = {operation: 'move', destination: dstIndexName};
-        return this._jsonRequest({ method: 'POST',
-                            url: '/1/indexes/' + encodeURIComponent(srcIndexName) + '/operation',
-                            body: postObj,
-                            callback: callback });
+  /*
+   * Initialize a new batch of search queries
+   */
+  startQueriesBatch: function() {
+    this.batch = [];
+  },
+  /*
+   * Add a search query in the batch
+   *
+   * @param query the full text query
+   * @param args (optional) if set, contains an object with query parameters:
+   *  - attributes: an array of object attribute names to retrieve
+   *     (if not set all attributes are retrieve)
+   *  - attributesToHighlight: an array of object attribute names to highlight
+   *     (if not set indexed attributes are highlighted)
+   *  - minWordSizefor1Typo: the minimum number of characters to accept one typo.
+   *     Defaults to 3.
+   *  - minWordSizefor2Typos: the minimum number of characters to accept two typos.
+   *     Defaults to 7.
+   *  - getRankingInfo: if set, the result hits will contain ranking information in
+   *     _rankingInfo attribute
+   *  - page: (pagination parameter) page to retrieve (zero base). Defaults to 0.
+   *  - hitsPerPage: (pagination parameter) number of hits per page. Defaults to 10.
+   */
+  addQueryInBatch: function(indexName, query, args) {
+    var params = 'query=' + encodeURIComponent(query);
+    if (!this._isUndefined(args) && args !== null) {
+      params = this._getSearchParams(args, params);
+    }
+    this.batch.push({ indexName: indexName, params: params });
+  },
+  /*
+   * Clear all queries in cache
+   */
+  clearCache: function() {
+    this.cache = {};
+  },
+  /*
+   * Launch the batch of queries using XMLHttpRequest.
+   * (Optimized for browser using a POST query to minimize number of OPTIONS queries)
+   *
+   * @param callback the function that will receive results
+   * @param delay (optional) if set, wait for this delay (in ms) and only send the batch if there was no other in the meantime.
+   */
+  sendQueriesBatch: function(callback, delay) {
+    var as = this;
+    var params = {requests: []};
+    for (var i = 0; i < as.batch.length; ++i) {
+      params.requests.push(as.batch[i]);
+    }
+    window.clearTimeout(as.onDelayTrigger);
+    if (!this._isUndefined(delay) && delay !== null && delay > 0) {
+      var onDelayTrigger = window.setTimeout( function() {
+        as._sendQueriesBatch(params, callback);
+      }, delay);
+      as.onDelayTrigger = onDelayTrigger;
+    } else {
+      return this._sendQueriesBatch(params, callback);
+    }
+  },
 
-    },
-    /**
-     * Copy an existing index.
-     * @param srcIndexName the name of index to copy.
-     * @param dstIndexName the new index name that will contains a copy of srcIndexName (destination will be overriten if it already exist).
-     * @param callback the result callback with two arguments
-     *  success: boolean set to true if the request was successfull
-     *  content: the server answer that contains the task ID
-     */
-    copyIndex: function(srcIndexName, dstIndexName, callback) {
-        var postObj = {operation: 'copy', destination: dstIndexName};
-        return this._jsonRequest({ method: 'POST',
-                            url: '/1/indexes/' + encodeURIComponent(srcIndexName) + '/operation',
-                            body: postObj,
-                            callback: callback });
-    },
-    /**
-     * Return last log entries.
-     * @param offset Specify the first entry to retrieve (0-based, 0 is the most recent log entry).
-     * @param length Specify the maximum number of entries to retrieve starting at offset. Maximum allowed value: 1000.
-     * @param callback the result callback with two arguments
-     *  success: boolean set to true if the request was successfull
-     *  content: the server answer that contains the task ID
-     */
-    getLogs: function(callback, offset, length) {
-        if (this._isUndefined(offset)) {
-            offset = 0;
-        }
-        if (this._isUndefined(length)) {
-            length = 10;
-        }
+   /**
+   * Set the number of milliseconds a request can take before automatically being terminated.
+   *
+   * @param {Number} milliseconds
+   */
+  setRequestTimeout: function(milliseconds)
+  {
+    if (milliseconds) {
+      this.requestTimeoutInMs = parseInt(milliseconds, 10);
+    }
+  },
 
-        return this._jsonRequest({ method: 'GET',
-                            url: '/1/logs?offset=' + offset + '&length=' + length,
-                            callback: callback });
-    },
-    /*
-     * List all existing indexes (paginated)
-     *
-     * @param callback the result callback with two arguments
-     *  success: boolean set to true if the request was successfull
-     *  content: the server answer with index list or error description if success is false.
-     * @param page The page to retrieve, starting at 0.
-     */
-    listIndexes: function(callback, page) {
-        var params = typeof page !== 'undefined' ? '?page=' + page : '';
-        return this._jsonRequest({ method: 'GET',
-                            url: '/1/indexes' + params,
-                            callback: callback });
-    },
+  /*
+   * Index class constructor.
+   * You should not use this method directly but use initIndex() function
+   */
+  Index: function(algoliasearch, indexName) {
+    this.indexName = indexName;
+    this.as = algoliasearch;
+    this.typeAheadArgs = null;
+    this.typeAheadValueOption = null;
 
-    /*
-     * Get the index object initialized
-     *
-     * @param indexName the name of index
-     * @param callback the result callback with one argument (the Index instance)
-     */
-    initIndex: function(indexName) {
-        return new this.Index(this, indexName);
-    },
-    /*
-     * List all existing user keys with their associated ACLs
-     *
-     * @param callback the result callback with two arguments
-     *  success: boolean set to true if the request was successfull
-     *  content: the server answer with user keys list or error description if success is false.
-     */
-    listUserKeys: function(callback) {
-        return this._jsonRequest({ method: 'GET',
-                            url: '/1/keys',
-                            callback: callback });
-    },
-    /*
-     * Get ACL of a user key
-     *
-     * @param callback the result callback with two arguments
-     *  success: boolean set to true if the request was successfull
-     *  content: the server answer with user keys list or error description if success is false.
-     */
-    getUserKeyACL: function(key, callback) {
-        return this._jsonRequest({ method: 'GET',
-                            url: '/1/keys/' + key,
-                            callback: callback });
-    },
-    /*
-     * Delete an existing user key
-     *
-     * @param callback the result callback with two arguments
-     *  success: boolean set to true if the request was successfull
-     *  content: the server answer with user keys list or error description if success is false.
-     */
-    deleteUserKey: function(key, callback) {
-        return this._jsonRequest({ method: 'DELETE',
-                            url: '/1/keys/' + key,
-                            callback: callback });
-    },
-    /*
-     * Add an existing 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/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 callback the result callback with two arguments
-     *  success: boolean set to true if the request was successfull
-     *  content: the server answer with user keys list or error description if success is false.
-     */
-    addUserKey: function(acls, callback) {
-        var aclsObject = {};
-        aclsObject.acl = acls;
-        return this._jsonRequest({ method: 'POST',
-                            url: '/1/keys',
-                            body: aclsObject,
-                            callback: callback });
-    },
-    /*
-     * Add an existing 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/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 Specify the maximum number of API calls allowed from an IP address per hour.
-     * @param maxHitsPerQuery Specify the maximum number of hits this API key can retrieve in one call.
-     * @param callback the result callback with two arguments
-     *  success: boolean set to true if the request was successfull
-     *  content: the server answer with user keys list or error description if success is false.
-     */
-    addUserKeyWithValidity: function(acls, validity, maxQueriesPerIPPerHour, maxHitsPerQuery, callback) {
-        var indexObj = this;
-        var aclsObject = {};
-        aclsObject.acl = acls;
-        aclsObject.validity = validity;
-        aclsObject.maxQueriesPerIPPerHour = maxQueriesPerIPPerHour;
-        aclsObject.maxHitsPerQuery = maxHitsPerQuery;
-        return this._jsonRequest({ method: 'POST',
-                            url: '/1/indexes/' + indexObj.indexName + '/keys',
-                            body: aclsObject,
-                            callback: callback });
-    },
+    // make sure every index instance has it's own cache
+    this.cache = {};
+  },
+   /**
+   * Add an extra field to the HTTP request
+   *
+   * @param key the header field name
+   * @param value the header field value
+   */
+  setExtraHeader: function(key, value) {
+    this.extraHeaders.push({ key: key, value: value});
+  },
 
-    /**
-     * Set the extra security tagFilters header
-     * @param {string|array} tags The list of tags defining the current security filters
-     */
-    setSecurityTags: function(tags) {
-        if (Object.prototype.toString.call(tags) === '[object Array]') {
-            var strTags = [];
-            for (var i = 0; i < tags.length; ++i) {
-                if (Object.prototype.toString.call(tags[i]) === '[object Array]') {
-                    var oredTags = [];
-                    for (var j = 0; j < tags[i].length; ++j) {
-                        oredTags.push(tags[i][j]);
-                    }
-                    strTags.push('(' + oredTags.join(',') + ')');
-                } else {
-                    strTags.push(tags[i]);
-                }
-            }
-            tags = strTags.join(',');
+  _sendQueriesBatch: function(params, callback) {
+     if (this.jsonp === null) {
+      var self = this;
+      return this._jsonRequest({ cache: this.cache,
+        method: 'POST',
+        url: '/1/indexes/*/queries',
+        body: params,
+        callback: function(success, content) {
+          if (!success) {
+            // retry first with JSONP
+            self.jsonp = true;
+            self._sendQueriesBatch(params, callback);
+          } else {
+            self.jsonp = false;
+            callback && callback(success, content);
+          }
         }
-        this.tagFilters = tags;
-    },
-
-    /**
-     * Set the extra user token header
-     * @param {string} userToken The token identifying a uniq user (used to apply rate limits)
-     */
-    setUserToken: function(userToken) {
-        this.userToken = userToken;
-    },
+      });
+    } else if (this.jsonp) {
+      var jsonpParams = '';
+      for (var i = 0; i < params.requests.length; ++i) {
+        var q = '/1/indexes/' + encodeURIComponent(params.requests[i].indexName) + '?' + params.requests[i].params;
+        jsonpParams += i + '=' + encodeURIComponent(q) + '&';
+      }
+      var pObj = {params: jsonpParams};
+      return this._jsonRequest({ cache: this.cache,
+                   method: 'GET',
+                   url: '/1/indexes/*',
+                   body: pObj,
+                   callback: callback });
+    } else {
+      return this._jsonRequest({ cache: this.cache,
+                   method: 'POST',
+                   url: '/1/indexes/*/queries',
+                   body: params,
+                      callback: callback});
+    }
+  },
+  /*
+   * Wrapper that try all hosts to maximize the quality of service
+   */
+  _jsonRequest: function(opts) {
+    var self = this;
+    var callback = opts.callback;
+    var cache = null;
+    var cacheID = opts.url;
+    var deferred = null;
+    if (this.options.jQuery) {
+      deferred = this.options.jQuery.$.Deferred();
+      deferred.promise = deferred.promise(); // promise is a property in angular
+    } else if (this.options.angular) {
+      deferred = this.options.angular.$q.defer();
+    }
 
-    /*
-     * Initialize a new batch of search queries
-     */
-    startQueriesBatch: function() {
-        this.batch = [];
-    },
-    /*
-     * Add a search query in the batch
-     *
-     * @param query the full text query
-     * @param args (optional) if set, contains an object with query parameters:
-     *  - attributes: an array of object attribute names to retrieve
-     *     (if not set all attributes are retrieve)
-     *  - attributesToHighlight: an array of object attribute names to highlight
-     *     (if not set indexed attributes are highlighted)
-     *  - minWordSizefor1Typo: the minimum number of characters to accept one typo.
-     *     Defaults to 3.
-     *  - minWordSizefor2Typos: the minimum number of characters to accept two typos.
-     *     Defaults to 7.
-     *  - getRankingInfo: if set, the result hits will contain ranking information in
-     *     _rankingInfo attribute
-     *  - page: (pagination parameter) page to retrieve (zero base). Defaults to 0.
-     *  - hitsPerPage: (pagination parameter) number of hits per page. Defaults to 10.
-     */
-    addQueryInBatch: function(indexName, query, args) {
-        var params = 'query=' + encodeURIComponent(query);
-        if (!this._isUndefined(args) && args !== null) {
-            params = this._getSearchParams(args, params);
+    if (!this._isUndefined(opts.body)) {
+      cacheID = opts.url + '_body_' + JSON.stringify(opts.body);
+    }
+    if (!this._isUndefined(opts.cache)) {
+      cache = opts.cache;
+      if (!this._isUndefined(cache[cacheID])) {
+        if (!this._isUndefined(callback) && callback) {
+          setTimeout(function () { callback(true, cache[cacheID]); }, 1);
         }
-        this.batch.push({ indexName: indexName, params: params });
-    },
-    /*
-     * Clear all queries in cache
-     */
-    clearCache: function() {
-        this.cache = {};
-    },
-    /*
-     * Launch the batch of queries using XMLHttpRequest.
-     * (Optimized for browser using a POST query to minimize number of OPTIONS queries)
-     *
-     * @param callback the function that will receive results
-     * @param delay (optional) if set, wait for this delay (in ms) and only send the batch if there was no other in the meantime.
-     */
-    sendQueriesBatch: function(callback, delay) {
-        var as = this;
-        var params = {requests: []};
-        for (var i = 0; i < as.batch.length; ++i) {
-            params.requests.push(as.batch[i]);
+        deferred && deferred.resolve(cache[cacheID]);
+        return deferred && deferred.promise;
+      }
+    }
+
+    opts.successiveRetryCount = 0;
+    var impl = function() {
+      if (opts.successiveRetryCount >= self.hosts.length) {
+        var error = { message: 'Cannot connect the Algolia\'s Search API. Please send an email to support@algolia.com to report the issue.' };
+        if (!self._isUndefined(callback) && callback) {
+          opts.successiveRetryCount = 0;
+          callback(false, error);
         }
-        window.clearTimeout(as.onDelayTrigger);
-        if (!this._isUndefined(delay) && delay !== null && delay > 0) {
-            var onDelayTrigger = window.setTimeout( function() {
-                as._sendQueriesBatch(params, callback);
-            }, delay);
-            as.onDelayTrigger = onDelayTrigger;
+        deferred && deferred.reject(error);
+        return;
+      }
+      opts.callback = function(retry, success, body) {
+        if (success && !self._isUndefined(opts.cache)) {
+          cache[cacheID] = body;
+        }
+        if (!success && retry) {
+          self.currentHostIndex = ++self.currentHostIndex % self.hosts.length;
+          opts.successiveRetryCount += 1;
+          impl();
         } else {
-            return this._sendQueriesBatch(params, callback);
+          opts.successiveRetryCount = 0;
+          deferred && (success ? deferred.resolve(body) : deferred.reject(body));
+          if (!self._isUndefined(callback) && callback) {
+            callback(success, body);
+          }
         }
-    },
+      };
+      opts.hostname = self.hosts[self.currentHostIndex];
+      self._jsonRequestByHost(opts);
+    };
+    impl();
 
-   /**
-     * Set the number of milliseconds a request can take before automatically being terminated.
-     *
-     * @param {Number} milliseconds
-     */
-    setRequestTimeout: function(milliseconds)
-    {
-        if (milliseconds) {
-            this.requestTimeoutInMs = parseInt(milliseconds, 10);
-        }
-    },
+    return deferred && deferred.promise;
+  },
 
-    /*
-     * Index class constructor.
-     * You should not use this method directly but use initIndex() function
-     */
-    Index: function(algoliasearch, indexName) {
-        this.indexName = indexName;
-        this.as = algoliasearch;
-        this.typeAheadArgs = null;
-        this.typeAheadValueOption = null;
-
-        // make sure every index instance has it's own cache
-        this.cache = {};
-    },
-   /**
-     * Add an extra field to the HTTP request
-     *
-     * @param key the header field name
-     * @param value the header field value
-     */
-    setExtraHeader: function(key, value) {
-        this.extraHeaders.push({ key: key, value: value});
-    },
+  _jsonRequestByHost: function(opts) {
+    var self = this;
+    var url = opts.hostname + opts.url;
+
+    if (this.jsonp) {
+      this._makeJsonpRequestByHost(url, opts);
+    } else if (this.options.jQuery) {
+      this._makejQueryRequestByHost(url, opts);
+    } else if (this.options.angular) {
+      this._makeAngularRequestByHost(url, opts);
+    } else {
+      this._makeXmlHttpRequestByHost(url, opts);
+    }
+  },
 
-    _sendQueriesBatch: function(params, callback) {
-
-       if (this.jsonp === null) {
-            var self = this;
-            return this._jsonRequest({ cache: this.cache,
-                method: 'POST',
-                url: '/1/indexes/*/queries',
-                body: params,
-                callback: function(success, content) {
-                    if (!success) {
-                        // retry first with JSONP
-                        self.jsonp = true;
-                        self._sendQueriesBatch(params, callback);
-                    } else {
-                        self.jsonp = false;
-                        callback && callback(success, content);
-                    }
-                }
-            });
-        } else if (this.jsonp) {
-            var jsonpParams = '';
-            for (var i = 0; i < params.requests.length; ++i) {
-                var q = '/1/indexes/' + encodeURIComponent(params.requests[i].indexName) + '?' + params.requests[i].params;
-                jsonpParams += i + '=' + encodeURIComponent(q) + '&';
-            }
-            var pObj = {params: jsonpParams};
-            return this._jsonRequest({ cache: this.cache,
-                                   method: 'GET',
-                                   url: '/1/indexes/*',
-                                   body: pObj,
-                                   callback: callback });
-        } else {
-            return this._jsonRequest({ cache: this.cache,
-                                   method: 'POST',
-                                   url: '/1/indexes/*/queries',
-                                   body: params,
-                                          callback: callback});
-        }
-    },
-    /*
-     * Wrapper that try all hosts to maximize the quality of service
-     */
-    _jsonRequest: function(opts) {
-        var self = this;
-        var callback = opts.callback;
-        var cache = null;
-        var cacheID = opts.url;
-        var deferred = null;
-        if (this.options.jQuery) {
-            deferred = this.options.jQuery.$.Deferred();
-            deferred.promise = deferred.promise(); // promise is a property in angular
-        } else if (this.options.angular) {
-            deferred = this.options.angular.$q.defer();
-        }
+  /**
+   * Make a $http
+   *
+   * @param url request url (includes endpoint and path)
+   * @param opts all request opts
+   */
+  _makeAngularRequestByHost: function(url, opts) {
+    var self = this;
+    var body = null;
 
-        if (!this._isUndefined(opts.body)) {
-            cacheID = opts.url + '_body_' + JSON.stringify(opts.body);
-        }
-        if (!this._isUndefined(opts.cache)) {
-            cache = opts.cache;
-            if (!this._isUndefined(cache[cacheID])) {
-                if (!this._isUndefined(callback) && callback) {
-                    setTimeout(function () { callback(true, cache[cacheID]); }, 1);
-                }
-                deferred && deferred.resolve(cache[cacheID]);
-                return deferred && deferred.promise;
-            }
-        }
+    if (!this._isUndefined(opts.body)) {
+      body = JSON.stringify(opts.body);
+    }
 
-        opts.successiveRetryCount = 0;
-        var impl = function() {
-            if (opts.successiveRetryCount >= self.hosts.length) {
-                var error = { message: 'Cannot connect the Algolia\'s Search API. Please send an email to support@algolia.com to report the issue.' };
-                if (!self._isUndefined(callback) && callback) {
-                    opts.successiveRetryCount = 0;
-                    callback(false, error);
-                }
-                deferred && deferred.reject(error);
-                return;
-            }
-            opts.callback = function(retry, success, obj, body) {
-                if (success && !self._isUndefined(opts.cache)) {
-                    cache[cacheID] = body;
-                }
-                if (!success && retry) {
-                    self.currentHostIndex = ++self.currentHostIndex % self.hosts.length;
-                    opts.successiveRetryCount += 1;
-                    impl();
-                } else {
-                    opts.successiveRetryCount = 0;
-                    deferred && (success ? deferred.resolve(body) : deferred.reject(body));
-                    if (!self._isUndefined(callback) && callback) {
-                        callback(success, body);
-                    }
-                }
-            };
-            opts.hostname = self.hosts[self.currentHostIndex];
-            self._jsonRequestByHost(opts);
-        };
-        impl();
+    url += ((url.indexOf('?') === -1) ? '?' : '&') + 'X-Algolia-API-Key=' + this.apiKey;
+    url += '&X-Algolia-Application-Id=' + this.applicationID;
+    if (this.userToken) {
+      url += '&X-Algolia-UserToken=' + encodeURIComponent(this.userToken);
+    }
+    if (this.tagFilters) {
+      url += '&X-Algolia-TagFilters=' + encodeURIComponent(this.tagFilters);
+    }
+    for (var i = 0; i < this.extraHeaders.length; ++i) {
+      url += '&' + this.extraHeaders[i].key + '=' + this.extraHeaders[i].value;
+    }
+    this.options.angular.$http({
+      url: url,
+      method: opts.method,
+      data: body,
+      cache: false,
+      timeout: (this.requestTimeoutInMs * (opts.successiveRetryCount + 1))
+    }).then(function(response) {
+      opts.callback(false, true, response.data);
+    }, function(response) {
+      if (response.status === 0) {
+        // xhr.timeout is not handled by Angular.js right now
+        // let's retry
+        opts.callback(true, false, response.data);
+      } else if (response.status == 400 || response.status === 403 || response.status === 404) {
+        opts.callback(false, false, response.data);
+      } else {
+        opts.callback(true, false, response.data);
+      }
+    });
+  },
 
-        return deferred && deferred.promise;
-    },
+  /**
+   * Make a $.ajax
+   *
+   * @param url request url (includes endpoint and path)
+   * @param opts all request opts
+   */
+  _makejQueryRequestByHost: function(url, opts) {
+    var self = this;
+    var body = null;
 
-    _jsonRequestByHost: function(opts) {
-        var self = this;
-        var url = opts.hostname + opts.url;
+    if (!this._isUndefined(opts.body)) {
+      body = JSON.stringify(opts.body);
+    }
 
-        if (this.jsonp) {
-            this._makeJsonpRequestByHost(url, opts);
-        } else if (this.options.jQuery) {
-            this._makejQueryRequestByHost(url, opts);
-        } else if (this.options.angular) {
-            this._makeAngularRequestByHost(url, opts);
+    url += ((url.indexOf('?') === -1) ? '?' : '&') + 'X-Algolia-API-Key=' + this.apiKey;
+    url += '&X-Algolia-Application-Id=' + this.applicationID;
+    if (this.userToken) {
+      url += '&X-Algolia-UserToken=' + encodeURIComponent(this.userToken);
+    }
+    if (this.tagFilters) {
+      url += '&X-Algolia-TagFilters=' + encodeURIComponent(this.tagFilters);
+    }
+    for (var i = 0; i < this.extraHeaders.length; ++i) {
+      url += '&' + this.extraHeaders[i].key + '=' + this.extraHeaders[i].value;
+    }
+    this.options.jQuery.$.ajax(url, {
+      type: opts.method,
+      timeout: (this.requestTimeoutInMs * (opts.successiveRetryCount + 1)),
+      dataType: 'json',
+      data: body,
+      error: function(xhr, textStatus, error) {
+        if (textStatus === 'timeout') {
+          opts.callback(true, false, { 'message': 'Timeout - Could not connect to endpoint ' + url } );
+        } else if (xhr.status === 400 || xhr.status === 403 || xhr.status === 404) {
+          opts.callback(false, false, xhr.responseJSON );
         } else {
-            this._makeXmlHttpRequestByHost(url, opts);
+          opts.callback(true, false, { 'message': error } );
         }
-    },
+      },
+      success: function(data, textStatus, xhr) {
+        opts.callback(false, true, data);
+      }
+    });
+  },
 
-    /**
-     * Make a $http
-     *
-     * @param url request url (includes endpoint and path)
-     * @param opts all request opts
-     */
-    _makeAngularRequestByHost: function(url, opts) {
-        var self = this;
-        var body = null;
+  /**
+   * Make a JSONP request
+   *
+   * @param url request url (includes endpoint and path)
+   * @param opts all request options
+   */
+  _makeJsonpRequestByHost: function(url, opts) {
+    if (opts.method !== 'GET') {
+      opts.callback(true, false, { 'message': 'Method ' + opts.method + ' ' + url + ' is not supported by JSONP.' });
+      return;
+    }
 
-        if (!this._isUndefined(opts.body)) {
-            body = JSON.stringify(opts.body);
-        }
+    var cbCalled = false;
+    var timedOut = false;
 
-        url += ((url.indexOf('?') === -1) ? '?' : '&') + 'X-Algolia-API-Key=' + this.apiKey;
-        url += '&X-Algolia-Application-Id=' + this.applicationID;
-        if (this.userToken) {
-            url += '&X-Algolia-UserToken=' + encodeURIComponent(this.userToken);
-        }
-        if (this.tagFilters) {
-            url += '&X-Algolia-TagFilters=' + encodeURIComponent(this.tagFilters);
-        }
-        for (var i = 0; i < this.extraHeaders.length; ++i) {
-            url += '&' + this.extraHeaders[i].key + '=' + this.extraHeaders[i].value;
-        }
-        this.options.angular.$http({
-            url: url,
-            method: opts.method,
-            data: body,
-            cache: false,
-            timeout: (this.requestTimeoutInMs * (opts.successiveRetryCount + 1))
-        }).then(function(response) {
-            opts.callback(false, true, null, response.data);
-        }, function(response) {
-            if (response.status === 0) {
-                // xhr.timeout is not handled by Angular.js right now
-                // let's retry
-                opts.callback(true, false, null, response.data);
-            } else if (response.status == 400 || response.status === 403 || response.status === 404) {
-                opts.callback(false, false, null, response.data);
-            } else {
-                opts.callback(true, false, null, response.data);
-            }
-        });
-    },
+    AlgoliaSearch.JSONPCounter += 1;
+    var head = document.getElementsByTagName('head')[0];
+    var script = document.createElement('script');
+    var cb = 'algoliaJSONP_' + AlgoliaSearch.JSONPCounter;
+    var done = false;
+    var ontimeout;
+    var success;
+    var clean;
 
-    /**
-     * Make a $.ajax
-     *
-     * @param url request url (includes endpoint and path)
-     * @param opts all request opts
-     */
-    _makejQueryRequestByHost: function(url, opts) {
-        var self = this;
-        var body = null;
+    window[cb] = function(data) {
+      try { delete window[cb]; } catch (e) { window[cb] = undefined; }
 
-        if (!this._isUndefined(opts.body)) {
-            body = JSON.stringify(opts.body);
-        }
+      if (timedOut) {
+        return;
+      }
 
-        url += ((url.indexOf('?') === -1) ? '?' : '&') + 'X-Algolia-API-Key=' + this.apiKey;
-        url += '&X-Algolia-Application-Id=' + this.applicationID;
-        if (this.userToken) {
-            url += '&X-Algolia-UserToken=' + encodeURIComponent(this.userToken);
-        }
-        if (this.tagFilters) {
-            url += '&X-Algolia-TagFilters=' + encodeURIComponent(this.tagFilters);
-        }
-        for (var i = 0; i < this.extraHeaders.length; ++i) {
-            url += '&' + this.extraHeaders[i].key + '=' + this.extraHeaders[i].value;
-        }
-        this.options.jQuery.$.ajax(url, {
-            type: opts.method,
-            timeout: (this.requestTimeoutInMs * (opts.successiveRetryCount + 1)),
-            dataType: 'json',
-            data: body,
-            error: function(xhr, textStatus, error) {
-                if (textStatus === 'timeout') {
-                    opts.callback(true, false, null, { 'message': 'Timeout - Could not connect to endpoint ' + url } );
-                } else if (xhr.status === 400 || xhr.status === 403 || xhr.status === 404) {
-                    opts.callback(false, false, null, xhr.responseJSON );
-                } else {
-                    opts.callback(true, false, null, { 'message': error } );
-                }
-            },
-            success: function(data, textStatus, xhr) {
-                opts.callback(false, true, null, data);
-            }
-        });
-    },
+      var status =
+        data && data.message && data.status ||
+        data && 200;
 
-    /**
-     * Make a JSONP request
-     *
-     * @param url request url (includes endpoint and path)
-     * @param opts all request options
-     */
-    _makeJsonpRequestByHost: function(url, opts) {
-        if (opts.method !== 'GET') {
-            opts.callback(true, false, null, { 'message': 'Method ' + opts.method + ' ' + url + ' is not supported by JSONP.' });
-            return;
-        }
+      var ok = status === 200;
+      var retry = !ok && status !== 400 && status !== 403 && status !== 404;
+      cbCalled = true;
+      opts.callback(retry, ok, data);
+    };
 
-        this.jsonpCounter = this.jsonpCounter || 0;
-        this.jsonpCounter += 1;
-        var head = document.getElementsByTagName('head')[0];
-        var script = document.createElement('script');
-        var cb = 'algoliaJSONP_' + this.jsonpCounter;
-        var done = false;
-        var ontimeout = null;
-
-        window[cb] = function(data) {
-            opts.callback(false, true, null, data);
-            try { delete window[cb]; } catch (e) { window[cb] = undefined; }
-        };
+    script.type = 'text/javascript';
+    url += '?callback=' + cb + '&X-Algolia-Application-Id=' + this.applicationID + '&X-Algolia-API-Key=' + this.apiKey;
 
-        script.type = 'text/javascript';
-        script.src = url + '?callback=' + cb + '&X-Algolia-Application-Id=' + this.applicationID + '&X-Algolia-API-Key=' + this.apiKey;
+    if (this.tagFilters) {
+      url += '&X-Algolia-TagFilters=' + encodeURIComponent(this.tagFilters);
+    }
 
-        if (this.tagFilters) {
-            script.src += '&X-Algolia-TagFilters=' + encodeURIComponent(this.tagFilters);
-        }
+    if (this.userToken) {
+      url += '&X-Algolia-UserToken=' + encodeURIComponent(this.userToken);
+    }
 
-        if (this.userToken) {
-            script.src += '&X-Algolia-UserToken=' + encodeURIComponent(this.userToken);
-        }
-        for (var i = 0; i < this.extraHeaders.length; ++i) {
-            script.src += '&' + this.extraHeaders[i].key + '=' + this.extraHeaders[i].value;
-        }
+    for (var i = 0; i < this.extraHeaders.length; ++i) {
+      url += '&' + this.extraHeaders[i].key + '=' + this.extraHeaders[i].value;
+    }
 
+    if (opts.body && opts.body.params) {
+      url += '&' + opts.body.params;
+    }
 
-        if (opts.body && opts.body.params) {
-            script.src += '&' + opts.body.params;
-        }
+    ontimeout = setTimeout(function() {
+      timedOut = true;
+      clean();
 
-        ontimeout = setTimeout(function() {
-            script.onload = script.onreadystatechange = script.onerror = null;
-            window[cb] = function(data) {
-                try { delete window[cb]; } catch (e) { window[cb] = undefined; }
-            };
+      opts.callback(true, false, { 'message': 'Timeout - Failed to load JSONP script.' });
+    }, this.requestTimeoutInMs);
 
-            opts.callback(true, false, null, { 'message': 'Timeout - Failed to load JSONP script.' });
-            head.removeChild(script);
+    success = function() {
+      if (done || timedOut) {
+        return;
+      }
 
-            clearTimeout(ontimeout);
-            ontimeout = null;
+      done = true;
+      clean();
 
-        }, this.requestTimeoutInMs);
+      // script loaded but did not call the fn => script loading error
+      if (!cbCalled) {
+        opts.callback(true, false, { 'message': 'Failed to load JSONP script.' });
+      }
+    };
 
-        script.onload = script.onreadystatechange = function() {
-            clearTimeout(ontimeout);
-            ontimeout = null;
+    clean = function() {
+      clearTimeout(ontimeout);
+      script.onload = null;
+      script.onreadystatechange = null;
+      script.onerror = null;
+      head.removeChild(script);
 
-            if (!done && (!this.readyState || this.readyState == 'loaded' || this.readyState == 'complete')) {
-                done = true;
+      try {
+        delete window[cb];
+        delete window[cb + '_loaded'];
+      } catch (e) {
+        window[cb] = null;
+        window[cb + '_loaded'] = null;
+      }
+    };
 
-                if (typeof window[cb + '_loaded'] === 'undefined') {
-                    opts.callback(true, false, null, { 'message': 'Failed to load JSONP script.' });
-                    try { delete window[cb]; } catch (e) { window[cb] = undefined; }
-                } else {
-                    try { delete window[cb + '_loaded']; } catch (e) { window[cb + '_loaded'] = undefined; }
-                }
-                script.onload = script.onreadystatechange = null; // Handle memory leak in IE
-                head.removeChild(script);
-            }
-        };
+    // script onreadystatechange needed only for
+    // <= IE8
+    // https://github.com/angular/angular.js/issues/4523
+    script.onreadystatechange = function() {
+      if (this.readyState === 'loaded' || this.readyState === 'complete') {
+        success();
+      }
+    };
 
-        script.onerror = function() {
-            clearTimeout(ontimeout);
-            ontimeout = null;
+    script.onload = function() {
+      success();
+    };
 
-            opts.callback(true, false, null, { 'message': 'Failed to load JSONP script.' });
-            head.removeChild(script);
-            try { delete window[cb]; } catch (e) { window[cb] = undefined; }
-        };
+    script.onerror = function() {
+      if (done || timedOut) {
+        return;
+      }
 
-        head.appendChild(script);
-    },
+      clean();
+      opts.callback(true, false, { 'message': 'Failed to load JSONP script.' });
+    };
 
-    /**
-     * Make a XmlHttpRequest
-     *
-     * @param url request url (includes endpoint and path)
-     * @param opts all request opts
-     */
-    _makeXmlHttpRequestByHost: function(url, opts) {
-        var self = this;
-        var xmlHttp = window.XMLHttpRequest ? new XMLHttpRequest() : {};
-        var body = null;
-        var ontimeout = null;
-
-        if (!this._isUndefined(opts.body)) {
-            body = JSON.stringify(opts.body);
-        }
+    script.async = true;
+    script.defer = true;
+    script.src = url;
 
-        url += ((url.indexOf('?') === -1) ? '?' : '&') + 'X-Algolia-API-Key=' + this.apiKey;
-        url += '&X-Algolia-Application-Id=' + this.applicationID;
-        if (this.userToken) {
-            url += '&X-Algolia-UserToken=' + encodeURIComponent(this.userToken);
-        }
-        if (this.tagFilters) {
-            url += '&X-Algolia-TagFilters=' + encodeURIComponent(this.tagFilters);
-        }
-        for (var i = 0; i < this.extraHeaders.length; ++i) {
-            url += '&' + this.extraHeaders[i].key + '=' + this.extraHeaders[i].value;
-        }
-        if ('withCredentials' in xmlHttp) {
-            xmlHttp.open(opts.method, url, true);
-            xmlHttp.timeout = this.requestTimeoutInMs * (opts.successiveRetryCount + 1);
-            if (body !== null) {
-                /* This content type is specified to follow CORS 'simple header' directive */
-                xmlHttp.setRequestHeader('Content-type', 'application/x-www-form-urlencoded');
-            }
-        } else if (typeof XDomainRequest !== 'undefined') {
-            // Handle IE8/IE9
-            // XDomainRequest only exists in IE, and is IE's way of making CORS requests.
-            xmlHttp = new XDomainRequest();
-            xmlHttp.open(opts.method, url);
-        } else {
-            // very old browser, not supported
-            opts.callback(false, false, null, { 'message': 'CORS not supported' });
-            return;
-        }
+    head.appendChild(script);
+  },
 
-        ontimeout = setTimeout(function() {
-            xmlHttp.abort();
-            // Prevent Internet Explorer 9, JScript Error c00c023f
-            if (xmlHttp.aborted === true) {
-              stopLoadAnimation();
-              return;
-            }
-            opts.callback(true, false, null, { 'message': 'Timeout - Could not connect to endpoint ' + url } );
+  /**
+   * Make a XmlHttpRequest
+   *
+   * @param url request url (includes endpoint and path)
+   * @param opts all request opts
+   */
+  _makeXmlHttpRequestByHost: function(url, opts) {
+    // no cors or XDomainRequest, no request
+    if (!this._support.cors && !this._support.hasXDomainRequest) {
+      // very old browser, not supported
+      opts.callback(false, false, { 'message': 'CORS not supported' });
+      return;
+    }
 
-            clearTimeout(ontimeout);
-            ontimeout = null;
+    var body = null;
+    var request = this._support.cors ? new XMLHttpRequest() : new XDomainRequest();
+    var ontimeout;
+    var self = this;
+    var timedOut;
+    var timeoutListener;
 
-        }, this.requestTimeoutInMs * (opts.successiveRetryCount + 1));
+    if (!this._isUndefined(opts.body)) {
+      body = JSON.stringify(opts.body);
+    }
 
-        xmlHttp.onload = function(event) {
-            clearTimeout(ontimeout);
-            ontimeout = null;
+    url += (url.indexOf('?') === -1 ? '?' : '&') + 'X-Algolia-API-Key=' + this.apiKey;
+    url += '&X-Algolia-Application-Id=' + this.applicationID;
 
-            if (!self._isUndefined(event) && event.target !== null) {
-                var success = false;
-                var response = null;
+    if (this.userToken) {
+      url += '&X-Algolia-UserToken=' + encodeURIComponent(this.userToken);
+    }
 
-                if (typeof XDomainRequest !== 'undefined') {
-                    // Handle CORS requests IE8/IE9
-                    response = event.target.responseText;
-                    success = (response && response.length > 0);
-                } else {
-                    response = event.target.response;
-                    success = (event.target.status === 200 || event.target.status === 201);
-                }
+    if (this.tagFilters) {
+      url += '&X-Algolia-TagFilters=' + encodeURIComponent(this.tagFilters);
+    }
 
-                var retry = !success && event.target.status !== 400 && event.target.status !== 403 && event.target.status !== 404;
-                opts.callback(retry, success, event.target, response ? JSON.parse(response) : null);
-            } else {
-                opts.callback(false, true, event, JSON.parse(xmlHttp.responseText));
-            }
-        };
-        xmlHttp.ontimeout = function(event) { // stop the network call but rely on ontimeout to call opt.callback
-        };
-        xmlHttp.onerror = function(event) {
-            clearTimeout(ontimeout);
-            ontimeout = null;
-            opts.callback(true, false, null, { 'message': 'Could not connect to host', 'error': event } );
-        };
+    for (var i = 0; i < this.extraHeaders.length; ++i) {
+      url += '&' + this.extraHeaders[i].key + '=' + this.extraHeaders[i].value;
+    }
 
-        xmlHttp.send(body);
-    },
+    timeoutListener = function() {
+      if (!self._support.timeout) {
+        timedOut = true;
+        request.abort();
+      }
 
-     /*
-     * Transform search param object in query string
-     */
-    _getSearchParams: function(args, params) {
-        if (this._isUndefined(args) || args === null) {
-            return params;
-        }
-        for (var key in args) {
-            if (key !== null && args.hasOwnProperty(key)) {
-                params += (params.length === 0) ? '?' : '&';
-                params += key + '=' + encodeURIComponent(Object.prototype.toString.call(args[key]) === '[object Array]' ? JSON.stringify(args[key]) : args[key]);
-            }
-        }
-        return params;
-    },
-    _isUndefined: function(obj) {
-        return obj === void 0;
-    },
+      opts.callback(true, false, { 'message': 'Timeout - Could not connect to endpoint ' + url } );
+    };
+
+    // do not rely on default XHR async flag, as some analytics code like hotjar
+    // breaks it and set it to false by default
+    if (request instanceof XMLHttpRequest) {
+      request.open(opts.method, url, true);
+    } else {
+      request.open(opts.method, url);
+    }
+
+    if (this._support.cors && body !== null && opts.method !== 'GET') {
+      request.setRequestHeader('Content-type', 'application/x-www-form-urlencoded');
+    }
+
+    // event object not received in IE8, at least
+    // but we do not use it, still important to note
+    request.onload = function(/*event*/) {
+      // When browser does not supports request.timeout, we can
+      // have both a load and timeout event
+      if (timedOut) {
+        return;
+      }
+
+      if (!self._support.timeout) {
+        clearTimeout(ontimeout);
+      }
+
+      var response = null;
+
+      try {
+        response = JSON.parse(request.responseText);
+      } catch(e) {}
 
-    /// internal attributes
-    applicationID: null,
-    apiKey: null,
-    tagFilters: null,
-    userToken: null,
-    hosts: [],
-    extraHeaders: []
+      var status =
+        // XHR provides a `status` property
+        request.status ||
+
+        // XDR does not have a `status` property,
+        // we rely on our own API response `status`, only
+        // provided when an error occurs, so we expect a .message
+        response && response.message && response.status ||
+
+        // XDR default to success when no response.status
+        response && 200;
+
+      var success = status === 200 || status === 201;
+      var retry = !success && status !== 400 && status !== 403 && status !== 404;
+
+      opts.callback(retry, success, response);
+    };
+
+    if (this._support.timeout) {
+      // .timeout supported by both XHR and XDR,
+      // we do receive timeout event, tested
+      request.timeout = this.requestTimeoutInMs * (opts.successiveRetryCount + 1);
+
+      request.ontimeout = timeoutListener;
+    } else {
+      ontimeout = setTimeout(timeoutListener, this.requestTimeoutInMs * (opts.successiveRetryCount + 1));
+    }
+
+    request.onerror = function(event) {
+      if (timedOut) {
+        return;
+      }
+
+      if (!self._support.timeout) {
+        clearTimeout(ontimeout);
+      }
+
+      // error event is trigerred both with XDR/XHR on:
+      //   - DNS error
+      //   - unallowed cross domain request
+      opts.callback(true, false, { 'message': 'Could not connect to host', 'error': event } );
+    };
+
+    request.send(body);
+  },
+
+   /*
+   * Transform search param object in query string
+   */
+  _getSearchParams: function(args, params) {
+    if (this._isUndefined(args) || args === null) {
+      return params;
+    }
+    for (var key in args) {
+      if (key !== null && args.hasOwnProperty(key)) {
+        params += (params.length === 0) ? '?' : '&';
+        params += key + '=' + encodeURIComponent(Object.prototype.toString.call(args[key]) === '[object Array]' ? JSON.stringify(args[key]) : args[key]);
+      }
+    }
+    return params;
+  },
+  _isUndefined: function(obj) {
+    return obj === void 0;
+  },
+
+  _support: {
+    hasXMLHttpRequest: 'XMLHttpRequest' in window,
+    hasXDomainRequest: 'XDomainRequest' in window,
+    cors: 'withCredentials' in new XMLHttpRequest(),
+    timeout: 'timeout' in new XMLHttpRequest()
+  }
 };
 
 /*
@@ -951,575 +1018,571 @@ AlgoliaSearch.prototype = {
  * You should use AlgoliaSearch.initIndex(indexName) to retrieve this object
  */
 AlgoliaSearch.prototype.Index.prototype = {
-        /*
-         * Clear all queries in cache
-         */
-        clearCache: function() {
-            this.cache = {};
-        },
-        /*
-         * Add an object in this index
-         *
-         * @param content contains the javascript object to add inside the index
-         * @param callback (optional) the result callback with two arguments:
-         *  success: boolean set to true if the request was successfull
-         *  content: the server answer that contains 3 elements: createAt, taskId and objectID
-         * @param objectID (optional) an objectID you want to attribute to this object
-         * (if the attribute already exist the old object will be overwrite)
-         */
-        addObject: function(content, callback, objectID) {
-            var indexObj = this;
-            if (this.as._isUndefined(objectID)) {
-                return this.as._jsonRequest({ method: 'POST',
-                                       url: '/1/indexes/' + encodeURIComponent(indexObj.indexName),
-                                       body: content,
-                                       callback: callback });
-            } else {
-                return this.as._jsonRequest({ method: 'PUT',
-                                       url: '/1/indexes/' + encodeURIComponent(indexObj.indexName) + '/' + encodeURIComponent(objectID),
-                                       body: content,
-                                       callback: callback });
-            }
+  /*
+   * Clear all queries in cache
+   */
+  clearCache: function() {
+    this.cache = {};
+  },
+  /*
+   * Add an object in this index
+   *
+   * @param content contains the javascript object to add inside the index
+   * @param callback (optional) the result callback with two arguments:
+   *  success: boolean set to true if the request was successfull
+   *  content: the server answer that contains 3 elements: createAt, taskId and objectID
+   * @param objectID (optional) an objectID you want to attribute to this object
+   * (if the attribute already exist the old object will be overwrite)
+   */
+  addObject: function(content, callback, objectID) {
+    var indexObj = this;
+    if (this.as._isUndefined(objectID)) {
+      return this.as._jsonRequest({ method: 'POST',
+                   url: '/1/indexes/' + encodeURIComponent(indexObj.indexName),
+                   body: content,
+                   callback: callback });
+    } else {
+      return this.as._jsonRequest({ method: 'PUT',
+                   url: '/1/indexes/' + encodeURIComponent(indexObj.indexName) + '/' + encodeURIComponent(objectID),
+                   body: content,
+                   callback: callback });
+    }
 
-        },
-        /*
-         * Add several objects
-         *
-         * @param objects contains an array of objects to add
-         * @param callback (optional) the result callback with two arguments:
-         *  success: boolean set to true if the request was successfull
-         *  content: the server answer that updateAt and taskID
-         */
-        addObjects: function(objects, callback) {
-            var indexObj = this;
-            var postObj = {requests:[]};
-            for (var i = 0; i < objects.length; ++i) {
-                var request = { action: 'addObject',
-                                body: objects[i] };
-                postObj.requests.push(request);
-            }
-            return this.as._jsonRequest({ method: 'POST',
-                                   url: '/1/indexes/' + encodeURIComponent(indexObj.indexName) + '/batch',
-                                   body: postObj,
-                                   callback: callback });
-        },
-        /*
-         * Get an object from this index
-         *
-         * @param objectID the unique identifier of the object to retrieve
-         * @param callback (optional) the result callback with two arguments
-         *  success: boolean set to true if the request was successfull
-         *  content: the object to retrieve or the error message if a failure occured
-         * @param attributes (optional) if set, contains the array of attribute names to retrieve
-         */
-        getObject: function(objectID, callback, attributes) {
-            if (Object.prototype.toString.call(callback) === '[object Array]' && !attributes) {
-                attributes = callback;
-                callback = null;
-            }
-            var indexObj = this;
-            var params = '';
-            if (!this.as._isUndefined(attributes)) {
-                params = '?attributes=';
-                for (var i = 0; i < attributes.length; ++i) {
-                    if (i !== 0) {
-                        params += ',';
-                    }
-                    params += attributes[i];
-                }
-            }
-            if (this.as.jsonp === null) {
-                return this.as._jsonRequest({ method: 'GET',
-                                       url: '/1/indexes/' + encodeURIComponent(indexObj.indexName) + '/' + encodeURIComponent(objectID) + params,
-                                       callback: callback });
-            } else {
-                var pObj = {params: params};
-                return this.as._jsonRequest({ method: 'GET',
-                                       url: '/1/indexes/' + encodeURIComponent(indexObj.indexName) + '/' + encodeURIComponent(objectID),
-                                       callback: callback,
-                                       body: pObj});
-            }
-        },
-
-        /*
-         * Update partially an object (only update attributes passed in argument)
-         *
-         * @param partialObject contains the javascript attributes to override, the
-         *  object must contains an objectID attribute
-         * @param callback (optional) the result callback with two arguments:
-         *  success: boolean set to true if the request was successfull
-         *  content: the server answer that contains 3 elements: createAt, taskId and objectID
-         */
-        partialUpdateObject: function(partialObject, callback) {
-            var indexObj = this;
-            return this.as._jsonRequest({ method: 'POST',
-                                   url: '/1/indexes/' + encodeURIComponent(indexObj.indexName) + '/' + encodeURIComponent(partialObject.objectID) + '/partial',
-                                   body: partialObject,
-                                   callback:  callback });
-        },
-        /*
-         * Partially Override the content of several objects
-         *
-         * @param objects contains an array of objects to update (each object must contains a objectID attribute)
-         * @param callback (optional) the result callback with two arguments:
-         *  success: boolean set to true if the request was successfull
-         *  content: the server answer that updateAt and taskID
-         */
-        partialUpdateObjects: function(objects, callback) {
-            var indexObj = this;
-            var postObj = {requests:[]};
-            for (var i = 0; i < objects.length; ++i) {
-                var request = { action: 'partialUpdateObject',
-                                objectID: objects[i].objectID,
-                                body: objects[i] };
-                postObj.requests.push(request);
-            }
-            return this.as._jsonRequest({ method: 'POST',
-                                   url: '/1/indexes/' + encodeURIComponent(indexObj.indexName) + '/batch',
-                                   body: postObj,
-                                   callback: callback });
-        },
-        /*
-         * Override the content of object
-         *
-         * @param object contains the javascript object to save, the object must contains an objectID attribute
-         * @param callback (optional) the result callback with two arguments:
-         *  success: boolean set to true if the request was successfull
-         *  content: the server answer that updateAt and taskID
-         */
-        saveObject: function(object, callback) {
-            var indexObj = this;
-            return this.as._jsonRequest({ method: 'PUT',
-                                   url: '/1/indexes/' + encodeURIComponent(indexObj.indexName) + '/' + encodeURIComponent(object.objectID),
-                                   body: object,
-                                   callback: callback });
-        },
-        /*
-         * Override the content of several objects
-         *
-         * @param objects contains an array of objects to update (each object must contains a objectID attribute)
-         * @param callback (optional) the result callback with two arguments:
-         *  success: boolean set to true if the request was successfull
-         *  content: the server answer that updateAt and taskID
-         */
-        saveObjects: function(objects, callback) {
-            var indexObj = this;
-            var postObj = {requests:[]};
-            for (var i = 0; i < objects.length; ++i) {
-                var request = { action: 'updateObject',
-                                objectID: objects[i].objectID,
-                                body: objects[i] };
-                postObj.requests.push(request);
-            }
-            return this.as._jsonRequest({ method: 'POST',
-                                   url: '/1/indexes/' + encodeURIComponent(indexObj.indexName) + '/batch',
-                                   body: postObj,
-                                   callback: callback });
-        },
-        /*
-         * Delete an object from the index
-         *
-         * @param objectID the unique identifier of object to delete
-         * @param callback (optional) the result callback with two arguments:
-         *  success: boolean set to true if the request was successfull
-         *  content: the server answer that contains 3 elements: createAt, taskId and objectID
-         */
-        deleteObject: function(objectID, callback) {
-            if (objectID === null || objectID.length === 0) {
-                callback(false, { message: 'empty objectID'});
-                return;
-            }
-            var indexObj = this;
-            return this.as._jsonRequest({ method: 'DELETE',
-                                   url: '/1/indexes/' + encodeURIComponent(indexObj.indexName) + '/' + encodeURIComponent(objectID),
-                                   callback: callback });
-        },
-        /*
-         * Search inside the index using XMLHttpRequest request (Using a POST query to
-         * minimize number of OPTIONS queries: Cross-Origin Resource Sharing).
-         *
-         * @param query the full text query
-         * @param callback the result callback with two arguments:
-         *  success: boolean set to true if the request was successfull. If false, the content contains the error.
-         *  content: the server answer that contains the list of results.
-         * @param args (optional) if set, contains an object with query parameters:
-         * - page: (integer) Pagination parameter used to select the page to retrieve.
-         *                   Page is zero-based and defaults to 0. Thus, to retrieve the 10th page you need to set page=9
-         * - hitsPerPage: (integer) Pagination parameter used to select the number of hits per page. Defaults to 20.
-         * - attributesToRetrieve: a string that contains the list of object attributes you want to retrieve (let you minimize the answer size).
-         *   Attributes are separated with a comma (for example "name,address").
-         *   You can also use a string array encoding (for example ["name","address"]).
-         *   By default, all attributes are retrieved. You can also use '*' to retrieve all values when an attributesToRetrieve setting is specified for your index.
-         * - attributesToHighlight: a string that contains the list of attributes you want to highlight according to the query.
-         *   Attributes are separated by a comma. You can also use a string array encoding (for example ["name","address"]).
-         *   If an attribute has no match for the query, the raw value is returned. By default all indexed text attributes are highlighted.
-         *   You can use `*` if you want to highlight all textual attributes. Numerical attributes are not highlighted.
-         *   A matchLevel is returned for each highlighted attribute and can contain:
-         *      - full: if all the query terms were found in the attribute,
-         *      - partial: if only some of the query terms were found,
-         *      - none: if none of the query terms were found.
-         * - attributesToSnippet: a string that contains the list of attributes to snippet alongside the number of words to return (syntax is `attributeName:nbWords`).
-         *    Attributes are separated by a comma (Example: attributesToSnippet=name:10,content:10).
-         *    You can also use a string array encoding (Example: attributesToSnippet: ["name:10","content:10"]). By default no snippet is computed.
-         * - minWordSizefor1Typo: the minimum number of characters in a query word to accept one typo in this word. Defaults to 3.
-         * - minWordSizefor2Typos: the minimum number of characters in a query word to accept two typos in this word. Defaults to 7.
-         * - getRankingInfo: if set to 1, the result hits will contain ranking information in _rankingInfo attribute.
-         * - aroundLatLng: search for entries around a given latitude/longitude (specified as two floats separated by a comma).
-         *   For example aroundLatLng=47.316669,5.016670).
-         *   You can specify the maximum distance in meters with the aroundRadius parameter (in meters) and the precision for ranking with aroundPrecision
-         *   (for example if you set aroundPrecision=100, two objects that are distant of less than 100m will be considered as identical for "geo" ranking parameter).
-         *   At indexing, you should specify geoloc of an object with the _geoloc attribute (in the form {"_geoloc":{"lat":48.853409, "lng":2.348800}})
-         * - insideBoundingBox: search entries inside a given area defined by the two extreme points of a rectangle (defined by 4 floats: p1Lat,p1Lng,p2Lat,p2Lng).
-         *   For example insideBoundingBox=47.3165,4.9665,47.3424,5.0201).
-         *   At indexing, you should specify geoloc of an object with the _geoloc attribute (in the form {"_geoloc":{"lat":48.853409, "lng":2.348800}})
-         * - numericFilters: a string that contains the list of numeric filters you want to apply separated by a comma.
-         *   The syntax of one filter is `attributeName` followed by `operand` followed by `value`. Supported operands are `<`, `<=`, `=`, `>` and `>=`.
-         *   You can have multiple conditions on one attribute like for example numericFilters=price>100,price<1000.
-         *   You can also use a string array encoding (for example numericFilters: ["price>100","price<1000"]).
-         * - tagFilters: filter the query by a set of tags. You can AND tags by separating them by commas.
-         *   To OR tags, you must add parentheses. For example, tags=tag1,(tag2,tag3) means tag1 AND (tag2 OR tag3).
-         *   You can also use a string array encoding, for example tagFilters: ["tag1",["tag2","tag3"]] means tag1 AND (tag2 OR tag3).
-         *   At indexing, tags should be added in the _tags** attribute of objects (for example {"_tags":["tag1","tag2"]}).
-         * - facetFilters: filter the query by a list of facets.
-         *   Facets are separated by commas and each facet is encoded as `attributeName:value`.
-         *   For example: `facetFilters=category:Book,author:John%20Doe`.
-         *   You can also use a string array encoding (for example `["category:Book","author:John%20Doe"]`).
-         * - facets: List of object attributes that you want to use for faceting.
-         *   Attributes are separated with a comma (for example `"category,author"` ).
-         *   You can also use a JSON string array encoding (for example ["category","author"]).
-         *   Only attributes that have been added in **attributesForFaceting** index setting can be used in this parameter.
-         *   You can also use `*` to perform faceting on all attributes specified in **attributesForFaceting**.
-         * - queryType: select how the query words are interpreted, it can be one of the following value:
-         *    - prefixAll: all query words are interpreted as prefixes,
-         *    - prefixLast: only the last word is interpreted as a prefix (default behavior),
-         *    - prefixNone: no query word is interpreted as a prefix. This option is not recommended.
-         * - optionalWords: a string that contains the list of words that should be considered as optional when found in the query.
-         *   The list of words is comma separated.
-         * - distinct: If set to 1, enable the distinct feature (disabled by default) if the attributeForDistinct index setting is set.
-         *   This feature is similar to the SQL "distinct" keyword: when enabled in a query with the distinct=1 parameter,
-         *   all hits containing a duplicate value for the attributeForDistinct attribute are removed from results.
-         *   For example, if the chosen attribute is show_name and several hits have the same value for show_name, then only the best
-         *   one is kept and others are removed.
-         * @param delay (optional) if set, wait for this delay (in ms) and only send the query if there was no other in the meantime.
-         */
-        search: function(query, callback, args, delay) {
-            if (query === undefined || query === null) {
-                query = '';
-            }
+  },
+  /*
+   * Add several objects
+   *
+   * @param objects contains an array of objects to add
+   * @param callback (optional) the result callback with two arguments:
+   *  success: boolean set to true if the request was successfull
+   *  content: the server answer that updateAt and taskID
+   */
+  addObjects: function(objects, callback) {
+    var indexObj = this;
+    var postObj = {requests:[]};
+    for (var i = 0; i < objects.length; ++i) {
+      var request = { action: 'addObject',
+              body: objects[i] };
+      postObj.requests.push(request);
+    }
+    return this.as._jsonRequest({ method: 'POST',
+                 url: '/1/indexes/' + encodeURIComponent(indexObj.indexName) + '/batch',
+                 body: postObj,
+                 callback: callback });
+  },
+  /*
+   * Get an object from this index
+   *
+   * @param objectID the unique identifier of the object to retrieve
+   * @param callback (optional) the result callback with two arguments
+   *  success: boolean set to true if the request was successfull
+   *  content: the object to retrieve or the error message if a failure occured
+   * @param attributes (optional) if set, contains the array of attribute names to retrieve
+   */
+  getObject: function(objectID, callback, attributes) {
+    if (Object.prototype.toString.call(callback) === '[object Array]' && !attributes) {
+      attributes = callback;
+      callback = null;
+    }
+    var indexObj = this;
+    var params = '';
+    if (!this.as._isUndefined(attributes)) {
+      params = '?attributes=';
+      for (var i = 0; i < attributes.length; ++i) {
+        if (i !== 0) {
+          params += ',';
+        }
+        params += attributes[i];
+      }
+    }
 
-            // no query = getAllObjects
-            if (typeof query === 'function') {
-                callback = query;
-                query = '';
-            }
+    return this.as._jsonRequest({ method: 'GET',
+                 url: '/1/indexes/' + encodeURIComponent(indexObj.indexName) + '/' + encodeURIComponent(objectID) + params,
+                 callback: callback });
+  },
+
+  /*
+   * Update partially an object (only update attributes passed in argument)
+   *
+   * @param partialObject contains the javascript attributes to override, the
+   *  object must contains an objectID attribute
+   * @param callback (optional) the result callback with two arguments:
+   *  success: boolean set to true if the request was successfull
+   *  content: the server answer that contains 3 elements: createAt, taskId and objectID
+   */
+  partialUpdateObject: function(partialObject, callback) {
+    var indexObj = this;
+    return this.as._jsonRequest({ method: 'POST',
+                 url: '/1/indexes/' + encodeURIComponent(indexObj.indexName) + '/' + encodeURIComponent(partialObject.objectID) + '/partial',
+                 body: partialObject,
+                 callback:  callback });
+  },
+  /*
+   * Partially Override the content of several objects
+   *
+   * @param objects contains an array of objects to update (each object must contains a objectID attribute)
+   * @param callback (optional) the result callback with two arguments:
+   *  success: boolean set to true if the request was successfull
+   *  content: the server answer that updateAt and taskID
+   */
+  partialUpdateObjects: function(objects, callback) {
+    var indexObj = this;
+    var postObj = {requests:[]};
+    for (var i = 0; i < objects.length; ++i) {
+      var request = { action: 'partialUpdateObject',
+              objectID: objects[i].objectID,
+              body: objects[i] };
+      postObj.requests.push(request);
+    }
+    return this.as._jsonRequest({ method: 'POST',
+                 url: '/1/indexes/' + encodeURIComponent(indexObj.indexName) + '/batch',
+                 body: postObj,
+                 callback: callback });
+  },
+  /*
+   * Override the content of object
+   *
+   * @param object contains the javascript object to save, the object must contains an objectID attribute
+   * @param callback (optional) the result callback with two arguments:
+   *  success: boolean set to true if the request was successfull
+   *  content: the server answer that updateAt and taskID
+   */
+  saveObject: function(object, callback) {
+    var indexObj = this;
+    return this.as._jsonRequest({ method: 'PUT',
+                 url: '/1/indexes/' + encodeURIComponent(indexObj.indexName) + '/' + encodeURIComponent(object.objectID),
+                 body: object,
+                 callback: callback });
+  },
+  /*
+   * Override the content of several objects
+   *
+   * @param objects contains an array of objects to update (each object must contains a objectID attribute)
+   * @param callback (optional) the result callback with two arguments:
+   *  success: boolean set to true if the request was successfull
+   *  content: the server answer that updateAt and taskID
+   */
+  saveObjects: function(objects, callback) {
+    var indexObj = this;
+    var postObj = {requests:[]};
+    for (var i = 0; i < objects.length; ++i) {
+      var request = { action: 'updateObject',
+              objectID: objects[i].objectID,
+              body: objects[i] };
+      postObj.requests.push(request);
+    }
+    return this.as._jsonRequest({ method: 'POST',
+                 url: '/1/indexes/' + encodeURIComponent(indexObj.indexName) + '/batch',
+                 body: postObj,
+                 callback: callback });
+  },
+  /*
+   * Delete an object from the index
+   *
+   * @param objectID the unique identifier of object to delete
+   * @param callback (optional) the result callback with two arguments:
+   *  success: boolean set to true if the request was successfull
+   *  content: the server answer that contains 3 elements: createAt, taskId and objectID
+   */
+  deleteObject: function(objectID, callback) {
+    if (objectID === null || objectID.length === 0) {
+      callback(false, { message: 'empty objectID'});
+      return;
+    }
+    var indexObj = this;
+    return this.as._jsonRequest({ method: 'DELETE',
+                 url: '/1/indexes/' + encodeURIComponent(indexObj.indexName) + '/' + encodeURIComponent(objectID),
+                 callback: callback });
+  },
+  /*
+   * Search inside the index using XMLHttpRequest request (Using a POST query to
+   * minimize number of OPTIONS queries: Cross-Origin Resource Sharing).
+   *
+   * @param query the full text query
+   * @param callback the result callback with two arguments:
+   *  success: boolean set to true if the request was successfull. If false, the content contains the error.
+   *  content: the server answer that contains the list of results.
+   * @param args (optional) if set, contains an object with query parameters:
+   * - page: (integer) Pagination parameter used to select the page to retrieve.
+   *                   Page is zero-based and defaults to 0. Thus, to retrieve the 10th page you need to set page=9
+   * - hitsPerPage: (integer) Pagination parameter used to select the number of hits per page. Defaults to 20.
+   * - attributesToRetrieve: a string that contains the list of object attributes you want to retrieve (let you minimize the answer size).
+   *   Attributes are separated with a comma (for example "name,address").
+   *   You can also use an array (for example ["name","address"]).
+   *   By default, all attributes are retrieved. You can also use '*' to retrieve all values when an attributesToRetrieve setting is specified for your index.
+   * - attributesToHighlight: a string that contains the list of attributes you want to highlight according to the query.
+   *   Attributes are separated by a comma. You can also use an array (for example ["name","address"]).
+   *   If an attribute has no match for the query, the raw value is returned. By default all indexed text attributes are highlighted.
+   *   You can use `*` if you want to highlight all textual attributes. Numerical attributes are not highlighted.
+   *   A matchLevel is returned for each highlighted attribute and can contain:
+   *      - full: if all the query terms were found in the attribute,
+   *      - partial: if only some of the query terms were found,
+   *      - none: if none of the query terms were found.
+   * - attributesToSnippet: a string that contains the list of attributes to snippet alongside the number of words to return (syntax is `attributeName:nbWords`).
+   *    Attributes are separated by a comma (Example: attributesToSnippet=name:10,content:10).
+   *    You can also use an array (Example: attributesToSnippet: ['name:10','content:10']). By default no snippet is computed.
+   * - minWordSizefor1Typo: the minimum number of characters in a query word to accept one typo in this word. Defaults to 3.
+   * - minWordSizefor2Typos: the minimum number of characters in a query word to accept two typos in this word. Defaults to 7.
+   * - getRankingInfo: if set to 1, the result hits will contain ranking information in _rankingInfo attribute.
+   * - aroundLatLng: search for entries around a given latitude/longitude (specified as two floats separated by a comma).
+   *   For example aroundLatLng=47.316669,5.016670).
+   *   You can specify the maximum distance in meters with the aroundRadius parameter (in meters) and the precision for ranking with aroundPrecision
+   *   (for example if you set aroundPrecision=100, two objects that are distant of less than 100m will be considered as identical for "geo" ranking parameter).
+   *   At indexing, you should specify geoloc of an object with the _geoloc attribute (in the form {"_geoloc":{"lat":48.853409, "lng":2.348800}})
+   * - insideBoundingBox: search entries inside a given area defined by the two extreme points of a rectangle (defined by 4 floats: p1Lat,p1Lng,p2Lat,p2Lng).
+   *   For example insideBoundingBox=47.3165,4.9665,47.3424,5.0201).
+   *   At indexing, you should specify geoloc of an object with the _geoloc attribute (in the form {"_geoloc":{"lat":48.853409, "lng":2.348800}})
+   * - numericFilters: a string that contains the list of numeric filters you want to apply separated by a comma.
+   *   The syntax of one filter is `attributeName` followed by `operand` followed by `value`. Supported operands are `<`, `<=`, `=`, `>` and `>=`.
+   *   You can have multiple conditions on one attribute like for example numericFilters=price>100,price<1000.
+   *   You can also use an array (for example numericFilters: ["price>100","price<1000"]).
+   * - tagFilters: filter the query by a set of tags. You can AND tags by separating them by commas.
+   *   To OR tags, you must add parentheses. For example, tags=tag1,(tag2,tag3) means tag1 AND (tag2 OR tag3).
+   *   You can also use an array, for example tagFilters: ["tag1",["tag2","tag3"]] means tag1 AND (tag2 OR tag3).
+   *   At indexing, tags should be added in the _tags** attribute of objects (for example {"_tags":["tag1","tag2"]}).
+   * - facetFilters: filter the query by a list of facets.
+   *   Facets are separated by commas and each facet is encoded as `attributeName:value`.
+   *   For example: `facetFilters=category:Book,author:John%20Doe`.
+   *   You can also use an array (for example `["category:Book","author:John%20Doe"]`).
+   * - facets: List of object attributes that you want to use for faceting.
+   *   Comma separated list: `"category,author"` or array `['category','author']`
+   *   Only attributes that have been added in **attributesForFaceting** index setting can be used in this parameter.
+   *   You can also use `*` to perform faceting on all attributes specified in **attributesForFaceting**.
+   * - queryType: select how the query words are interpreted, it can be one of the following value:
+   *    - prefixAll: all query words are interpreted as prefixes,
+   *    - prefixLast: only the last word is interpreted as a prefix (default behavior),
+   *    - prefixNone: no query word is interpreted as a prefix. This option is not recommended.
+   * - optionalWords: a string that contains the list of words that should be considered as optional when found in the query.
+   *   Comma separated and array are accepted.
+   * - distinct: If set to 1, enable the distinct feature (disabled by default) if the attributeForDistinct index setting is set.
+   *   This feature is similar to the SQL "distinct" keyword: when enabled in a query with the distinct=1 parameter,
+   *   all hits containing a duplicate value for the attributeForDistinct attribute are removed from results.
+   *   For example, if the chosen attribute is show_name and several hits have the same value for show_name, then only the best
+   *   one is kept and others are removed.
+   * - restrictSearchableAttributes: List of attributes you want to use for textual search (must be a subset of the attributesToIndex index setting)
+   * either comma separated or as an array
+   * @param delay (optional) if set, wait for this delay (in ms) and only send the query if there was no other in the meantime.
+   */
+  search: function(query, callback, args, delay) {
+    if (query === undefined || query === null) {
+      query = '';
+    }
 
-            if (typeof callback === 'object' && (this.as._isUndefined(args) || !args)) {
-                args = callback;
-                callback = null;
-            }
+    // no query = getAllObjects
+    if (typeof query === 'function') {
+      callback = query;
+      query = '';
+    }
 
-            var indexObj = this;
-            var params = 'query=' + encodeURIComponent(query);
-            if (!this.as._isUndefined(args) && args !== null) {
-                params = this.as._getSearchParams(args, params);
-            }
-            window.clearTimeout(indexObj.onDelayTrigger);
-            if (!this.as._isUndefined(delay) && delay !== null && delay > 0) {
-                var onDelayTrigger = window.setTimeout( function() {
-                    indexObj._search(params, callback);
-                }, delay);
-                indexObj.onDelayTrigger = onDelayTrigger;
-            } else {
-                return this._search(params, callback);
-            }
-        },
-
-        /*
-         * Browse all index content
-         *
-         * @param page Pagination parameter used to select the page to retrieve.
-         *             Page is zero-based and defaults to 0. Thus, to retrieve the 10th page you need to set page=9
-         * @param hitsPerPage: Pagination parameter used to select the number of hits per page. Defaults to 1000.
-         */
-        browse: function(page, callback, hitsPerPage) {
-            if (+callback > 0 && (this.as._isUndefined(hitsPerPage) || !hitsPerPage)) {
-                hitsPerPage = callback;
-                callback = null;
-            }
-            var indexObj = this;
-            var params = '?page=' + page;
-            if (!this.as._isUndefined(hitsPerPage)) {
-                params += '&hitsPerPage=' + hitsPerPage;
-            }
-            return this.as._jsonRequest({ method: 'GET',
-                                   url: '/1/indexes/' + encodeURIComponent(indexObj.indexName) + '/browse' + params,
-                                   callback: callback });
-        },
-
-        /*
-         * Get a Typeahead.js adapter
-         * @param searchParams contains an object with query parameters (see search for details)
-         */
-        ttAdapter: function(params) {
-            var self = this;
-            return function(query, cb) {
-                self.search(query, function(success, content) {
-                    if (success) {
-                        cb(content.hits);
-                    }
-                }, params);
-            };
-        },
-
-        /*
-         * Wait the publication of a task on the server.
-         * All server task are asynchronous and you can check with this method that the task is published.
-         *
-         * @param taskID the id of the task returned by server
-         * @param callback the result callback with with two arguments:
-         *  success: boolean set to true if the request was successfull
-         *  content: the server answer that contains the list of results
-         */
-        waitTask: function(taskID, callback) {
-            var indexObj = this;
-            return this.as._jsonRequest({ method: 'GET',
-                                   url: '/1/indexes/' + encodeURIComponent(indexObj.indexName) + '/task/' + taskID,
-                                   callback: function(success, body) {
-                if (success) {
-                    if (body.status === 'published') {
-                        callback(true, body);
-                    } else {
-                        setTimeout(function() { indexObj.waitTask(taskID, callback); }, 100);
-                    }
-                } else {
-                    callback(false, body);
-                }
-            }});
-        },
-
-        /*
-         * This function deletes the index content. Settings and index specific API keys are kept untouched.
-         *
-         * @param callback (optional) the result callback with two arguments
-         *  success: boolean set to true if the request was successfull
-         *  content: the settings object or the error message if a failure occured
-         */
-        clearIndex: function(callback) {
-            var indexObj = this;
-            return this.as._jsonRequest({ method: 'POST',
-                                   url: '/1/indexes/' + encodeURIComponent(indexObj.indexName) + '/clear',
-                                   callback: callback });
-        },
-        /*
-         * Get settings of this index
-         *
-         * @param callback (optional) the result callback with two arguments
-         *  success: boolean set to true if the request was successfull
-         *  content: the settings object or the error message if a failure occured
-         */
-        getSettings: function(callback) {
-            var indexObj = this;
-            return this.as._jsonRequest({ method: 'GET',
-                                   url: '/1/indexes/' + encodeURIComponent(indexObj.indexName) + '/settings',
-                                   callback: callback });
-        },
-
-        /*
-         * Set settings for this index
-         *
-         * @param settigns the settings object that can contains :
-         * - minWordSizefor1Typo: (integer) the minimum number of characters to accept one typo (default = 3).
-         * - minWordSizefor2Typos: (integer) the minimum number of characters to accept two typos (default = 7).
-         * - hitsPerPage: (integer) the number of hits per page (default = 10).
-         * - attributesToRetrieve: (array of strings) default list of attributes to retrieve in objects.
-         *   If set to null, all attributes are retrieved.
-         * - attributesToHighlight: (array of strings) default list of attributes to highlight.
-         *   If set to null, all indexed attributes are highlighted.
-         * - attributesToSnippet**: (array of strings) default list of attributes to snippet alongside the number of words to return (syntax is attributeName:nbWords).
-         *   By default no snippet is computed. If set to null, no snippet is computed.
-         * - attributesToIndex: (array of strings) the list of fields you want to index.
-         *   If set to null, all textual and numerical attributes of your objects are indexed, but you should update it to get optimal results.
-         *   This parameter has two important uses:
-         *     - Limit the attributes to index: For example if you store a binary image in base64, you want to store it and be able to
-         *       retrieve it but you don't want to search in the base64 string.
-         *     - Control part of the ranking*: (see the ranking parameter for full explanation) Matches in attributes at the beginning of
-         *       the list will be considered more important than matches in attributes further down the list.
-         *       In one attribute, matching text at the beginning of the attribute will be considered more important than text after, you can disable
-         *       this behavior if you add your attribute inside `unordered(AttributeName)`, for example attributesToIndex: ["title", "unordered(text)"].
-         * - attributesForFaceting: (array of strings) The list of fields you want to use for faceting.
-         *   All strings in the attribute selected for faceting are extracted and added as a facet. If set to null, no attribute is used for faceting.
-         * - attributeForDistinct: (string) The attribute name used for the Distinct feature. This feature is similar to the SQL "distinct" keyword: when enabled
-         *   in query with the distinct=1 parameter, all hits containing a duplicate value for this attribute are removed from results.
-         *   For example, if the chosen attribute is show_name and several hits have the same value for show_name, then only the best one is kept and others are removed.
-         * - ranking: (array of strings) controls the way results are sorted.
-         *   We have six available criteria:
-         *    - typo: sort according to number of typos,
-         *    - geo: sort according to decreassing distance when performing a geo-location based search,
-         *    - proximity: sort according to the proximity of query words in hits,
-         *    - attribute: sort according to the order of attributes defined by attributesToIndex,
-         *    - exact:
-         *        - if the user query contains one word: sort objects having an attribute that is exactly the query word before others.
-         *          For example if you search for the "V" TV show, you want to find it with the "V" query and avoid to have all popular TV
-         *          show starting by the v letter before it.
-         *        - if the user query contains multiple words: sort according to the number of words that matched exactly (and not as a prefix).
-         *    - custom: sort according to a user defined formula set in **customRanking** attribute.
-         *   The standard order is ["typo", "geo", "proximity", "attribute", "exact", "custom"]
-         * - customRanking: (array of strings) lets you specify part of the ranking.
-         *   The syntax of this condition is an array of strings containing attributes prefixed by asc (ascending order) or desc (descending order) operator.
-         *   For example `"customRanking" => ["desc(population)", "asc(name)"]`
-         * - 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.
-         * - highlightPreTag: (string) Specify the string that is inserted before the highlighted parts in the query result (default to "<em>").
-         * - highlightPostTag: (string) Specify the string that is inserted after the highlighted parts in the query result (default to "</em>").
-         * - optionalWords: (array of strings) Specify a list of words that should be considered as optional when found in the query.
-         * @param callback (optional) the result callback with two arguments
-         *  success: boolean set to true if the request was successfull
-         *  content: the server answer or the error message if a failure occured
-         */
-        setSettings: function(settings, callback) {
-            var indexObj = this;
-            return this.as._jsonRequest({ method: 'PUT',
-                                   url: '/1/indexes/' + encodeURIComponent(indexObj.indexName) + '/settings',
-                                   body: settings,
-                                   callback: callback });
-        },
-        /*
-         * List all existing user keys associated to this index
-         *
-         * @param callback the result callback with two arguments
-         *  success: boolean set to true if the request was successfull
-         *  content: the server answer with user keys list or error description if success is false.
-         */
-        listUserKeys: function(callback) {
-            var indexObj = this;
-            return this.as._jsonRequest({ method: 'GET',
-                                   url: '/1/indexes/' + encodeURIComponent(indexObj.indexName) + '/keys',
-                                   callback: callback });
-        },
-        /*
-         * Get ACL of a user key associated to this index
-         *
-         * @param callback the result callback with two arguments
-         *  success: boolean set to true if the request was successfull
-         *  content: the server answer with user keys list or error description if success is false.
-         */
-        getUserKeyACL: function(key, callback) {
-            var indexObj = this;
-            return this.as._jsonRequest({ method: 'GET',
-                                   url: '/1/indexes/' + encodeURIComponent(indexObj.indexName) + '/keys/' + key,
-                                   callback: callback });
-        },
-        /*
-         * Delete an existing user key associated to this index
-         *
-         * @param callback the result callback with two arguments
-         *  success: boolean set to true if the request was successfull
-         *  content: the server answer with user keys list or error description if success is false.
-         */
-        deleteUserKey: function(key, callback) {
-            var indexObj = this;
-            return this.as._jsonRequest({ method: 'DELETE',
-                                   url: '/1/indexes/' + encodeURIComponent(indexObj.indexName) + '/keys/' + key,
-                                   callback: callback });
-        },
-        /*
-         * Add an existing user key associated to this index
-         *
-         * @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/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 callback the result callback with two arguments
-         *  success: boolean set to true if the request was successfull
-         *  content: the server answer with user keys list or error description if success is false.
-         */
-        addUserKey: function(acls, callback) {
-            var indexObj = this;
-            var aclsObject = {};
-            aclsObject.acl = acls;
-            return this.as._jsonRequest({ method: 'POST',
-                                   url: '/1/indexes/' + encodeURIComponent(indexObj.indexName) + '/keys',
-                                   body: aclsObject,
-                                   callback: callback });
-        },
-        /*
-         * Add an existing user key associated to this index
-         *
-         * @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/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 Specify the maximum number of API calls allowed from an IP address per hour.
-         * @param maxHitsPerQuery Specify the maximum number of hits this API key can retrieve in one call.
-         * @param callback the result callback with two arguments
-         *  success: boolean set to true if the request was successfull
-         *  content: the server answer with user keys list or error description if success is false.
-         */
-        addUserKeyWithValidity: function(acls, validity, maxQueriesPerIPPerHour, maxHitsPerQuery, callback) {
-            var indexObj = this;
-            var aclsObject = {};
-            aclsObject.acl = acls;
-            aclsObject.validity = validity;
-            aclsObject.maxQueriesPerIPPerHour = maxQueriesPerIPPerHour;
-            aclsObject.maxHitsPerQuery = maxHitsPerQuery;
-            return this.as._jsonRequest({ method: 'POST',
-                                   url: '/1/indexes/' + encodeURIComponent(indexObj.indexName) + '/keys',
-                                   body: aclsObject,
-                                   callback: callback });
-        },
-        ///
-        /// Internal methods only after this line
-        ///
-        _search: function(params, callback) {
-            var pObj = {params: params};
-            if (this.as.jsonp === null) {
-                var self = this;
-                return this.as._jsonRequest({ cache: this.cache,
-                    method: 'POST',
-                    url: '/1/indexes/' + encodeURIComponent(this.indexName) + '/query',
-                    body: pObj,
-                    callback: function(success, content) {
-                        if (!success) {
-                            // retry first with JSONP
-                            self.as.jsonp = true;
-                            self._search(params, callback);
-                        } else {
-                            self.as.jsonp = false;
-                            callback && callback(success, content);
-                        }
-                    }
-                });
-            } else if (this.as.jsonp) {
-                return this.as._jsonRequest({ cache: this.cache,
-                                       method: 'GET',
-                                       url: '/1/indexes/' + encodeURIComponent(this.indexName),
-                                       body: pObj,
-                                       callback: callback });
-            } else {
-                return this.as._jsonRequest({ cache: this.cache,
-                                       method: 'POST',
-                                       url: '/1/indexes/' + encodeURIComponent(this.indexName) + '/query',
-                                       body: pObj,
-                                       callback: callback});
-            }
-        },
+    if (typeof callback === 'object' && (this.as._isUndefined(args) || !args)) {
+      args = callback;
+      callback = null;
+    }
+
+    var indexObj = this;
+    var params = 'query=' + encodeURIComponent(query);
+    if (!this.as._isUndefined(args) && args !== null) {
+      params = this.as._getSearchParams(args, params);
+    }
+    window.clearTimeout(indexObj.onDelayTrigger);
+    if (!this.as._isUndefined(delay) && delay !== null && delay > 0) {
+      var onDelayTrigger = window.setTimeout( function() {
+        indexObj._search(params, callback);
+      }, delay);
+      indexObj.onDelayTrigger = onDelayTrigger;
+    } else {
+      return this._search(params, callback);
+    }
+  },
+
+  /*
+   * Browse all index content
+   *
+   * @param page Pagination parameter used to select the page to retrieve.
+   *             Page is zero-based and defaults to 0. Thus, to retrieve the 10th page you need to set page=9
+   * @param hitsPerPage: Pagination parameter used to select the number of hits per page. Defaults to 1000.
+   */
+  browse: function(page, callback, hitsPerPage) {
+    if (+callback > 0 && (this.as._isUndefined(hitsPerPage) || !hitsPerPage)) {
+      hitsPerPage = callback;
+      callback = null;
+    }
+    var indexObj = this;
+    var params = '?page=' + page;
+    if (!this.as._isUndefined(hitsPerPage)) {
+      params += '&hitsPerPage=' + hitsPerPage;
+    }
+    return this.as._jsonRequest({ method: 'GET',
+                 url: '/1/indexes/' + encodeURIComponent(indexObj.indexName) + '/browse' + params,
+                 callback: callback });
+  },
+
+  /*
+   * Get a Typeahead.js adapter
+   * @param searchParams contains an object with query parameters (see search for details)
+   */
+  ttAdapter: function(params) {
+    var self = this;
+    return function(query, cb) {
+      self.search(query, function(success, content) {
+        if (success) {
+          cb(content.hits);
+        } else {
+          cb(content && content.message);
+        }
+      }, params);
+    };
+  },
+
+  /*
+   * Wait the publication of a task on the server.
+   * All server task are asynchronous and you can check with this method that the task is published.
+   *
+   * @param taskID the id of the task returned by server
+   * @param callback the result callback with with two arguments:
+   *  success: boolean set to true if the request was successfull
+   *  content: the server answer that contains the list of results
+   */
+  waitTask: function(taskID, callback) {
+    var indexObj = this;
+    return this.as._jsonRequest({ method: 'GET',
+                 url: '/1/indexes/' + encodeURIComponent(indexObj.indexName) + '/task/' + taskID,
+                 callback: function(success, body) {
+      if (success) {
+        if (body.status === 'published') {
+          callback(true, body);
+        } else {
+          setTimeout(function() { indexObj.waitTask(taskID, callback); }, 100);
+        }
+      } else {
+        callback(false, body);
+      }
+    }});
+  },
+
+  /*
+   * This function deletes the index content. Settings and index specific API keys are kept untouched.
+   *
+   * @param callback (optional) the result callback with two arguments
+   *  success: boolean set to true if the request was successfull
+   *  content: the settings object or the error message if a failure occured
+   */
+  clearIndex: function(callback) {
+    var indexObj = this;
+    return this.as._jsonRequest({ method: 'POST',
+                 url: '/1/indexes/' + encodeURIComponent(indexObj.indexName) + '/clear',
+                 callback: callback });
+  },
+  /*
+   * Get settings of this index
+   *
+   * @param callback (optional) the result callback with two arguments
+   *  success: boolean set to true if the request was successfull
+   *  content: the settings object or the error message if a failure occured
+   */
+  getSettings: function(callback) {
+    var indexObj = this;
+    return this.as._jsonRequest({ method: 'GET',
+                 url: '/1/indexes/' + encodeURIComponent(indexObj.indexName) + '/settings',
+                 callback: callback });
+  },
+
+  /*
+   * Set settings for this index
+   *
+   * @param settigns the settings object that can contains :
+   * - minWordSizefor1Typo: (integer) the minimum number of characters to accept one typo (default = 3).
+   * - minWordSizefor2Typos: (integer) the minimum number of characters to accept two typos (default = 7).
+   * - hitsPerPage: (integer) the number of hits per page (default = 10).
+   * - attributesToRetrieve: (array of strings) default list of attributes to retrieve in objects.
+   *   If set to null, all attributes are retrieved.
+   * - attributesToHighlight: (array of strings) default list of attributes to highlight.
+   *   If set to null, all indexed attributes are highlighted.
+   * - attributesToSnippet**: (array of strings) default list of attributes to snippet alongside the number of words to return (syntax is attributeName:nbWords).
+   *   By default no snippet is computed. If set to null, no snippet is computed.
+   * - attributesToIndex: (array of strings) the list of fields you want to index.
+   *   If set to null, all textual and numerical attributes of your objects are indexed, but you should update it to get optimal results.
+   *   This parameter has two important uses:
+   *     - Limit the attributes to index: For example if you store a binary image in base64, you want to store it and be able to
+   *       retrieve it but you don't want to search in the base64 string.
+   *     - Control part of the ranking*: (see the ranking parameter for full explanation) Matches in attributes at the beginning of
+   *       the list will be considered more important than matches in attributes further down the list.
+   *       In one attribute, matching text at the beginning of the attribute will be considered more important than text after, you can disable
+   *       this behavior if you add your attribute inside `unordered(AttributeName)`, for example attributesToIndex: ["title", "unordered(text)"].
+   * - attributesForFaceting: (array of strings) The list of fields you want to use for faceting.
+   *   All strings in the attribute selected for faceting are extracted and added as a facet. If set to null, no attribute is used for faceting.
+   * - attributeForDistinct: (string) The attribute name used for the Distinct feature. This feature is similar to the SQL "distinct" keyword: when enabled
+   *   in query with the distinct=1 parameter, all hits containing a duplicate value for this attribute are removed from results.
+   *   For example, if the chosen attribute is show_name and several hits have the same value for show_name, then only the best one is kept and others are removed.
+   * - ranking: (array of strings) controls the way results are sorted.
+   *   We have six available criteria:
+   *    - typo: sort according to number of typos,
+   *    - geo: sort according to decreassing distance when performing a geo-location based search,
+   *    - proximity: sort according to the proximity of query words in hits,
+   *    - attribute: sort according to the order of attributes defined by attributesToIndex,
+   *    - exact:
+   *        - if the user query contains one word: sort objects having an attribute that is exactly the query word before others.
+   *          For example if you search for the "V" TV show, you want to find it with the "V" query and avoid to have all popular TV
+   *          show starting by the v letter before it.
+   *        - if the user query contains multiple words: sort according to the number of words that matched exactly (and not as a prefix).
+   *    - custom: sort according to a user defined formula set in **customRanking** attribute.
+   *   The standard order is ["typo", "geo", "proximity", "attribute", "exact", "custom"]
+   * - customRanking: (array of strings) lets you specify part of the ranking.
+   *   The syntax of this condition is an array of strings containing attributes prefixed by asc (ascending order) or desc (descending order) operator.
+   *   For example `"customRanking" => ["desc(population)", "asc(name)"]`
+   * - 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.
+   * - highlightPreTag: (string) Specify the string that is inserted before the highlighted parts in the query result (default to "<em>").
+   * - highlightPostTag: (string) Specify the string that is inserted after the highlighted parts in the query result (default to "</em>").
+   * - optionalWords: (array of strings) Specify a list of words that should be considered as optional when found in the query.
+   * @param callback (optional) the result callback with two arguments
+   *  success: boolean set to true if the request was successfull
+   *  content: the server answer or the error message if a failure occured
+   */
+  setSettings: function(settings, callback) {
+    var indexObj = this;
+    return this.as._jsonRequest({ method: 'PUT',
+                 url: '/1/indexes/' + encodeURIComponent(indexObj.indexName) + '/settings',
+                 body: settings,
+                 callback: callback });
+  },
+  /*
+   * List all existing user keys associated to this index
+   *
+   * @param callback the result callback with two arguments
+   *  success: boolean set to true if the request was successfull
+   *  content: the server answer with user keys list or error description if success is false.
+   */
+  listUserKeys: function(callback) {
+    var indexObj = this;
+    return this.as._jsonRequest({ method: 'GET',
+                 url: '/1/indexes/' + encodeURIComponent(indexObj.indexName) + '/keys',
+                 callback: callback });
+  },
+  /*
+   * Get ACL of a user key associated to this index
+   *
+   * @param callback the result callback with two arguments
+   *  success: boolean set to true if the request was successfull
+   *  content: the server answer with user keys list or error description if success is false.
+   */
+  getUserKeyACL: function(key, callback) {
+    var indexObj = this;
+    return this.as._jsonRequest({ method: 'GET',
+                 url: '/1/indexes/' + encodeURIComponent(indexObj.indexName) + '/keys/' + key,
+                 callback: callback });
+  },
+  /*
+   * Delete an existing user key associated to this index
+   *
+   * @param callback the result callback with two arguments
+   *  success: boolean set to true if the request was successfull
+   *  content: the server answer with user keys list or error description if success is false.
+   */
+  deleteUserKey: function(key, callback) {
+    var indexObj = this;
+    return this.as._jsonRequest({ method: 'DELETE',
+                 url: '/1/indexes/' + encodeURIComponent(indexObj.indexName) + '/keys/' + key,
+                 callback: callback });
+  },
+  /*
+   * Add an existing user key associated to this index
+   *
+   * @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/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 callback the result callback with two arguments
+   *  success: boolean set to true if the request was successfull
+   *  content: the server answer with user keys list or error description if success is false.
+   */
+  addUserKey: function(acls, callback) {
+    var indexObj = this;
+    var aclsObject = {};
+    aclsObject.acl = acls;
+    return this.as._jsonRequest({ method: 'POST',
+                 url: '/1/indexes/' + encodeURIComponent(indexObj.indexName) + '/keys',
+                 body: aclsObject,
+                 callback: callback });
+  },
+  /*
+   * Add an existing user key associated to this index
+   *
+   * @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/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 Specify the maximum number of API calls allowed from an IP address per hour.
+   * @param maxHitsPerQuery Specify the maximum number of hits this API key can retrieve in one call.
+   * @param callback the result callback with two arguments
+   *  success: boolean set to true if the request was successfull
+   *  content: the server answer with user keys list or error description if success is false.
+   */
+  addUserKeyWithValidity: function(acls, validity, maxQueriesPerIPPerHour, maxHitsPerQuery, callback) {
+    var indexObj = this;
+    var aclsObject = {};
+    aclsObject.acl = acls;
+    aclsObject.validity = validity;
+    aclsObject.maxQueriesPerIPPerHour = maxQueriesPerIPPerHour;
+    aclsObject.maxHitsPerQuery = maxHitsPerQuery;
+    return this.as._jsonRequest({ method: 'POST',
+                 url: '/1/indexes/' + encodeURIComponent(indexObj.indexName) + '/keys',
+                 body: aclsObject,
+                 callback: callback });
+  },
+  ///
+  /// Internal methods only after this line
+  ///
+  _search: function(params, callback) {
+    var pObj = {params: params};
+    if (this.as.jsonp === null) {
+      var self = this;
+      return this.as._jsonRequest({ cache: this.cache,
+        method: 'POST',
+        url: '/1/indexes/' + encodeURIComponent(this.indexName) + '/query',
+        body: pObj,
+        callback: function(success, content) {
+          var status = content && content.status;
+          if (success || status && Math.floor(status / 100) === 4 || Math.floor(status / 100) === 1) {
+            self.as.jsonp = false;
+            callback && callback(success, content);
+          } else {
+            self.as.jsonp = true;
+            self._search(params, callback);
+          }
+        }
+      });
+    } else if (this.as.jsonp) {
+      return this.as._jsonRequest({ cache: this.cache,
+                   method: 'GET',
+                   url: '/1/indexes/' + encodeURIComponent(this.indexName),
+                   body: pObj,
+                   callback: callback });
+    } else {
+      return this.as._jsonRequest({ cache: this.cache,
+                   method: 'POST',
+                   url: '/1/indexes/' + encodeURIComponent(this.indexName) + '/query',
+                   body: pObj,
+                   callback: callback});
+    }
+  },
 
-        // internal attributes
-        as: null,
-        indexName: null,
-        typeAheadArgs: null,
-        typeAheadValueOption: null
+  // internal attributes
+  as: null,
+  indexName: null,
+  typeAheadArgs: null,
+  typeAheadValueOption: null
 };
 
 /*
@@ -1876,7 +1939,7 @@ AlgoliaSearch.prototype.Index.prototype = {
         }
         var aggregatedAnswer = content.results[0];
         aggregatedAnswer.disjunctiveFacets = aggregatedAnswer.disjunctiveFacets || {};
-        aggregatedAnswer.facetStats = aggregatedAnswer.facetStats || {};
+        aggregatedAnswer.facets_stats = aggregatedAnswer.facets_stats || {};
         // create disjunctive facets from facets (disjunctive facets without refinements)
         for (var facet in unusedDisjunctiveFacets) {
           if (aggregatedAnswer.facets[facet] && !aggregatedAnswer.disjunctiveFacets[facet]) {
@@ -1903,9 +1966,13 @@ AlgoliaSearch.prototype.Index.prototype = {
           }
           // aggregate the disjunctive facets stats
           for (var stats in content.results[i + 1].facets_stats) {
-            aggregatedAnswer.facetStats[stats] = content.results[i + 1].facets_stats[stats];
+            aggregatedAnswer.facets_stats[stats] = content.results[i + 1].facets_stats[stats];
           }
         }
+
+        // Backward compatibility
+        aggregatedAnswer.facetStats = aggregatedAnswer.facets_stats;
+
         // add the excludes
         for (var exclude in self.excludes) {
           if (self.excludes[exclude]) {
@@ -1969,7 +2036,8 @@ AlgoliaSearch.prototype.Index.prototype = {
         attributesToHighlight: [],
         attributesToSnippet: [],
         facets: facet,
-        facetFilters: this._getFacetFilters(facet)
+        facetFilters: this._getFacetFilters(facet),
+        analytics: false
       });
     },