Merge lp:~urbanape/bindwood/with-couch-libraries into lp:~urbanape/bindwood/trunk

[Zachery Bir]

[Zachery Bir (urbanape)]

We now have an extension that will propagate additions to CouchDB as well as deletions and modifications to bookmarks currently in CouchDB.

To test:

1) Ensure you have a local CouchDB running on port 5984 with a database called 'bookmarks'.

2) (Re)start Firefox with the extension in place

3) Add a bookmark

4) Verify it exists in CouchDB

5) Change the bookmark in Firefox (title or URI)

6) Verify the change was recorded (new rev #)

7) Delete the bookmark in Firefox

8) Verify the record no longer exists in CouchDB

[Stuart Langridge (sil)]

1. it's an extension to save your bookmarks to your desktop CouchDB, not to Ubuntu One
2. it would be useful to add some comments explaining it a bit, perhaps?
3. localhost:5984 is hardcoded (this will obviously be changed later, so it's probably OK now)

review: Approve

[Joshua Blount (jblount)]

This looks fine, noting that sil's comments are valid.

review: Approve

=== modified file 'chrome.manifest'
--- chrome.manifest	2009-06-30 13:47:50 +0000
+++ chrome.manifest	2009-07-02 13:41:07 +0000
@@ -1,2 +1,3 @@
-content ubuntuone-firefox-bookmark-sync chrome/content/
-overlay chrome://browser/content/browser.xul    chrome://ubuntuone-firefox-bookmark-sync/content/browserOverlay.xul
+content bindwood chrome/content/
+locale  bindwood en     chrome/locale/en/
+overlay chrome://browser/content/browser.xul    chrome://bindwood/content/browserOverlay.xul
 
=== modified file 'chrome/content/browserOverlay.xul'
--- chrome/content/browserOverlay.xul	2009-06-30 13:47:50 +0000
+++ chrome/content/browserOverlay.xul	2009-07-02 15:11:14 +0000
@@ -1,15 +1,25 @@
 <?xml version="1.0"?>
 
-<!DOCTYPE overlay SYSTEM "chrome://ubuntuone-firefox-bookmark-sync/locale/ubuntuone-firefox-bookmark-sync.dtd">
+<!DOCTYPE overlay SYSTEM "chrome://bindwood/locale/en/bindwood.dtd">
 
-<overlay id="ubuntuone-firefox-bookmark-sync"
+<overlay id="bindwood"
          xmlns="http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul">
 
+  <script type="application/x-javascript" src="chrome://bindwood/content/couch.js" />
+  <script type="application/x-javascript" src="chrome://bindwood/content/sync.js" />
+
+  <window id="main-window">
+    <script type="application/x-javascript">
+      var bmsvc = Components.classes["@mozilla.org/browser/nav-bookmarks-service;1"].getService(Components.interfaces.nsINavBookmarksService);
+      window.addEventListener("load", function() { bmsvc.addObserver(BindWoodListener, false); }, false);
+    </script>
+  </window>
+
   <menupopup id="menu_ToolsPopup">
-    <menuitem id="UbuntuOneFirefoxBookmarkSync"
+    <menuitem id="BindWoodSync"
               label="Sync Bookmarks (well, alert)"
               insertbefore="javascriptConsole"
-              oncommand="alert('syncing...');" />
+              oncommand="syncBookmarks();" />
   </menupopup>
 
 </overlay>
 
=== added file 'chrome/content/couch.js'
--- chrome/content/couch.js	1970-01-01 00:00:00 +0000
+++ chrome/content/couch.js	2009-07-02 15:11:14 +0000
@@ -0,0 +1,395 @@
+// Licensed under the Apache License, Version 2.0 (the "License"); you may not
+// use this file except in compliance with the License.  You may obtain a copy
+// of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+// WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
+// License for the specific language governing permissions and limitations under
+// the License.
+
+// A simple class to represent a database. Uses XMLHttpRequest to interface with
+// the CouchDB server.
+
+function CouchDB(name, httpHeaders) {
+  this.name = name;
+  this.uri = "/" + encodeURIComponent(name) + "/";
+  
+  // The XMLHttpRequest object from the most recent request. Callers can
+  // use this to check result http status and headers.
+  this.last_req = null;
+  
+  this.request = function(method, uri, requestOptions) {
+      requestOptions = requestOptions || {}
+      requestOptions.headers = combine(requestOptions.headers, httpHeaders)
+      return CouchDB.request(method, uri, requestOptions);
+    }
+
+  // Creates the database on the server
+  this.createDb = function() {
+    this.last_req = this.request("PUT", this.uri);
+    CouchDB.maybeThrowError(this.last_req);
+    return JSON.parse(this.last_req.responseText);
+  }
+
+  // Deletes the database on the server
+  this.deleteDb = function() {
+    this.last_req = this.request("DELETE", this.uri);
+    if (this.last_req.status == 404)
+      return false;
+    CouchDB.maybeThrowError(this.last_req);
+    return JSON.parse(this.last_req.responseText);
+  }
+
+  // Save a document to the database
+  this.save = function(doc, options) {
+    if (doc._id == undefined)
+      doc._id = CouchDB.newUuids(1)[0];
+
+    this.last_req = this.request("PUT", this.uri  + 
+        encodeURIComponent(doc._id) + encodeOptions(options),
+        {body: JSON.stringify(doc)});
+    CouchDB.maybeThrowError(this.last_req);
+    var result = JSON.parse(this.last_req.responseText);
+    doc._rev = result.rev;
+    return result;
+  }
+
+  // Open a document from the database
+  this.open = function(docId, options) {
+    this.last_req = this.request("GET", this.uri + encodeURIComponent(docId) + encodeOptions(options));
+    if (this.last_req.status == 404)
+      return null;
+    CouchDB.maybeThrowError(this.last_req);
+    return JSON.parse(this.last_req.responseText);
+  }
+
+  // Deletes a document from the database
+  this.deleteDoc = function(doc) {
+    this.last_req = this.request("DELETE", this.uri + encodeURIComponent(doc._id) + "?rev=" + doc._rev);
+    CouchDB.maybeThrowError(this.last_req);
+    var result = JSON.parse(this.last_req.responseText);
+    doc._rev = result.rev; //record rev in input document
+    doc._deleted = true;
+    return result;
+  }
+
+  // Deletes an attachment from a document
+  this.deleteDocAttachment = function(doc, attachment_name) {
+    this.last_req = this.request("DELETE", this.uri + encodeURIComponent(doc._id) + "/" + attachment_name + "?rev=" + doc._rev);
+    CouchDB.maybeThrowError(this.last_req);
+    var result = JSON.parse(this.last_req.responseText);
+    doc._rev = result.rev; //record rev in input document
+    return result;
+  }
+  
+  this.bulkSave = function(docs, options) {
+    // first prepoulate the UUIDs for new documents
+    var newCount = 0
+    for (var i=0; i<docs.length; i++) {
+      if (docs[i]._id == undefined)
+        newCount++;
+    }
+    var newUuids = CouchDB.newUuids(docs.length);
+    var newCount = 0
+    for (var i=0; i<docs.length; i++) {
+      if (docs[i]._id == undefined)
+        docs[i]._id = newUuids.pop();
+    }
+    var json = {"docs": docs};
+    // put any options in the json
+    for (var option in options) {
+      json[option] = options[option];
+    }
+    this.last_req = this.request("POST", this.uri + "_bulk_docs", {
+      body: JSON.stringify(json)
+    });
+    if (this.last_req.status == 417) {
+      return {errors: JSON.parse(this.last_req.responseText)};
+    }
+    else {
+      CouchDB.maybeThrowError(this.last_req);
+      var results = JSON.parse(this.last_req.responseText);
+      for (var i = 0; i < docs.length; i++) {
+        if(results[i].rev)
+          docs[i]._rev = results[i].rev;
+      }
+      return results;
+    }
+  }
+  
+  this.ensureFullCommit = function() {
+    this.last_req = this.request("POST", this.uri + "_ensure_full_commit");
+    CouchDB.maybeThrowError(this.last_req);
+    return JSON.parse(this.last_req.responseText);
+  }
+
+  // Applies the map function to the contents of database and returns the results.
+  this.query = function(mapFun, reduceFun, options, keys) {
+    var body = {language: "javascript"};
+    if(keys) {
+      body.keys = keys ;      
+    }
+    if (typeof(mapFun) != "string")
+      mapFun = mapFun.toSource ? mapFun.toSource() : "(" + mapFun.toString() + ")";
+    body.map = mapFun;
+    if (reduceFun != null) {
+      if (typeof(reduceFun) != "string")
+        reduceFun = reduceFun.toSource ? reduceFun.toSource() : "(" + reduceFun.toString() + ")";
+      body.reduce = reduceFun;
+    }
+    if (options && options.options != undefined) {
+        body.options = options.options;
+        delete options.options;
+    }
+    this.last_req = this.request("POST", this.uri + "_temp_view" + encodeOptions(options), {
+      headers: {"Content-Type": "application/json"},
+      body: JSON.stringify(body)
+    });
+    CouchDB.maybeThrowError(this.last_req);
+    return JSON.parse(this.last_req.responseText);
+  }
+
+  this.view = function(viewname, options, keys) {
+    var viewParts = viewname.split('/');
+    var viewPath = this.uri + "_design/" + viewParts[0] + "/_view/" 
+        + viewParts[1] + encodeOptions(options);
+    if(!keys) {
+      this.last_req = this.request("GET", viewPath);      
+    } else {
+      this.last_req = this.request("POST", viewPath, {
+        headers: {"Content-Type": "application/json"},
+        body: JSON.stringify({keys:keys})
+      });      
+    }
+    if (this.last_req.status == 404)
+      return null;
+    CouchDB.maybeThrowError(this.last_req);
+    return JSON.parse(this.last_req.responseText);
+  }
+
+  // gets information about the database
+  this.info = function() {
+    this.last_req = this.request("GET", this.uri);
+    CouchDB.maybeThrowError(this.last_req);
+    return JSON.parse(this.last_req.responseText);
+  }
+
+  this.allDocs = function(options,keys) {
+    if(!keys) {
+      this.last_req = this.request("GET", this.uri + "_all_docs" + encodeOptions(options));      
+    } else {
+      this.last_req = this.request("POST", this.uri + "_all_docs" + encodeOptions(options), {
+        headers: {"Content-Type": "application/json"},
+        body: JSON.stringify({keys:keys})
+      });      
+    }
+    CouchDB.maybeThrowError(this.last_req);
+    return JSON.parse(this.last_req.responseText);
+  }
+  
+  this.designDocs = function() {
+    return this.allDocs({startkey:"_design", endkey:"_design0"});
+  };
+
+  this.allDocsBySeq = function(options,keys) {
+    var req = null;
+    if(!keys) {
+      req = this.request("GET", this.uri + "_all_docs_by_seq" + encodeOptions(options));      
+    } else {
+      req = this.request("POST", this.uri + "_all_docs_by_seq" + encodeOptions(options), {
+        headers: {"Content-Type": "application/json"},
+        body: JSON.stringify({keys:keys})
+      });      
+    }
+    CouchDB.maybeThrowError(req);
+    return JSON.parse(req.responseText);
+  }
+
+  this.compact = function() {
+    this.last_req = this.request("POST", this.uri + "_compact");
+    CouchDB.maybeThrowError(this.last_req);
+    return JSON.parse(this.last_req.responseText);
+  }
+  
+  this.setDbProperty = function(propId, propValue) {
+    this.last_req = this.request("PUT", this.uri + propId,{
+      body:JSON.stringify(propValue)
+    });
+    CouchDB.maybeThrowError(this.last_req);
+    return JSON.parse(this.last_req.responseText);
+  }
+  
+  this.getDbProperty = function(propId) {
+    this.last_req = this.request("GET", this.uri + propId);
+    CouchDB.maybeThrowError(this.last_req);
+    return JSON.parse(this.last_req.responseText);
+  }
+  
+  this.setAdmins = function(adminsArray) {
+    this.last_req = this.request("PUT", this.uri + "_admins",{
+      body:JSON.stringify(adminsArray)
+    });
+    CouchDB.maybeThrowError(this.last_req);
+    return JSON.parse(this.last_req.responseText);
+  }
+  
+  this.getAdmins = function() {
+    this.last_req = this.request("GET", this.uri + "_admins");
+    CouchDB.maybeThrowError(this.last_req);
+    return JSON.parse(this.last_req.responseText);
+  }
+  
+  // Convert a options object to an url query string.
+  // ex: {key:'value',key2:'value2'} becomes '?key="value"&key2="value2"'
+  function encodeOptions(options) {
+    var buf = []
+    if (typeof(options) == "object" && options !== null) {
+      for (var name in options) {
+        if (!options.hasOwnProperty(name)) continue;
+        var value = options[name];
+        if (name == "key" || name == "startkey" || name == "endkey") {
+          value = toJSON(value);
+        }
+        buf.push(encodeURIComponent(name) + "=" + encodeURIComponent(value));
+      }
+    }
+    if (!buf.length) {
+      return "";
+    }
+    return "?" + buf.join("&");
+  }
+
+  function toJSON(obj) {
+    return obj !== null ? JSON.stringify(obj) : null;
+  }
+  
+  function combine(object1, object2) {
+    if (!object2)
+      return object1;
+    if (!object1)
+      return object2;
+      
+    for (var name in object2)
+      object1[name] = object2[name];
+      
+    return object1;
+  }
+  
+  
+}
+
+// this is the XMLHttpRequest object from last request made by the following
+// CouchDB.* functions (except for calls to request itself).
+// Use this from callers to check HTTP status or header values of requests.
+CouchDB.last_req = null; 
+
+
+CouchDB.allDbs = function() {
+  CouchDB.last_req = CouchDB.request("GET", "/_all_dbs");
+    CouchDB.maybeThrowError(CouchDB.last_req);
+  return JSON.parse(CouchDB.last_req.responseText);
+}
+
+CouchDB.allDesignDocs = function() {
+  var ddocs = {}, dbs = CouchDB.allDbs();
+  for (var i=0; i < dbs.length; i++) {
+    var db = new CouchDB(dbs[i]);
+    ddocs[dbs[i]] = db.designDocs();
+  };
+  return ddocs;
+};
+
+CouchDB.getVersion = function() {
+  CouchDB.last_req = CouchDB.request("GET", "/");
+  CouchDB.maybeThrowError(CouchDB.last_req);
+  return JSON.parse(CouchDB.last_req.responseText).version;
+}
+
+CouchDB.replicate = function(source, target, rep_options) {
+  rep_options = rep_options || {};
+  var headers = rep_options.headers || {};
+  CouchDB.last_req = CouchDB.request("POST", "/_replicate", {
+    headers: headers,
+    body: JSON.stringify({source: source, target: target})
+  });
+  CouchDB.maybeThrowError(CouchDB.last_req);
+  return JSON.parse(CouchDB.last_req.responseText);
+}
+
+CouchDB.request = function(method, uri, options) {
+  options = options || {};
+  var req = null;
+  if (typeof(XMLHttpRequest) != "undefined") {
+    req = new XMLHttpRequest();
+  } else if (typeof(ActiveXObject) != "undefined") {
+    req = new ActiveXObject("Microsoft.XMLHTTP");
+  } else {
+    throw new Error("No XMLHTTPRequest support detected");
+  }
+  req.open(method, "http://localhost:5984" + uri, false);
+  if (options.headers) {
+    var headers = options.headers;
+    for (var headerName in headers) {
+      if (!headers.hasOwnProperty(headerName)) continue;
+      req.setRequestHeader(headerName, headers[headerName]);
+    }
+  }
+  req.send(options.body || "");
+  return req;
+}
+
+CouchDB.requestStats = function(module, key, test) {
+  var query_arg = "";
+  if(test !== null) {
+    query_arg = "?flush=true";
+  }
+
+  var stat = CouchDB.request("GET", "/_stats/" + module + "/" + key + query_arg).responseText;
+  return JSON.parse(stat)[module][key];
+}
+
+CouchDB.uuids_cache = [];
+
+CouchDB.newUuids = function(n) {
+  if (CouchDB.uuids_cache.length >= n) {
+    var uuids = CouchDB.uuids_cache.slice(CouchDB.uuids_cache.length - n);
+    if(CouchDB.uuids_cache.length - n == 0) {
+      CouchDB.uuids_cache = [];
+    } else {
+      CouchDB.uuids_cache =
+          CouchDB.uuids_cache.slice(0, CouchDB.uuids_cache.length - n);
+    }
+    return uuids;
+  } else {
+    CouchDB.last_req = CouchDB.request("GET", "/_uuids?count=" + (100 + n));
+    CouchDB.maybeThrowError(CouchDB.last_req);
+    var result = JSON.parse(CouchDB.last_req.responseText);
+    CouchDB.uuids_cache =
+        CouchDB.uuids_cache.concat(result.uuids.slice(0, 100));
+    return result.uuids.slice(100);
+  }
+}
+
+CouchDB.maybeThrowError = function(req) {
+  if (req.status >= 400) {
+    try {
+      var result = JSON.parse(req.responseText);
+    } catch (ParseError) {
+      var result = {error:"unknown", reason:req.responseText};
+    }
+    throw result;
+  }
+}
+
+CouchDB.params = function(options) {
+  options = options || {};
+  var returnArray = [];
+  for(var key in options) {
+    var value = options[key];
+    returnArray.push(key + "=" + value);
+  }
+  return returnArray.join("&");
+}
 \ No newline at end of file
 
=== added file 'chrome/content/sync.js'
--- chrome/content/sync.js	1970-01-01 00:00:00 +0000
+++ chrome/content/sync.js	2009-07-02 17:56:29 +0000
@@ -0,0 +1,68 @@
+function _writeMessage(aMessage) {
+    var consoleService = Components.classes["@mozilla.org/consoleservice;1"]
+        .getService(Components.interfaces.nsIConsoleService);
+    consoleService.logStringMessage("BindWood: " + aMessage);
+}
+
+function syncBookmarks() {
+    alert('Syncing bookmarks...');
+    var couch = new CouchDB('bookmarks');
+    var total_documents = couch.allDocs().total_rows;
+    var all_documents = new Array();
+    if (total_documents > 0) {
+        all_documents = dc.all('bookmarks').rows;
+    }
+
+    for (var i = 0; i < all_documents.length; i++) {
+        alert(all_documents[i].id);
+    }
+}
+
+// An nsINavBookmarkObserver
+var BindWoodListener = {
+    onBeginUpdateBatch: function() {},
+    onEndUpdateBatch: function() {},
+    onItemAdded: function(aItemId, aFolder, aIndex) {
+        netscape.security.PrivilegeManager.enablePrivilege("UniversalBrowserRead UniversalBrowserWrite");
+        var couch = new CouchDB('bookmarks');
+
+        var doc = {_id: aItemId.toString()};
+        try {
+            var result = couch.save(doc);
+            _writeMessage("Saved record: " + result.rev);
+        } catch(e) {
+            _writeMessage("Error '" + e.error + "': " + e.reason);
+        }
+        return true;
+    },
+    onItemRemoved: function(aItemId, aFolder, aIndex) {
+        netscape.security.PrivilegeManager.enablePrivilege("UniversalBrowserRead UniversalBrowserWrite");
+        var couch = new CouchDB('bookmarks');
+
+        var doc = couch.open(aItemId.toString());
+        try {
+            var result = couch.deleteDoc(doc);
+            _writeMessage("Deleted record: " + result.rev);
+        } catch(e) {
+            _writeMessage("Error '" + e.error + "': " + e.reason);
+        }
+        return true;
+    },
+    onItemChanged: function(aBookmarkId, aProperty, aIsAnnotationProperty, aValue) {
+        netscape.security.PrivilegeManager.enablePrivilege("UniversalBrowserRead UniversalBrowserWrite");
+        var couch = new CouchDB('bookmarks');
+
+        var doc = couch.open(aBookmarkId.toString());
+        doc[aProperty.toString()] = aValue.toString();
+        try {
+            var result = couch.save(doc);
+            _writeMessage("Updated record: " + result.rev + ", setting (" + aProperty.toString() + ") to (" + aValue.toString() + ")");
+        } catch(e) {
+            _writeMessage("Error '" + e.error + "': " + e.reason);
+        }
+        return true;
+    },
+    onItemVisited: function(aBookmarkId, aVisitID, time) {},
+    onItemMoved: function(aItemId, aOldParent, aOldIndex, aNewParent, aNewIndex) {},
+    QueryInterface: XPCOMUtils.generateQI([Components.interfaces.nsINavBookmarkObserver])
+};
 
=== added file 'chrome/content/tutorial.html'
--- chrome/content/tutorial.html	1970-01-01 00:00:00 +0000
+++ chrome/content/tutorial.html	2009-07-02 13:41:07 +0000
@@ -0,0 +1,8 @@
+<html>
+  <head>
+    <title>BindWood Tutorial</title>
+  </head>
+  <body>
+    This is BindWood.
+  </body>
+</html>
 
=== added directory 'chrome/locale'
=== added directory 'chrome/locale/en'
=== added file 'chrome/locale/en/bindwood.dtd'
=== modified file 'install.rdf'
--- install.rdf	2009-06-30 13:47:50 +0000
+++ install.rdf	2009-07-02 13:41:07 +0000
@@ -3,7 +3,7 @@
      xmlns:em="http://www.mozilla.org/2004/em-rdf#">
 
   <Description about="urn:mozilla:install-manifest">
-    <em:id>[e-mail]</em:id>
+    <em:id>[e-mail]</em:id>
     <em:version>1.0</em:version>
     <em:type>2</em:type>
 
@@ -18,7 +18,7 @@
     </em:targetApplication>
 
     <!-- Front End MetaData -->
-    <em:name>UbuntuOne Bookmarks Sync</em:name>
+    <em:name>BindWood</em:name>
     <em:description>An extension to synchronize your bookmarks to UbuntuOne.</em:description>
     <em:creator>Zachery Bir</em:creator>
     <em:homepageURL>http://launchpad.net/ubuntuone-firefox-bookmark-sync</em:homepageURL>