Switch up source api for more flexibility.

src/bloodhound/bloodhound.js

@@ -15,7 +15,7 @@ var Bloodhound = (function() {
   // constructor
   // -----------
 
-  function Bloodhound(o) {
+  function Bloodhound(o, initialize) {
     if (!o || (!o.local && !o.prefetch && !o.remote)) {
       $.error('one of local, prefetch, or remote is required');
     }
@@ -39,6 +39,9 @@ var Bloodhound = (function() {
     // only initialize storage if there's a cacheKey otherwise
     // loading from storage on subsequent page loads is impossible
     this.storage = this.cacheKey ? new PersistentStorage(this.cacheKey) : null;
+
+    // if the initialize argument is truthy, kick off initialization
+    o.initialize && this.initialize();
   }
 
   // static methods
@@ -61,13 +64,13 @@ var Bloodhound = (function() {
     __ttAdapter: function ttAdapter() {
       var that = this;
 
-      return this.transport ? withBackfill : withoutBackfill;
+      return this.transport ? withAsync : withoutAsync;
 
-      function withBackfill(query, backfill) {
-        return that.get(query, backfill);
+      function withAsync(query, sync, async) {
+        return that.get(query, sync, async);
       }
 
-      function withoutBackfill(query) {
+      function withoutAsync(query) {
         return that.get(query);
       }
     },
@@ -187,24 +190,27 @@ var Bloodhound = (function() {
 
     add: function add(data) {
       this.index.add(data);
+      return this;
     },
 
-    get: function get(query, backfill) {
+    get: function get(query, sync, async) {
       var that = this, local;
 
       local = this.sorter(this.index.get(query));
 
-      if (this.remote) {
-        local.length < this.remote.sufficient ?
-          this._getFromRemote(query, processRemote) :
-          this._cancelLastRemoteRequest();
+      // return a copy to guarantee no changes within this scope
+      // as this array will get used when processing the remote results
+      sync(this.remote ? local.slice() : local);
+
+      if (this.remote && local.length < this.remote.sufficient) {
+        this._getFromRemote(query, processRemote);
+      }
 
-        // return a copy to guarantee no changes within this scope
-        // as this array will get used when processing the remote results
-        return local.slice();
+      else if (this.remote) {
+        this._cancelLastRemoteRequest();
       }
 
-      return local;
+      return this;
 
       function processRemote(remote) {
         var nonDuplicates = [];
@@ -220,7 +226,7 @@ var Bloodhound = (function() {
           !isDuplicate && nonDuplicates.push(r);
         });
 
-        backfill && backfill(nonDuplicates);
+        async && async(nonDuplicates);
       }
     },
 
@@ -230,14 +236,17 @@ var Bloodhound = (function() {
 
     clear: function clear() {
       this.index.reset();
+      return this;
     },
 
     clearPrefetchCache: function clearPrefetchCache() {
       this.storage && this.storage.clear();
+      return this;
     },
 
     clearRemoteCache: function clearRemoteCache() {
       this.transport && Transport.resetCache();
+      return this;
     },
 
     // DEPRECATED: will be removed in v1

src/bloodhound/transport.js

@@ -24,7 +24,6 @@ var Transport = (function() {
     this._send = o.transport ? callbackToDeferred(o.transport) : $.ajax;
     this._get = o.rateLimiter ? o.rateLimiter(this._get) : this._get;
 
-    // eh, should this even exist? relying on the browser's cache may be enough
     this._cache = o.cache === false ? new LruCache(0) : sharedCache;
   }
 
@@ -78,12 +77,12 @@ var Transport = (function() {
       }
 
       function done(resp) {
-        cb && cb(null, resp);
+        cb(null, resp);
         that._cache.set(fingerprint, resp);
       }
 
       function fail() {
-        cb && cb(true);
+        cb(true);
       }
 
       function always() {
@@ -103,24 +102,23 @@ var Transport = (function() {
     get: function(o, cb) {
       var resp, fingerprint;
 
+      cb = cb || $.noop;
       o = _.isString(o) ? { url: o } : (o || {});
+
       fingerprint = this._fingerprint(o);
 
       this.cancelled = false;
       this.lastReq = fingerprint;
 
       // in-memory cache hit
       if (resp = this._cache.get(fingerprint)) {
-        // defer to stay consistent with behavior of ajax call
-        _.defer(function() { cb && cb(null, resp); });
+        cb(null, resp);
       }
 
+      // go to network
       else {
         this._get(o, cb);
       }
-
-      // return bool indicating whether or not a cache hit occurred
-      return !!resp;
     },
 
     cancel: function() {

src/typeahead/dataset.js

@@ -230,7 +230,7 @@ var Dataset = (function() {
     },
 
     update: function update(query) {
-      var that = this, canceled = false, results, rendered;
+      var that = this, canceled = false, ignoreSync = false, rendered = 0;
 
       // cancel possible pending update
       this.cancel();
@@ -241,23 +241,36 @@ var Dataset = (function() {
         that.async && that.trigger('asyncCanceled', query);
       };
 
-      results = (this.source(query, append) || []).slice(0, this.limit);
-      rendered = results.length;
+      this.source(query, sync, async);
 
-      this._overwrite(query, results);
+      // any calls to the sync callback from here on out should be ignored
+      // as they would have been done asynchronously
+      ignoreSync = true;
 
       if (rendered < this.limit && this.async) {
-        this.trigger('asyncRequested', query);
+        that.trigger('asyncRequested', query);
       }
 
-      function append(results) {
+      function sync(results) {
+        if (ignoreSync) { return; }
+
+        ignoreSync = true;
+        results = (results || []).slice(0, that.limit);
+        rendered = results.length;
+
+        that._overwrite(query, results);
+      }
+
+      function async(results) {
         results = results || [];
+
         // if the update has been canceled or if the query has changed
         // do not render the results as they've become outdated
         if (!canceled && rendered < that.limit) {
           that.cancel = $.noop;
-          that._append(query, results.slice(0, that.limit - rendered));
           rendered += results.length;
+          that._append(query, results.slice(0, that.limit - rendered));
+
           that.async && that.trigger('asyncReceived', query);
         }
       }