Merge lp:~sil/bindwood/design-view into lp:~urbanape/bindwood/trunk

[Stuart Langridge]

[Stuart Langridge (sil)]

Add a design document, providing a more convenient view on your bookmarks

[lp:~sil/bindwood/design-view]

13. By Stuart Langridge on 2009-07-06

Add more debug messages

[Zachery Bir (urbanape)]

Looks good and has been merged into lp:~urbanape/bindwood/dbus-and-local-uuids

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-03 02:22:26 +0000
@@ -1,15 +1,27 @@
 <?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">
 
-  <menupopup id="menu_ToolsPopup">
-    <menuitem id="UbuntuOneFirefoxBookmarkSync"
+  <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">
+      window.addEventListener("load", Bindwood.init, true);
+
+      var bmsvc = Components.classes["@mozilla.org/browser/nav-bookmarks-service;1"].getService(Components.interfaces.nsINavBookmarksService);
+      window.addEventListener("load", function() { bmsvc.addObserver(Bindwood.Observer, false); }, false);
+    </script>
+  </window>
+
+  <menupopup id="bookmarksMenuPopup">
+    <menuitem id="BindwoodSync"
               label="Sync Bookmarks (well, alert)"
-              insertbefore="javascriptConsole"
-              oncommand="alert('syncing...');" />
+              oncommand="pullBookmarks(false);"
+              insertafter="bookmarksShowAll" />
   </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-06 10:49:17 +0000
@@ -0,0 +1,396 @@
+// 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) {
+  Bindwood.writeMessage("CouchDB.request connecting to " + uri);
+  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("&");
+}
 
