Merge lp:~ursinha/launchpad/add-date-last-changed-who-changed-to-specifications into lp:launchpad/db-devel

[Ursula Junque]

[r=stub][bug=916043][incr] Add date_last_changed and last_changed_by to specification.

This branch adds two new columns to table specification: date_last_changed and last_changed_by. These two should be updated whenever one updates a blueprint, so it's possible to know, well, when the last change was made and who did it.

[Stuart Bishop (stub)]

Looks good.

I'm told we want to order specifications by last update time, so we will need an index on that column.

review: Approve (db)

[Ursula Junque (ursinha)]

> Looks good.
>
> I'm told we want to order specifications by last update time, so we will need
> an index on that column.

Done!

=== modified file 'buildout.cfg'
--- buildout.cfg	2011-12-30 06:47:17 +0000
+++ buildout.cfg	2012-01-13 14:12:26 +0000
@@ -43,7 +43,7 @@
     rm -rf ${buildout:yui-directory}/yui-${versions:yui}/*
     tar -zxf download-cache/dist/yui-${versions:yui}.tar.gz \
         -C ${buildout:yui-directory}/yui-${versions:yui}
-    ln -s ../../../../${buildout:yui-directory}/yui-${versions:yui} \
+    ln -sf ../../../../${buildout:yui-directory}/yui-${versions:yui} \
         lib/canonical/launchpad/icing/yui
 
 [filetemplates]

=== added file 'database/schema/patch-2209-04-0.sql'
--- database/schema/patch-2209-04-0.sql	1970-01-01 00:00:00 +0000
+++ database/schema/patch-2209-04-0.sql	2012-01-13 14:12:26 +0000
@@ -0,0 +1,17 @@
+-- Copyright 2011 Canonical Ltd.  This software is licensed under the
+-- GNU Affero General Public License version 3 (see the file LICENSE).
+
+SET client_min_messages=ERROR;
+
+ALTER TABLE specification
+    ADD COLUMN date_last_changed timestamp without time zone,
+    ADD COLUMN last_changed_by integer REFERENCES person;
+
+ALTER TABLE specification ALTER COLUMN date_last_changed SET DEFAULT (CURRENT_TIMESTAMP AT TIME ZONE 'UTC');
+
+CREATE INDEX specification__last_changed_by__idx ON specification USING btree (last_changed_by) WHERE (last_changed_by IS NOT NULL);
+CREATE INDEX specification__date_last_changed__idx ON specification USING btree (date_last_changed);
+
+INSERT INTO LaunchpadDatabaseRevision VALUES (2209, 04, 0);
+
+

=== modified file 'lib/canonical/launchpad/icing/css/base.css'
--- lib/canonical/launchpad/icing/css/base.css	2011-12-07 04:57:36 +0000
+++ lib/canonical/launchpad/icing/css/base.css	2012-01-13 14:12:26 +0000
@@ -264,6 +264,9 @@
 table.sortable img.sortarrow {
     padding-left: 2px;
     }
+table.sortable th {
+    cursor: pointer;
+    }
 th.ascending {
     background-image: url(/@@/arrowDown);
     background-position: center right;

=== modified file 'lib/canonical/launchpad/icing/css/components/bug_listing.css'
--- lib/canonical/launchpad/icing/css/components/bug_listing.css	2011-12-21 06:19:51 +0000
+++ lib/canonical/launchpad/icing/css/components/bug_listing.css	2012-01-13 14:12:26 +0000
@@ -15,13 +15,10 @@
     float: left;
     padding-right: 10px;
     }
-div.buglisting-col2,
-div.buglisting-col3 {
+div.buglisting-col2 {
     float: left;
     margin-top: 2px;
-    }
-div.buglisting-col2 {
-    width: 40%;
+    width: 68%;
     }
 div#client-listing .status,
 div#client-listing .importance {
@@ -33,7 +30,7 @@
     line-height: 12px;
     text-align: center;
     margin: 5px 10px 0 0;
-}
+    }
 div#client-listing .importance {
     width: 65px;
     }

=== modified file 'lib/lp/app/javascript/comment.js'
--- lib/lp/app/javascript/comment.js	2011-08-09 14:18:02 +0000
+++ lib/lp/app/javascript/comment.js	2012-01-13 14:12:26 +0000
@@ -20,11 +20,13 @@
      */
     initializer: function() {
         this.submit_button = this.get_submit();
-        this.comment_input = Y.one('[id="field.comment"]');
+        this.comment_input = Y.one(
+            'div#add-comment-form [id="field.comment"]');
         this.lp_client = new Y.lp.client.Launchpad();
         this.error_handler = new Y.lp.client.ErrorHandler();
-        this.error_handler.clearProgressUI = bind(this.clearProgressUI, this);
-        this.error_handler.showError = bind(function (error_msg) {
+        this.error_handler.clearProgressUI = Y.bind(
+            this.clearProgressUI, this);
+        this.error_handler.showError = Y.bind(function (error_msg) {
             Y.lp.app.errors.display_error(this.submit_button, error_msg);
         }, this);
         this.progress_message = Y.Node.create(
@@ -39,7 +41,7 @@
      * @method get_submit
      */
     get_submit: function(){
-        return Y.one('[id="field.actions.save"]');
+        return Y.one('div#add-comment-form input[id="field.actions.save"]');
     },
     /**
      * Implementation of Widget.renderUI.
@@ -86,9 +88,9 @@
             return;
         }
         this.activateProgressUI('Saving...');
-        this.post_comment(bind(function(message_entry) {
+        this.post_comment(Y.bind(function(message_entry) {
             this.get_comment_HTML(
-                message_entry, bind(this.insert_comment_HTML, this));
+                message_entry, Y.bind(this.insert_comment_HTML, this));
             this._add_comment_success();
         }, this));
     },
@@ -186,9 +188,9 @@
      * @method bindUI
      */
     bindUI: function(){
-        this.comment_input.on('keyup', bind(this.syncUI, this));
-        this.comment_input.on('mouseup', bind(this.syncUI, this));
-        this.submit_button.on('click', bind(this.add_comment, this));
+        this.comment_input.on('keyup', this.syncUI, this);
+        this.comment_input.on('mouseup', this.syncUI, this);
+        this.submit_button.on('click', this.add_comment, this);
     },
     /**
      * Implementation of Widget.syncUI: Update appearance according to state.
@@ -325,7 +327,7 @@
         window.scrollTo(0, Y.one('#add-comment').getY());
         this.lp_client.get(object_url, {
             on: {
-                success: bind(function(comment){
+                success: Y.bind(function(comment){
                     this.set_in_reply_to(comment);
                     this.clearProgressUI();
                     this.syncUI();
@@ -380,11 +382,11 @@
      */
     bindUI: function() {
         CodeReviewComment.superclass.bindUI.apply(this);
-        this.vote_input.on('keyup', bind(this.syncUI, this));
-        this.vote_input.on('change', bind(this.syncUI, this));
-        this.review_type.on('keyup', bind(this.syncUI, this));
-        this.review_type.on('mouseup', bind(this.syncUI, this));
-        Y.all('a.menu-link-reply').on('click', bind(this.reply_clicked, this));
+        this.vote_input.on('keyup', this.syncUI, this);
+        this.vote_input.on('change', this.syncUI, this);
+        this.review_type.on('keyup', this.syncUI, this);
+        this.review_type.on('mouseup', this.syncUI, this);
+        Y.all('a.menu-link-reply').on('click', this.reply_clicked, this);
     },
     /**
      * Implementation of Widget.syncUI: Update appearance according to state.

=== modified file 'lib/lp/app/javascript/extras/extras.js'
--- lib/lp/app/javascript/extras/extras.js	2011-08-05 09:23:53 +0000
+++ lib/lp/app/javascript/extras/extras.js	2012-01-13 14:12:26 +0000
@@ -10,8 +10,6 @@
 
 YUI.add('lp.extras', function(Y) {
 
-Y.log('loading lp.extras');
-
 var namespace = Y.namespace("lp.extras"),
     NodeList = Y.NodeList;
 

=== modified file 'lib/lp/app/javascript/foldables.js'
--- lib/lp/app/javascript/foldables.js	2012-01-10 17:23:23 +0000
+++ lib/lp/app/javascript/foldables.js	2012-01-13 14:12:26 +0000
@@ -46,7 +46,6 @@
         included.each(function (span, index, list) {
             if (span.hasClass('foldable-quoted')) {
                 var quoted_lines = span.all('br');
-                debugger;
                 if (quoted_lines && quoted_lines.size() <= 11) {
                     // We do not hide short quoted passages (12 lines) by
                     // default.

=== modified file 'lib/lp/app/javascript/sorttable/sorttable.js'
--- lib/lp/app/javascript/sorttable/sorttable.js	2009-06-03 14:52:54 +0000
+++ lib/lp/app/javascript/sorttable/sorttable.js	2012-01-13 14:12:26 +0000
@@ -1,309 +1,469 @@
-/* 
- * Table sorting Javascript. MIT-licensed. Originally from 
- *
- *     http://www.kryogenix.org/code/browser/sorttable/
- * 
- * 2005-07-13: Initial import. Changed the arrow code to use the images
- *             included with Plone instead of the entities. Also changed
- *             the way sorting of a previously-sorted column behaves
- *             slightly. Reformatted to try keeping to 80 columns. (kiko)
- *
- * 2006-03-13: Added support for indicating sortkeys (direct and
- *             reverse) inside table cells. Removed tabs. (kiko)
- *
- * 2006-04-08: Fixed matching of "sortable". Added support for "initial-sort".
- *             Made sorting stable. (ddaa)
- *
- * 2006-04-11: Fixed numeric sorting to be robust in the presence of
- *             whitespace; added trim(). Note that parseFloat() deals
- *             with leading and trailing whitespace just fine. (kiko)
- *
- * 2006-04-12: Added default-sort and default-revsort classes. When
- *             the data in the table is already pre-sorted, you can use
- *             these classes to indicate by which column they were
- *             ordered by. This, in turn, allows us to correctly
- *             Javascript-sort them later. (kiko)
- *
- * 2006-10-15: Moved the window load event to main-template.pt, so that this
- *             script's load event doesn't stomp those of other scripts. (mpt)
+/*
+  SortTable
+  version 2
+  7th April 2007
+  Stuart Langridge, http://www.kryogenix.org/code/browser/sorttable/
+  
+  Instructions:
+  Download this file
+  Add <script src="sorttable.js"></script> to your HTML
+  Add class="sortable" to any table you'd like to make sortable
+  Click on the headers to sort
+  
+  Thanks to many, many people for contributions and suggestions.
+  Licenced as X11: http://www.kryogenix.org/code/browser/licence.html
+  This basically means: do what you want with it.
+*/
+
+/**
+ * New api is:
+ * var sortable = new Y.lp.app.sortable.Sortable();
+ * sortable.init();
  */
 
-var SORT_COLUMN_INDEX;
-
-var arrowUp = "/@@/arrowUp";
-var arrowDown = "/@@/arrowDown";
-var arrowBlank = "/@@/arrowBlank";
-
-function trim(str) {
-    return str.replace(/^\s*|\s*$/g, "");
-}
-
-function sortables_init() {
-    // Find all tables with class sortable and make them sortable
-    if (!document.getElementsByTagName) return;
-    tbls = document.getElementsByTagName("table");
-    for (ti=0;ti<tbls.length;ti++) {
-        thisTbl = tbls[ti];
-        if (((' '+thisTbl.className+' ').indexOf(" sortable ") != -1) && 
-             (thisTbl.id)) {
-            ts_makeSortable(thisTbl);
-        }
-    }
-}
-
-function ts_makeSortable(table) {
-    if (table.tHead && table.tHead.rows && table.tHead.rows.length > 0) {
-        var firstRow = table.tHead.rows[0];
-    } else if (table.rows && table.rows.length > 0) {
-        var firstRow = table.rows[0];
-    }
-    if (!firstRow) return;
-
-    // We have a first row: assume it's the header, and make its
-    // contents clickable links
-    for (var i=0;i<firstRow.cells.length;i++) {
-        var cell = firstRow.cells[i];
-        var txt = ts_getInnerText(cell);
-        cell.innerHTML = '<a href="#" class="sortheader" onclick="ts_resortTable(this); return false;">' 
-                         + txt + 
-                         '<img class="sortarrow" src="'+arrowBlank+'" height="6" width="9"></a>';
-    }
-
-    // Sort by the first column whose title cell has initial-sort class.
-    for (var i=0; i<firstRow.cells.length; i++) {
-        var cell = firstRow.cells[i];
-        var lnk = ts_firstChildByName(cell, 'A');
-        var img = ts_firstChildByName(lnk, 'IMG')
-        if ((' ' + cell.className + ' ').indexOf(" default-sort ") != -1) {
-            ts_arrowDown(img);
-        }
-        if ((' ' + cell.className + ' ').indexOf(" default-revsort ") != -1) {
-            ts_arrowUp(img);
-        }
-        if ((' ' + cell.className + ' ').indexOf(" initial-sort ") != -1) {
-            ts_resortTable(lnk);
-        }
-    }
-}
-
-function ts_getInnerText(el) {
-    if (typeof el == "string") return el;
-    if (typeof el == "undefined") { return el };
-    if (el.innerText) return el.innerText;    //Not needed but it is faster
-    var str = "";
-
-    var cs = el.childNodes;
-    var l = cs.length;
-    for (var i = 0; i < l; i++) {
-        node = cs[i];
-        switch (node.nodeType) {
-            case 1: //ELEMENT_NODE
-                if (node.className == "sortkey") {
-                    return ts_getInnerText(node);
-                } else if (node.className == "revsortkey") {
-                    return "-" + ts_getInnerText(node);
-                } else {
-                    str += ts_getInnerText(node);
-                    break;
-                }
-            case 3:    //TEXT_NODE
-                str += node.nodeValue;
-                break;
-        }
-    }
-    return str;
-}
-
-function ts_firstChildByName(el, name) {
-    for (var ci=0; ci < el.childNodes.length; ci++) {
-        if (el.childNodes[ci].tagName && 
-            el.childNodes[ci].tagName.toLowerCase() == name.toLowerCase())
-            return el.childNodes[ci];
-    }
-}
-
-function ts_arrowUp(img) {
-    img.setAttribute('sortdir','up');
-    img.src = arrowUp;
-}
-
-function ts_arrowDown(img) {
-    img.setAttribute('sortdir','down');
-    img.src = arrowDown;
-}
-
-function ts_resortTable(lnk) {
-    // get the img
-    var img = ts_firstChildByName(lnk, 'IMG')
-    var td = lnk.parentNode;
-    var column = td.cellIndex;
-    var table = getParent(td,'TABLE');
-
-    if (table.rows.length <= 1) return;
-
-    SORT_COLUMN_INDEX = column;
-    // If some previous column contains a colspan, we need to increase
-    // the column index to compensate for it.
-    while (td.previousSibling != null) {
-        td = td.previousSibling;
-        if (td.nodeType != 1) {
-            continue
-        }
-        colspan = td.getAttribute("colspan");
-        if (colspan) {
-            SORT_COLUMN_INDEX += parseInt(colspan) - 1;
-        }
-    }
-
-    // Work out a type for the column
-    var itm = ts_getInnerText(table.rows[1].cells[SORT_COLUMN_INDEX]);
-    itm = trim(itm);
-
-    sortfn = ts_sort_caseinsensitive;
-    if (itm.match(/^\d\d[\/-]\d\d[\/-]\d\d\d\d$/)) sortfn = ts_sort_date;
-    if (itm.match(/^\d\d[\/-]\d\d[\/-]\d\d$/)) sortfn = ts_sort_date;
-    if (itm.match(/^[£$]/)) sortfn = ts_sort_currency;
-    if (itm.match(/^-?[\d\.]+$/)) sortfn = ts_sort_numeric;
-
-    var firstRow = new Array();
-    var newRows = new Array();
-    for (i=0;i<table.rows[0].length;i++) { firstRow[i] = table.rows[0][i]; }
-    for (j=1;j<table.rows.length;j++) {
-        newRows[j-1] = table.rows[j];
-        newRows[j-1].oldPosition = j-1;
-    }
-
-    newRows.sort(ts_stableSort(sortfn));
-
-    if (img.getAttribute("sortdir") == 'down') {
-        newRows.reverse();
-        ts_arrowUp(img);
-    } else {
-        ts_arrowDown(img);
-    }
-
-    // We appendChild rows that already exist to the tbody, so it moves
-    // them rather than creating new ones
-    for (i=0;i<newRows.length;i++) { 
-        if (!newRows[i].className || 
-            (newRows[i].className && 
-             (newRows[i].className.indexOf('sortbottom') == -1)))
-                // don't do sortbottom rows
-                table.tBodies[0].appendChild(newRows[i]);
-    }
-    // do sortbottom rows only
-    for (i=0;i<newRows.length;i++) { 
-        if (newRows[i].className && 
-            (newRows[i].className.indexOf('sortbottom') != -1)) 
-                table.tBodies[0].appendChild(newRows[i]);
-    }
-
-    // Delete any other arrows there may be showing
-    var allimgs = document.getElementsByTagName("img");
-    for (var ci=0; ci<allimgs.length; ci++) {
-        var one_img = allimgs[ci];
-        if (one_img != img && 
-            one_img.className == 'sortarrow' &&
-            getParent(one_img, "table") == getParent(lnk, "table")) { 
-                one_img.src = arrowBlank;
-                one_img.setAttribute('sortdir', '');
-        }
-    }
-}
-
-function getParent(el, pTagName) {
-    if (el == null) 
-        return null;
-    else if (el.nodeType == 1 && 
-             el.tagName.toLowerCase() == pTagName.toLowerCase())
-        // Gecko bug, supposed to be uppercase
-        return el;
-    else
-        return getParent(el.parentNode, pTagName);
-}
-
-function ts_stableSort(sortfn) {
-    // Return a comparison function based on sortfn, but using oldPosition
-    // attributes to discriminate between objects that sortfn compares as
-    // equal, effectively providing stable sort.
-    function stableSort(a, b) {
-        var cmp = sortfn(a, b);
-        if (cmp != 0) {
-            return cmp;
-        } else {
-                return a.oldPosition - b.oldPosition;
-        }
-    }
-    return stableSort;
-}
-
-function ts_sort_date(a,b) {
-    // y2k notes: two digit years less than 50 are treated as 20XX,
-    // greater than 50 are treated as 19XX
-    aa = trim(ts_getInnerText(a.cells[SORT_COLUMN_INDEX]));
-    bb = trim(ts_getInnerText(b.cells[SORT_COLUMN_INDEX]));
-    if (aa.length == 10) {
-        dt1 = aa.substr(6,4)+aa.substr(3,2)+aa.substr(0,2);
-    } else {
-        yr = aa.substr(6,2);
-        if (parseInt(yr) < 50) { yr = '20'+yr; } else { yr = '19'+yr; }
-        dt1 = yr+aa.substr(3,2)+aa.substr(0,2);
-    }
-    if (bb.length == 10) {
-        dt2 = bb.substr(6,4)+bb.substr(3,2)+bb.substr(0,2);
-    } else {
-        yr = bb.substr(6,2);
-        if (parseInt(yr) < 50) { yr = '20'+yr; } else { yr = '19'+yr; }
-        dt2 = yr+bb.substr(3,2)+bb.substr(0,2);
-    }
-    if (dt1==dt2) return 0;
-    if (dt1<dt2) return -1;
-    return 1;
-}
-
-function ts_sort_currency(a,b) { 
-    aa = ts_getInnerText(a.cells[SORT_COLUMN_INDEX]).replace(/[^0-9.]/g,'');
-    bb = ts_getInnerText(b.cells[SORT_COLUMN_INDEX]).replace(/[^0-9.]/g,'');
-    return parseFloat(aa) - parseFloat(bb);
-}
-
-function ts_sort_numeric(a,b) {
-    aa = parseFloat(ts_getInnerText(a.cells[SORT_COLUMN_INDEX]));
-    if (isNaN(aa)) aa = 0;
-    bb = parseFloat(ts_getInnerText(b.cells[SORT_COLUMN_INDEX])); 
-    if (isNaN(bb)) bb = 0;
-    return aa-bb;
-}
-
-function ts_sort_caseinsensitive(a,b) {
-    aa = ts_getInnerText(a.cells[SORT_COLUMN_INDEX]).toLowerCase();
-    bb = ts_getInnerText(b.cells[SORT_COLUMN_INDEX]).toLowerCase();
-    if (aa==bb) return 0;
-    if (aa<bb) return -1;
-    return 1;
-}
-
-function ts_sort_default(a,b) {
-    aa = ts_getInnerText(a.cells[SORT_COLUMN_INDEX]);
-    bb = ts_getInnerText(b.cells[SORT_COLUMN_INDEX]);
-    if (aa==bb) return 0;
-    if (aa<bb) return -1;
-    return 1;
-}
-
-
-// addEvent and removeEvent
-// cross-browser event handling for IE5+, NS6 and Mozilla
-// By Scott Andrew
-function addEvent(elm, evType, fn, useCapture) {
-    if (elm.addEventListener){
-        elm.addEventListener(evType, fn, useCapture);
-        return true;
-    } else if (elm.attachEvent){
-        var r = elm.attachEvent("on"+evType, fn);
-        return r;
-    } else {
-        alert("Handler could not be removed");
-    }
-}
-
+ 
+YUI.add('lp.app.sorttable', function(Y) {
+
+    var namespace = Y.namespace('lp.app.sorttable');
+
+    var stIsIE = /*@cc_on!@*/false;
+
+    sorttable = {
+      init: function() {
+        // quit if this function has already been called
+        if (arguments.callee.done) return;
+        // flag this function so we don't do the same thing twice
+        arguments.callee.done = true;
+        
+        if (!document.createElement || !document.getElementsByTagName) return;
+        
+        sorttable.DATE_RE = /^(\d\d?)[\/\.-](\d\d?)[\/\.-]((\d\d)?\d\d)$/;
+        
+        forEach(document.getElementsByTagName('table'), function(table) {
+          if (table.className.search(/\bsortable\b/) != -1) {
+            sorttable.makeSortable(table);
+          }
+        });
+        
+      },
+      
+      makeSortable: function(table) {
+        if (table.getElementsByTagName('thead').length == 0) {
+          // table doesn't have a tHead. Since it should have, create one and
+          // put the first table row in it.
+          the = document.createElement('thead');
+          the.appendChild(table.rows[0]);
+          table.insertBefore(the,table.firstChild);
+        }
+        // Safari doesn't support table.tHead, sigh
+        if (table.tHead == null) table.tHead = table.getElementsByTagName('thead')[0];
+        
+        if (table.tHead.rows.length != 1) return; // can't cope with two header rows
+        
+        // Sorttable v1 put rows with a class of "sortbottom" at the bottom (as
+        // "total" rows, for example). This is B&R, since what you're supposed
+        // to do is put them in a tfoot. So, if there are sortbottom rows,
+        // for backwards compatibility, move them to tfoot (creating it if needed).
+        sortbottomrows = [];
+        for (var i=0; i<table.rows.length; i++) {
+          if (table.rows[i].className.search(/\bsortbottom\b/) != -1) {
+            sortbottomrows[sortbottomrows.length] = table.rows[i];
+          }
+        }
+        if (sortbottomrows) {
+          if (table.tFoot == null) {
+            // table doesn't have a tfoot. Create one.
+            tfo = document.createElement('tfoot');
+            table.appendChild(tfo);
+          }
+          for (var i=0; i<sortbottomrows.length; i++) {
+            tfo.appendChild(sortbottomrows[i]);
+          }
+          delete sortbottomrows;
+        }
+        
+        // work through each column and calculate its type
+        headrow = table.tHead.rows[0].cells;
+        for (var i=0; i<headrow.length; i++) {
+          // manually override the type with a sorttable_type attribute
+          if (!headrow[i].className.match(/\bsorttable_nosort\b/)) { // skip this col
+            mtch = headrow[i].className.match(/\bsorttable_([a-z0-9]+)\b/);
+            if (mtch) { override = mtch[1]; }
+              if (mtch && typeof sorttable["sort_"+override] == 'function') {
+                headrow[i].sorttable_sortfunction = sorttable["sort_"+override];
+              } else {
+                headrow[i].sorttable_sortfunction = sorttable.guessType(table,i);
+              }
+              // make it clickable to sort
+              headrow[i].sorttable_columnindex = i;
+              headrow[i].sorttable_tbody = table.tBodies[0];
+              dean_addEvent(headrow[i],"click", function(e) {
+
+              if (this.className.search(/\bsorttable_sorted\b/) != -1) {
+                // if we're already sorted by this column, just 
+                // reverse the table, which is quicker
+                sorttable.reverse(this.sorttable_tbody);
+                this.className = this.className.replace('sorttable_sorted',
+                                                        'sorttable_sorted_reverse');
+                this.removeChild(document.getElementById('sorttable_sortfwdind'));
+                sortrevind = document.createElement('span');
+                sortrevind.id = "sorttable_sortrevind";
+                sortrevind.innerHTML = stIsIE ? '&nbsp<font face="webdings">5</font>' : '&nbsp;&#x25B4;';
+                this.appendChild(sortrevind);
+                return;
+              }
+              if (this.className.search(/\bsorttable_sorted_reverse\b/) != -1) {
+                // if we're already sorted by this column in reverse, just 
+                // re-reverse the table, which is quicker
+                sorttable.reverse(this.sorttable_tbody);
+                this.className = this.className.replace('sorttable_sorted_reverse',
+                                                        'sorttable_sorted');
+                this.removeChild(document.getElementById('sorttable_sortrevind'));
+                sortfwdind = document.createElement('span');
+                sortfwdind.id = "sorttable_sortfwdind";
+                sortfwdind.innerHTML = stIsIE ? '&nbsp<font face="webdings">6</font>' : '&nbsp;&#x25BE;';
+                this.appendChild(sortfwdind);
+                return;
+              }
+              
+              // remove sorttable_sorted classes
+              theadrow = this.parentNode;
+              forEach(theadrow.childNodes, function(cell) {
+                if (cell.nodeType == 1) { // an element
+                  cell.className = cell.className.replace('sorttable_sorted_reverse','');
+                  cell.className = cell.className.replace('sorttable_sorted','');
+                }
+              });
+              sortfwdind = document.getElementById('sorttable_sortfwdind');
+              if (sortfwdind) { sortfwdind.parentNode.removeChild(sortfwdind); }
+              sortrevind = document.getElementById('sorttable_sortrevind');
+              if (sortrevind) { sortrevind.parentNode.removeChild(sortrevind); }
+              
+              this.className += ' sorttable_sorted';
+              sortfwdind = document.createElement('span');
+              sortfwdind.id = "sorttable_sortfwdind";
+              sortfwdind.innerHTML = stIsIE ? '&nbsp<font face="webdings">6</font>' : '&nbsp;&#x25BE;';
+              this.appendChild(sortfwdind);
+
+                // build an array to sort. This is a Schwartzian transform thing,
+                // i.e., we "decorate" each row with the actual sort key,
+                // sort based on the sort keys, and then put the rows back in order
+                // which is a lot faster because you only do getInnerText once per row
+                row_array = [];
+                col = this.sorttable_columnindex;
+                rows = this.sorttable_tbody.rows;
+                for (var j=0; j<rows.length; j++) {
+                  row_array[row_array.length] = [sorttable.getInnerText(rows[j].cells[col]), rows[j]];
+                }
+                /* If you want a stable sort, uncomment the following line */
+                //sorttable.shaker_sort(row_array, this.sorttable_sortfunction);
+                /* and comment out this one */
+                row_array.sort(this.sorttable_sortfunction);
+                
+                tb = this.sorttable_tbody;
+                for (var j=0; j<row_array.length; j++) {
+                  tb.appendChild(row_array[j][1]);
+                }
+                
+                delete row_array;
+              });
+            }
+        }
+      },
+      
+      guessType: function(table, column) {
+        // guess the type of a column based on its first non-blank row
+        sortfn = sorttable.sort_alpha;
+        for (var i=0; i<table.tBodies[0].rows.length; i++) {
+          text = sorttable.getInnerText(table.tBodies[0].rows[i].cells[column]);
+          if (text != '') {
+            if (text.match(/^-?[£$¤]?[\d,.]+%?$/)) {
+              return sorttable.sort_numeric;
+            }
+            // check for a date: dd/mm/yyyy or dd/mm/yy 
+            // can have / or . or - as separator
+            // can be mm/dd as well
+            possdate = text.match(sorttable.DATE_RE)
+            if (possdate) {
+              // looks like a date
+              first = parseInt(possdate[1]);
+              second = parseInt(possdate[2]);
+              if (first > 12) {
+                // definitely dd/mm
+                return sorttable.sort_ddmm;
+              } else if (second > 12) {
+                return sorttable.sort_mmdd;
+              } else {
+                // looks like a date, but we can't tell which, so assume
+                // that it's dd/mm (English imperialism!) and keep looking
+                sortfn = sorttable.sort_ddmm;
+              }
+            }
+          }
+        }
+        return sortfn;
+      },
+      
+      getInnerText: function(node) {
+        // gets the text we want to use for sorting for a cell.
+        // strips leading and trailing whitespace.
+        // this is *not* a generic getInnerText function; it's special to sorttable.
+        // for example, you can override the cell text with a customkey attribute.
+        // it also gets .value for <input> fields.
+        
+        hasInputs = (typeof node.getElementsByTagName == 'function') &&
+                     node.getElementsByTagName('input').length;
+        
+        if (node.getAttribute("sorttable_customkey") != null) {
+          return node.getAttribute("sorttable_customkey");
+        }
+        else if (typeof node.textContent != 'undefined' && !hasInputs) {
+          return node.textContent.replace(/^\s+|\s+$/g, '');
+        }
+        else if (typeof node.innerText != 'undefined' && !hasInputs) {
+          return node.innerText.replace(/^\s+|\s+$/g, '');
+        }
+        else if (typeof node.text != 'undefined' && !hasInputs) {
+          return node.text.replace(/^\s+|\s+$/g, '');
+        }
+        else {
+          switch (node.nodeType) {
+            case 3:
+              if (node.nodeName.toLowerCase() == 'input') {
+                return node.value.replace(/^\s+|\s+$/g, '');
+              }
+            case 4:
+              return node.nodeValue.replace(/^\s+|\s+$/g, '');
+              break;
+            case 1:
+            case 11:
+              var innerText = '';
+              for (var i = 0; i < node.childNodes.length; i++) {
+                innerText += sorttable.getInnerText(node.childNodes[i]);
+              }
+              return innerText.replace(/^\s+|\s+$/g, '');
+              break;
+            default:
+              return '';
+          }
+        }
+      },
+      
+      reverse: function(tbody) {
+        // reverse the rows in a tbody
+        newrows = [];
+        for (var i=0; i<tbody.rows.length; i++) {
+          newrows[newrows.length] = tbody.rows[i];
+        }
+        for (var i=newrows.length-1; i>=0; i--) {
+           tbody.appendChild(newrows[i]);
+        }
+        delete newrows;
+      },
+      
+      /* sort functions
+         each sort function takes two parameters, a and b
+         you are comparing a[0] and b[0] */
+      sort_numeric: function(a,b) {
+        aa = parseFloat(a[0].replace(/[^0-9.-]/g,''));
+        if (isNaN(aa)) aa = 0;
+        bb = parseFloat(b[0].replace(/[^0-9.-]/g,'')); 
+        if (isNaN(bb)) bb = 0;
+        return aa-bb;
+      },
+      sort_alpha: function(a,b) {
+        if (a[0]==b[0]) return 0;
+        if (a[0]<b[0]) return -1;
+        return 1;
+      },
+      sort_ddmm: function(a,b) {
+        mtch = a[0].match(sorttable.DATE_RE);
+        y = mtch[3]; m = mtch[2]; d = mtch[1];
+        if (m.length == 1) m = '0'+m;
+        if (d.length == 1) d = '0'+d;
+        dt1 = y+m+d;
+        mtch = b[0].match(sorttable.DATE_RE);
+        y = mtch[3]; m = mtch[2]; d = mtch[1];
+        if (m.length == 1) m = '0'+m;
+        if (d.length == 1) d = '0'+d;
+        dt2 = y+m+d;
+        if (dt1==dt2) return 0;
+        if (dt1<dt2) return -1;
+        return 1;
+      },
+      sort_mmdd: function(a,b) {
+        mtch = a[0].match(sorttable.DATE_RE);
+        y = mtch[3]; d = mtch[2]; m = mtch[1];
+        if (m.length == 1) m = '0'+m;
+        if (d.length == 1) d = '0'+d;
+        dt1 = y+m+d;
+        mtch = b[0].match(sorttable.DATE_RE);
+        y = mtch[3]; d = mtch[2]; m = mtch[1];
+        if (m.length == 1) m = '0'+m;
+        if (d.length == 1) d = '0'+d;
+        dt2 = y+m+d;
+        if (dt1==dt2) return 0;
+        if (dt1<dt2) return -1;
+        return 1;
+      },
+      
+      shaker_sort: function(list, comp_func) {
+        // A stable sort function to allow multi-level sorting of data
+        // see: http://en.wikipedia.org/wiki/Cocktail_sort
+        // thanks to Joseph Nahmias
+        var b = 0;
+        var t = list.length - 1;
+        var swap = true;
+
+        while(swap) {
+            swap = false;
+            for(var i = b; i < t; ++i) {
+                if ( comp_func(list[i], list[i+1]) > 0 ) {
+                    var q = list[i]; list[i] = list[i+1]; list[i+1] = q;
+                    swap = true;
+                }
+            } // for
+            t--;
+
+            if (!swap) break;
+
+            for(var i = t; i > b; --i) {
+                if ( comp_func(list[i], list[i-1]) < 0 ) {
+                    var q = list[i]; list[i] = list[i-1]; list[i-1] = q;
+                    swap = true;
+                }
+            } // for
+            b++;
+
+        } // while(swap)
+      }  
+    }
+
+    // written by Dean Edwards, 2005
+    // with input from Tino Zijdel, Matthias Miller, Diego Perini
+
+    // http://dean.edwards.name/weblog/2005/10/add-event/
+
+    function dean_addEvent(element, type, handler) {
+        if (element.addEventListener) {
+            element.addEventListener(type, handler, false);
+        } else {
+            // assign each event handler a unique ID
+            if (!handler.$$guid) handler.$$guid = dean_addEvent.guid++;
+            // create a hash table of event types for the element
+            if (!element.events) element.events = {};
+            // create a hash table of event handlers for each element/event pair
+            var handlers = element.events[type];
+            if (!handlers) {
+                handlers = element.events[type] = {};
+                // store the existing event handler (if there is one)
+                if (element["on" + type]) {
+                    handlers[0] = element["on" + type];
+                }
+            }
+            // store the event handler in the hash table
+            handlers[handler.$$guid] = handler;
+            // assign a global event handler to do all the work
+            element["on" + type] = handleEvent;
+        }
+    };
+    // a counter used to create unique IDs
+    dean_addEvent.guid = 1;
+
+    function removeEvent(element, type, handler) {
+        if (element.removeEventListener) {
+            element.removeEventListener(type, handler, false);
+        } else {
+            // delete the event handler from the hash table
+            if (element.events && element.events[type]) {
+                delete element.events[type][handler.$$guid];
+            }
+        }
+    };
+
+    function handleEvent(event) {
+        var returnValue = true;
+        // grab the event object (IE uses a global event object)
+        event = event || fixEvent(((this.ownerDocument || this.document || this).parentWindow || window).event);
+        // get a reference to the hash table of event handlers
+        var handlers = this.events[event.type];
+        // execute each event handler
+        for (var i in handlers) {
+            this.$$handleEvent = handlers[i];
+            if (this.$$handleEvent(event) === false) {
+                returnValue = false;
+            }
+        }
+        return returnValue;
+    };
+
+    function fixEvent(event) {
+        // add W3C standard event methods
+        event.preventDefault = fixEvent.preventDefault;
+        event.stopPropagation = fixEvent.stopPropagation;
+        return event;
+    };
+    fixEvent.preventDefault = function() {
+        this.returnValue = false;
+    };
+    fixEvent.stopPropagation = function() {
+      this.cancelBubble = true;
+    }
+
+    // Dean's forEach: http://dean.edwards.name/base/forEach.js
+    /*
+        forEach, version 1.0
+        Copyright 2006, Dean Edwards
+        License: http://www.opensource.org/licenses/mit-license.php
+    */
+
+    // array-like enumeration
+    if (!Array.forEach) { // mozilla already supports this
+        Array.forEach = function(array, block, context) {
+            for (var i = 0; i < array.length; i++) {
+                block.call(context, array[i], i, array);
+            }
+        };
+    }
+
+    // generic enumeration
+    Function.prototype.forEach = function(object, block, context) {
+        for (var key in object) {
+            if (typeof this.prototype[key] == "undefined") {
+                block.call(context, object[key], key, object);
+            }
+        }
+    };
+
+    // character enumeration
+    String.forEach = function(string, block, context) {
+        Array.forEach(string.split(""), function(chr, index) {
+            block.call(context, chr, index, string);
+        });
+    };
+
+    // globally resolve forEach enumeration
+    var forEach = function(object, block, context) {
+        if (object) {
+            var resolve = Object; // default
+            if (object instanceof Function) {
+                // functions have a "length" property
+                resolve = Function;
+            } else if (object.forEach instanceof Function) {
+                // the object implements a custom forEach method so use that
+                object.forEach(block, context);
+                return;
+            } else if (typeof object == "string") {
+                // the object is a string
+                resolve = String;
+            } else if (typeof object.length == "number") {
+                // the object is array-like
+                resolve = Array;
+            }
+            resolve.forEach(object, block, context);
+        }
+    };
+
+    namespace.SortTable = sorttable;
+
+}, "0.1", {});

=== modified file 'lib/lp/app/javascript/tests/test_foldables.js'
--- lib/lp/app/javascript/tests/test_foldables.js	2012-01-10 17:36:29 +0000
+++ lib/lp/app/javascript/tests/test_foldables.js	2012-01-13 14:12:26 +0000
@@ -82,7 +82,6 @@
         },
 
         test_doesnt_hide_short: function () {
-            debugger;
             this._add_comment(quote_comment);
             Y.lp.app.foldables.activate();
             Y.Assert.isNull(Y.one('a'));

=== modified file 'lib/lp/app/templates/base-layout-macros.pt'
--- lib/lp/app/templates/base-layout-macros.pt	2012-01-11 13:59:39 +0000
+++ lib/lp/app/templates/base-layout-macros.pt	2012-01-13 14:12:26 +0000
@@ -106,10 +106,11 @@
     </script>
 
   <script id="base-layout-load-scripts" type="text/javascript">
-    LPS.use('node', 'event-delegate', 'lp', 'lp.app.foldables', 'lp.app.links',
-        'lp.app.longpoll', 'lp.app.inlinehelp', function(Y) {
+    LPS.use('node', 'event-delegate', 'lp', 'lp.app.foldables',
+            'lp.app.links', 'lp.app.sorttable', 'lp.app.longpoll',
+            'lp.app.inlinehelp', function(Y) {
         Y.on('load', function(e) {
-            sortables_init();
+            Y.lp.app.sorttable.SortTable.init();
             Y.lp.app.inlinehelp.init_help();
             Y.lp.activate_collapsibles();
             Y.lp.app.foldables.activate();

=== modified file 'lib/lp/archiveuploader/tests/nascentuploadfile.txt'
--- lib/lp/archiveuploader/tests/nascentuploadfile.txt	2011-12-30 06:14:56 +0000
+++ lib/lp/archiveuploader/tests/nascentuploadfile.txt	2012-01-13 14:12:26 +0000
@@ -270,37 +270,6 @@
     >>> addr['person'].creation_comment
     u'when the some-source_6.6.6 package was uploaded to hoary/RELEASE'
 
-If the email address is registered but not associated with a person it will be
-associated with a new Person. This involves updating the email address,
-something for which the uploader must have explicit permissions (bug 589073).
-
-    >>> sig_file.policy.create_people
-    True
-
-    >>> from lp.services.database.sqlbase import commit
-    >>> from lp.services.identity.interfaces.account import IAccountSet
-    >>> from lp.registry.interfaces.person import (
-    ...      PersonCreationRationale, IPersonSet)
-    >>> (acct, email) = getUtility(IAccountSet).createAccountAndEmail(
-    ...          "[e-mail]", PersonCreationRationale.UNKNOWN,
-    ...          "fo", "secr1t")
-    >>> person = getUtility(IPersonSet).createPersonWithoutEmail("fo",
-    ...          rationale=PersonCreationRationale.UNKNOWN)
-    >>> person.account = acct
-
-    Commit the changes so the emailaddress will have to be updated later
-    rather than inserted.
-
-    >>> commit()
-
-    >>> addr = sig_file.parseAddress("Foo <[e-mail]>")
-    >>> print addr['person'].creation_rationale.name
-    UNKNOWN
-    >>> commit()
-
-    >>> print addr['email']
-    [e-mail]
-
 If the use an un-initialized policy to create a launchpad person the
 creation_rationale will still be possible, however missing important
 information, the upload target:

=== modified file 'lib/lp/bugs/browser/tests/test_bugtask.py'
--- lib/lp/bugs/browser/tests/test_bugtask.py	2011-12-30 06:14:56 +0000
+++ lib/lp/bugs/browser/tests/test_bugtask.py	2012-01-13 14:12:26 +0000
@@ -183,7 +183,7 @@
         self.invalidate_caches(bug.default_bugtask)
         self.getUserBrowser(url, owner)
         # At least 20 of these should be removed.
-        self.assertThat(recorder, HasQueryCount(LessThan(106)))
+        self.assertThat(recorder, HasQueryCount(LessThan(107)))
         count_with_no_branches = recorder.count
         for sp in sourcepackages:
             self.makeLinkedBranchMergeProposal(sp, bug, owner)

=== modified file 'lib/lp/bugs/doc/externalbugtracker-comment-imports.txt'
--- lib/lp/bugs/doc/externalbugtracker-comment-imports.txt	2011-12-29 05:29:36 +0000
+++ lib/lp/bugs/doc/externalbugtracker-comment-imports.txt	2012-01-13 14:12:26 +0000
@@ -179,23 +179,6 @@
     >>> bug.messages[-1].owner.name
     u'no-priv'
 
-This also works if the address is associated with an Account, but not a
-Person. This should only happen when the user has logged into ShipIt but
-not Launchpad. A new Person is created.
-
-    >>> account = factory.makeAccount(email="[e-mail]")
-    >>> external_bugtracker.poster_tuple = (
-    ...     'Account Only', '[e-mail]')
-    >>> external_bugtracker.remote_comments['account-only-comment'] = (
-    ...     "Account-only comment.")
-    >>> bugwatch_updater.importBugComments()
-    INFO:...:Imported 1 comments for remote bug 123456 on ...
-
-    >>> bug.messages[-1].owner.name
-    u'account-only'
-    >>> bug.messages[-1].owner.account == account
-    True
-
 It's also possible for Launchpad to create Persons from remote
 bugtracker users when the remote bugtracker doesn't specify an email
 address. In those cases, the ExternalBugTracker's getPosterForComment()

=== modified file 'lib/lp/bugs/scripts/bugimport.py'
--- lib/lp/bugs/scripts/bugimport.py	2011-12-30 06:14:56 +0000
+++ lib/lp/bugs/scripts/bugimport.py	2012-01-13 14:12:26 +0000
@@ -168,8 +168,9 @@
             person = None
 
         if person is None:
-            address = getUtility(IEmailAddressSet).getByEmail(email)
-            if address is None:
+            person = getUtility(IPersonSet).getByEmail(email)
+
+            if person is None:
                 self.logger.debug('creating person for %s' % email)
                 # Has the short name been taken?
                 if name is not None and (
@@ -184,26 +185,6 @@
                         rationale=PersonCreationRationale.BUGIMPORT,
                         comment=('when importing bugs for %s' %
                                  self.product.displayname)))
-            elif address.personID is None:
-                # The user has an Account and and EmailAddress linked
-                # to that account.
-                assert address.accountID is not None, (
-                    "Email address not linked to an Account: %s " % email)
-                self.logger.debug(
-                    'creating person from account for %s' % email)
-                if name is not None and (
-                    person_set.getByName(name) is not None):
-                    # The short name is already taken, so we'll pass
-                    # None to createPerson(), which will take care of
-                    # creating a unique one.
-                    name = None
-                person = address.account.createPerson(
-                    rationale=PersonCreationRationale.BUGIMPORT,
-                    name=name, comment=('when importing bugs for %s' %
-                                        self.product.displayname))
-            else:
-                # EmailAddress and Person are in different stores.
-                person = person_set.get(address.personID)
 
             self.person_id_cache[email] = person.id
 

=== modified file 'lib/lp/bugs/scripts/tests/test_bugimport.py'
--- lib/lp/bugs/scripts/tests/test_bugimport.py	2012-01-05 00:15:32 +0000
+++ lib/lp/bugs/scripts/tests/test_bugimport.py	2012-01-13 14:12:26 +0000
@@ -297,34 +297,6 @@
         self.assertNotEqual(person.preferredemail, None)
         self.assertEqual(person.preferredemail.email, '[e-mail]')
 
-    def test_person_from_account(self):
-        # If an Account record exists for a user's email address, but
-        # no Person record is linked to it, the bug importer creates a
-        # Person and links the three piece of information together.
-        account = self.factory.makeAccount("Sam")
-        personnode = ET.fromstring(
-            '<person xmlns="https://launchpad.net/xmlns/2006/bugs" />')
-        personnode.set('name', generate_nick(account.preferredemail.email))
-        personnode.set('email', account.preferredemail.email)
-        personnode.text = account.displayname
-
-        product = getUtility(IProductSet).getByName('netapplet')
-        importer = bugimport.BugImporter(
-            product, 'bugs.xml', 'bug-map.pickle', verify_users=True)
-        person = importer.getPerson(personnode)
-
-        # The person returned is associated with the account.
-        self.failUnlessEqual(account.id, person.accountID)
-        # The creation comment and rationale are set correctly.
-        self.failUnlessEqual(
-            'when importing bugs for %s' % product.displayname,
-            person.creation_comment)
-        self.failUnlessEqual(
-            PersonCreationRationale.BUGIMPORT,
-            person.creation_rationale)
-        # The person's email addresses are hidden by default.
-        self.failUnless(person.hide_email_addresses)
-
 
 class GetMilestoneTestCase(unittest.TestCase):
     """Tests for the BugImporter.getMilestone() method."""

=== modified file 'lib/lp/bugs/templates/buglisting.mustache'
--- lib/lp/bugs/templates/buglisting.mustache	2011-12-20 00:00:03 +0000
+++ lib/lp/bugs/templates/buglisting.mustache	2012-01-13 14:12:26 +0000
@@ -22,60 +22,60 @@
             {{/show_id}}
             <a href="{{bug_url}}" class="bugtitle">{{title}}</a>
         </div>
-    </div>
-    <div class="buglisting-col3">
-        {{#show_targetname}}
-            <span class="{{bugtarget_css}} field">
-                {{bugtarget}}
-            </span>
-        {{/show_targetname}}
-        {{#show_milestone_name}}
-            <span class="sprite milestone field">
-                {{#milestone_name}}
-                {{milestone_name}}
-                {{/milestone_name}}
-                {{^milestone_name}}
-                No milestone set
-                {{/milestone_name}}
-            </span>
-        {{/show_milestone_name}}
-        {{#show_date_last_updated}}
-            <span class="sprite milestone field">
-                Last updated {{last_updated}}
-            </span>
-        {{/show_date_last_updated}}
-        {{#show_assignee}}
-            <span class="sprite person field">
-                {{#assignee}}Assignee: {{assignee}}{{/assignee}}
-                {{^assignee}}Assignee: None{{/assignee}}
-            </span>
-        {{/show_assignee}}
-        {{#show_reporter}}
-            <span class="sprite person field">
-                Reporter: {{reporter}}
-            </span>
-        {{/show_reporter}}
-        {{#show_datecreated}}
-            <span class="sprite milestone field">
-                {{age}}
-            </span>
-        {{/show_datecreated}}
-        {{#show_tag}}
-            <span class="field">Tags:
-              {{^has_tags}}None{{/has_tags}}
-              {{#tags}}
-                 <a href="{{url}}" class="tag">{{tag}}</a>&#160;
-              {{/tags}}
-            </span>
-        {{/show_tag}}
-        {{#show_heat}}
-            <span class="bug-heat-icons">
-                 {{{bug_heat_html}}}
-            </span>
-        {{/show_heat}}
-        <span class="bug-related-icons">
-            {{{badges}}}
-        </span>
+        <div class="buginfo-extra">
+            {{#show_targetname}}
+                <span class="{{bugtarget_css}} field">
+                    {{bugtarget}}
+                </span>
+            {{/show_targetname}}
+            {{#show_milestone_name}}
+                <span class="sprite milestone field">
+                    {{#milestone_name}}
+                    {{milestone_name}}
+                    {{/milestone_name}}
+                    {{^milestone_name}}
+                    No milestone set
+                    {{/milestone_name}}
+                </span>
+            {{/show_milestone_name}}
+            {{#show_date_last_updated}}
+                <span class="sprite milestone field">
+                    Last updated {{last_updated}}
+                </span>
+            {{/show_date_last_updated}}
+            {{#show_assignee}}
+                <span class="sprite person field">
+                    {{#assignee}}Assignee: {{assignee}}{{/assignee}}
+                    {{^assignee}}Assignee: None{{/assignee}}
+                </span>
+            {{/show_assignee}}
+            {{#show_reporter}}
+                <span class="sprite person field">
+                    Reporter: {{reporter}}
+                </span>
+            {{/show_reporter}}
+            {{#show_datecreated}}
+                <span class="sprite milestone field">
+                    {{age}}
+                </span>
+            {{/show_datecreated}}
+            {{#show_tag}}
+                <span class="field">Tags:
+                  {{^has_tags}}None{{/has_tags}}
+                  {{#tags}}
+                     <a href="{{url}}" class="tag">{{tag}}</a>&#160;
+                  {{/tags}}
+                </span>
+            {{/show_tag}}
+            {{#show_heat}}
+                <span class="bug-heat-icons">
+                     {{{bug_heat_html}}}
+                </span>
+            {{/show_heat}}
+            <span class="bug-related-icons">
+                {{{badges}}}
+            </span>
+        </div>
     </div>
 
   </div>

=== modified file 'lib/lp/registry/doc/person-account.txt'
--- lib/lp/registry/doc/person-account.txt	2011-12-18 13:45:20 +0000
+++ lib/lp/registry/doc/person-account.txt	2012-01-13 14:12:26 +0000
@@ -31,8 +31,7 @@
 the profile. Sample Person cannot claim it.
 
     >>> login('[e-mail]')
-    >>> matsubara.account.activate(
-    ...     comment="test", password='ok', preferred_email=emailaddress)
+    >>> matsubara.account.reactivate(comment="test", password='ok')
     Traceback (most recent call last):
     ...
     Unauthorized: ...'launchpad.Special')
@@ -42,8 +41,8 @@
 
     >>> from zope.security.proxy import removeSecurityProxy
     >>> login('[e-mail]')
-    >>> matsubara.account.activate(
-    ...     comment="test", password='ok', preferred_email=emailaddress)
+    >>> matsubara.account.reactivate(comment="test", password='ok')
+    >>> matsubara.setPreferredEmail(emailaddress)
     >>> import transaction
     >>> transaction.commit()
     >>> matsubara.is_valid_person
@@ -52,7 +51,7 @@
     <DBItem AccountStatus.ACTIVE, ...>
     >>> matsubara.account.status_comment
     u'test'
-    >>> removeSecurityProxy(matsubara.account.preferredemail).email
+    >>> removeSecurityProxy(matsubara.preferredemail).email
     u'[e-mail]'
 
 
@@ -212,15 +211,7 @@
 Reactivating user accounts
 --------------------------
 
-Accounts can be reactivated. A comment and a non-None preferred email address
-are required to reactivate() an account, though.
-
-    >>> foobar.account.reactivate(
-    ...     'This will raise an error.', password='', preferred_email=None)
-    Traceback (most recent call last):
-     ...
-    AssertionError: Account ... cannot be activated without a preferred
-                    email address.
+Accounts can be reactivated.
 
     >>> foobar.reactivate(
     ...     'User reactivated the account using reset password.',

=== modified file 'lib/lp/registry/doc/person.txt'
--- lib/lp/registry/doc/person.txt	2012-01-04 23:49:46 +0000
+++ lib/lp/registry/doc/person.txt	2012-01-13 14:12:26 +0000
@@ -132,9 +132,6 @@
     >>> p.account_status
     <DBItem AccountStatus.NOACCOUNT...
 
-    >>> email.accountID == p.accountID
-    True
-
     >>> p.setPreferredEmail(email)
     >>> email.status
     <DBItem EmailAddressStatus.PREFERRED...
@@ -145,10 +142,7 @@
     >>> from lp.services.identity.model.account import Account
     >>> from lp.services.database.lpstorm import IMasterStore
     >>> account = IMasterStore(Account).get(Account, p.accountID)
-    >>> account.activate(
-    ...     "Activated by doc test.",
-    ...     password=p.password,
-    ...     preferred_email=email)
+    >>> account.reactivate("Activated by doc test.", password=p.password)
     >>> p.account_status
     <DBItem AccountStatus.ACTIVE...
 

=== modified file 'lib/lp/registry/model/person.py'
--- lib/lp/registry/model/person.py	2012-01-06 19:56:39 +0000
+++ lib/lp/registry/model/person.py	2012-01-13 14:12:26 +0000
@@ -2540,7 +2540,8 @@
     def reactivate(self, comment, password, preferred_email):
         """See `IPersonSpecialRestricted`."""
         account = IMasterObject(self.account)
-        account.reactivate(comment, password, preferred_email)
+        account.reactivate(comment, password)
+        self.setPreferredEmail(preferred_email)
         if '-deactivatedaccount' in self.name:
             # The name was changed by deactivateAccount(). Restore the
             # name, but we must ensure it does not conflict with a current
@@ -3108,97 +3109,81 @@
         # possible replication lag issues but this might actually be
         # unnecessary.
         with MasterDatabasePolicy():
-            store = IMasterStore(EmailAddress)
-            join = store.using(
-                EmailAddress,
-                LeftJoin(Account, EmailAddress.accountID == Account.id))
-            email, account = (
-                join.find(
-                    (EmailAddress, Account),
-                    EmailAddress.email.lower() ==
-                        ensure_unicode(email_address).lower()).one()
+            email, person = (
+                getUtility(IPersonSet).getByEmails([email_address]).one()
                 or (None, None))
-            identifier = store.find(
+            identifier = IStore(OpenIdIdentifier).find(
                 OpenIdIdentifier, identifier=openid_identifier).one()
 
-            if email is None and identifier is None:
-                # Neither the Email Address not the OpenId Identifier
-                # exist in the database. Create the email address,
-                # account, and associated info. OpenIdIdentifier is
-                # created later.
-                account_set = getUtility(IAccountSet)
-                account, email = account_set.createAccountAndEmail(
-                    email_address, creation_rationale, full_name,
-                    password=None)
-                db_updated = True
-
-            elif email is None:
-                # The Email Address does not exist in the database,
-                # but the OpenId Identifier does. Create the Email
-                # Address and link it to the account.
-                assert account is None, 'Retrieved an account but not email?'
-                account = identifier.account
-                emailaddress_set = getUtility(IEmailAddressSet)
-                email = emailaddress_set.new(
-                    email_address, account=account)
-                db_updated = True
-
-            elif account is None:
-                # Email address exists, but there is no Account linked
-                # to it. Create the Account and link it to the
-                # EmailAddress.
+            if email is None:
+                if identifier is None:
+                    # Neither the Email Address not the OpenId Identifier
+                    # exist in the database. Create the email address,
+                    # account, and associated info. OpenIdIdentifier is
+                    # created later.
+                    person_set = getUtility(IPersonSet)
+                    person, email = person_set.createPersonAndEmail(
+                        email_address, creation_rationale, comment=comment,
+                        displayname=full_name)
+                    db_updated = True
+                else:
+                    # The Email Address does not exist in the database,
+                    # but the OpenId Identifier does. Create the Email
+                    # Address and link it to the person.
+                    person = IPerson(identifier.account, None)
+                    assert person is not None, (
+                        'Received a personless account.')
+                    emailaddress_set = getUtility(IEmailAddressSet)
+                    email = emailaddress_set.new(email_address, person=person)
+                    db_updated = True
+            elif email.person.account is None:
+                # Email address and person exist, but there is no
+                # account. Create and link it.
                 account_set = getUtility(IAccountSet)
                 account = account_set.new(
                     AccountCreationRationale.OWNER_CREATED_LAUNCHPAD,
                     full_name)
-                email.account = account
+                removeSecurityProxy(email.person).account = account
                 db_updated = True
 
+            person = email.person
+            assert person.account is not None
+
             if identifier is None:
                 # This is the first time we have seen that
                 # OpenIdIdentifier. Link it.
                 identifier = OpenIdIdentifier()
-                identifier.account = account
+                identifier.account = person.account
                 identifier.identifier = openid_identifier
-                store.add(identifier)
+                IStore(OpenIdIdentifier).add(identifier)
                 db_updated = True
-
-            elif identifier.account != account:
+            elif identifier.account != person.account:
                 # The ISD OpenId server may have linked this OpenId
                 # identifier to a new email address, or the user may
                 # have transfered their email address to a different
                 # Launchpad Account. If that happened, repair the
                 # link - we trust the ISD OpenId server.
-                identifier.account = account
+                identifier.account = person.account
                 db_updated = True
 
             # We now have an account, email address, and openid identifier.
 
-            if account.status == AccountStatus.SUSPENDED:
+            if person.account.status == AccountStatus.SUSPENDED:
                 raise AccountSuspendedError(
                     "The account matching the identifier is suspended.")
 
-            elif account.status in [AccountStatus.DEACTIVATED,
-                                    AccountStatus.NOACCOUNT]:
-                password = ''  # Needed just to please reactivate() below.
-                removeSecurityProxy(account).reactivate(
-                    comment, password, removeSecurityProxy(email))
+            elif person.account.status in [AccountStatus.DEACTIVATED,
+                                           AccountStatus.NOACCOUNT]:
+                password = ''
+                removeSecurityProxy(person.account).reactivate(
+                    comment, password)
+                removeSecurityProxy(person).setPreferredEmail(email)
                 db_updated = True
             else:
                 # Account is active, so nothing to do.
                 pass
 
-            if IPerson(account, None) is None:
-                removeSecurityProxy(account).createPerson(
-                    creation_rationale, comment=comment)
-                db_updated = True
-
-            person = IPerson(account)
-            if email.personID != person.id:
-                removeSecurityProxy(email).person = person
-                db_updated = True
-
-            return person, db_updated
+            return email.person, db_updated
 
     def newTeam(self, teamowner, name, displayname, teamdescription=None,
                 subscriptionpolicy=TeamSubscriptionPolicy.MODERATED,
@@ -3251,12 +3236,8 @@
         person = self._newPerson(
             name, displayname, hide_email_addresses, rationale=rationale,
             comment=comment, registrant=registrant, account=account)
-
-        email = getUtility(IEmailAddressSet).new(
-                email, person, account=account)
-
-        assert email.accountID is not None, (
-            'Failed to link EmailAddress to Account')
+        email = getUtility(IEmailAddressSet).new(email, person)
+
         return person, email
 
     def createPersonWithoutEmail(
@@ -3299,55 +3280,14 @@
     def ensurePerson(self, email, displayname, rationale, comment=None,
                      registrant=None):
         """See `IPersonSet`."""
-        # Start by checking if there is an `EmailAddress` for the given
-        # text address.  There are many cases where an email address can be
-        # created without an associated `Person`. For instance, we created
-        # an account linked to the address through an external system such
-        # SSO or ShipIt.
-        email_address = getUtility(IEmailAddressSet).getByEmail(email)
+        person = getUtility(IPersonSet).getByEmail(email)
 
-        # There is no `EmailAddress` for this text address, so we need to
-        # create both the `Person` and `EmailAddress` here and we are done.
-        if email_address is None:
+        if person is None:
             person, email_address = self.createPersonAndEmail(
                 email, rationale, comment=comment, displayname=displayname,
                 registrant=registrant, hide_email_addresses=True)
-            return person
-
-        # There is an `EmailAddress` for this text address, but no
-        # associated `Person`.
-        if email_address.person is None:
-            assert email_address.accountID is not None, (
-                '%s is not associated to a person or account'
-                % email_address.email)
-            account = IMasterStore(Account).get(
-                Account, email_address.accountID)
-            account_person = self.getByAccount(account)
-            if account_person is None:
-                # There is no associated `Person` to the email `Account`.
-                # This is probably because the account was created externally
-                # to Launchpad. Create just the `Person`, associate it with
-                # the `EmailAddress` and return it.
-                name = generate_nick(email)
-                account_person = self._newPerson(
-                    name, displayname, hide_email_addresses=True,
-                    rationale=rationale, comment=comment,
-                    registrant=registrant, account=email_address.account)
-            # There is (now) a `Person` linked to the `Account`, link the
-            # `EmailAddress` to this `Person` and return it.
-            master_email = IMasterStore(EmailAddress).get(
-                EmailAddress, email_address.id)
-            master_email.personID = account_person.id
-            # Populate the previously empty 'preferredemail' cached
-            # property, so the Person record is up-to-date.
-            if master_email.status == EmailAddressStatus.PREFERRED:
-                cache = get_property_cache(account_person)
-                cache.preferredemail = master_email
-            return account_person
-
-        # Easy, return the `Person` associated with the existing
-        # `EmailAddress`.
-        return IMasterStore(Person).get(Person, email_address.personID)
+
+        return person
 
     def getByName(self, name, ignore_merged=True):
         """See `IPersonSet`."""

=== modified file 'lib/lp/registry/tests/test_mailinglistapi.py'
--- lib/lp/registry/tests/test_mailinglistapi.py	2012-01-01 02:58:52 +0000
+++ lib/lp/registry/tests/test_mailinglistapi.py	2012-01-13 14:12:26 +0000
@@ -73,10 +73,6 @@
     def test_isRegisteredInLaunchpad_email_no_email_address(self):
         self.assertFalse(self.api.isRegisteredInLaunchpad('[e-mail]'))
 
-    def test_isRegisteredInLaunchpad_email_without_person(self):
-        self.factory.makeAccount('Me', email='[e-mail]')
-        self.assertFalse(self.api.isRegisteredInLaunchpad('[e-mail]'))
-
     def test_isRegisteredInLaunchpad_archive_address_is_false(self):
         # The Mailman archive address can never be owned by an Lp user
         # because such a user would have acces to all lists.

=== modified file 'lib/lp/registry/tests/test_personset.py'
--- lib/lp/registry/tests/test_personset.py	2012-01-06 15:14:48 +0000
+++ lib/lp/registry/tests/test_personset.py	2012-01-13 14:12:26 +0000
@@ -229,7 +229,6 @@
             email = from_person.preferredemail
             email.status = EmailAddressStatus.NEW
             email.person = to_person
-            email.account = to_person.account
         transaction.commit()
 
     def _do_merge(self, from_person, to_person, reviewer=None):
@@ -725,12 +724,10 @@
 
         # The old email address is still there and correctly linked.
         self.assertIs(self.email, found.preferredemail)
-        self.assertIs(self.email.account, self.account)
         self.assertIs(self.email.person, self.person)
 
         # The new email address is there too and correctly linked.
         new_email = self.store.find(EmailAddress, email=new_email).one()
-        self.assertIs(new_email.account, self.account)
         self.assertIs(new_email.person, self.person)
         self.assertEqual(EmailAddressStatus.NEW, new_email.status)
 
@@ -751,32 +748,9 @@
         # It is correctly linked to an account, emailaddress and
         # identifier.
         self.assertIs(found, found.preferredemail.person)
-        self.assertIs(found.account, found.preferredemail.account)
         self.assertEqual(
             new_identifier, found.account.openid_identifiers.any().identifier)
 
-    def testNoPerson(self):
-        # If the account is not linked to a Person, create one. ShipIt
-        # users fall into this category the first time they log into
-        # Launchpad.
-        self.email.person = None
-        self.person.account = None
-
-        found, updated = self.person_set.getOrCreateByOpenIDIdentifier(
-            self.identifier.identifier, self.email.email, 'New Name',
-            PersonCreationRationale.UNKNOWN, 'No Comment')
-        found = removeSecurityProxy(found)
-
-        # We have a new Person
-        self.assertIs(True, updated)
-        self.assertIsNot(self.person, found)
-
-        # It is correctly linked to an account, emailaddress and
-        # identifier.
-        self.assertIs(found, found.preferredemail.person)
-        self.assertIs(found.account, found.preferredemail.account)
-        self.assertIn(self.identifier, list(found.account.openid_identifiers))
-
     def testNoAccount(self):
         # EmailAddress is linked to a Person, but there is no Account.
         # Convert this stub into something valid.
@@ -795,7 +769,6 @@
         self.assertEqual(
             new_identifier, found.account.openid_identifiers.any().identifier)
         self.assertIs(self.email.person, found)
-        self.assertIs(self.email.account, found.account)
         self.assertEqual(EmailAddressStatus.PREFERRED, self.email.status)
 
     def testMovedEmailAddress(self):
@@ -916,41 +889,6 @@
             self.email_address, self.displayname, self.rationale)
         self.assertTrue(ensured_person.hide_email_addresses)
 
-    def test_ensurePerson_for_existing_account(self):
-        # IPerson.ensurePerson creates missing Person for existing
-        # Accounts.
-        test_account = self.factory.makeAccount(
-            self.displayname, email=self.email_address)
-        self.assertIs(None, test_account.preferredemail.person)
-
-        ensured_person = self.person_set.ensurePerson(
-            self.email_address, self.displayname, self.rationale)
-        self.assertEquals(test_account.id, ensured_person.account.id)
-        self.assertEquals(
-            test_account.preferredemail, ensured_person.preferredemail)
-        self.assertEquals(ensured_person, test_account.preferredemail.person)
-        self.assertTrue(ensured_person.hide_email_addresses)
-
-    def test_ensurePerson_for_existing_account_with_person(self):
-        # IPerson.ensurePerson return existing Person for existing
-        # Accounts and additionally bounds the account email to the
-        # Person in question.
-
-        # Create a testing `Account` and a testing `Person` directly,
-        # linked.
-        testing_account = self.factory.makeAccount(
-            self.displayname, email=self.email_address)
-        testing_person = removeSecurityProxy(
-            testing_account).createPerson(self.rationale)
-        self.assertEqual(
-            testing_person, testing_account.preferredemail.person)
-
-        # Since there's an existing Person for the given email address,
-        # IPersonSet.ensurePerson() will just return it.
-        ensured_person = self.person_set.ensurePerson(
-            self.email_address, self.displayname, self.rationale)
-        self.assertEqual(testing_person, ensured_person)
-
 
 class TestPersonSetGetOrCreateByOpenIDIdentifier(TestCaseWithFactory):
 
@@ -977,25 +915,6 @@
         self.assertEqual(person, result)
         self.assertFalse(db_updated)
 
-    def test_existing_account_no_person(self):
-        # A person is created with the correct rationale.
-        account = self.factory.makeAccount('purchaser')
-        openid_ident = removeSecurityProxy(
-            account).openid_identifiers.any().identifier
-
-        person, db_updated = self.callGetOrCreate(openid_ident)
-
-        self.assertEqual(account, person.account)
-        # The person is created with the correct rationale and creation
-        # comment.
-        self.assertEqual(
-            "when purchasing an application via Software Center.",
-            person.creation_comment)
-        self.assertEqual(
-            PersonCreationRationale.SOFTWARE_CENTER_PURCHASE,
-            person.creation_rationale)
-        self.assertTrue(db_updated)
-
     def test_existing_deactivated_account(self):
         # An existing deactivated account will be reactivated.
         person = self.factory.makePerson(

=== modified file 'lib/lp/registry/xmlrpc/mailinglist.py'
--- lib/lp/registry/xmlrpc/mailinglist.py	2012-01-01 02:58:52 +0000
+++ lib/lp/registry/xmlrpc/mailinglist.py	2012-01-13 14:12:26 +0000
@@ -225,7 +225,6 @@
             return False
         email_address = getUtility(IEmailAddressSet).getByEmail(address)
         return (email_address is not None and
-                email_address.personID is not None and
                 not email_address.person.is_team and
                 email_address.status in (EmailAddressStatus.VALIDATED,
                                          EmailAddressStatus.PREFERRED))

=== modified file 'lib/lp/scripts/garbo.py'
--- lib/lp/scripts/garbo.py	2012-01-06 18:59:36 +0000
+++ lib/lp/scripts/garbo.py	2012-01-13 14:12:26 +0000
@@ -701,7 +701,7 @@
                     AND Person.id IN (%s)
                 """ % people_ids)
             self.store.execute("""
-                UPDATE EmailAddress SET person=NULL
+                DELETE FROM EmailAddress
                 WHERE person IN (%s)
                 """ % people_ids)
             # This cascade deletes any PersonSettings records.

=== modified file 'lib/lp/security.py'
--- lib/lp/security.py	2012-01-06 17:35:41 +0000
+++ lib/lp/security.py	2012-01-13 14:12:26 +0000
@@ -147,7 +147,6 @@
 from lp.registry.interfaces.role import (
     IHasDrivers,
     IHasOwner,
-    IPersonRoles,
     )
 from lp.registry.interfaces.sourcepackage import ISourcePackage
 from lp.registry.interfaces.teammembership import (
@@ -168,6 +167,7 @@
     IOAuthAccessToken,
     IOAuthRequestToken,
     )
+from lp.services.webapp.authorization import check_permission
 from lp.services.openid.interfaces.openididentifier import IOpenIdIdentifier
 from lp.services.webapp.interfaces import ILaunchpadRoot
 from lp.services.worlddata.interfaces.country import ICountry
@@ -237,6 +237,30 @@
         return True
 
 
+class LimitedViewDeferredToView(AuthorizationBase):
+    """The default ruleset for the launchpad.LimitedView permission.
+
+    Few objects define LimitedView permission because it is only needed
+    in cases where a user may know something about a private object. The
+    default behaviour is to check if the user has launchpad.View permission;
+    private objects must define their own launchpad.LimitedView checker to
+    trully check the permission.
+    """
+    permission = 'launchpad.LimitedView'
+    usedfor = Interface
+
+    def checkUnauthenticated(self):
+        # The forward adapter approach is not reliable because the object
+        # might not define a permission checker for launchpad.View.
+        # eg. IHasMilestones is implicitly public to anonymous users,
+        #     there is no nearest adapter to call checkUnauthenticated.
+        return check_permission('launchpad.View', self.obj)
+
+    def checkAuthenticated(self, user):
+        return self.forwardCheckAuthenticated(
+            user, self.obj, 'launchpad.View')
+
+
 class AdminByAdminsTeam(AuthorizationBase):
     permission = 'launchpad.Admin'
     usedfor = Interface
@@ -2632,7 +2656,7 @@
         # Anonymous users can never see email addresses.
         return False
 
-    def checkAccountAuthenticated(self, account):
+    def checkAuthenticated(self, user):
         """Can the user see the details of this email address?
 
         If the email address' owner doesn't want his email addresses to be
@@ -2640,17 +2664,13 @@
         admins can see them.
         """
         # Always allow users to see their own email addresses.
-        if self.obj.account == account:
+        if self.obj.person == user:
             return True
 
         if not (self.obj.person is None or
                 self.obj.person.hide_email_addresses):
             return True
 
-        user = IPersonRoles(IPerson(account, None), None)
-        if user is None:
-            return False
-
         return (self.obj.person is not None and user.inTeam(self.obj.person)
                 or user.in_commercial_admin
                 or user.in_registry_experts
@@ -2661,12 +2681,11 @@
     permission = 'launchpad.Edit'
     usedfor = IEmailAddress
 
-    def checkAccountAuthenticated(self, account):
+    def checkAuthenticated(self, user):
         # Always allow users to see their own email addresses.
-        if self.obj.account == account:
+        if self.obj.person == user:
             return True
-        return super(EditEmailAddress, self).checkAccountAuthenticated(
-            account)
+        return super(EditEmailAddress, self).checkAuthenticated(user)
 
 
 class ViewGPGKey(AnonymousAuthorization):

=== modified file 'lib/lp/services/identity/doc/account.txt'
--- lib/lp/services/identity/doc/account.txt	2011-12-24 17:49:30 +0000
+++ lib/lp/services/identity/doc/account.txt	2012-01-13 14:12:26 +0000
@@ -13,7 +13,7 @@
 implements the IAccountSet interface.
 
     >>> from zope.interface.verify import verifyObject
-    >>> from lp.registry.interfaces.person import IPerson
+    >>> from lp.registry.interfaces.person import IPersonSet
     >>> from lp.services.identity.interfaces.account import (
     ...     IAccount, IAccountSet)
 
@@ -21,37 +21,8 @@
     >>> verifyObject(IAccountSet, account_set)
     True
 
-
-Looking up accounts by email address
-------------------------------------
-
-Accounts are generally looked up by email address.
-
-    >>> login('[e-mail]')
-    >>> account = account_set.getByEmail('[e-mail]')
-    >>> IAccount.providedBy(account)
-    True
-
-If the account is not found, a LookupError is raised.
-
-    >>> account_set.getByEmail('invalid@whatever')
-    Traceback (most recent call last):
-    ...
-    LookupError:...
-
-Only admins or the person attached to an account can see or edit Account
-details. This is obviously wrong, as the account should have access
-rather than the (optional) attached person. In particular, it means
-Accounts without Person records cannot be managed by the Account owner.
-Fixing this involves more surgery to Launchpad's security systems.
-
-    >>> stub_account = account_set.getByEmail('[e-mail]')
-    >>> stub_account.date_created
-    Traceback (most recent call last):
-    ...
-    Unauthorized...
-
-    >>> del stub_account
+    >>> account = getUtility(IPersonSet).getByEmail(
+    ...     '[e-mail]').account
 
 
 Looking up accounts by their database ID
@@ -102,49 +73,16 @@
     True
     >>> login('[e-mail]')
 
-An account has a displayname, and a preferred email address.
+An account has a displayname.
 
     >>> print account.displayname
     No Privileges Person
-    >>> print account.preferredemail.email
-    [e-mail]
 
 Account objects have a useful string representation.
 
     >>> account
     <Account 'No Privileges Person' (Active account)>
 
-The account can have additional validated and guessed email
-addresses.  This will be empty if the user has only a single validated
-email address.
-
-    >>> [email.email for email in account.validated_emails]
-    []
-    >>> [email.email for email in account.guessed_emails]
-    []
-
-If we add a new guessed email address, it will be included in the
-guessed list.
-
-    >>> from lp.services.identity.interfaces.emailaddress import (
-    ...     EmailAddressStatus,
-    ...     IEmailAddressSet,
-    ...     )
-    >>> email = getUtility(IEmailAddressSet).new(
-    ...     "[e-mail]", account=account,
-    ...     status=EmailAddressStatus.NEW)
-    >>> [email.email for email in account.guessed_emails]
-    [u'[e-mail]']
-
-If we add a validated email address, it will show up in the validated
-list.
-
-    >>> email = getUtility(IEmailAddressSet).new(
-    ...     "[e-mail]", account=account,
-    ...     status=EmailAddressStatus.VALIDATED)
-    >>> [email.email for email in account.validated_emails]
-    [u'[e-mail]']
-
 It also has an encrypted password.
 
     >>> print account.password
@@ -226,8 +164,6 @@
     Passwordless
     >>> print passwordless_account.password
     None
-    >>> print passwordless_account.preferredemail
-    None
 
 The new() method accepts the optional parameters of password and
 password_is_encrypted. If password_is_encrypted is False, the default,
@@ -249,95 +185,3 @@
     >>> Store.of(clear_account).flush()
     >>> print clear_account.password
     clear_password
-
-
-Valid Accounts
---------------
-
-Like person objects, an account is considered valid if it is in the
-active state and has a preferred email address.  So a newly created
-account with no email address is not valid.
-
-    >>> account = account_set.new(
-    ...     AccountCreationRationale.USER_CREATED,
-    ...     "Valid Account Test")
-    >>> account.status = AccountStatus.ACTIVE
-    >>> account.is_valid
-    False
-
-Let's add a new email address to the account.
-
-    >>> email = getUtility(IEmailAddressSet).new(
-    ...     "[e-mail]", account=account)
-    >>> account.is_valid
-    False
-
-The account is still not valid because it has no preferred email.
-Setting the email to preferred fixes this.
-
-    >>> from lp.services.identity.interfaces.emailaddress import EmailAddressStatus
-    >>> email.status = EmailAddressStatus.PREFERRED
-    >>> account.is_valid
-    True
-
-If the account is deactivated, it won't be considered valid any more:
-
-    >>> account.status = AccountStatus.DEACTIVATED
-    >>> account.is_valid
-    False
-
-
-Creating an IPerson for an Account
-----------------------------------
-
-Newly created accounts without an associated Person can be 'promoted' to full
-Launchpad accounts with an attached Person.
-
-    # We need to change database policy here again, as the SSO Server cannot
-    # modify tables in the lpmain replication set.
-    >>> from lp.services.webapp.dbpolicy import MasterDatabasePolicy
-    >>> from lp.services.webapp.interfaces import IStoreSelector
-    >>> getUtility(IStoreSelector).push(MasterDatabasePolicy())
-
-    >>> from lp.registry.interfaces.person import PersonCreationRationale
-    >>> fresh_account, email = account_set.createAccountAndEmail(
-    ...     '[e-mail]',
-    ...     AccountCreationRationale.OWNER_CREATED_UBUNTU_SHOP,
-    ...     'Display name', 'password')
-    >>> IPerson(fresh_account)
-    Traceback (most recent call last):
-      ...
-    TypeError: ('Could not adapt', ...
-
-    >>> person = fresh_account.createPerson(
-    ...     PersonCreationRationale.OWNER_CREATED_LAUNCHPAD)
-    >>> transaction.commit()
-    >>> person.account == fresh_account
-    True
-    >>> IPerson(fresh_account) == person
-    True
-    >>> person.preferredemail == fresh_account.preferredemail
-    True
-    >>> person.creation_rationale
-    <DBItem PersonCreationRationale.OWNER_CREATED_LAUNCHPAD...
-
-However, if the account has an associated person or has no preferred email
-address, a new Person cannot be created.
-
-    >>> person = fresh_account.createPerson(
-    ...     PersonCreationRationale.OWNER_CREATED_LAUNCHPAD)
-    Traceback (most recent call last):
-    ...
-    AssertionError: Can't create a Person for an account which already has
-    one.
-
-    >>> print clear_account.preferredemail
-    None
-    >>> person = clear_account.createPerson(
-    ...     PersonCreationRationale.OWNER_CREATED_LAUNCHPAD)
-    Traceback (most recent call last):
-    ...
-    AssertionError: Can't create a Person for an account which has no email.
-
-    >>> db_policy = getUtility(IStoreSelector).pop()
-

=== modified file 'lib/lp/services/identity/interfaces/account.py'
--- lib/lp/services/identity/interfaces/account.py	2011-12-24 16:54:44 +0000
+++ lib/lp/services/identity/interfaces/account.py	2012-01-13 14:12:26 +0000
@@ -23,21 +23,15 @@
     DBEnumeratedType,
     DBItem,
     )
-from lazr.restful.fields import (
-    CollectionField,
-    Reference,
-    )
 from zope.interface import (
     Attribute,
     Interface,
     )
 from zope.schema import (
-    Bool,
     Choice,
     Datetime,
     Int,
     Text,
-    TextLine,
     )
 
 from lp import _
@@ -223,58 +217,6 @@
         title=_("The status of this account"), required=True,
         readonly=False, vocabulary=AccountStatus)
 
-    is_valid = Bool(
-        title=_("True if this account is active and has a valid email."),
-        required=True, readonly=True)
-
-    # We should use schema=IEmailAddress here, but we can't because that would
-    # cause circular dependencies.
-    preferredemail = Reference(
-        title=_("Preferred email address"),
-        description=_("The preferred email address for this person. "
-                      "The one we'll use to communicate with them."),
-        readonly=True, required=False, schema=Interface)
-
-    validated_emails = CollectionField(
-        title=_("Confirmed e-mails of this account."),
-        description=_(
-            "Confirmed e-mails are the ones in the VALIDATED state.  The "
-            "user has confirmed that they are active and that they control "
-            "them."),
-        readonly=True, required=False,
-        value_type=Reference(schema=Interface))
-
-    guessed_emails = CollectionField(
-        title=_("Guessed e-mails of this account."),
-        description=_(
-            "Guessed e-mails are the ones in the NEW state.  We believe "
-            "that the user owns the address, but they have not confirmed "
-            "the fact."),
-        readonly=True, required=False,
-        value_type=Reference(schema=Interface))
-
-    def setPreferredEmail(email):
-        """Set the given email address as this account's preferred one.
-
-        If ``email`` is None, the preferred email address is unset, which
-        will make the account invalid.
-        """
-
-    def validateAndEnsurePreferredEmail(email):
-        """Ensure this account has a preferred email.
-
-        If this account doesn't have a preferred email, <email> will be set as
-        this account's preferred one. Otherwise it'll be set as VALIDATED and
-        this account will keep their old preferred email.
-
-        This method is meant to be the only one to change the status of an
-        email address, but as we all know the real world is far from ideal
-        and we have to deal with this in one more place, which is the case
-        when people explicitly want to change their preferred email address.
-        On that case, though, all we have to do is use
-        account.setPreferredEmail().
-        """
-
 
 class IAccountPrivate(Interface):
     """Private information on an `IAccount`."""
@@ -290,16 +232,6 @@
     password = PasswordField(
         title=_("Password."), readonly=False, required=True)
 
-    def createPerson(rationale, name=None, comment=None):
-        """Create and return a new `IPerson` associated with this account.
-
-        :param rationale: A member of `AccountCreationRationale`.
-        :param name: Specify a name for the `IPerson` instead of
-            using an automatically generated one.
-        :param comment: Populate `IPerson.creation_comment`. See
-            `IPerson`.
-        """
-
 
 class IAccountSpecialRestricted(Interface):
     """Attributes of `IAccount` protected with launchpad.Special."""
@@ -312,12 +244,7 @@
         title=_("Why are you deactivating your account?"),
         required=False, readonly=False)
 
-    # XXX sinzui 2008-07-14 bug=248518:
-    # This method would assert the password is not None, but
-    # setPreferredEmail() passes the Person's current password, which may
-    # be None.  Once that callsite is fixed, we will be able to check that the
-    # password is not None here and get rid of the reactivate() method below.
-    def activate(comment, password, preferred_email):
+    def reactivate(comment, password):
         """Activate this account.
 
         Set the account status to ACTIVE, the account's password to the given
@@ -325,15 +252,6 @@
 
         :param comment: An explanation of why the account status changed.
         :param password: The user's password.
-        :param preferred_email: The `EmailAddress` to set as the account's
-            preferred email address. It cannot be None.
-        """
-
-    def reactivate(comment, password, preferred_email):
-        """Reactivate this account.
-
-        Just like `IAccountSpecialRestricted`.activate() above, but here the
-        password can't be None or the empty string.
         """
 
 
@@ -364,24 +282,6 @@
         :raises LookupError: If the account is not found.
         """
 
-    def createAccountAndEmail(email, rationale, displayname, password,
-                              password_is_encrypted=False):
-        """Create and return both a new `IAccount` and `IEmailAddress`.
-
-        The account will be in the ACTIVE state, with the email address set as
-        its preferred email address.
-        """
-
-    def getByEmail(email):
-        """Return the `IAccount` linked to the given email address.
-
-        :param email: A string, not an `IEmailAddress` provider.
-
-        :return: An `IAccount`.
-
-        :raises LookupError: If the account is not found.
-        """
-
     def getByOpenIDIdentifier(openid_identity):
         """Return the `IAccount` with the given OpenID identifier.
 
@@ -390,4 +290,3 @@
          :return: An `IAccount`
          :raises LookupError: If the account is not found.
          """
-

=== modified file 'lib/lp/services/identity/interfaces/emailaddress.py'
--- lib/lp/services/identity/interfaces/emailaddress.py	2012-01-05 00:15:32 +0000
+++ lib/lp/services/identity/interfaces/emailaddress.py	2012-01-13 14:12:26 +0000
@@ -32,7 +32,6 @@
 
 from lp import _
 from lp.registry.interfaces.role import IHasOwner
-from lp.services.identity.interfaces.account import IAccount
 
 
 class InvalidEmailAddress(Exception):
@@ -99,8 +98,6 @@
     status = Choice(
         title=_('Email Address Status'), required=True, readonly=False,
         vocabulary=EmailAddressStatus)
-    account = Object(title=_('Account'), schema=IAccount, required=False)
-    accountID = Int(title=_('AccountID'), required=False, readonly=True)
     person = exported(
         Reference(title=_('Person'), required=False, readonly=False,
                   schema=Interface))
@@ -131,12 +128,10 @@
 class IEmailAddressSet(Interface):
     """The set of EmailAddresses."""
 
-    def new(email, person=None, status=EmailAddressStatus.NEW, account=None):
+    def new(email, person=None, status=EmailAddressStatus.NEW):
         """Create a new EmailAddress with the given email.
 
-        The newly created EmailAddress will point to the person
-        and/or account. If account is omitted and the person has a linked
-        account, that account will be used.
+        The newly created EmailAddress will point to the person.
 
         The given status must be an item of EmailAddressStatus.
 

=== modified file 'lib/lp/services/identity/model/account.py'
--- lib/lp/services/identity/model/account.py	2011-12-30 06:14:56 +0000
+++ lib/lp/services/identity/model/account.py	2012-01-13 14:12:26 +0000
@@ -15,16 +15,13 @@
     StringCol,
     )
 from storm.locals import ReferenceSet
-from storm.store import Store
 from zope.component import getUtility
 from zope.interface import implements
-from zope.security.proxy import removeSecurityProxy
 
 from lp.services.database.constants import UTC_NOW
 from lp.services.database.datetimecol import UtcDateTimeCol
 from lp.services.database.enumcol import EnumCol
 from lp.services.database.lpstorm import (
-    IMasterObject,
     IMasterStore,
     IStore,
     )
@@ -35,12 +32,6 @@
     IAccount,
     IAccountSet,
     )
-from lp.services.identity.interfaces.emailaddress import (
-    EmailAddressStatus,
-    IEmailAddress,
-    IEmailAddressSet,
-    )
-from lp.services.identity.model.emailaddress import EmailAddress
 from lp.services.openid.model.openididentifier import OpenIdIdentifier
 from lp.services.webapp.interfaces import IPasswordEncryptor
 
@@ -70,100 +61,11 @@
         return "<%s '%s' (%s)>" % (
             self.__class__.__name__, displayname, self.status)
 
-    def _getEmails(self, status):
-        """Get related `EmailAddress` objects with the given status."""
-        result = IStore(EmailAddress).find(
-            EmailAddress, accountID=self.id, status=status)
-        result.order_by(EmailAddress.email.lower())
-        return result
-
-    @property
-    def preferredemail(self):
-        """See `IAccount`."""
-        return self._getEmails(EmailAddressStatus.PREFERRED).one()
-
-    @property
-    def validated_emails(self):
-        """See `IAccount`."""
-        return self._getEmails(EmailAddressStatus.VALIDATED)
-
-    @property
-    def guessed_emails(self):
-        """See `IAccount`."""
-        return self._getEmails(EmailAddressStatus.NEW)
-
-    def setPreferredEmail(self, email):
-        """See `IAccount`."""
-        if email is None:
-            # Mark preferred email address as validated, if it exists.
-            # XXX 2009-03-30 jamesh bug=349482: we should be able to
-            # use ResultSet.set() here :(
-            for address in self._getEmails(EmailAddressStatus.PREFERRED):
-                address.status = EmailAddressStatus.VALIDATED
-            return
-
-        if not IEmailAddress.providedBy(email):
-            raise TypeError("Any person's email address must provide the "
-                            "IEmailAddress Interface. %r doesn't." % email)
-
-        email = IMasterObject(removeSecurityProxy(email))
-        assert email.accountID == self.id
-
-        # If we have the preferred email address here, we're done.
-        if email.status == EmailAddressStatus.PREFERRED:
-            return
-
-        existing_preferred_email = self.preferredemail
-        if existing_preferred_email is not None:
-            assert Store.of(email) is Store.of(existing_preferred_email), (
-                "Store of %r is not the same as store of %r" %
-                (email, existing_preferred_email))
-            existing_preferred_email.status = EmailAddressStatus.VALIDATED
-            # Make sure the old preferred email gets flushed before
-            # setting the new preferred email.
-            Store.of(email).add_flush_order(existing_preferred_email, email)
-
-        email.status = EmailAddressStatus.PREFERRED
-
-    def validateAndEnsurePreferredEmail(self, email):
-        """See `IAccount`."""
-        if not IEmailAddress.providedBy(email):
-            raise TypeError(
-                "Any person's email address must provide the IEmailAddress "
-                "interface. %s doesn't." % email)
-
-        assert email.accountID == self.id, 'Wrong account! %r, %r' % (
-            email.accountID, self.id)
-
-        # This email is already validated and is this person's preferred
-        # email, so we have nothing to do.
-        if email.status == EmailAddressStatus.PREFERRED:
-            return
-
-        email = IMasterObject(email)
-
-        if self.preferredemail is None:
-            # This branch will be executed only in the first time a person
-            # uses Launchpad. Either when creating a new account or when
-            # resetting the password of an automatically created one.
-            self.setPreferredEmail(email)
-        else:
-            email.status = EmailAddressStatus.VALIDATED
-
-    def activate(self, comment, password, preferred_email):
+    def reactivate(self, comment, password):
         """See `IAccountSpecialRestricted`."""
-        if preferred_email is None:
-            raise AssertionError(
-                "Account %s cannot be activated without a "
-                "preferred email address." % self.id)
         self.status = AccountStatus.ACTIVE
         self.status_comment = comment
         self.password = password
-        self.validateAndEnsurePreferredEmail(preferred_email)
-
-    def reactivate(self, comment, password, preferred_email):
-        """See `IAccountSpecialRestricted`."""
-        self.activate(comment, password, preferred_email)
 
     # The password is actually stored in a separate table for security
     # reasons, so use a property to hide this implementation detail.
@@ -201,39 +103,6 @@
 
     password = property(_get_password, _set_password)
 
-    @property
-    def is_valid(self):
-        """See `IAccount`."""
-        if self.status != AccountStatus.ACTIVE:
-            return False
-        return self.preferredemail is not None
-
-    def createPerson(self, rationale, name=None, comment=None):
-        """See `IAccount`."""
-        # Need a local import because of circular dependencies.
-        from lp.registry.model.person import (
-            generate_nick, Person, PersonSet)
-        assert self.preferredemail is not None, (
-            "Can't create a Person for an account which has no email.")
-        person = IMasterStore(Person).find(Person, accountID=self.id).one()
-        assert person is None, (
-            "Can't create a Person for an account which already has one.")
-        if name is None:
-            name = generate_nick(self.preferredemail.email)
-        person = PersonSet()._newPerson(
-            name, self.displayname, hide_email_addresses=True,
-            rationale=rationale, account=self, comment=comment)
-
-        # Update all associated email addresses to point at the new person.
-        result = IMasterStore(EmailAddress).find(
-            EmailAddress, accountID=self.id)
-        # XXX 2009-03-30 jamesh bug=349482: we should be able to
-        # use ResultSet.set() here :(
-        for email in result:
-            email.personID = person.id
-
-        return person
-
 
 class AccountSet:
     """See `IAccountSet`."""
@@ -269,39 +138,6 @@
             raise LookupError(id)
         return account
 
-    def createAccountAndEmail(self, email, rationale, displayname, password,
-                              password_is_encrypted=False,
-                              openid_identifier=None):
-        """See `IAccountSet`."""
-        # Convert the PersonCreationRationale to an AccountCreationRationale.
-        account_rationale = getattr(AccountCreationRationale, rationale.name)
-        account = self.new(
-            account_rationale, displayname, password=password,
-            password_is_encrypted=password_is_encrypted,
-            openid_identifier=openid_identifier)
-        account.status = AccountStatus.ACTIVE
-        email = getUtility(IEmailAddressSet).new(
-            email, status=EmailAddressStatus.PREFERRED, account=account)
-        return account, email
-
-    def getByEmail(self, email):
-        """See `IAccountSet`."""
-        store = IStore(Account)
-        try:
-            email = email.decode('US-ASCII')
-        except (UnicodeDecodeError, UnicodeEncodeError):
-            # Non-ascii email addresses are not legal, so assume there are no
-            # matching addresses in Launchpad.
-            raise LookupError(repr(email))
-        account = store.find(
-            Account,
-            EmailAddress.account == Account.id,
-            EmailAddress.email.lower()
-                == email.strip().lower()).one()
-        if account is None:
-            raise LookupError(email)
-        return account
-
     def getByOpenIDIdentifier(self, openid_identifier):
         """See `IAccountSet`."""
         store = IStore(Account)

=== modified file 'lib/lp/services/identity/model/emailaddress.py'
--- lib/lp/services/identity/model/emailaddress.py	2012-01-05 00:15:32 +0000
+++ lib/lp/services/identity/model/emailaddress.py	2012-01-13 14:12:26 +0000
@@ -56,9 +56,6 @@
             dbName='email', notNull=True, unique=True, alternateID=True)
     status = EnumCol(dbName='status', schema=EmailAddressStatus, notNull=True)
     person = ForeignKey(dbName='person', foreignKey='Person', notNull=False)
-    account = ForeignKey(
-            dbName='account', foreignKey='Account', notNull=False,
-            default=None)
 
     def __repr__(self):
         return '<EmailAddress at 0x%x <%s> [%s]>' % (
@@ -116,8 +113,7 @@
         return EmailAddress.selectOne(
             "lower(email) = %s" % quote(email.strip().lower()))
 
-    def new(self, email, person=None, status=EmailAddressStatus.NEW,
-            account=None):
+    def new(self, email, person=None, status=EmailAddressStatus.NEW):
         """See IEmailAddressSet."""
         email = email.strip()
 
@@ -129,26 +125,11 @@
             raise EmailAddressAlreadyTaken(
                 "The email address '%s' is already registered." % email)
         assert status in EmailAddressStatus.items
-        if person is None:
-            personID = None
-        else:
-            if account is None:
-                account = person.account
-            personID = person.id
-            accountID = account and account.id
-            assert person.accountID == accountID, (
-                "Email address '%s' must be linked to same account as "
-                "person '%s'.  Expected %r (%s), got %r (%s)" % (
-                    email, person.name, person.account, person.accountID,
-                    account, accountID))
-        # We use personID instead of just person, as in some cases the
-        # Person record will not yet be replicated from the main
-        # Store to the auth master Store.
+        assert person
         return EmailAddress(
             email=email,
             status=status,
-            personID=personID,
-            account=account)
+            person=person)
 
 
 class UndeletableEmailAddress(Exception):

=== modified file 'lib/lp/services/identity/tests/test_account.py'
--- lib/lp/services/identity/tests/test_account.py	2012-01-01 02:58:52 +0000
+++ lib/lp/services/identity/tests/test_account.py	2012-01-13 14:12:26 +0000
@@ -6,25 +6,7 @@
 __metaclass__ = type
 __all__ = []
 
-from testtools.testcase import ExpectedException
-import transaction
-from zope.component import getUtility
-
-from lp.registry.interfaces.person import (
-    IPerson,
-    PersonCreationRationale,
-    )
-from lp.services.identity.interfaces.account import (
-    AccountCreationRationale,
-    IAccountSet,
-    )
-from lp.services.identity.interfaces.emailaddress import EmailAddressStatus
-from lp.services.webapp.authorization import check_permission
-from lp.testing import (
-    ANONYMOUS,
-    login,
-    TestCaseWithFactory,
-    )
+from lp.testing import TestCaseWithFactory
 from lp.testing.layers import DatabaseFunctionalLayer
 
 
@@ -44,225 +26,3 @@
         distro = self.factory.makeAccount(u'\u0170-account')
         ignore, displayname, status_1, status_2 = repr(distro).rsplit(' ', 3)
         self.assertEqual("'\\u0170-account'", displayname)
-
-
-class TestPersonlessAccountPermissions(TestCaseWithFactory):
-    """In order for Person-less accounts to see their non-public details and
-    email addresses, we had to change the security adapters for IAccount and
-    IEmailAddress to accept the 'user' argument being either a Person or an
-    Account.
-
-    Here we login() with one of these person-less accounts and show that they
-    can see their details, including email addresses.
-    """
-    layer = DatabaseFunctionalLayer
-
-    def setUp(self):
-        TestCaseWithFactory.setUp(self, '[e-mail]')
-        self.email = '[e-mail]'
-        self.account = self.factory.makeAccount(
-            'Test account, without a person', email=self.email)
-
-    def test_can_view_their_emails(self):
-        login(self.email)
-        self.failUnless(
-            check_permission('launchpad.View', self.account.preferredemail))
-
-    def test_can_view_their_own_details(self):
-        login(self.email)
-        self.failUnless(check_permission('launchpad.View', self.account))
-
-    def test_can_change_their_own_details(self):
-        login(self.email)
-        self.failUnless(check_permission('launchpad.Edit', self.account))
-
-    def test_emails_of_personless_acounts_cannot_be_seen_by_others(self):
-        # Email addresses are visible to others only when the user has
-        # explicitly chosen to have them shown, and that state is stored in
-        # IPerson.hide_email_addresses, so for accounts that have no
-        # associated Person, we will hide the email addresses from others.
-        login('[e-mail]')
-        self.failIf(check_permission(
-            'launchpad.View', self.account.preferredemail))
-
-        # Anonymous users can't see them either.
-        login(ANONYMOUS)
-        self.failIf(check_permission(
-            'launchpad.View', self.account.preferredemail))
-
-
-class CreatePersonTests(TestCaseWithFactory):
-    """Tests for `IAccount.createPerson`."""
-
-    layer = DatabaseFunctionalLayer
-
-    def setUp(self):
-        super(CreatePersonTests, self).setUp(user='[e-mail]')
-
-    def test_createPerson(self):
-        account = self.factory.makeAccount("Test Account")
-        # Account has no person.
-        self.assertEqual(IPerson(account, None), None)
-        self.assertEqual(account.preferredemail.person, None)
-
-        person = account.createPerson(PersonCreationRationale.UNKNOWN)
-        transaction.commit()
-        self.assertNotEqual(person, None)
-        self.assertEqual(person.account, account)
-        self.assertEqual(IPerson(account), person)
-        self.assertEqual(account.preferredemail.person, person)
-
-        # Trying to create a person for an account with a person fails.
-        self.assertRaises(AssertionError, account.createPerson,
-                          PersonCreationRationale.UNKNOWN)
-
-    def test_createPerson_requires_email(self):
-        # It isn't possible to create a person for an account with no
-        # preferred email address.
-        account = getUtility(IAccountSet).new(
-            AccountCreationRationale.UNKNOWN, "Test Account")
-        self.assertEqual(account.preferredemail, None)
-        self.assertRaises(AssertionError, account.createPerson,
-                          PersonCreationRationale.UNKNOWN)
-
-    def test_createPerson_sets_EmailAddress_person(self):
-        # All email addresses for the account are associated with the
-        # new person
-        account = self.factory.makeAccount("Test Account")
-        valid_email = self.factory.makeEmail(
-            "[e-mail]", None, account,
-            EmailAddressStatus.VALIDATED)
-        new_email = self.factory.makeEmail(
-            "[e-mail]", None, account,
-            EmailAddressStatus.NEW)
-        old_email = self.factory.makeEmail(
-            "[e-mail]", None, account,
-            EmailAddressStatus.OLD)
-
-        person = account.createPerson(PersonCreationRationale.UNKNOWN)
-        transaction.commit()
-        self.assertEqual(valid_email.person, person)
-        self.assertEqual(new_email.person, person)
-        self.assertEqual(old_email.person, person)
-
-    def test_createPerson_uses_name(self):
-        # A optional user name can be provided. Normally the name is
-        # generated from the email address.
-        account = self.factory.makeAccount("Test Account")
-        person = account.createPerson(
-            PersonCreationRationale.UNKNOWN, name="sam.bell")
-        self.failUnlessEqual("sam.bell", person.name)
-
-    def test_createPerson_uses_comment(self):
-        # An optional creation comment can be provided.
-        account = self.factory.makeAccount("Test Account")
-        person = account.createPerson(
-            PersonCreationRationale.UNKNOWN,
-            comment="when importing He-3 from the Moon")
-        self.failUnlessEqual(
-            "when importing He-3 from the Moon",
-            person.creation_comment)
-
-    def test_getByEmail_non_ascii_bytes(self):
-        """Lookups for non-ascii addresses should raise LookupError.
-
-        This tests the case where input is a bytestring.
-        """
-        with ExpectedException(LookupError, r"'SaraS\\[e-mail]'"):
-            getUtility(IAccountSet).getByEmail('SaraS\[e-mail]')
-
-    def test_getByEmail_non_ascii_unicode(self):
-        """Lookups for non-ascii addresses should raise LookupError.
-
-        This tests the case where input is a unicode string.
-        """
-        with ExpectedException(LookupError, r"u'SaraS\\xe1nchez@.*.net'"):
-            getUtility(IAccountSet).getByEmail(u'SaraS\[e-mail]')
-
-
-class EmailManagementTests(TestCaseWithFactory):
-    """Test email account management interfaces for `IAccount`."""
-
-    layer = DatabaseFunctionalLayer
-
-    def setUp(self):
-        super(EmailManagementTests, self).setUp(user='[e-mail]')
-
-    def test_setPreferredEmail(self):
-        # Setting a new preferred email marks the old one as VALIDATED.
-        account = self.factory.makeAccount("Test Account")
-        first_email = account.preferredemail
-        second_email = self.factory.makeEmail(
-            "[e-mail]", None, account,
-            EmailAddressStatus.VALIDATED)
-        transaction.commit()
-        account.setPreferredEmail(second_email)
-        transaction.commit()
-        self.assertEqual(account.preferredemail, second_email)
-        self.assertEqual(second_email.status, EmailAddressStatus.PREFERRED)
-        self.assertEqual(first_email.status, EmailAddressStatus.VALIDATED)
-
-    def test_setPreferredEmail_None(self):
-        # Setting the preferred email to None sets the old preferred
-        # email to VALIDATED.
-        account = self.factory.makeAccount("Test Account")
-        email = account.preferredemail
-        transaction.commit()
-        account.setPreferredEmail(None)
-        transaction.commit()
-        self.assertEqual(account.preferredemail, None)
-        self.assertEqual(email.status, EmailAddressStatus.VALIDATED)
-
-    def test_validateAndEnsurePreferredEmail(self):
-        # validateAndEnsurePreferredEmail() sets the email status to
-        # VALIDATED if there is no existing preferred email.
-        account = self.factory.makeAccount("Test Account")
-        self.assertNotEqual(account.preferredemail, None)
-        new_email = self.factory.makeEmail(
-            "[e-mail]", None, account,
-            EmailAddressStatus.NEW)
-        transaction.commit()
-        account.validateAndEnsurePreferredEmail(new_email)
-        transaction.commit()
-        self.assertEqual(new_email.status, EmailAddressStatus.VALIDATED)
-
-    def test_validateAndEsnurePreferredEmail_no_preferred(self):
-        # validateAndEnsurePreferredEmail() sets the new email as
-        # preferred if there was no preferred email.
-        account = self.factory.makeAccount("Test Account")
-        account.setPreferredEmail(None)
-        new_email = self.factory.makeEmail(
-            "[e-mail]", None, account,
-            EmailAddressStatus.NEW)
-        transaction.commit()
-        account.validateAndEnsurePreferredEmail(new_email)
-        transaction.commit()
-        self.assertEqual(new_email.status, EmailAddressStatus.PREFERRED)
-
-    def test_validated_emails(self):
-        account = self.factory.makeAccount("Test Account")
-        self.factory.makeEmail(
-            "[e-mail]", None, account,
-            EmailAddressStatus.NEW)
-        validated_email = self.factory.makeEmail(
-            "[e-mail]", None, account,
-            EmailAddressStatus.VALIDATED)
-        self.factory.makeEmail(
-            "[e-mail]", None, account,
-            EmailAddressStatus.OLD)
-        transaction.commit()
-        self.assertContentEqual(account.validated_emails, [validated_email])
-
-    def test_guessed_emails(self):
-        account = self.factory.makeAccount("Test Account")
-        new_email = self.factory.makeEmail(
-            "[e-mail]", None, account,
-            EmailAddressStatus.NEW)
-        self.factory.makeEmail(
-            "[e-mail]", None, account,
-            EmailAddressStatus.VALIDATED)
-        self.factory.makeEmail(
-            "[e-mail]", None, account,
-            EmailAddressStatus.OLD)
-        transaction.commit()
-        self.assertContentEqual(account.guessed_emails, [new_email])

=== modified file 'lib/lp/services/mail/incoming.py'
--- lib/lp/services/mail/incoming.py	2011-12-30 02:24:09 +0000
+++ lib/lp/services/mail/incoming.py	2012-01-13 14:12:26 +0000
@@ -225,13 +225,7 @@
         setupInteraction(authutil.unauthenticatedPrincipal())
         return None
 
-    # People with accounts but no related person will have a principal, but
-    # the person adaptation will fail.
     person = IPerson(principal, None)
-    if person is None:
-        setupInteraction(authutil.unauthenticatedPrincipal())
-        return None
-
     if person.account_status != AccountStatus.ACTIVE:
         raise InactiveAccount(
             "Mail from a user with an inactive account.")

=== modified file 'lib/lp/services/mail/tests/test_incoming.py'
--- lib/lp/services/mail/tests/test_incoming.py	2012-01-01 02:58:52 +0000
+++ lib/lp/services/mail/tests/test_incoming.py	2012-01-13 14:12:26 +0000
@@ -104,13 +104,6 @@
         mail = self.factory.makeSignedMessage(email_address=unknown)
         self.assertThat(authenticateEmail(mail), Is(None))
 
-    def test_accounts_without_person(self):
-        # An account without a person should be the same as an unknown email.
-        email = '[e-mail]'
-        self.factory.makeAccount(email=email)
-        mail = self.factory.makeSignedMessage(email_address=email)
-        self.assertThat(authenticateEmail(mail), Is(None))
-
 
 class TestExtractAddresses(TestCaseWithFactory):
 

=== modified file 'lib/lp/services/verification/browser/logintoken.py'
--- lib/lp/services/verification/browser/logintoken.py	2012-01-05 00:15:32 +0000
+++ lib/lp/services/verification/browser/logintoken.py	2012-01-13 14:12:26 +0000
@@ -441,13 +441,11 @@
         validated = (
             EmailAddressStatus.VALIDATED, EmailAddressStatus.PREFERRED)
         requester = self.context.requester
-        account = requester.account
 
         emailset = getUtility(IEmailAddressSet)
         email = emailset.getByEmail(self.context.email)
         if email is not None:
-            if email.personID is not None and (
-                requester is None or email.personID != requester.id):
+            if requester is None or email.personID != requester.id:
                 dupe = email.person
                 dname = cgi.escape(dupe.name)
                 # Yes, hardcoding an autogenerated field name is an evil
@@ -463,12 +461,6 @@
                     'case you should be able to <a href="${url}">merge them'
                     '</a> into a single one.',
                     mapping=dict(url=url))))
-            elif account is not None and email.accountID != account.id:
-                # Email address is owned by a personless account.  We
-                # can't offer to perform a merge here.
-                self.addError(
-                    'This email address is already registered for another '
-                    'account')
             elif email.status in validated:
                 self.addError(_(
                     "This email address is already registered and validated "
@@ -523,7 +515,7 @@
 
     def markEmailAsValid(self, email):
         """Mark the given email address as valid."""
-        self.context.requester.account.validateAndEnsurePreferredEmail(email)
+        self.context.requester.validateAndEnsurePreferredEmail(email)
 
 
 class ValidateTeamEmailView(ValidateEmailView):
@@ -595,7 +587,6 @@
         # that this new email does not have the PREFERRED status.
         email.status = EmailAddressStatus.NEW
         email.personID = requester.id
-        email.accountID = requester.accountID
         requester.validateAndEnsurePreferredEmail(email)
 
         # Need to flush all changes we made, so subsequent queries we make

=== modified file 'lib/lp/services/webapp/authentication.py'
--- lib/lp/services/webapp/authentication.py	2012-01-01 02:58:52 +0000
+++ lib/lp/services/webapp/authentication.py	2012-01-13 14:12:26 +0000
@@ -68,7 +68,7 @@
         if login is not None:
             login_src = getUtility(IPlacelessLoginSource)
             principal = login_src.getPrincipalByLogin(login)
-            if principal is not None and principal.account.is_valid:
+            if principal is not None and principal.person.is_valid_person:
                 password = credentials.getPassword()
                 if principal.validate(password):
                     # We send a LoggedInEvent here, when the
@@ -107,7 +107,7 @@
             # available in login source. This happens when account has
             # become invalid for some reason, such as being merged.
             return None
-        elif principal.account.is_valid:
+        elif principal.person.is_valid_person:
             login = authdata['login']
             assert login, 'login is %s!' % repr(login)
             notify(CookieAuthPrincipalIdentifiedEvent(
@@ -276,13 +276,11 @@
         validate the password against so it may then email a validation
         request to the user and inform them it has done so.
         """
-        try:
-            account = getUtility(IAccountSet).getByEmail(login)
-        except LookupError:
+        person = getUtility(IPersonSet).getByEmail(login)
+        if person is None or person.account is None:
             return None
-        else:
-            return self._principalForAccount(
-                account, access_level, scope, want_password)
+        return self._principalForAccount(
+            person.account, access_level, scope, want_password)
 
     def _principalForAccount(self, account, access_level, scope,
                              want_password=True):

=== modified file 'lib/lp/services/webapp/login.py'
--- lib/lp/services/webapp/login.py	2012-01-01 02:58:52 +0000
+++ lib/lp/services/webapp/login.py	2012-01-13 14:12:26 +0000
@@ -323,11 +323,11 @@
         finally:
             timeline_action.finish()
 
-    def login(self, account):
+    def login(self, person):
         loginsource = getUtility(IPlacelessLoginSource)
         # We don't have a logged in principal, so we must remove the security
         # proxy of the account's preferred email.
-        email = removeSecurityProxy(account.preferredemail).email
+        email = removeSecurityProxy(person.preferredemail).email
         logInPrincipal(
             self.request, loginsource.getPrincipalByLogin(email), email)
 
@@ -383,7 +383,7 @@
             return self.suspended_account_template()
 
         with MasterDatabasePolicy():
-            self.login(person.account)
+            self.login(person)
 
         if should_update_last_write:
             # This is a GET request but we changed the database, so update

=== modified file 'lib/lp/services/webapp/publication.py'
--- lib/lp/services/webapp/publication.py	2012-01-01 02:58:52 +0000
+++ lib/lp/services/webapp/publication.py	2012-01-13 14:12:26 +0000
@@ -341,9 +341,10 @@
         # automated tests.
         if request.get('PATH_INFO') not in [u'/+opstats', u'/+haproxy']:
             principal = auth_utility.authenticate(request)
-        if principal is None or principal.person is None:
-            # This is either an unauthenticated user or a user who
-            # authenticated on our OpenID server using a personless account.
+        if principal is not None:
+            assert principal.person is not None
+        else:
+            # This is an unauthenticated user.
             principal = auth_utility.unauthenticatedPrincipal()
             assert principal is not None, "Missing unauthenticated principal."
         return principal

=== modified file 'lib/lp/services/webapp/tests/test_authentication.py'
--- lib/lp/services/webapp/tests/test_authentication.py	2012-01-01 02:58:52 +0000
+++ lib/lp/services/webapp/tests/test_authentication.py	2012-01-13 14:12:26 +0000
@@ -9,17 +9,7 @@
 import unittest
 
 from contrib.oauth import OAuthRequest
-from zope.app.security.principalregistry import UnauthenticatedPrincipal
-
-from lp.services.config import config
-from lp.services.webapp.authentication import LaunchpadPrincipal
-from lp.services.webapp.login import logInPrincipal
-from lp.services.webapp.publication import LaunchpadBrowserPublication
-from lp.services.webapp.servers import LaunchpadTestRequest
-from lp.testing import (
-    login,
-    TestCaseWithFactory,
-    )
+from lp.testing import TestCaseWithFactory
 from lp.testing.layers import (
     DatabaseFunctionalLayer,
     LaunchpadFunctionalLayer,
@@ -31,32 +21,6 @@
     )
 
 
-class TestAuthenticationOfPersonlessAccounts(TestCaseWithFactory):
-    layer = DatabaseFunctionalLayer
-
-    def setUp(self):
-        TestCaseWithFactory.setUp(self)
-        self.email = '[e-mail]'
-        self.request = LaunchpadTestRequest()
-        self.account = self.factory.makeAccount(
-            'Personless account', email=self.email)
-        self.principal = LaunchpadPrincipal(
-            self.account.id, self.account.displayname,
-            self.account.displayname, self.account)
-        login(self.email)
-
-    def test_navigate_anonymously_on_launchpad_dot_net(self):
-        # A user with the credentials of a personless account will browse
-        # launchpad.net anonymously.
-        logInPrincipal(self.request, self.principal, self.email)
-        self.request.response.setCookie(
-            config.launchpad_session.cookie, 'xxx')
-
-        publication = LaunchpadBrowserPublication(None)
-        principal = publication.getPrincipal(self.request)
-        self.failUnless(isinstance(principal, UnauthenticatedPrincipal))
-
-
 class TestOAuthParsing(TestCaseWithFactory):
 
     layer = DatabaseFunctionalLayer

=== modified file 'lib/lp/services/webapp/tests/test_authutility.py'
--- lib/lp/services/webapp/tests/test_authutility.py	2012-01-01 02:58:52 +0000
+++ lib/lp/services/webapp/tests/test_authutility.py	2012-01-13 14:12:26 +0000
@@ -31,16 +31,16 @@
 
 class DummyPerson(object):
     implements(IPerson)
-    is_valid = True
+    is_valid_person = True
 
 
 class DummyAccount(object):
     implements(IAccount)
-    is_valid = True
     person = DummyPerson()
 
 
 Bruce = LaunchpadPrincipal(42, 'bruce', 'Bruce', DummyAccount(), 'bruce!')
+Bruce.person = Bruce.account.person
 
 
 class DummyPlacelessLoginSource(object):

=== modified file 'lib/lp/services/webapp/tests/test_login.py'
--- lib/lp/services/webapp/tests/test_login.py	2012-01-04 11:57:57 +0000
+++ lib/lp/services/webapp/tests/test_login.py	2012-01-13 14:12:26 +0000
@@ -292,25 +292,6 @@
         self.assertEquals(
             view.fake_consumer.requested_url, 'http://example.com?foo=bar')
 
-    def test_personless_account(self):
-        # When there is no Person record associated with the account, we
-        # create one.
-        account = self.factory.makeAccount('Test account')
-        self.assertIs(None, IPerson(account, None))
-        with SRegResponse_fromSuccessResponse_stubbed():
-            view, html = self._createViewWithResponse(account)
-        self.assertIsNot(None, IPerson(account, None))
-        self.assertTrue(view.login_called)
-        response = view.request.response
-        self.assertEquals(httplib.TEMPORARY_REDIRECT, response.getStatus())
-        self.assertEquals(view.request.form['starting_url'],
-                          response.getHeader('Location'))
-
-        # We also update the last_write flag in the session, to make sure
-        # further requests use the master DB and thus see the newly created
-        # stuff.
-        self.assertLastWriteIsSet(view.request)
-
     def test_unseen_identity(self):
         # When we get a positive assertion about an identity URL we've never
         # seen, we automatically register an account with that identity
@@ -329,11 +310,11 @@
         account = account_set.getByOpenIDIdentifier(identifier)
         self.assertIsNot(None, account)
         self.assertEquals(AccountStatus.ACTIVE, account.status)
+        person = IPerson(account, None)
+        self.assertIsNot(None, person)
+        self.assertEquals('Foo User', person.displayname)
         self.assertEquals('[e-mail]',
-                          removeSecurityProxy(account.preferredemail).email)
-        person = IPerson(account, None)
-        self.assertIsNot(None, person)
-        self.assertEquals('Foo User', person.displayname)
+                          removeSecurityProxy(person.preferredemail).email)
 
         # We also update the last_write flag in the session, to make sure
         # further requests use the master DB and thus see the newly created

=== modified file 'lib/lp/services/webapp/tests/test_login_account.py'
--- lib/lp/services/webapp/tests/test_login_account.py	2012-01-01 02:58:52 +0000
+++ lib/lp/services/webapp/tests/test_login_account.py	2012-01-13 14:12:26 +0000
@@ -17,7 +17,6 @@
 from lp.services.webapp.authentication import LaunchpadPrincipal
 from lp.services.webapp.interfaces import (
     CookieAuthLoggedInEvent,
-    ILaunchpadPrincipal,
     IPlacelessAuthUtility,
     )
 from lp.services.webapp.login import (
@@ -27,7 +26,6 @@
     )
 from lp.services.webapp.servers import LaunchpadTestRequest
 from lp.testing import (
-    ANONYMOUS,
     login,
     TestCaseWithFactory,
     )
@@ -172,34 +170,3 @@
         principal = getUtility(IPlacelessAuthUtility).authenticate(
             self.request)
         self.failUnless(principal is None)
-
-
-class TestLoggingInWithPersonlessAccount(TestCaseWithFactory):
-    layer = DatabaseFunctionalLayer
-
-    def setUp(self):
-        TestCaseWithFactory.setUp(self)
-        self.request = LaunchpadTestRequest()
-        login(ANONYMOUS)
-        account_set = getUtility(IAccountSet)
-        account, email = account_set.createAccountAndEmail(
-            '[e-mail]', AccountCreationRationale.UNKNOWN,
-            'Display name', 'password')
-        self.principal = LaunchpadPrincipal(
-            account.id, account.displayname, account.displayname, account)
-        login('[e-mail]')
-
-    def test_logInPrincipal(self):
-        # logInPrincipal() will log the given principal in and not worry about
-        # its lack of an associated Person.
-        logInPrincipal(self.request, self.principal, '[e-mail]')
-
-        # Ensure we are using cookie auth.
-        self.assertIsNotNone(
-            self.request.response.getCookie(config.launchpad_session.cookie)
-            )
-
-        placeless_auth_utility = getUtility(IPlacelessAuthUtility)
-        principal = placeless_auth_utility.authenticate(self.request)
-        self.failUnless(ILaunchpadPrincipal.providedBy(principal))
-        self.failUnless(principal.person is None)

=== modified file 'lib/lp/services/webservice/configuration.py'
--- lib/lp/services/webservice/configuration.py	2012-01-01 02:58:52 +0000
+++ lib/lp/services/webservice/configuration.py	2012-01-13 14:12:26 +0000
@@ -26,7 +26,7 @@
     active_versions = ["beta", "1.0", "devel"]
     last_version_with_mutator_named_operations = "beta"
     first_version_with_total_size_link = "devel"
-    view_permission = "launchpad.View"
+    view_permission = "launchpad.LimitedView"
     require_explicit_versions = True
     compensate_for_mod_compress_etag_modification = True
 

=== modified file 'lib/lp/testing/factory.py'
--- lib/lp/testing/factory.py	2012-01-04 23:49:46 +0000
+++ lib/lp/testing/factory.py	2012-01-13 14:12:26 +0000
@@ -561,7 +561,7 @@
             pocket)
         return ProxyFactory(location)
 
-    def makeAccount(self, displayname=None, email=None, password=None,
+    def makeAccount(self, displayname=None, password=None,
                     status=AccountStatus.ACTIVE,
                     rationale=AccountCreationRationale.UNKNOWN):
         """Create and return a new Account."""
@@ -570,13 +570,6 @@
         account = getUtility(IAccountSet).new(
             rationale, displayname, password=password)
         removeSecurityProxy(account).status = status
-        if email is None:
-            email = self.getUniqueEmailAddress()
-        email_status = EmailAddressStatus.PREFERRED
-        if status != AccountStatus.ACTIVE:
-            email_status = EmailAddressStatus.NEW
-        email = self.makeEmail(
-            email, person=None, account=account, email_status=email_status)
         self.makeOpenIdIdentifier(account)
         return account
 
@@ -731,10 +724,8 @@
             # setPreferredEmail no longer activates the account
             # automatically.
             account = IMasterStore(Account).get(Account, person.accountID)
-            account.activate(
-                "Activated by factory.makePersonByName",
-                password='foo',
-                preferred_email=email)
+            account.reactivate(
+                "Activated by factory.makePersonByName", password='foo')
             person.setPreferredEmail(email)
 
         if not use_default_autosubscribe_policy:
@@ -745,20 +736,16 @@
                     MailingListAutoSubscribePolicy.NEVER)
         account = IMasterStore(Account).get(Account, person.accountID)
         getUtility(IEmailAddressSet).new(
-            alternative_address, person, EmailAddressStatus.VALIDATED,
-            account)
+            alternative_address, person, EmailAddressStatus.VALIDATED)
         return person
 
-    def makeEmail(self, address, person, account=None, email_status=None):
+    def makeEmail(self, address, person, email_status=None):
         """Create a new email address for a person.
 
         :param address: The email address to create.
         :type address: string
         :param person: The person to assign the email address to.
         :type person: `IPerson`
-        :param account: The account to assign the email address to.  Will use
-            the given person's account if None is provided.
-        :type person: `IAccount`
         :param email_status: The default status of the email address,
             if given.  If not given, `EmailAddressStatus.VALIDATED`
             will be used.
@@ -769,7 +756,7 @@
         if email_status is None:
             email_status = EmailAddressStatus.VALIDATED
         return getUtility(IEmailAddressSet).new(
-            address, person, email_status, account)
+            address, person, email_status)
 
     def makeTeam(self, owner=None, displayname=None, email=None, name=None,
                  description=None, icon=None, logo=None,

=== modified file 'lib/lp/testing/tests/test_login.py'
--- lib/lp/testing/tests/test_login.py	2012-01-01 02:58:52 +0000
+++ lib/lp/testing/tests/test_login.py	2012-01-13 14:12:26 +0000
@@ -104,13 +104,6 @@
         e = self.assertRaises(ValueError, login_person, team)
         self.assertEqual(str(e), "Got team, expected person: %r" % (team,))
 
-    def test_login_account(self):
-        # Calling login_person with an account logs you in with that account.
-        person = self.factory.makePerson()
-        account = person.account
-        login_person(account)
-        self.assertLoggedIn(person)
-
     def test_login_with_email(self):
         # login() logs a person in by email.
         email = '[e-mail]'

=== modified file 'lib/lp/testopenid/browser/server.py'
--- lib/lp/testopenid/browser/server.py	2012-01-01 02:58:52 +0000
+++ lib/lp/testopenid/browser/server.py	2012-01-13 14:12:26 +0000
@@ -230,9 +230,10 @@
         else:
             response = self.openid_request.answer(True)
 
+        person = IPerson(self.account)
         sreg_fields = dict(
-            nickname=IPerson(self.account).name,
-            email=self.account.preferredemail.email,
+            nickname=person.name,
+            email=person.preferredemail.email,
             fullname=self.account.displayname)
         sreg_request = SRegRequest.fromOpenIDRequest(self.openid_request)
         sreg_response = SRegResponse.extractResponse(

=== modified file 'lib/lp/translations/utilities/tests/test_file_importer.py'
--- lib/lp/translations/utilities/tests/test_file_importer.py	2011-12-30 01:48:17 +0000
+++ lib/lp/translations/utilities/tests/test_file_importer.py	2012-01-13 14:12:26 +0000
@@ -353,21 +353,6 @@
                 po_importer.potemplate.displayname),
             'Did not create the correct comment for %s' % test_email)
 
-    def test_getPersonByEmail_personless_account(self):
-        # An Account without a Person attached is a difficult case for
-        # _getPersonByEmail: it has to create the Person but re-use an
-        # existing Account and email address.
-        (pot_importer, po_importer) = self._createImporterForExportedEntries()
-        test_email = '[e-mail]'
-        account = self.factory.makeAccount('Send me Ubuntu', test_email)
-
-        person = po_importer._getPersonByEmail(test_email)
-
-        self.assertEqual(account, person.account)
-
-        # The same person will come up for the same address next time.
-        self.assertEqual(person, po_importer._getPersonByEmail(test_email))
-
     def test_getPersonByEmail_bad_address(self):
         # _getPersonByEmail returns None for malformed addresses.
         (pot_importer, po_importer) = self._createImporterForExportedEntries()