X-Git-Url: https://git.donarmstrong.com/dactyl.git?a=blobdiff_plain;f=common%2Fcontent%2Fbookmarks.js;h=dd64e545cc8e0a763f5c3f5079f4b77d6692a1f5;hb=247daf849abc85f4cfb10fa358c62c8daf8db95b;hp=09f088c54fef59759a0c14206954ec51c9d4adca;hpb=354a049cce8415487552ce405cce167b7071fe1f;p=dactyl.git

diff --git a/common/content/bookmarks.js b/common/content/bookmarks.js
index 09f088c..dd64e54 100644
--- a/common/content/bookmarks.js
+++ b/common/content/bookmarks.js
@@ -1,6 +1,6 @@
 // Copyright (c) 2006-2008 by Martin Stubenschrott <stubenschrott@vimperator.org>
 // Copyright (c) 2007-2011 by Doug Kearns <dougkearns@gmail.com>
-// Copyright (c) 2008-2013 Kris Maglione <maglione.k@gmail.com>
+// Copyright (c) 2008-2014 Kris Maglione <maglione.k@gmail.com>
 //
 // This work is licensed for reuse under an MIT license. Details are
 // given in the LICENSE.txt file included with this file.
@@ -73,7 +73,7 @@ var Bookmarks = Module("bookmarks", {
         if (id != null)
             var bmark = bookmarkcache.bookmarks[id];
         else if (!force) {
-            if (keyword && Set.has(bookmarkcache.keywords, keyword))
+            if (keyword && hasOwnProperty(bookmarkcache.keywords, keyword))
                 bmark = bookmarkcache.keywords[keyword];
             else if (bookmarkcache.isBookmarked(uri))
                 for (bmark in bookmarkcache)
@@ -172,7 +172,7 @@ var Bookmarks = Module("bookmarks", {
         }
     },
 
-    isBookmarked: deprecated("bookmarkcache.isBookmarked", { get: function isBookmarked() bookmarkcache.closure.isBookmarked }),
+    isBookmarked: deprecated("bookmarkcache.isBookmarked", { get: function isBookmarked() bookmarkcache.bound.isBookmarked }),
 
     /**
      * Remove a bookmark or bookmarks. If *ids* is an array, removes the
@@ -189,7 +189,7 @@ var Bookmarks = Module("bookmarks", {
                 let uri = util.newURI(ids);
                 ids = services.bookmarks
                               .getBookmarkIdsForURI(uri, {})
-                              .filter(bookmarkcache.closure.isRegularBookmark);
+                              .filter(bookmarkcache.bound.isRegularBookmark);
             }
             ids.forEach(function (id) {
                 let bmark = bookmarkcache.bookmarks[id];
@@ -223,7 +223,7 @@ var Bookmarks = Module("bookmarks", {
             if (!alias)
                 alias = "search"; // for search engines which we can't find a suitable alias
 
-            if (Set.has(aliases, alias))
+            if (hasOwnProperty(aliases, alias))
                 alias += ++aliases[alias];
             else
                 aliases[alias] = 0;
@@ -232,6 +232,31 @@ var Bookmarks = Module("bookmarks", {
         }).toObject();
     },
 
+    /**
+     * Returns true if the given search engine provides suggestions.
+     * engine based on the given *query*. The results are always in the
+     * form of an array of strings. If *callback* is provided, the
+     * request is executed asynchronously and *callback* is called on
+     * completion. Otherwise, the request is executed synchronously and
+     * the results are returned.
+     *
+     * @param {string} engineName The name of the search engine from
+     *      which to request suggestions.
+     * @returns {boolean}
+     */
+    hasSuggestions: function hasSuggestions(engineName, query, callback) {
+        const responseType = "application/x-suggestions+json";
+
+        if (hasOwnProperty(this.suggestionProviders, engineName))
+            return true;
+
+        let engine = hasOwnProperty(this.searchEngines, engineName) && this.searchEngines[engineName];
+        if (engine && engine.supportsResponseType(responseType))
+            return true;
+
+        return false;
+    },
+
     /**
      * Retrieves a list of search suggestions from the named search
      * engine based on the given *query*. The results are always in the
@@ -251,14 +276,15 @@ var Bookmarks = Module("bookmarks", {
     getSuggestions: function getSuggestions(engineName, query, callback) {
         const responseType = "application/x-suggestions+json";
 
-        if (Set.has(this.suggestionProviders, engineName))
+        if (hasOwnProperty(this.suggestionProviders, engineName))
             return this.suggestionProviders[engineName](query, callback);
 
-        let engine = Set.has(this.searchEngines, engineName) && this.searchEngines[engineName];
+        let engine = hasOwnProperty(this.searchEngines, engineName) && this.searchEngines[engineName];
         if (engine && engine.supportsResponseType(responseType))
             var queryURI = engine.getSubmission(query, responseType).uri.spec;
+
         if (!queryURI)
-            return (callback || util.identity)([]);
+            return promises.fail();
 
         function parse(req) JSON.parse(req.responseText)[1].filter(isString);
         return this.makeSuggestions(queryURI, parse, callback);
@@ -271,25 +297,25 @@ var Bookmarks = Module("bookmarks", {
      * @param {string} url The URL to fetch.
      * @param {function(XMLHttpRequest):[string]} parser The function which
      *      parses the response.
+     * @returns {Promise<Array>}
      */
-    makeSuggestions: function makeSuggestions(url, parser, callback) {
-        function process(req) {
+    makeSuggestions: function makeSuggestions(url, parser) {
+        let deferred = Promise.defer();
+
+        let req = util.fetchUrl(url);
+        req.then(function process(req) {
             let results = [];
             try {
                 results = parser(req);
             }
             catch (e) {
-                util.reportError(e);
+                return deferred.reject(e);
             }
-            if (callback)
-                return callback(results);
-            return results;
-        }
+            deferred.resolve(results);
+        }, Cu.reportError);
 
-        let req = util.httpGet(url, callback && process);
-        if (callback)
-            return req;
-        return process(req);
+        promises.oncancel(deferred, r => promises.cancel(req, reason));
+        return deferred.promise;
     },
 
     suggestionProviders: {},
@@ -320,7 +346,7 @@ var Bookmarks = Module("bookmarks", {
             param = query.substr(offset + 1);
         }
 
-        var engine = Set.has(bookmarks.searchEngines, keyword) && bookmarks.searchEngines[keyword];
+        var engine = hasOwnProperty(bookmarks.searchEngines, keyword) && bookmarks.searchEngines[keyword];
         if (engine) {
             if (engine.searchForm && !param)
                 return engine.searchForm;
@@ -536,7 +562,7 @@ var Bookmarks = Module("bookmarks", {
             "Delete a bookmark",
             function (args) {
                 if (args.bang)
-                    commandline.input(_("bookmark.prompt.deleteAll") + " ",
+                    commandline.input(_("bookmark.prompt.deleteAll") + " ").then(
                         function (resp) {
                             if (resp && resp.match(/^y(es)?$/i)) {
                                 bookmarks.remove(Object.keys(bookmarkcache.bookmarks));
@@ -628,7 +654,7 @@ var Bookmarks = Module("bookmarks", {
     },
 
     completion: function initCompletion() {
-        completion.bookmark = function bookmark(context, tags, extra = {}) {
+        completion.bookmark = function bookmark(context, tags, extra={}) {
             context.title = ["Bookmark", "Title"];
             context.format = bookmarks.format;
             iter(extra).forEach(function ([k, v]) {
@@ -655,7 +681,7 @@ var Bookmarks = Module("bookmarks", {
                          keyword, true);
 
             let item = keywords[keyword];
-            if (item && item.url.indexOf("%s") > -1)
+            if (item && item.url.contains("%s"))
                 context.fork("keyword/" + keyword, keyword.length + space.length, null, function (context) {
                     context.format = history.format;
                     context.title = [/*L*/keyword + " Quick Search"];
@@ -668,7 +694,7 @@ var Bookmarks = Module("bookmarks", {
                         return history.get({ uri: util.newURI(begin), uriIsPrefix: true }).map(function (item) {
                             let rest = item.url.length - end.length;
                             let query = item.url.substring(begin.length, rest);
-                            if (item.url.substr(rest) == end && query.indexOf("&") == -1)
+                            if (item.url.substr(rest) == end && query.contains("&"))
                                 try {
                                     item.url = decodeURIComponent(query.replace(/#.*/, "").replace(/\+/g, " "));
                                     return item;
@@ -696,16 +722,19 @@ var Bookmarks = Module("bookmarks", {
             let engineList = (engineAliases || options["suggestengines"].join(",") || "google").split(",");
 
             engineList.forEach(function (name) {
+                if (!bookmarks.hasSuggestions(name))
+                    return;
+
                 var desc = name;
                 let engine = bookmarks.searchEngines[name];
                 if (engine)
-                    var desc = engine.description;
-                else if (!Set.has(bookmarks.suggestionProviders, name))
-                    return;
+                    desc = engine.description;
+
 
                 let [, word] = /^\s*(\S+)/.exec(context.filter) || [];
                 if (!kludge && word == name) // FIXME: Check for matching keywords
                     return;
+
                 let ctxt = context.fork(name, 0);
 
                 ctxt.title = [/*L*/desc + " Suggestions"];
@@ -717,14 +746,20 @@ var Bookmarks = Module("bookmarks", {
                     return;
 
                 let words = ctxt.filter.toLowerCase().split(/\s+/g);
-                ctxt.completions = ctxt.completions.filter(i => words.every(w => i.toLowerCase().indexOf(w) >= 0));
+                ctxt.completions = ctxt.completions.filter(i => words.every(w => i.toLowerCase().contains(w)));
 
                 ctxt.hasItems = ctxt.completions.length;
                 ctxt.incomplete = true;
-                ctxt.cache.request = bookmarks.getSuggestions(name, ctxt.filter, function (compl) {
+                ctxt.cache.request = bookmarks.getSuggestions(name, ctxt.filter);
+                ctxt.cache.request.then(function (compl) {
                     ctxt.incomplete = false;
-                    ctxt.completions = array.uniq(ctxt.completions.filter(c => compl.indexOf(c) >= 0)
+                    ctxt.completions = array.uniq(ctxt.completions.filter(c => compl.contains(c))
                                                       .concat(compl), true);
+                }, function (e) {
+                    ctxt.incomplete = false;
+                    ctxt.completions = [];
+                    if (e)
+                        Cu.reportError(e);
                 });
             });
         };