=== added file 'chrome/content/sync.js'
--- chrome/content/sync.js	1970-01-01 00:00:00 +0000
+++ chrome/content/sync.js	2009-07-06 16:00:58 +0000
@@ -0,0 +1,358 @@
+/* Lots and lots of debugging information */
+var Bindwood = {
+    bookmarksService: Components.classes["@mozilla.org/browser/nav-bookmarks-service;1"]
+            .getService(Components.interfaces.nsINavBookmarksService),
+
+    writeMessage: function(aMessage) {
+        // convenience method for logging. Way better than alert()s.
+        var consoleService = Components.classes["@mozilla.org/consoleservice;1"]
+            .getService(Components.interfaces.nsIConsoleService);
+        consoleService.logStringMessage("Bindwood: " + aMessage);
+    },
+
+    writeError: function(aMessage, e) {
+        Bindwood.writeMessage(aMessage + "message: '" + e.message + "', reason: '" + e.reason + "', description: '" + e.description + "', error: '" + e.error + "'");
+    },
+
+    init: function() {
+        // Start the process and de-register ourself
+        // http://forums.mozillazine.org/viewtopic.php?f=19&t=657911&start=0
+        // It ensures that we're only running that code on the first window.
+        if(Components.classes["@mozilla.org/appshell/window-mediator;1"]
+           .getService(Components.interfaces.nsIWindowMediator)
+           .getEnumerator("").getNext() == window) {
+            try {
+                Bindwood.writeMessage("About to push bookmarks (startup)");
+                Bindwood.pushBookmarks();
+            } catch(e) {
+                Bindwood.writeError("Error when calling pushBookmarks: ", e);
+            }
+            Bindwood.writeMessage("Creating view");
+            Bindwood.createView();
+            Bindwood.writeMessage("About to pull bookmarks (startup)");
+            Bindwood.pullBookmarks();
+        }
+    },
+    
+    createView: function() {
+        var DDID = "_design/views";
+        var couch = new CouchDB('bookmarks');
+        var current_doc;
+        try {
+            current_doc = couch.open(DDID);
+            if (current_doc !== null) {
+                Bindwood.writeMessage("View already exists; leaving it alone");
+            } else {
+                new_doc = {
+                    _id: DDID,
+                    views: {
+                        display: {
+                         map: "function(doc) { " +
+                           "var scheme = doc.uri.split(':',1)[0]; " +
+                           "var uri; " +
+                           "if (scheme == 'http' || scheme == 'https') {" +
+                             "uri = doc.uri.split('/')[2];" +
+                             "if (uri.length < 30) {" +
+                               " uri += '/' + " + 
+                               "doc.uri.split('/',4)[3].substr(0,30-uri.length) + '...';" +
+                             "}" +
+                           "} else {" +
+                           "uri = scheme + ' URL';" +
+                           "}" +
+                           "emit(doc.title, uri);" +
+                         "}"
+                       }
+                    }
+                };
+                try {
+                    couch.save(new_doc);
+                    Bindwood.writeMessage("Added view");
+                } catch(e) {
+                    Bindwood.writeError("Problem saving view: ", e);
+                }
+            }
+        } catch(e) {
+            // some kind of error fetching the existing design doc
+            Bindwood.writeError("Problem checking for view: ", e);
+        }
+    },
+
+    pushBookmarks: function() {
+        // Prime the pump, so to speak, by uploading all our local
+        // bookmarks to CouchDB (if they're not there already).
+        Bindwood.writeMessage("in pushBookmarks");
+        var couch = new CouchDB('bookmarks');
+        // Create the DB if it doesn't already exist
+        try {
+            Bindwood.writeMessage("creating database");
+            couch.createDb();
+        } catch (e) {
+            Bindwood.writeError("Error when creating database in pushBookmarks (file_exists is OK here): ", e);
+        }
+        
+        Bindwood.writeMessage("about to push toolbar bookmarks");
+        Bindwood.pushBookmarksFromList(Bindwood.bookmarksService.toolbarFolder, 
+            "toolbarFolder", couch);
+        Bindwood.writeMessage("about to push menu bookmarks");
+        Bindwood.pushBookmarksFromList(Bindwood.bookmarksService.bookmarksMenuFolder, 
+            "bookmarksMenuFolder", couch);
+    },
+    
+    getBookmarksFromList: function(bookmarksList) {
+        Bindwood.writeMessage("in getBookmarksFromList with list " + bookmarksList);
+        var retval = [];
+        var historyService = Components.classes["@mozilla.org/browser/nav-history-service;1"]
+            .getService(Components.interfaces.nsINavHistoryService);
+        var options = historyService.getNewQueryOptions();
+        var query = historyService.getNewQuery();
+        query.setFolders([bookmarksList], 1);
+        var result = historyService.executeQuery(query, options);
+        var rootNode = result.root;
+        rootNode.containerOpen = true;
+        for (var i=0; i<rootNode.childCount; i++) {
+            var node = rootNode.getChild(i);
+            if (Bindwood.bookmarksService.getItemType(node.itemId) !=
+                Components.interfaces.nsINavBookmarksService.TYPE_BOOKMARK) {
+                continue;
+            }
+
+            var title = Bindwood.bookmarksService.getItemTitle(node.itemId);
+            Bindwood.writeMessage("got bookmark '" + title + "'");
+            try {
+                var metadata = Bindwood.bookmarksService.getBookmarkURI(node.itemId);
+            } catch(e) {
+                Bindwood.writeError("problem fetching metadata for bookmark '" + title + "': ", e);
+                continue;
+            }
+            var guid = Bindwood.bookmarksService.getItemGUID(node.itemId);
+            Bindwood.writeMessage("got GUID");
+            retval.push({title: title, metadata:metadata,guid:guid, id:node.itemId});
+        }
+        rootNode.containerOpen = false;
+        return retval;
+    },
+    
+    pushBookmarksFromList: function(bookmarksList, bookmarksListName, db) {
+        Bindwood.writeMessage("in pushBookmarksFromList");
+        var bookmarkData = Bindwood.getBookmarksFromList(bookmarksList);
+        for (i=0; i<bookmarkData.length; i++) {
+            // find this bookmark in CouchDB
+            Bindwood.writeMessage("searching for bookmark '" + bookmarkData[i].title + "' in Couch");
+            var results = db.query(function(doc) {
+                if (doc.application_annotations &&
+                    doc.application_annotations.Firefox &&
+                    doc.application_annotations.Firefox.guid) {
+                    emit(doc.application_annotations.Firefox.guid, doc);
+                }
+            }, null, {
+                startkey: bookmarkData[i].guid, endkey: bookmarkData[i].guid
+            });
+
+            if (results.rows.length === 0) {
+                // this bookmark is not in CouchDB, so write it
+                Bindwood.writeMessage("Didn't find it, so creating it");
+                var record = {
+                    record_type: "http://example.com/bookmark",
+                    uri: bookmarkData[i].metadata.spec,
+                    title: bookmarkData[i].title,
+                    application_annotations: {
+                        Firefox: {
+                            guid: bookmarkData[i].guid,
+                            list: bookmarksListName
+                        }
+                    }
+                };
+                try {
+                    db.save(record);
+                } catch(e) {
+                    Bindwood.writeError("Problem saving bookmark to CouchDB; bookmark is " + JSON.stringify(record) + ": ", e);
+                }
+            } else {
+                // bookmark is already in CouchDB, so do nothing
+                Bindwood.writeMessage("Did find it, so don't need to do anything");
+            }
+        }
+    },
+    
+    pullBookmarks: function() {
+        Bindwood.writeMessage("in pullBookmarks");
+        var couch = new CouchDB('bookmarks');
+        // Fetch all bookmark documents from the database
+        // the query function is evaluated by Couch, which doesn't know
+        // what Bindwood.RECORD_TYPE is, so we string-encode it first to
+        // include the literal value
+        try {
+            var rows = couch.query(function (doc) { 
+                if (doc.record_type == "http://example.com/bookmark") { 
+                    emit(doc._id,doc);
+                }
+            });
+        } catch(e) {
+            Bindwood.writeError("Problem fetching all bookmarks from Couch:", e);
+        }
+        for (var i=0; i<rows.rows.length; i++) {
+            var recordid = rows.rows[i].id;
+            var bm = rows.rows[i].value;
+            if (bm.application_annotations && bm.application_annotations.Firefox &&
+                bm.application_annotations.Firefox.guid) {
+                // this bookmark has a guid, so check its values haven't changed
+                // find the bookmark with this guid
+                var itemId = Bindwood.bookmarksService.getItemIdForGUID(
+                    bm.application_annotations.Firefox.guid);
+                if (itemId == -1) {
+                    // This bookmark has a guid, but it's not one of ours.
+                    // We need to work out whether (a) it's the same as one
+                    //   of ours but with a different guid (so we need to
+                    //   make the guids the same), or (b) it's a new one
+                    //   that happens to have been created on a different
+                    //   machine.
+                    // For the moment, punt on this.
+                } else {
+                    var title = Bindwood.bookmarksService.getItemTitle(itemId);
+                    var metadata = Bindwood.bookmarksService.getBookmarkURI(itemId);
+                    if (title != bm.title) {
+                        Bindwood.bookmarksService.setItemTitle(itemId, bm.title);
+                    }
+                    if (metadata.spec != bm.uri) {
+                        metadata.spec = bm.uri;
+                        Bindwood.bookmarksService.changeBookmarkURI(itemId, metadata);
+                    }
+                }
+            } else {
+                // this bookmark has no guid, so create it from fresh in Firefox
+                var list;
+                if (bm.application_annotations && bm.application_annotations.Firefox &&
+                    bm.application_annotations.Firefox.list) {
+                    switch (bm.application_annotations.Firefox.list) {
+                        case "toolbarFolder":
+                            list = Bindwood.bookmarksService.toolbarFolder;
+                            break;
+                        case "bookmarksMenuFolder":
+                            list = Bindwood.bookmarksService.bookmarksMenuFolder;
+                            break;
+                        default:
+                            list = Bindwood.bookmarksService.toolbarFolder;
+                            break;
+                    }
+                } else {
+                    list = Bindwood.bookmarksService.toolbarFolder;
+                }
+                var metadata = Components.classes["@mozilla.org/network/io-service;1"]
+                      .getService(Components.interfaces.nsIIOService)
+                      .newURI(bm.uri, null, null);
+
+                var itemId = Bindwood.bookmarksService.insertBookmark(list, 
+                    metadata, -1, bm.title);
+                // and then write the new guid back to the record
+                var guid = Bindwood.bookmarksService.getItemGUID(itemId);
+                var doc = couch.open(recordid);
+                if (!doc.application_annotations) {
+                    doc.application_annotations = {};
+                }
+                if (!doc.application_annotations.Firefox) {
+                    doc.application_annotations.Firefox = {};
+                }
+                doc.application_annotations.Firefox.guid = guid;
+                couch.save(doc);
+            }
+        }
+        // reschedule ourself
+        setTimeout(Bindwood.pullBookmarks, 5000);
+    },
+
+    Observer: {
+        // An nsINavBookmarkObserver
+        onBeginUpdateBatch: function() {},
+        onEndUpdateBatch: function() {},
+        onItemAdded: function(aItemId, aFolder, aIndex) {
+            // A bookmark has been added, so we create a blank entry
+            // in Couch with our local itemId attached.
+            Bindwood.writeMessage("onItemAdded!!!!" + Bindwood.bookmarksService.getItemGUID(aItemId));
+            var list;
+            switch(aFolder) {
+                case Bindwood.bookmarksService.toolbarFolder:
+                    list = "toolbarFolder";
+                    break;
+                case Bindwood.bookmarksService.bookmarksMenuFolder:
+                    list = "bookmarksMenuFolder";
+                    break;
+                default:
+                    list = "toolbarFolder";
+                    break;
+            }
+            
+            netscape.security.PrivilegeManager.enablePrivilege("UniversalBrowserRead UniversalBrowserWrite");
+            var couch = new CouchDB('bookmarks');
+
+            var doc = {
+                record_type: "http://example.com/bookmark",
+                application_annotations: {
+                    Firefox: {
+                        guid: Bindwood.bookmarksService.getItemGUID(aItemId),
+                        list: list
+                    }
+                }
+            };
+            try {
+                var result = couch.save(doc);
+                Bindwood.writeMessage("Saved record: " + result.rev);
+            } catch(e) {
+                Bindwood.writeMessage("Error '" + e.error + "': " + e.reason);
+            }
+            return true;
+        },
+        onItemRemoved: function(aItemId, aFolder, aIndex) {
+            // A bookmark has been removed. This is called after it's
+            // been removed locally, though we're passed the itemId,
+            // which we use to delete from Couch.
+            var guid = Bindwood.bookmarksService.getItemGUID(aItemId);
+            var results = db.query(function(doc) {
+                if (doc.application_annotations &&
+                    doc.application_annotations.Firefox &&
+                    doc.application_annotations.Firefox.guid) {
+                    emit(doc.application_annotations.Firefox.guid, doc);
+                }
+            }, null, {
+                startkey: guid, endkey: guid
+            });
+            Bindwood.writeMessage("deleted item " + JSON.stringify(results));   
+        },
+        onItemChanged: function(aBookmarkId, aProperty, aIsAnnotationProperty, aValue) {
+            // A property of a bookmark has changed. On multiple
+            // property updates, this will be called multiple times,
+            // once per property (i.e., for title and URI)
+            bindwood.writeMessage("in onItemChanged: " + aProperty + " changed to " + aValue);
+            netscape.security.PrivilegeManager.enablePrivilege("UniversalBrowserRead UniversalBrowserWrite");
+            var couch = new CouchDB('bookmarks');
+            var guid = Bindwood.bookmarksService.getItemGUID(aBookmarkId);
+            var results = db.query(function(doc) {
+                if (doc.application_annotations &&
+                    doc.application_annotations.Firefox &&
+                    doc.application_annotations.Firefox.guid) {
+                    emit(doc.application_annotations.Firefox.guid, doc);
+                }
+            }, null, {
+                startkey: guid, endkey: guid
+            });
+            if (results.rows.length === 0) {
+                Bindwood.writeMessage("a bookmark has changed, but this bookmark isn't in CouchDB. this isn't supposed to happen.");
+                return;
+            }
+            Bindwood.writeMessage("We don't actually update Couch here.");
+            return;
+
+            var doc = couch.open(results.rows[0].id);
+            doc[aProperty.toString()] = aValue.toString();
+            try {
+                var result = couch.save(doc);
+                Bindwood.writeMessage("Updated record: " + result.rev + ", setting (" + aProperty.toString() + ") to (" + aValue.toString() + ")");
+            } catch(e) {
+                Bindwood.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-03 02:22:26 +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,8 +18,8 @@
     </em:targetApplication>
 
     <!-- Front End MetaData -->
-    <em:name>UbuntuOne Bookmarks Sync</em:name>
-    <em:description>An extension to synchronize your bookmarks to UbuntuOne.</em:description>
+    <em:name>BindWood</em:name>
+    <em:description>An extension to synchronize your bookmarks to a local CouchDB.</em:description>
     <em:creator>Zachery Bir</em:creator>
     <em:homepageURL>http://launchpad.net/ubuntuone-firefox-bookmark-sync</em:homepageURL>
   </Description>