Merge lp:bzr-loom into lp:~launchpad-pqm/bzr-loom/trunk

[Aaron Bentley]

Update to tip for bzr 2.2 support.

Update Launchpad copy of bzr-loom to trunk tip for bzr 2.2 support.
(Otherwise, you get API breakage.)

[Paul Hummer (rockstar)]

review: Approve

=== added file '.testr.conf'
--- .testr.conf	1970-01-01 00:00:00 +0000
+++ .testr.conf	2010-08-05 18:57:44 +0000
@@ -0,0 +1,4 @@
+[DEFAULT]
+# not quite idea, because 'all tests' is too many, and 'just loom' is too few.
+test_command=bzr selftest --subunit $IDOPTION
+test_id_option=--load-list $IDFILE
 
=== modified file 'HOWTO'
--- HOWTO	2008-09-12 01:55:17 +0000
+++ HOWTO	2010-08-05 18:57:44 +0000
@@ -47,6 +47,11 @@
 
 This will convert your branch to a loom - at this point you will require the
 loom plugin to use bzr on it. It will also create a thread called 'upstream'.
+
+The bzr ``nick`` is used to index into the threads in the loom. The current
+thread is the bzr nick for the branch and is recorded in commits as such. You
+can use ``bzr nick newname`` to change the name of a thread.
+
 If you do 'bzr push' to a new branch now, it will make the remote branch be a
 loom as well. If you push to an existing normal bzr branch, then the current
 thread of your loom is what will be pushed. You can use this to publish
@@ -177,7 +182,7 @@
 When you are doing an update to upstream and they have merged a patch, your
 thread will suddenly lose all its changes. Lets say in the example above that
 upstream have merged the autoconf update. When you are updating that thread,
-add in a call to ``diff -r thread:`` and you will see no changes.
+add in a call to ``diff -r below:`` and you will see no changes.
 
     % bzr up-thread
     All changes applied successfully.
@@ -201,3 +206,16 @@
       debian
     =>fix 64-bit compilation
       upstream
+
+
+Showing a single patch
+----------------------
+
+You can show a single patch without knowing the names of other threads by using
+the below: and thread: revision specifiers::
+
+    % bzr show-loom
+      debian
+    =>update-configure
+      upstream
+    % bzr diff -r below:update-configure..thread:update-configure
 
=== modified file 'NEWS'
--- NEWS	2008-11-19 07:18:17 +0000
+++ NEWS	2010-08-05 18:57:44 +0000
@@ -5,7 +5,95 @@
 .. contents::
 
 IN DEVELOPMENT
---------------
+==============
+
+NOTES WHEN UPGRADING
+--------------------
+
+* bzr-loom requires bzr 2.2.0 (or very recent 2.2b releases) due to an API
+  change in bzr needed to fix branching and pulling of looms. On older versions
+  of bzr bzr-loom will still work for most operations but will fail when making
+  new branches as part of a push or branch operation. (Robert Collins, #201613)
+
+CHANGES
+-------
+
+* --auto is now the default on up-thread. You can supply a thread name to stop
+  at a given thread, or --manual to go up a single thread. (Aaron Bentley)
+
+* ``bzr combine-thread`` now accepts a ``--force`` option.
+
+FEATURES
+--------
+
+* A new revision specifier ``below:`` has been added. (Robert Collins, #195282)
+
+IMPROVEMENTS
+------------
+
+* Loom now takes advantage of lazy loading of bzr objects (though not to a
+  complete degree), reducing the overhead of having it installed.
+  (Robert Collins)
+
+BUGFIXES
+--------
+
+* ``bzr combine-thread`` will no longer combine threads without ``--force``
+  when the thread being removed has work not merged into either the thread
+  above or below. (Robert Collins, #506235)
+
+* ``bzr loomify`` explicitly checks that branches being converted are not Looms
+  already. This should not have been needed, but apparently it was.
+  (Robert Collins, #600452)
+
+* ``bzr nick`` will now rename a thread rather than setting the current thread
+  pointer to an invalid value. (Robert Collins, #203203, #260947, #304608)
+
+* ``bzr nick`` will now rename the branch too. (Vincent Ladeuil, #606174)
+
+* ``switch`` now accepts the ``--directory`` option. (Vincent Ladeuil, #595563)
+
+* The ``thread:`` revision specifier will no longer throw an attribute error
+  when used on a normal branch. (Robert Collins, #231283)
+
+API BREAKS
+----------
+
+TESTING
+-------
+
+INTERNALS
+---------
+
+2.1
+===
+
+  NOTES WHEN UPGRADING:
+  
+  CHANGES:
+
+  FEATURES:
+
+  IMPROVEMENTS:
+
+  BUGFIXES:
+
+  * Stop using APIs deprecated for 2.1.0 (child progress bars for
+    merge and trace.info). (Vincent Ladeuil, #528472)
+
+  * Work with changes to bzr trunk - colocated branches and switch -r.
+
+  API BREAKS:
+
+  TESTING:
+
+  INTERNALS:
+
+  * .testr.conf added to help use with testr - still need to specify what tests
+    to run. (Robert Collins)
+
+2.0
+===
 
   NOTES WHEN UPGRADING:
   
@@ -21,14 +109,26 @@
     * ``bzr switch`` now accepts ``top:`` and ``bottom:`` to jump to the top
       and bottom thread respectively. (Jonathan Lange)
 
+    * ``bzr switch -b newthread`` now works. (Robert Collins, #433811)
+
     * ``bzr push`` now pushes the last-loom rather than creating an empty loom.
       (Robert Collins, #201613)
 
     * ``up`` and ``down`` are now aliases for ``up-thread`` and
       ``down-thread`` respectively.
 
+    * ``up-thread`` now notifies when a thread becomes empty. This is a step
+      towards removing it automatically/prompting to do so.
+      (James Westby, #195133)
+
   BUGFIXES:
 
+    * ``pull`` expects the keywork local. (Mark Lee, #379347)
+
+    * ``setup.py`` doesn't actually install. (Mark Lee, #379069)
+
+    * module has no attribute ``PushResult``. (Robert Collins)
+
   API BREAKS:
 
   TESTING:
@@ -37,7 +137,7 @@
 
 
 1.3
----
+===
 
   IMPROVEMENTS:
 
 
=== modified file 'README'
--- README	2008-09-12 01:55:17 +0000
+++ README	2010-08-05 18:57:44 +0000
@@ -77,9 +77,11 @@
 branch will pull into the current thread of a loom. This assymetry makes it easy
 to work with developers who are not using looms.
 
-Loom also adds a new revision specifier 'thread:'. You can use this to diff
-against threads in the current loom. For example: 'bzr diff -r thread:' will
-show you the difference between the current thread and the thread below it.
+Loom also adds new revision specifiers 'thread:' and 'below:'. You can use these
+to diff against threads in the current Loom. For instance, 'bzr diff -r
+thread:' will show you the different between the thread below yours, and your
+thread. See ``bzr help revisionspec`` for the detailed help on these two
+revision specifiers.
 
 
 Documentation
 
=== modified file 'TODO'
--- TODO	2008-01-20 07:34:29 +0000
+++ TODO	2010-08-05 18:57:44 +0000
@@ -95,7 +95,7 @@
   TODO either means changing 'diff's defaults, adding a flag to diff, or using
   a different revspec prefix; or something like that.)
 - export-patch to export the diff from this thread to the lower thread (using -ancestry logic) to a file named as the warp is named. (what about / ?)
-- during up-thread, if we could pull or if there is no diff, then the thread has been merged, offer to remove it.
+- during up-thread, if we could pull or if there is no diff, then the thread has been merged, offer to remove it. (Currently suggests to remove it).
 - loom to have the same 'tree root id' as its branches, to allow nested looms by reference. EEK!.
 - show-loom to allow -r -1.
 - combine-thread to warn if the thread being combined has changes not present in the one below it. I.e. by ancestry, or by doing a merge and recording differences. For bonus points, do the merge, but record the lower thread as the last-revision in the tree still, and set no pending-merges. This preserves the difference whilst still combining the threads.
@@ -110,5 +110,4 @@
   therein as well, to support uncommit between record calls.
 - combine-thread should de-dup penmding merges (use case: up-thread finds a fully merged thread so there are pending merges but no diff between threads; this is when combine-thread is often called).
 - support tags on push/pull in looms
-- bzr nick <name> should rename the current thread (by adding one with the new name and in current-thread deleted the active location - same as merging a delete.
 - perhaps bzr send should send the whole loom ? (e.g. as a patch bomb - a series of patches?)
 
=== modified file '__init__.py'
--- __init__.py	2008-09-12 01:55:17 +0000
+++ __init__.py	2010-08-05 18:57:44 +0000
@@ -48,19 +48,21 @@
    to remove a thread which has been merged into upstream. 
 
 
-Loom also adds a new revision specifier 'thread:'. You can use this to diff
-against threads in the current Loom. For instance, 'bzr diff -r thread:' will
-show you the different between the thread below yours, and your thread.
+Loom also adds new revision specifiers 'thread:' and 'below:'. You can use these
+to diff against threads in the current Loom. For instance, 'bzr diff -r
+thread:' will show you the different between the thread below yours, and your
+thread. See ``bzr help revisionspec`` for the detailed help on these two
+revision specifiers.
 """
 
-version_info = (1, 4, 0, 'dev', 0)
+from version import bzr_plugin_version as version_info
 
 import bzrlib.builtins
 import bzrlib.commands
+import bzrlib.revisionspec
 
-import branch
 import commands
-import revspec
+import formats
 
 
 for command in [
@@ -74,8 +76,12 @@
     'show_loom',
     'up_thread',
     ]:
-    bzrlib.commands.register_command(getattr(commands, 'cmd_' + command))
+    bzrlib.commands.plugin_cmds.register_lazy('cmd_' + command, [],
+        'bzrlib.plugins.loom.commands')
 
+# XXX: bzr fix needed: for status and switch, we have to register directly, not
+# lazily, because register_lazy does not stack in the same way register_command
+# does.
 if not hasattr(bzrlib.builtins, "cmd_switch"):
     # provide a switch command (allows 
     bzrlib.commands.register_command(getattr(commands, 'cmd_switch'))
@@ -86,6 +92,19 @@
 commands.cmd_status._original_command = bzrlib.commands.register_command(
     commands.cmd_status, True)
 
+revspec_registry = getattr(bzrlib.revisionspec, 'revspec_registry', None)
+if revspec_registry is not None:
+    revspec_registry.register_lazy('thread:', 'bzrlib.plugins.loom.revspec',
+                                   'RevisionSpecThread')
+    revspec_registry.register_lazy('below:', 'bzrlib.plugins.loom.revspec',
+                                   'RevisionSpecBelow')
+else:
+    import revspec
+    bzrlib.revisionspec.SPEC_TYPES.append(revspec.RevisionSpecThread)
+    bzrlib.revisionspec.SPEC_TYPES.append(revspec.RevisionSpecBelow)
+
+#register loom formats
+formats.register_formats()
 
 def test_suite():
     import bzrlib.plugins.loom.tests
 
=== modified file 'branch.py'
--- branch.py	2009-04-23 09:09:12 +0000
+++ branch.py	2010-08-05 18:57:44 +0000
@@ -31,13 +31,14 @@
 from bzrlib.decorators import needs_read_lock, needs_write_lock
 import bzrlib.errors
 import bzrlib.osutils
-from bzrlib import symbol_versioning
+from bzrlib import remote, symbol_versioning
 import bzrlib.trace
 import bzrlib.ui
 from bzrlib.revision import is_null, NULL_REVISION
 import bzrlib.tree
 import bzrlib.urlutils
 
+import formats
 import loom_io
 import loom_state
 
@@ -45,6 +46,26 @@
 EMPTY_REVISION = 'empty:'
 
 
+def create_thread(loom, thread_name):
+    """Create a thread in the branch loom called thread."""
+    require_loom_branch(loom)
+    loom.lock_write()
+    try:
+        loom.new_thread(thread_name, loom.nick)
+        loom._set_nick(thread_name)
+    finally:
+        loom.unlock()
+
+
+class AlreadyLoom(bzrlib.errors.BzrError):
+
+    _fmt = """Loom %(loom)s is already a loom."""
+
+    def __init__(self, loom):
+        bzrlib.errors.BzrError.__init__(self)
+        self.loom = loom
+
+
 def loomify(branch):
     """Convert branch to a loom.
 
@@ -53,6 +74,12 @@
     try:
         branch.lock_write()
         try:
+            require_loom_branch(branch)
+        except NotALoom:
+            pass
+        else:
+            raise AlreadyLoom(branch)
+        try:
             format = {
                 bzrlib.branch.BzrBranchFormat5: BzrBranchLoomFormat1,
                 bzrlib.branch.BzrBranchFormat6: BzrBranchLoomFormat6,
@@ -65,25 +92,12 @@
         branch.unlock()
 
 
-def require_loom_branch(branch):
-    """Return None if branch is already loomified, or raise NotALoom."""
-    if not branch._format.__class__ in LOOM_FORMATS:
-        raise NotALoom(branch)
-
-
-class NotALoom(bzrlib.errors.BzrError):
-
-    _fmt = ("The branch %(branch)s is not a loom. "
-        "You can use 'bzr loomify' to make it into a loom.")
-
-    def __init__(self, branch):
-        bzrlib.errors.BzrError.__init__(self)
-        self.branch = branch
+require_loom_branch = formats.require_loom_branch
+NotALoom = formats.NotALoom
 
 
 class LoomThreadError(bzrlib.errors.BzrError):
-
-    _fmt = """Base class for Loom-Thread errors."""
+    """Base class for Loom-Thread errors."""
 
     def __init__(self, branch, thread):
         bzrlib.errors.BzrError.__init__(self)
@@ -198,14 +212,14 @@
             if len(threads) <= current_index:
                 # removed the end
                 # take the new end thread
-                self.nick = threads[-1][0]
+                self._set_nick(threads[-1][0])
                 new_rev = threads[-1][1]
                 if new_rev == EMPTY_REVISION:
                     new_rev = bzrlib.revision.NULL_REVISION
                 self.generate_revision_history(new_rev)
                 return
             # non-end thread removed.
-            self.nick = threads[current_index][0]
+            self._set_nick(threads[current_index][0])
             new_rev = threads[current_index][1]
             if new_rev == EMPTY_REVISION:
                 new_rev = bzrlib.revision.NULL_REVISION
@@ -229,85 +243,25 @@
     def clone(self, to_bzrdir, revision_id=None, repository_policy=None):
         """Clone the branch into to_bzrdir.
         
-        This differs from the base clone by cloning the loom and 
-        setting the current nick to the top of the loom.
+        This differs from the base clone by cloning the loom, setting the
+        current nick to the top of the loom, not honouring any branch format
+        selection on the target bzrdir, and ensuring that the format of
+        the created branch is stacking compatible.
         """
-        result = self._format.initialize(to_bzrdir)
+        # If the target is a stackable repository, force-upgrade the
+        # output loom format
+        if (isinstance(to_bzrdir, bzrdir.BzrDirMeta1) and
+            to_bzrdir._format.repository_format.supports_external_lookups):
+            format = BzrBranchLoomFormat7()
+        else:
+            format = self._format
+        result = format.initialize(to_bzrdir)
         if repository_policy is not None:
             repository_policy.configure_branch(result)
-        self.copy_content_into(result, revision_id=revision_id)
+        bzrlib.branch.InterBranch.get(self, result).copy_content_into(
+            revision_id=revision_id)
         return result
 
-    @needs_read_lock
-    def copy_content_into(self, destination, revision_id=None):
-        # XXX: hint for bzrlib - break this into two routines, one for
-        # copying the last-rev pointer, one for copying parent etc.
-        destination.lock_write()
-        try:
-            source_nick = self.nick
-            state = self.get_loom_state()
-            parents = state.get_parents()
-            if parents:
-                loom_tip = parents[0]
-            else:
-                loom_tip = None
-            threads = self.get_threads(state.get_basis_revision_id())
-            if revision_id not in (None, NULL_REVISION):
-                if threads:
-                    # revision_id should be in the loom, or its an error 
-                    found_threads = [thread for thread, rev in threads
-                        if rev == revision_id]
-                    if not found_threads:
-                        # the thread we have been asked to set in the remote 
-                        # side has not been recorded yet, so its data is not
-                        # present at this point.
-                        raise UnrecordedRevision(self, revision_id)
-
-                # pull in the warp, which was skipped during the initial pull
-                # because the front end does not know what to pull.
-                # nb: this is mega huge hacky. THINK. RBC 2006062
-                nested = bzrlib.ui.ui_factory.nested_progress_bar()
-                try:
-                    if parents:
-                        destination.repository.fetch(self.repository,
-                            revision_id=parents[0])
-                    if threads:
-                        for thread, rev_id in reversed(threads):
-                            # fetch the loom content for this revision
-                            destination.repository.fetch(self.repository,
-                                revision_id=rev_id)
-                finally:
-                    nested.finished()
-            state = loom_state.LoomState()
-            try:
-                require_loom_branch(destination)
-                if threads:
-                    last_rev = threads[-1][1]
-                    if last_rev == EMPTY_REVISION:
-                        last_rev = bzrlib.revision.NULL_REVISION
-                    destination.generate_revision_history(last_rev)
-                    state.set_parents([loom_tip])
-                    state.set_threads(
-                        (thread + ([thread[1]],) for thread in threads)
-                        )
-                else:
-                    # no threads yet, be a normal branch.
-                    self._synchronize_history(destination, revision_id)
-                destination._set_last_loom(state)
-            except NotALoom:
-                self._synchronize_history(destination, revision_id)
-            try:
-                parent = self.get_parent()
-            except bzrlib.errors.InaccessibleParent, e:
-                bzrlib.trace.mutter('parent was not accessible to copy: %s', e)
-            else:
-                if parent:
-                    destination.set_parent(parent)
-            if threads:
-                destination.nick = threads[-1][0]
-        finally:
-            destination.unlock()
-
     def _get_checkout_format(self):
         """Checking out a Loom gets a regular branch for now.
         
@@ -435,22 +389,25 @@
             result.append((name, rev_id))
         return result
 
-    @needs_write_lock
-    def pull(self, source, overwrite=False, stop_revision=None,
-        run_hooks=True, possible_transports=None, _override_hook_target=None):
-        """Pull from a branch into this loom.
-
-        If the remote branch is a non-loom branch, the pull is done against the
-        current warp. If it is a loom branch, then the pull is done against the
-        entire loom and the current thread set to the top thread.
-        """
-        if not isinstance(source, LoomSupport):
-            return super(LoomSupport, self).pull(source,
-                overwrite=overwrite, stop_revision=stop_revision,
-                possible_transports=possible_transports,
-                _override_hook_target=_override_hook_target)
-        return _Puller(source, self).transfer(overwrite, stop_revision,
-            run_hooks, possible_transports, _override_hook_target)
+    def _loom_get_nick(self):
+        return self._get_nick(local=True)
+
+    def _rename_thread(self, nick):
+        """Rename the current thread to nick."""
+        state = self.get_loom_state()
+        threads = state.get_threads()
+        if not len(threads):
+            # No threads at all - probably a default initialised loom in the
+            # test suite.
+            return  self._set_nick(nick)
+        current_index = state.thread_index(self.nick)
+        threads[current_index] = (nick,) + threads[current_index][1:]
+        state.set_threads(threads)
+        self._set_last_loom(state)
+        # Preserve default behavior: set the branch nick
+        self._set_nick(nick)
+
+    nick = property(_loom_get_nick, _rename_thread)
 
     @needs_read_lock
     def push(self, target, overwrite=False, stop_revision=None,
@@ -606,10 +563,20 @@
 
 
 class _Puller(object):
+    # XXX: Move into InterLoomBranch.
 
     def __init__(self, source, target):
         self.target = target
         self.source = source
+        # If _Puller has been created, we need real branch objects.
+        self.real_target = self.unwrap_branch(target)
+        self.real_source = self.unwrap_branch(source)
+
+    def unwrap_branch(self, branch):
+        if isinstance(branch, remote.RemoteBranch):
+            branch._ensure_real()
+            return branch._real_branch
+        return branch
 
     def prepare_result(self, _override_hook_target):
         result = self.make_result()
@@ -669,8 +636,10 @@
         return result
 
     def transfer(self, overwrite, stop_revision, run_hooks=True,
-                 possible_transports=None, _override_hook_target=None):
+        possible_transports=None, _override_hook_target=None, local=False):
         """Implementation of push and pull"""
+        if local:
+            raise bzrlib.errors.LocalRequiresBoundBranch()
         # pull the loom, and position our
         pb = bzrlib.ui.ui_factory.nested_progress_bar()
         try:
@@ -678,7 +647,7 @@
             self.target.lock_write()
             self.source.lock_read()
             try:
-                source_state = self.source.get_loom_state()
+                source_state = self.real_source.get_loom_state()
                 source_parents = source_state.get_parents()
                 if not source_parents:
                     return self.plain_transfer(result, run_hooks,
@@ -724,7 +693,7 @@
                 # and save the state.
                 self.target._set_last_loom(my_state)
                 # set the branch nick.
-                self.target.nick = threads[-1][0]
+                self.target._set_nick(threads[-1][0])
                 # and position the branch on the top loom
                 new_rev = threads[-1][1]
                 if new_rev == EMPTY_REVISION:
@@ -743,7 +712,7 @@
 
     @staticmethod
     def make_result():
-        return bzrlib.branch.PushResult()
+        return bzrlib.branch.BranchPushResult()
 
     @staticmethod
     def post_hooks():
@@ -780,9 +749,11 @@
     # A mixin is not ideal because it is tricky to test, but it seems to be the
     # best solution for now.
 
-    def initialize(self, a_bzrdir):
+    def initialize(self, a_bzrdir, name=None):
         """Create a branch of this format in a_bzrdir."""
-        super(LoomFormatMixin, self).initialize(a_bzrdir)
+        if name is not None:
+            raise bzrlib.errors.NoColocatedBranchSupport(self)
+        super(LoomFormatMixin, self).initialize(a_bzrdir, name=None)
         branch_transport = a_bzrdir.get_branch_transport(self)
         files = []
         state = loom_state.LoomState()
@@ -801,15 +772,21 @@
             control_files.unlock()
         return self.open(a_bzrdir, _found=True, )
 
-    def open(self, a_bzrdir, _found=False, ignore_fallbacks=False):
+    def open(self, a_bzrdir, name=None, _found=False, ignore_fallbacks=False):
         """Return the branch object for a_bzrdir
 
         _found is a private parameter, do not use it. It is used to indicate
                if format probing has already be done.
+
+        :param name: The 'colocated branches' name for the branch to open.
+            in future, Loom may use that to return a Thread, but for now
+            it is unused.
         """
         if not _found:
             format = BranchFormat.find_format(a_bzrdir)
             assert format.__class__ == self.__class__
+        if name is not None:
+            raise bzrlib.errors.NoColocatedBranchSupport(self)
         transport = a_bzrdir.get_branch_transport(None)
         control_files = bzrlib.lockable_files.LockableFiles(
             transport, 'lock', bzrlib.lockdir.LockDir)
@@ -923,13 +900,136 @@
         return "bzr loom format 7 (based on bzr branch format 7)\n"
 
 
-bzrlib.branch.BranchFormat.register_format(BzrBranchLoomFormat1())
-bzrlib.branch.BranchFormat.register_format(BzrBranchLoomFormat6())
-bzrlib.branch.BranchFormat.register_format(BzrBranchLoomFormat7())
-
-
-LOOM_FORMATS = [
-    BzrBranchLoomFormat1,
-    BzrBranchLoomFormat6,
-    BzrBranchLoomFormat7,
-]
+# Handle the smart server:
+
+class InterLoomBranch(bzrlib.branch.GenericInterBranch):
+
+    @classmethod
+    def _get_branch_formats_to_test(klass):
+        return [
+            (bzrlib.branch.BranchFormat._default_format,
+             BzrBranchLoomFormat7()),
+            (BzrBranchLoomFormat7(),
+             bzrlib.branch.BranchFormat._default_format),
+            (BzrBranchLoomFormat7(), BzrBranchLoomFormat7()),
+            ]
+
+    def unwrap_branch(self, branch):
+        if isinstance(branch, remote.RemoteBranch):
+            branch._ensure_real()
+            return branch._real_branch
+        return branch
+
+    @classmethod
+    def is_compatible(klass, source, target):
+        # 1st cut: special case and handle all *->Loom and Loom->*
+        return klass.branch_is_loom(source) or klass.branch_is_loom(target)
+
+    def get_loom_state(self, branch):
+        branch = self.unwrap_branch(branch)
+        return branch.get_loom_state()
+
+    def get_threads(self, branch, revision_id):
+        branch = self.unwrap_branch(branch)
+        return branch.get_threads(revision_id)
+
+    @classmethod
+    def branch_is_loom(klass, branch):
+        format = klass.unwrap_format(branch._format)
+        return isinstance(format, LoomFormatMixin)
+
+    @needs_write_lock
+    def copy_content_into(self, revision_id=None):
+        if not self.__class__.branch_is_loom(self.source):
+            # target is loom, but the generic code path works Just Fine for
+            # regular to loom copy_content_into.
+            return super(InterLoomBranch, self).copy_content_into(
+                revision_id=revision_id)
+        # XXX: hint for bzrlib - break this into two routines, one for
+        # copying the last-rev pointer, one for copying parent etc.
+        source_nick = self.source.nick
+        state = self.get_loom_state(self.source)
+        parents = state.get_parents()
+        if parents:
+            loom_tip = parents[0]
+        else:
+            loom_tip = None
+        threads = self.get_threads(self.source, state.get_basis_revision_id())
+        if revision_id not in (None, NULL_REVISION):
+            if threads:
+                # revision_id should be in the loom, or its an error 
+                found_threads = [thread for thread, rev in threads
+                    if rev == revision_id]
+                if not found_threads:
+                    # the thread we have been asked to set in the remote 
+                    # side has not been recorded yet, so its data is not
+                    # present at this point.
+                    raise UnrecordedRevision(self.source, revision_id)
+
+            # pull in the warp, which was skipped during the initial pull
+            # because the front end does not know what to pull.
+            # nb: this is mega huge hacky. THINK. RBC 2006062
+            nested = bzrlib.ui.ui_factory.nested_progress_bar()
+            try:
+                if parents:
+                    self.target.repository.fetch(self.source.repository,
+                        revision_id=parents[0])
+                if threads:
+                    for thread, rev_id in reversed(threads):
+                        # fetch the loom content for this revision
+                        self.target.repository.fetch(self.source.repository,
+                            revision_id=rev_id)
+            finally:
+                nested.finished()
+        state = loom_state.LoomState()
+        try:
+            require_loom_branch(self.target)
+            if threads:
+                last_rev = threads[-1][1]
+                if last_rev == EMPTY_REVISION:
+                    last_rev = bzrlib.revision.NULL_REVISION
+                self.target.generate_revision_history(last_rev)
+                state.set_parents([loom_tip])
+                state.set_threads(
+                    (thread + ([thread[1]],) for thread in threads)
+                    )
+            else:
+                # no threads yet, be a normal branch.
+                self.source._synchronize_history(self.target, revision_id)
+            target_loom = self.unwrap_branch(self.target)
+            target_loom._set_last_loom(state)
+        except NotALoom:
+            self.source._synchronize_history(self.target, revision_id)
+        try:
+            parent = self.source.get_parent()
+        except bzrlib.errors.InaccessibleParent, e:
+            bzrlib.trace.mutter('parent was not accessible to copy: %s', e)
+        else:
+            if parent:
+                self.target.set_parent(parent)
+        if threads:
+            self.target._set_nick(threads[-1][0])
+
+    @needs_write_lock
+    def pull(self, overwrite=False, stop_revision=None,
+        run_hooks=True, possible_transports=None, _override_hook_target=None,
+        local=False):
+        """Perform a pull, reading from self.source and writing to self.target.
+
+        If the source branch is a non-loom branch, the pull is done against the
+        current warp. If it is a loom branch, then the pull is done against the
+        entire loom and the current thread set to the top thread.
+        """
+        # Special code only needed when both source and targets are looms:
+        if (self.__class__.branch_is_loom(self.target) and
+            self.__class__.branch_is_loom(self.source)):
+            return _Puller(self.source, self.target).transfer(overwrite, stop_revision,
+                run_hooks, possible_transports, _override_hook_target, local)
+        return super(InterLoomBranch, self).pull(
+            overwrite=overwrite, stop_revision=stop_revision,
+            possible_transports=possible_transports,
+            _override_hook_target=_override_hook_target, local=local,
+            run_hooks=run_hooks)
+
+
+bzrlib.branch.InterBranch.register_optimiser(InterLoomBranch)
 
=== modified file 'commands.py'
--- commands.py	2009-02-13 02:30:24 +0000
+++ commands.py	2010-08-05 18:57:44 +0000
@@ -17,18 +17,23 @@
 
 """Loom commands."""
 
-from bzrlib import workingtree
+from bzrlib import bzrdir, directory_service, workingtree
 import bzrlib.commands
 import bzrlib.branch
 from bzrlib import errors
+from bzrlib.lazy_import import lazy_import
 import bzrlib.merge
 from bzrlib.option import Option
 import bzrlib.revision
 import bzrlib.trace
 import bzrlib.transport
 
+import formats
+
+lazy_import(globals(), """
 import branch
 from tree import LoomTreeDecorator
+""")
 
 
 class cmd_loomify(bzrlib.commands.Command):
@@ -67,7 +72,7 @@
 
 
 class cmd_combine_thread(bzrlib.commands.Command):
-    """Combine the current thread with the thread below it.
+    __doc__ = """Combine the current thread with the thread below it.
     
     This will currently refuse to operate on the last thread, but in the future
     will just turn the loom into a normal branch again.
@@ -79,23 +84,53 @@
      * Change threads to the thread below.
     """
 
-    def run(self):
+    takes_options = [
+        Option('force', help='Combine even if work in the thread is not '
+            'integrated up or down the loom.'),
+        ]
+
+    def run(self, force=False):
         (tree, path) = workingtree.WorkingTree.open_containing('.')
         branch.require_loom_branch(tree.branch)
-        tree.lock_write()
-        try:
-            current_thread = tree.branch.nick
-            state = tree.branch.get_loom_state()
+        self.add_cleanup(tree.lock_write().unlock)
+        current_thread = tree.branch.nick
+        state = tree.branch.get_loom_state()
+        if not force:
+            # Check for unmerged work.
+            # XXX: Layering issue whom should be caring for the check, not the
+            # command thats for sure.
             threads = state.get_threads()
-            new_thread = state.get_new_thread_after_deleting(current_thread)
-            if new_thread is None:
-                raise branch.CannotCombineOnLastThread
-            bzrlib.trace.note("Combining thread '%s' into '%s'",
-                current_thread, new_thread)
-            LoomTreeDecorator(tree).down_thread(new_thread)
-            tree.branch.remove_thread(current_thread)
-        finally:
-            tree.unlock()
+            current_index = state.thread_index(current_thread)
+            rev_below = None
+            rev_current = threads[current_index][1]
+            rev_above = None
+            if current_index:
+                # There is a thread below
+                rev_below = threads[current_index - 1][1]
+            if current_index < len(threads) - 1:
+                rev_above = threads[current_index + 1][1]
+            graph = tree.branch.repository.get_graph()
+            candidates = [rev for rev in
+                (rev_below, rev_current, rev_above) if rev]
+            heads = graph.heads(candidates)
+            # If current is not a head, its trivially merged, or
+            # if current is == rev_below, its also merged, or
+            # if there is only one thread its merged (well its not unmerged).
+            if (rev_current == rev_below or rev_current not in heads or
+                (rev_below is None and rev_above is None)):
+                merged = True
+            else:
+                merged = False
+            if not merged:
+                raise errors.BzrCommandError("Thread '%s' has unmerged work"
+                    ". Use --force to combine anyway." % current_thread)
+        new_thread = state.get_new_thread_after_deleting(current_thread)
+        if new_thread is None:
+            raise branch.CannotCombineOnLastThread
+        bzrlib.trace.note("Combining thread '%s' into '%s'",
+            current_thread, new_thread)
+        LoomTreeDecorator(tree).down_thread(new_thread)
+        tree.branch.remove_thread(current_thread)
 
 
 class cmd_create_thread(bzrlib.commands.Command):
@@ -106,19 +141,15 @@
 
     The thread-name must be a valid branch 'nickname', and must not be the name
     of an existing thread in your loom.
+
+    The new thread is created immediately after the current thread.
     """
 
     takes_args = ['thread']
 
     def run(self, thread):
         (loom, path) = bzrlib.branch.Branch.open_containing('.')
-        branch.require_loom_branch(loom)
-        loom.lock_write()
-        try:
-            loom.new_thread(thread, loom.nick)
-            loom.nick = thread
-        finally:
-            loom.unlock()
+        branch.create_thread(loom, thread)
 
 
 class cmd_show_loom(bzrlib.commands.Command):
@@ -160,7 +191,7 @@
         else:
             path = file_list[0]
         (loom, _) = bzrlib.branch.Branch.open_containing(path)
-        branch.require_loom_branch(loom)
+        formats.require_loom_branch(loom)
         loom.lock_read()
         try:
             print 'Current thread: %s' % loom.nick
@@ -172,7 +203,7 @@
         self._original_command().run_argv_aliases(argv, alias_argv)
         try:
             super(cmd_status, self).run_argv_aliases(list(argv), alias_argv)
-        except branch.NotALoom:
+        except formats.NotALoom:
             pass
 
 
@@ -208,15 +239,43 @@
             return thread[0]
         return to_location
 
-    def run(self, to_location, force=False):
-        (tree, path) = workingtree.WorkingTree.open_containing('.')
-        tree = LoomTreeDecorator(tree)
+    def run(self, to_location=None, force=False, create_branch=False,
+            revision=None, directory=None):
+        # The top of this is cribbed from bzr; because bzr isn't factored out
+        # enough.
+        if directory is None:
+            directory = u'.'
+        control_dir, path = bzrdir.BzrDir.open_containing(directory)
+        if to_location is None:
+            if revision is None:
+                raise errors.BzrCommandError(
+                    'You must supply either a revision or a location')
+            to_location = '.'
         try:
-            thread_name = self._get_thread_name(tree.branch, to_location)
-            return tree.down_thread(thread_name)
-        except (AttributeError, branch.NoSuchThread):
-            # When there is no thread its probably an external branch
-            # that we have been given.
+            from_branch = control_dir.open_branch()
+        except errors.NotBranchError:
+            from_branch = None
+        if create_branch:
+            if from_branch is None:
+                raise errors.BzrCommandError(
+                    'cannot create branch without source branch')
+            to_location = directory_service.directories.dereference(
+                to_location)
+        if from_branch is not None:
+            # Note: reopens.
+            (tree, path) = workingtree.WorkingTree.open_containing(directory)
+            tree = LoomTreeDecorator(tree)
+            try:
+                if create_branch:
+                    return branch.create_thread(tree.branch, to_location)
+                thread_name = self._get_thread_name(tree.branch, to_location)
+                return tree.down_thread(thread_name)
+            except (AttributeError, branch.NoSuchThread, branch.NotALoom):
+                # When there is no thread its probably an external branch
+                # that we have been given.
+                raise errors.MustUseDecorated
+        else:
+            # switching to a relocated branch
             raise errors.MustUseDecorated
 
     def run_argv_aliases(self, argv, alias_argv=None):
@@ -307,26 +366,34 @@
 
 
 class cmd_up_thread(bzrlib.commands.Command):
-    """Move the branch up a thread in the loom.
-    
+    """Move the branch up to the top thread in the loom.
+
     This merges the changes done in this thread but not incorporated into
     the next thread up into the next thread up and switches your tree to be
-    that thread.
+    that thread.  Unless there are conflicts, or --manual is specified, it
+    will then commit and repeat the process.
     """
 
+    takes_args = ['thread?']
+
     takes_options = ['merge-type', Option('auto',
-        help='Automatically commit and merge repeatedly.')]
+        help='Deprecated - now the default.'),
+        Option('manual', help='Perform commit manually.'),
+        ]
 
     _see_also = ['down-thread', 'switch']
 
-    def run(self, merge_type=None, auto=False):
+    def run(self, merge_type=None, manual=False, thread=None, auto=None):
         (tree, path) = workingtree.WorkingTree.open_containing('.')
         branch.require_loom_branch(tree.branch)
         tree = LoomTreeDecorator(tree)
-        if not auto:
+        if manual:
+            if thread is not None:
+                raise errors.BzrCommandError('Specifying a thread does not'
+                                             ' work with --manual.')
             return tree.up_thread(merge_type)
         else:
-            return tree.up_many(merge_type)
+            return tree.up_many(merge_type, thread)
 
 
 class cmd_export_loom(bzrlib.commands.Command):
 
=== added file 'formats.py'
--- formats.py	1970-01-01 00:00:00 +0000
+++ formats.py	2010-08-05 18:57:44 +0000
@@ -0,0 +1,74 @@
+# Loom, a plugin for bzr to assist in developing focused patches.
+# Copyright (C) 2010 Canonical Limited.
+# 
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License version 2 as published
+# by the Free Software Foundation.
+# 
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+# 
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
+#
+
+"""Format information about formats for Loom.
+
+This is split out from the implementation of the formats to permit lazy
+loading without requiring the implementation code to be cryptic.
+"""
+
+__all__ = [
+    'NotALoom',
+    'register_formats',
+    'require_loom_branch',
+    ]
+
+from bzrlib.lazy_import import lazy_import
+import bzrlib.errors
+
+lazy_import(globals(), """
+from bzrlib import branch as _mod_branch
+""")
+
+
+_LOOM_FORMATS = {
+    "Bazaar-NG Loom branch format 1\n": "BzrBranchLoomFormat1",
+    "Bazaar-NG Loom branch format 6\n": "BzrBranchLoomFormat6",
+    "Bazaar-NG Loom branch format 7\n": "BzrBranchLoomFormat7",
+    }
+
+def register_formats():
+    if getattr(_mod_branch, 'MetaDirBranchFormatFactory', None):
+        branch_formats = [_mod_branch.MetaDirBranchFormatFactory(format_string,
+            "bzrlib.plugins.loom.branch", format_class) for 
+            (format_string, format_class) in _LOOM_FORMATS.iteritems()]
+    else:
+        # Compat for folk not running bleeding edge. Like me as I commit this.
+        import branch
+        branch_formats = [
+            branch.BzrBranchLoomFormat1(),
+            branch.BzrBranchLoomFormat6(),
+            branch.BzrBranchLoomFormat7(),
+            ]
+    map(_mod_branch.BranchFormat.register_format, branch_formats)
+
+
+def require_loom_branch(branch):
+    """Return None if branch is already loomified, or raise NotALoom."""
+    if branch._format.network_name() not in _LOOM_FORMATS:
+        raise NotALoom(branch)
+
+
+# TODO: define errors without importing all errors.
+class NotALoom(bzrlib.errors.BzrError):
+
+    _fmt = ("The branch %(branch)s is not a loom. "
+        "You can use 'bzr loomify' to make it into a loom.")
+
+    def __init__(self, branch):
+        bzrlib.errors.BzrError.__init__(self)
+        self.branch = branch
 
=== modified file 'revspec.py'
--- revspec.py	2009-02-13 02:30:24 +0000
+++ revspec.py	2010-08-05 18:57:44 +0000
@@ -18,52 +18,87 @@
 """Loom specific revision-specifiers."""
 
 
-from bzrlib import revisionspec
 from bzrlib.plugins.loom.branch import NoLowerThread
+from bzrlib.plugins.loom.formats import require_loom_branch
 from bzrlib.revisionspec import RevisionSpec, RevisionInfo
 
 
-class RevisionSpecThread(RevisionSpec):
-    """The thread: revision specifier."""
-
-    help_txt = """Selects the tip of a revision from a loom.
-
-    Selects the tip of a thread in a loom.  
-
-    Examples::
-
-      thread:                   -> return the tip of the next lower thread.
-      thread:foo                -> return the tip of the thread named 'foo'
-
-    see also: loom
-    """
-
-    prefix = 'thread:'
+class LoomRevisionSpec(RevisionSpec):
+    """A revision spec that needs a loom."""
 
     def _match_on(self, branch, revs):
          return RevisionInfo(branch, None, self._as_revision_id(branch))
 
     def _as_revision_id(self, branch):
-        # '' -> next lower
-        # foo -> named
+        require_loom_branch(branch)
         branch.lock_read()
         try:
             state = branch.get_loom_state()
             threads = state.get_threads()
-            if len(self.spec):
-                index = state.thread_index(self.spec)
-            else:
-                current_thread = branch.nick
-                index = state.thread_index(current_thread) - 1
-                if index < 0:
-                    raise NoLowerThread()
-            return threads[index][1]
+            return self._as_thread_revision_id(branch, state, threads)
         finally:
             branch.unlock()
 
 
-revspec_registry = getattr(revisionspec, 'revspec_registry', None)
-if revspec_registry is not None:
-    revspec_registry.register('thread:', RevisionSpecThread)
-else:
-    revisionspec.SPEC_TYPES.append(RevisionSpecThread)
+class RevisionSpecBelow(LoomRevisionSpec):
+    """The below: revision specifier."""
+
+    help_txt = """Selects the tip of the thread below a thread from a loom.
+
+    Selects the tip of the thread below a thread in a loom.  
+
+    Examples::
+
+      below:                   -> return the tip of the next lower thread.
+      below:foo                -> return the tip of the thread under the one
+                                  named 'foo'
+
+    see also: loom, the thread: revision specifier
+    """
+
+    prefix = 'below:'
+
+    def _as_thread_revision_id(self, branch, state, threads):
+        # '' -> next lower
+        # foo -> thread under foo
+        if len(self.spec):
+            index = state.thread_index(self.spec)
+        else:
+            current_thread = branch.nick
+            index = state.thread_index(current_thread)
+        if index < 1:
+            raise NoLowerThread()
+        return threads[index - 1][1]
+
+
+class RevisionSpecThread(LoomRevisionSpec):
+    """The thread: revision specifier."""
+
+    help_txt = """Selects the tip of a thread from a loom.
+
+    Selects the tip of a thread in a loom.  
+
+    Examples::
+
+      thread:                   -> return the tip of the next lower thread.
+      thread:foo                -> return the tip of the thread named 'foo'
+
+    see also: loom, the below: revision specifier
+    """
+
+    prefix = 'thread:'
+
+    def _as_thread_revision_id(self, branch, state, threads):
+        # '' -> next lower
+        # foo -> named
+        if len(self.spec):
+            index = state.thread_index(self.spec)
+        else:
+            current_thread = branch.nick
+            index = state.thread_index(current_thread) - 1
+            if index < 0:
+                raise NoLowerThread()
+        return threads[index][1]
+
+
+
 
=== modified file 'setup.py'
--- setup.py	2008-05-30 02:39:07 +0000
+++ setup.py	2010-08-05 18:57:44 +0000
@@ -20,13 +20,11 @@
     "Bazaar-NG Loom branch format 6\n":"Loom branch format 6",
     }
 
-bzr_plugin_version = (1, 4, 0, 'dev', 0)
-bzr_minimum_version = (1, 0, 0)
-bzr_maximum_version = None
+from version import *
 
-if __name__ == 'main':
+if __name__ == '__main__':
     setup(name="Loom",
-          version="1.4.0dev0",
+          version="2.2.1dev0",
           description="Loom plugin for bzr.",
           author="Canonical Ltd",
           author_email="[e-mail]",
 
=== modified file 'tests/__init__.py'
--- tests/__init__.py	2008-09-12 01:55:17 +0000
+++ tests/__init__.py	2010-08-05 18:57:44 +0000
@@ -22,6 +22,7 @@
 import bzrlib.plugins.loom.branch
 from bzrlib.tests import TestCaseWithTransport
 from bzrlib.tests.TestUtil import TestLoader, TestSuite
+from bzrlib.workingtree import WorkingTree
 
 
 def test_suite():
@@ -41,7 +42,9 @@
 
     def get_tree_with_loom(self, path="."):
         """Get a tree with no commits in loom format."""
-        tree = self.make_branch_and_tree(path)
+        # May open on Remote - we want the vfs backed version for loom tests.
+        self.make_branch_and_tree(path)
+        tree = WorkingTree.open(path)
         bzrlib.plugins.loom.branch.loomify(tree.branch)
         return tree.bzrdir.open_workingtree()
 
 
=== modified file 'tests/blackbox.py'
--- tests/blackbox.py	2008-11-24 16:38:16 +0000
+++ tests/blackbox.py	2010-08-05 18:57:44 +0000
@@ -35,7 +35,7 @@
     def _add_patch(self, tree, name):
         """Add a patch to a new thread, returning the revid of te commit."""
         tree.branch.new_thread(name)
-        tree.branch.nick = name
+        tree.branch._set_nick(name)
         self.build_tree([name])
         tree.add(name)
         return tree.commit(name)
@@ -147,11 +147,11 @@
         self.assertShowLoom(['vendor'], 'vendor')
         tree.branch.new_thread('debian')
         self.assertShowLoom(['vendor', 'debian'], 'vendor')
-        tree.branch.nick = 'debian'
+        tree.branch._set_nick('debian')
         self.assertShowLoom(['vendor', 'debian'], 'debian')
         tree.branch.new_thread('patch A', 'vendor')
         self.assertShowLoom(['vendor', 'patch A', 'debian'], 'debian')
-        tree.branch.nick = 'patch A'
+        tree.branch._set_nick('patch A')
         self.assertShowLoom(['vendor', 'patch A', 'debian'], 'patch A')
 
     def test_show_loom_with_location(self):
@@ -266,6 +266,17 @@
             "All changes applied successfully.\nMoved to thread 'thread2'.\n",
             err)
 
+    def test_switch_dash_b(self):
+        # 'bzr switch -b new-thread' makes and switches to a new thread.
+        tree = self.get_vendor_loom()
+        self._add_patch(tree, 'thread2')
+        LoomTreeDecorator(tree).down_thread('vendor')
+        self.assertEqual(tree.branch.nick, 'vendor')
+        out, err = self.run_bzr(['switch', '-b', 'thread1'], retcode=0)
+        self.assertEqual(tree.branch.nick, 'thread1')
+        self.assertEqual('', out)
+        self.assertEqual('', err)
+
 
 class TestRecord(TestsWithLooms):
 
@@ -281,7 +292,7 @@
         """Adding a new thread is enough to allow recording."""
         tree = self.get_vendor_loom()
         tree.branch.new_thread('feature')
-        tree.branch.nick = 'feature'
+        tree.branch._set_nick('feature')
         out, err = self.run_bzr(['record', 'add feature branch.'])
         self.assertEqual('Loom recorded.\n', out)
         self.assertEqual('', err)
@@ -303,7 +314,7 @@
         """moving down when the revision is unchanged should work."""
         tree = self.get_vendor_loom()
         tree.branch.new_thread('patch')
-        tree.branch.nick = 'patch'
+        tree.branch._set_nick('patch')
         rev = tree.last_revision()
         out, err = self.run_bzr(['down-thread'])
         self.assertEqual('', out)
@@ -314,7 +325,7 @@
     def test_down_thread_removes_changes_between_threads(self):
         tree = self.get_vendor_loom()
         tree.branch.new_thread('patch')
-        tree.branch.nick = 'patch'
+        tree.branch._set_nick('patch')
         rev = tree.last_revision()
         self.build_tree(['afile'])
         tree.add('afile')
@@ -336,7 +347,7 @@
         """Do a down thread when the lower patch is not in the r-h of the old."""
         tree = self.get_vendor_loom()
         tree.branch.new_thread('patch')
-        tree.branch.nick = 'vendor'
+        tree.branch._set_nick('vendor')
         # do a null change in vendor - a new release.
         vendor_release = tree.commit('new vendor release.', allow_pointless=True)
         # pop up, then down
@@ -389,7 +400,7 @@
         """Trying to down-thread with changes causes an error."""
         tree = self.get_vendor_loom()
         tree.branch.new_thread('upper-thread')
-        tree.branch.nick = 'upper-thread'
+        tree.branch._set_nick('upper-thread')
         self.build_tree(['new-file'])
         tree.add('new-file')
         out, err = self.run_bzr('down-thread', retcode=3)
@@ -405,33 +416,35 @@
         self.assertEqual('', out)
         self.assertEqual(
             'bzr: ERROR: Cannot move up from the highest thread.\n', err)
-        
+
     def test_up_thread_same_revision(self):
         """moving up when the revision is unchanged should work."""
         tree = self.get_vendor_loom()
         tree.branch.new_thread('patch')
-        tree.branch.nick = 'vendor'
+        tree.branch._set_nick('vendor')
         rev = tree.last_revision()
         out, err = self.run_bzr(['up-thread'])
         self.assertEqual('', out)
         self.assertEqual('', err)
         self.assertEqual('patch', tree.branch.nick)
         self.assertEqual(rev, tree.last_revision())
-        
-    def test_up_thread_preserves_changes(self):
+
+    def test_up_thread_manual_preserves_changes(self):
         tree = self.get_vendor_loom()
         tree.branch.new_thread('patch')
-        tree.branch.nick = 'vendor'
+        tree.branch._set_nick('vendor')
         patch_rev = tree.last_revision()
         # add a change in vendor - a new release.
         self.build_tree(['afile'])
         tree.add('afile')
         vendor_release = tree.commit('new vendor release adds a file.')
-        out, err = self.run_bzr(['up-thread'])
+        out, err = self.run_bzr(['up-thread', '--manual'])
         self.assertEqual('', out)
         self.assertEqual(
             "All changes applied successfully.\n"
-            "Moved to thread 'patch'.\n", err)
+            "Moved to thread 'patch'.\n"
+            'This thread is now empty, you may wish to run "bzr '
+            'combine-thread" to remove it.\n', err)
         self.assertEqual('patch', tree.branch.nick)
         # the tree needs to be updated.
         self.assertEqual(patch_rev, tree.last_revision())
@@ -442,11 +455,18 @@
         self.run_bzr(['diff'], retcode=1)
         self.assertEqual([patch_rev, vendor_release], tree.get_parent_ids())
 
+    def test_up_thread_manual_rejects_specified_thread(self):
+        tree = self.get_vendor_loom()
+        tree.branch.new_thread('patch')
+        out, err = self.run_bzr('up-thread --manual patch', retcode=3)
+        self.assertContainsRe(err, 'Specifying a thread does not work with'
+                              ' --manual.')
+
     def test_up_thread_gets_conflicts(self):
         """Do a change in both the baseline and the next patch up."""
         tree = self.get_vendor_loom()
         tree.branch.new_thread('patch')
-        tree.branch.nick = 'patch'
+        tree.branch._set_nick('patch')
         # add a change in patch - a new release.
         self.build_tree(['afile'])
         tree.add('afile')
@@ -483,14 +503,72 @@
         self.run_bzr(['down-thread'])
         self.run_bzr(['up-thread', '--lca'])
 
-    def test_up_thread_auto(self):
+    def test_up_thread_no_manual(self):
         tree = self.get_vendor_loom()
         tree.branch.new_thread('middle')
         tree.branch.new_thread('top')
-        self.run_bzr('up-thread --auto')
+        self.run_bzr('up-thread')
         branch = _mod_branch.Branch.open('.')
         self.assertEqual('top', branch.nick)
 
+    def test_up_with_clean_merge_leaving_thread_empty(self):
+        """This tests what happens when a thread becomes empty.
+        
+        A thread becomes empty when all its changes are included in
+        a lower thread, and so its diff to the thread below contains
+        nothing.
+        
+        The user should be warned when this happens.
+        """
+        tree = self.get_vendor_loom()
+        self.build_tree(['afile'])
+        tree.add('afile')
+        patch_rev = tree.commit('add afile in base')
+        tree.branch.new_thread('patch')
+        tree.branch._set_nick('patch')
+        # make a change to afile in patch.
+        f = open('afile', 'wb')
+        try:
+            f.write('new contents of afile\n')
+        finally:
+            f.close()
+        patch_rev = tree.commit('make a change to afile')
+        # make the same change in vendor.
+        self.run_bzr(['down-thread'])
+        f = open('afile', 'wb')
+        try:
+            f.write('new contents of afile\n')
+        finally:
+            f.close()
+        vendor_release = tree.commit('make the same change to afile')
+        # check that the trees no longer differ after the up merge,
+        # and that we are 
+        out, err = self.run_bzr(['up-thread', '--manual'])
+        self.assertEqual('', out)
+        self.assertStartsWith(err,
+            "All changes applied successfully.\n"
+            "Moved to thread 'patch'.\n"
+            'This thread is now empty, you may wish to run "bzr '
+            'combine-thread" to remove it.\n')
+        self.assertEqual('patch', tree.branch.nick)
+        # the tree needs to be updated.
+        self.assertEqual(patch_rev, tree.last_revision())
+        # the branch needs to be updated.
+        self.assertEqual(patch_rev, tree.branch.last_revision())
+        self.assertTrue(tree.has_filename('afile'))
+        # diff should return 0 now as we have no uncommitted changes.
+        self.run_bzr(['diff'])
+        self.assertEqual([patch_rev, vendor_release], tree.get_parent_ids())
+
+    def test_up_thread_accepts_thread(self):
+        tree = self.get_vendor_loom()
+        tree.branch.new_thread('lower-middle')
+        tree.branch.new_thread('upper-middle')
+        tree.branch.new_thread('top')
+        self.run_bzr('up-thread upper-middle')
+        branch = _mod_branch.Branch.open('.')
+        self.assertEqual('upper-middle', branch.nick)
+
 
 class TestPush(TestsWithLooms):
 
@@ -592,7 +670,7 @@
         # not in, so we can revert that by name,
         tree = self.get_vendor_loom()
         tree.branch.new_thread('after-vendor')
-        tree.branch.nick = 'after-vendor'
+        tree.branch._set_nick('after-vendor')
         tree.commit('after-vendor commit', allow_pointless=True)
         tree.branch.record_loom('save loom with vendor and after-vendor')
         old_threads = tree.branch.get_loom_state().get_threads()
@@ -632,6 +710,56 @@
         loom_tree.down_thread()
         return tree, loom_tree
 
+    def get_loom_with_unique_thread(self):
+        """Return a loom with a unique thread.
+
+        That is:
+        vendor:[]
+        unique-thread:[vendor]
+        above-vendor:[vendor]
+
+        - unique-thread has work not in vendor and not in above-vendor.
+
+        The returned loom is on the vendor thread.
+        """
+        tree, _ = self.get_two_thread_loom()
+        tree.branch.new_thread('unique-thread', 'vendor')
+        loom_tree = LoomTreeDecorator(tree)
+        loom_tree.up_thread()
+        self.build_tree(['file-b'])
+        tree.add('file-b')
+        tree.commit('a unique change', rev_id='uniquely-yrs-1')
+        loom_tree.down_thread()
+        return tree, loom_tree
+
+    def test_combine_unmerged_thread_force(self):
+        """Combining a thread with unique work works with --force."""
+        tree, loom_tree = self.get_loom_with_unique_thread()
+        vendor_revid = tree.last_revision()
+        loom_tree.up_thread()
+        out, err = self.run_bzr(['combine-thread', '--force'])
+        self.assertEqual('', out)
+        self.assertEqual(
+            "Combining thread 'unique-thread' into 'vendor'\n"
+            'All changes applied successfully.\n'
+            "Moved to thread 'vendor'.\n",
+            err)
+        self.assertEqual(vendor_revid, tree.last_revision())
+        self.assertEqual('vendor', tree.branch.nick)
+
+    def test_combine_unmerged_thread_errors(self):
+        """Combining a thread with unique work errors without --force."""
+        tree, loom_tree = self.get_loom_with_unique_thread()
+        loom_tree.up_thread()
+        unique_revid = tree.last_revision()
+        out, err = self.run_bzr(['combine-thread'], retcode=3)
+        self.assertEqual('', out)
+        self.assertEqual("bzr: ERROR: "
+"Thread 'unique-thread' has unmerged work. Use --force to combine anyway.\n",
+            err)
+        self.assertEqual(unique_revid, tree.last_revision())
+        self.assertEqual('unique-thread', tree.branch.nick)
+
     def test_combine_last_two_threads(self):
         """Doing a combine on two threads gives you just the bottom one."""
         tree, loom_tree = self.get_two_thread_loom()
 
=== modified file 'tests/test_branch.py'
--- tests/test_branch.py	2008-11-24 16:38:16 +0000
+++ tests/test_branch.py	2010-08-05 18:57:44 +0000
@@ -23,6 +23,7 @@
 from bzrlib.branch import Branch
 import bzrlib.errors as errors
 from bzrlib.plugins.loom.branch import (
+    AlreadyLoom,
     EMPTY_REVISION,
     loomify,
     require_loom_branch,
@@ -33,7 +34,10 @@
 from bzrlib.plugins.loom.tree import LoomTreeDecorator
 import bzrlib.revision
 from bzrlib.revision import NULL_REVISION
-from bzrlib.tests import TestCaseWithTransport
+from bzrlib.tests import (
+    TestCaseWithTransport,
+    test_server,
+    )
 from bzrlib.transport import get_transport
 from bzrlib.workingtree import WorkingTree
 
@@ -48,11 +52,18 @@
         self.assertFileEqual('Loom current 1\n\n', '.bzr/branch/last-loom')
 
 
+
+class StubFormat(object):
+
+    def network_name(self):
+        return "Nothing to see."
+
+
 class LockableStub(object):
 
     def __init__(self):
         self._calls = []
-        self._format = "Nothing to see."
+        self._format = StubFormat()
 
     def lock_write(self):
         self._calls.append(("write",))
@@ -67,8 +78,7 @@
         branch = self.make_branch('.')
         self.assertRaises(NotALoom, require_loom_branch, branch)
 
-
-    def works_on_loom(self, format):
+    def works_on_format(self, format):
         branch = self.make_branch('.', format)
         loomify(branch)
         # reopen it
@@ -76,13 +86,19 @@
         self.assertEqual(None, require_loom_branch(branch))
 
     def test_works_on_loom1(self):
-        self.works_on_loom('knit')
+        self.works_on_format('knit')
 
     def test_works_on_loom6(self):
-        self.works_on_loom('pack-0.92')
+        self.works_on_format('pack-0.92')
 
     def test_works_on_loom7(self):
-        self.works_on_loom('1.6')
+        self.works_on_format('1.6')
+
+    def test_no_harm_to_looms(self):
+        branch = self.make_branch('.')
+        loomify(branch)
+        branch = branch.bzrdir.open_branch()
+        self.assertRaises(AlreadyLoom, loomify, branch)
 
 
 class TestLoomify(TestCaseWithTransport):
@@ -132,6 +148,7 @@
             bzrlib.plugins.loom.branch.LoomBranch7,
             bzrlib.plugins.loom.branch.BzrBranchLoomFormat7)
 
+
 class TestLoom(TestCaseWithLoom):
 
     def make_loom(self, path):
@@ -184,9 +201,9 @@
         tree.branch.new_thread('baseline')
         tree.branch.new_thread('middlepoint')
         tree.branch.new_thread('endpoint')
-        tree.branch.nick = 'middlepoint'
+        tree.branch._set_nick('middlepoint')
         rev_id2 = tree.commit('middle', allow_pointless=True)
-        tree.branch.nick = 'endpoint'
+        tree.branch._set_nick('endpoint')
         rev_id3 = tree.commit('end', allow_pointless=True)
         tree.branch.new_thread('afterbase', 'baseline')
         tree.branch.new_thread('aftermiddle', 'middlepoint')
@@ -209,7 +226,7 @@
         tree = self.get_tree_with_one_commit()
         tree.branch.new_thread('baseline')
         tree.branch.new_thread('tail')
-        tree.branch.nick = 'baseline'
+        tree.branch._set_nick('baseline')
         first_rev = tree.last_revision()
         # lock the tree to prevent unlock triggering implicit record
         tree.lock_write()
@@ -230,7 +247,7 @@
 
     def test_clone_empty_loom(self):
         source_tree = self.get_tree_with_loom('source')
-        source_tree.branch.nick = 'source'
+        source_tree.branch._set_nick('source')
         target_tree = source_tree.bzrdir.clone('target').open_workingtree()
         self.assertLoomSproutedOk(source_tree, target_tree)
 
@@ -244,7 +261,7 @@
         source_tree = self.get_tree_with_one_commit('source')
         source_tree.branch.new_thread('bottom')
         source_tree.branch.new_thread('top')
-        source_tree.branch.nick = 'top'
+        source_tree.branch._set_nick('top')
         source_tree.commit('phwoar', allow_pointless=True)
         source_tree.branch.record_loom('commit to loom')
         target_tree = source_tree.bzrdir.clone('target').open_workingtree()
@@ -252,23 +269,33 @@
 
     def test_clone_nonempty_loom_bottom(self):
         """Cloning loom should reset the current loom pointer."""
+        self.make_and_clone_simple_loom()
+
+    def make_and_clone_simple_loom(self):
         source_tree = self.get_tree_with_one_commit('source')
         source_tree.branch.new_thread('bottom')
         source_tree.branch.new_thread('top')
-        source_tree.branch.nick = 'top'
+        source_tree.branch._set_nick('top')
         source_tree.commit('phwoar', allow_pointless=True)
         source_tree.branch.record_loom('commit to loom')
         LoomTreeDecorator(source_tree).down_thread()
-        # now clone
-        target_tree = source_tree.bzrdir.clone('target').open_workingtree()
+        # now clone from the 'default url' - transport_server rather than
+        # vfs_server.
+        source_branch = Branch.open(self.get_url('source'))
+        target_tree = source_branch.bzrdir.sprout('target').open_workingtree()
         self.assertLoomSproutedOk(source_tree, target_tree)
 
+    def test_sprout_remote_loom(self):
+        # RemoteBranch should permit sprouting properly.
+        self.transport_server = test_server.SmartTCPServer_for_testing
+        self.make_and_clone_simple_loom()
+
     def test_sprout_nonempty_loom_bottom(self):
         """Sprouting always resets the loom to the top."""
         source_tree = self.get_tree_with_one_commit('source')
         source_tree.branch.new_thread('bottom')
         source_tree.branch.new_thread('top')
-        source_tree.branch.nick = 'top'
+        source_tree.branch._set_nick('top')
         source_tree.commit('phwoar', allow_pointless=True)
         source_tree.branch.record_loom('commit to loom')
         LoomTreeDecorator(source_tree).down_thread()
@@ -322,10 +349,10 @@
         source = self.get_tree_with_loom('source')
         source.branch.new_thread('bottom')
         source.branch.new_thread('top')
-        source.branch.nick = 'bottom'
+        source.branch._set_nick('bottom')
         source.branch.record_loom('commit to loom')
         target = source.bzrdir.sprout('target').open_branch()
-        target.nick = 'top'
+        target._set_nick('top')
         # put a commit in the bottom and top of this loom
         bottom_rev1 = source.commit('commit my arse')
         source_loom_tree = LoomTreeDecorator(source)
@@ -355,14 +382,20 @@
         
     def test_pull_into_empty_loom(self):
         """Doing a pull into a loom with no loom revisions works."""
+        self.pull_into_empty_loom()
+
+    def pull_into_empty_loom(self):
         source = self.get_tree_with_loom('source')
         target = source.bzrdir.sprout('target').open_branch()
         source.branch.new_thread('a thread')
-        source.branch.nick = 'a thread'
+        source.branch._set_nick('a thread')
         # put a commit in the thread for source.
         bottom_rev1 = source.commit('commit a thread')
         source.branch.record_loom('commit to loom')
-        target.pull(source.branch)
+        # now pull from the 'default url' - transport_server rather than
+        # vfs_server - this may be a RemoteBranch.
+        source_branch = Branch.open(self.get_url('source'))
+        target.pull(source_branch)
         # check loom threads
         threads = target.get_loom_state().get_threads()
         self.assertEqual(
@@ -374,12 +407,17 @@
             self.assertTrue(target.repository.has_revision(rev_id))
         self.assertEqual(source.branch.loom_parents(), target.loom_parents())
 
+    def test_pull_remote_loom(self):
+        # RemoteBranch should permit sprouting properly.
+        self.transport_server = test_server.SmartTCPServer_for_testing
+        self.pull_into_empty_loom()
+
     def test_pull_thread_at_null(self):
         """Doing a pull when the source loom has a thread with no history."""
         source = self.get_tree_with_loom('source')
         target = source.bzrdir.sprout('target').open_branch()
         source.branch.new_thread('a thread')
-        source.branch.nick = 'a thread'
+        source.branch._set_nick('a thread')
         source.branch.record_loom('commit to loom')
         target.pull(source.branch)
         # check loom threads
@@ -398,10 +436,10 @@
         source = self.get_tree_with_loom('source')
         source.branch.new_thread('bottom')
         source.branch.new_thread('top')
-        source.branch.nick = 'bottom'
+        source.branch._set_nick('bottom')
         source.branch.record_loom('commit to loom')
         target = source.bzrdir.sprout('target').open_branch()
-        target.nick = 'top'
+        target._set_nick('top')
         # put a commit in the bottom and top of this loom
         bottom_rev1 = source.commit('commit bottom')
         source_loom_tree = LoomTreeDecorator(source)
@@ -432,7 +470,7 @@
     def test_implicit_record(self):
         tree = self.get_tree_with_loom('source')
         tree.branch.new_thread('bottom')
-        tree.branch.nick = 'bottom'
+        tree.branch._set_nick('bottom')
         tree.lock_write()
         try:
             bottom_rev1 = tree.commit('commit my arse')
@@ -453,7 +491,7 @@
         self.assertEqual([], tree.branch.loom_parents())
         # add a thread and record it.
         tree.branch.new_thread('bottom')
-        tree.branch.nick = 'bottom'
+        tree.branch._set_nick('bottom')
         rev_id = tree.branch.record_loom('Setup test loom.')
         # after recording, the parents list should have changed.
         self.assertEqual([rev_id], tree.branch.loom_parents())
@@ -464,7 +502,7 @@
         # new threads
         tree.branch.new_thread('foo')
         tree.branch.new_thread('bar')
-        tree.branch.nick = 'bar'
+        tree.branch._set_nick('bar')
         last_rev = tree.branch.last_revision()
         # and a change to the revision history of this thread
         tree.commit('change bar', allow_pointless=True)
@@ -478,7 +516,7 @@
         # new threads
         tree.branch.new_thread('foo')
         tree.branch.new_thread('bar')
-        tree.branch.nick = 'bar'
+        tree.branch._set_nick('bar')
         # and a change to the revision history of this thread
         tree.commit('change bar', allow_pointless=True)
         # now record
@@ -503,7 +541,7 @@
         # new threads
         tree.branch.new_thread('base')
         tree.branch.new_thread('top')
-        tree.branch.nick = 'top'
+        tree.branch._set_nick('top')
         # and a change to the revision history of this thread
         tree.tree.commit('change top', allow_pointless=True)
         last_rev = tree.branch.last_revision()
@@ -527,7 +565,7 @@
         tree.branch.new_thread('foo')
         tree.branch.new_thread('bar')
         # do a commit, so the last_revision should change.
-        tree.branch.nick = 'bar'
+        tree.branch._set_nick('bar')
         tree.commit('bar-ness', allow_pointless=True)
         tree.branch.revert_thread('bar')
         self.assertEqual(
@@ -540,11 +578,11 @@
         # ensure we have some stuff to revert
         tree.branch.new_thread('foo')
         tree.branch.new_thread('bar')
-        tree.branch.nick = 'foo'
+        tree.branch._set_nick('foo')
         # record the loom to put the threads in the basis
         tree.branch.record_loom('record it!')
         # do a commit, so the last_revision should change.
-        tree.branch.nick = 'bar'
+        tree.branch._set_nick('bar')
         tree.commit('bar-ness', allow_pointless=True)
         tree.branch.revert_thread('bar')
         self.assertEqual(
@@ -558,7 +596,7 @@
         tree = self.get_tree_with_loom()
         tree.branch.new_thread('bar')
         tree.branch.new_thread('foo')
-        tree.branch.nick = 'bar'
+        tree.branch._set_nick('bar')
         tree.branch.remove_thread('foo')
         state = tree.branch.get_loom_state()
         self.assertEqual([('bar', 'empty:', [])], state.get_threads())
@@ -569,17 +607,17 @@
         self.assertEqual([], tree.branch.get_threads(NULL_REVISION))
         # and loom history should make no difference:
         tree.branch.new_thread('foo')
-        tree.branch.nick = 'foo'
+        tree.branch._set_nick('foo')
         tree.branch.record_loom('foo')
         self.assertEqual([], tree.branch.get_threads(NULL_REVISION))
 
     def get_multi_threaded(self):
         tree = self.get_tree_with_loom()
         tree.branch.new_thread('thread1')
-        tree.branch.nick = 'thread1'
+        tree.branch._set_nick('thread1')
         tree.commit('thread1', rev_id='thread1-id')
         tree.branch.new_thread('thread2', 'thread1')
-        tree.branch.nick = 'thread2'
+        tree.branch._set_nick('thread2')
         tree.commit('thread2', rev_id='thread2-id')
         return tree
 
@@ -635,3 +673,14 @@
         export_branch = Branch.open_from_transport(
             root_transport.clone('thread1'))
         self.assertEqual('thread1-id', export_branch.last_revision())
+
+    def test_set_nick_renames_thread(self):
+        tree = self.get_tree_with_loom()
+        tree.branch.new_thread(tree.branch.nick)
+        orig_threads = tree.branch.get_loom_state().get_threads()
+        new_thread_name = 'new thread name'
+        tree.branch.nick = new_thread_name
+        new_threads = tree.branch.get_loom_state().get_threads()
+        self.assertNotEqual(orig_threads, new_threads)
+        self.assertEqual(new_thread_name, new_threads[0][0])
+        self.assertEqual(new_thread_name, tree.branch.nick)
 
=== modified file 'tests/test_revspec.py'
--- tests/test_revspec.py	2008-09-12 01:55:17 +0000
+++ tests/test_revspec.py	2010-08-05 18:57:44 +0000
@@ -19,26 +19,29 @@
 """Tests of the loom revision-specifiers."""
 
 
-import bzrlib
+import bzrlib.errors
 from bzrlib.plugins.loom.branch import NoLowerThread, NoSuchThread
 from bzrlib.plugins.loom.tests import TestCaseWithLoom
 import bzrlib.plugins.loom.tree
 from bzrlib.revisionspec import RevisionSpec
 
 
-class TestThreadRevSpec(TestCaseWithLoom):
-    """Tests of the ThreadRevisionSpecifier."""
-    
+class TestRevSpec(TestCaseWithLoom):
+
     def get_two_thread_loom(self):
         tree = self.get_tree_with_loom('source')
         tree.branch.new_thread('bottom')
         tree.branch.new_thread('top')
-        tree.branch.nick = 'bottom'
+        tree.branch._set_nick('bottom')
         rev_id_bottom = tree.commit('change bottom')
         loom_tree = bzrlib.plugins.loom.tree.LoomTreeDecorator(tree)
         loom_tree.up_thread()
         rev_id_top = tree.commit('change top')
         return tree, loom_tree, rev_id_bottom, rev_id_top
+
+
+class TestThreadRevSpec(TestRevSpec):
+    """Tests of the ThreadRevisionSpecifier."""
     
     def test_thread_colon_at_bottom_errors(self):
         tree, loom_tree, rev_id, _ = self.get_two_thread_loom()
@@ -69,3 +72,44 @@
         loom_tree.down_thread()
         spec = RevisionSpec.from_string('thread:top')
         self.assertEqual(rev_id, spec.as_revision_id(tree.branch))
+
+    def test_thread_on_non_loom_gives_BzrError(self):
+        tree = self.make_branch_and_tree('.')
+        spec = RevisionSpec.from_string('thread:')
+        err = self.assertRaises(bzrlib.errors.BzrError, spec.as_revision_id,
+            tree.branch)
+        self.assertFalse(err.internal_error)
+
+
+class TestBelowRevSpec(TestRevSpec):
+    """Tests of the below: revision specifier."""
+
+    def test_below_gets_tip_of_thread_below(self):
+        tree, loom_tree, _, rev_id = self.get_two_thread_loom()
+        loom_tree.down_thread()
+        expected_id = tree.branch.last_revision()
+        loom_tree.up_thread()
+        spec = RevisionSpec.from_string('below:')
+        self.assertEqual(expected_id, spec.as_revision_id(tree.branch))
+
+    def test_below_on_bottom_thread_gives_BzrError(self):
+        tree, loom_tree, _, rev_id = self.get_two_thread_loom()
+        loom_tree.down_thread()
+        spec = RevisionSpec.from_string('below:')
+        err = self.assertRaises(bzrlib.errors.BzrError, spec.as_revision_id,
+            tree.branch)
+        self.assertFalse(err.internal_error)
+
+    def test_below_named_thread(self):
+        tree, loom_tree, _, rev_id = self.get_two_thread_loom()
+        loom_tree.down_thread()
+        expected_id = tree.branch.last_revision()
+        spec = RevisionSpec.from_string('below:top')
+        self.assertEqual(expected_id, spec.as_revision_id(tree.branch))
+
+    def test_below_on_non_loom_gives_BzrError(self):
+        tree = self.make_branch_and_tree('.')
+        spec = RevisionSpec.from_string('below:')
+        err = self.assertRaises(bzrlib.errors.BzrError, spec.as_revision_id,
+            tree.branch)
+        self.assertFalse(err.internal_error)
 
=== modified file 'tests/test_tree.py'
--- tests/test_tree.py	2008-11-24 16:38:16 +0000
+++ tests/test_tree.py	2010-08-05 18:57:44 +0000
@@ -38,14 +38,14 @@
         tree = self.get_tree_with_loom('source')
         tree.branch.new_thread('bottom')
         tree.branch.new_thread('top')
-        tree.branch.nick = 'bottom'
+        tree.branch._set_nick('bottom')
         return bzrlib.plugins.loom.tree.LoomTreeDecorator(tree)
 
     def test_down_thread(self):
         tree = self.get_tree_with_loom('source')
         tree.branch.new_thread('bottom')
         tree.branch.new_thread('top')
-        tree.branch.nick = 'top'
+        tree.branch._set_nick('top')
         loom_tree = bzrlib.plugins.loom.tree.LoomTreeDecorator(tree)
         loom_tree.down_thread()
         self.assertEqual('bottom', tree.branch.nick)
@@ -53,7 +53,7 @@
     def _add_thread(self, tree, name):
         """Create a new thread with a commit and return the commit id."""
         tree.branch.new_thread(name)
-        tree.branch.nick = name
+        tree.branch._set_nick(name)
         return tree.commit(name)
 
     def test_down_named_thread(self):
@@ -78,7 +78,7 @@
         tree = self.get_tree_with_loom('tree')
         tree.branch.new_thread('bottom')
         tree.branch.new_thread('top')
-        tree.branch.nick = 'bottom'
+        tree.branch._set_nick('bottom')
         bottom_rev1 = tree.commit('bottom_commit')
         tree_loom_tree = bzrlib.plugins.loom.tree.LoomTreeDecorator(tree)
         tree_loom_tree.up_thread()
@@ -89,10 +89,10 @@
         """up-thread into a thread that already has this thread is a no-op."""
         tree = self.get_tree_with_loom('tree')
         tree.branch.new_thread('bottom')
-        tree.branch.nick = 'bottom'
+        tree.branch._set_nick('bottom')
         bottom_rev1 = tree.commit('bottom_commit')
         tree.branch.new_thread('top', 'bottom')
-        tree.branch.nick = 'top'
+        tree.branch._set_nick('top')
         top_rev1 = tree.commit('top_commit', allow_pointless=True)
         tree_loom_tree = bzrlib.plugins.loom.tree.LoomTreeDecorator(tree)
         tree_loom_tree.down_thread()
@@ -108,10 +108,10 @@
         """up-thread from a thread with new work."""
         tree = self.get_tree_with_loom('tree')
         tree.branch.new_thread('bottom')
-        tree.branch.nick = 'bottom'
+        tree.branch._set_nick('bottom')
         bottom_rev1 = tree.commit('bottom_commit')
         tree.branch.new_thread('top', 'bottom')
-        tree.branch.nick = 'top'
+        tree.branch._set_nick('top')
         top_rev1 = tree.commit('top_commit', allow_pointless=True)
         tree_loom_tree = bzrlib.plugins.loom.tree.LoomTreeDecorator(tree)
         tree_loom_tree.down_thread()
@@ -144,14 +144,16 @@
         self.build_tree_contents([('source/a', 'c')])
         loom_tree.tree.commit('content to c')
         loom_tree.up_thread(_mod_merge.WeaveMerger)
-        self.failIfExists('source/a.BASE')
+        # Disabled because WeaveMerger writes BASE files now. XXX: Figure out
+        # how to test this actually worked, again.
+        # self.failIfExists('source/a.BASE')
 
     def get_loom_with_three_threads(self):
         tree = self.get_tree_with_loom('source')
         tree.branch.new_thread('bottom')
         tree.branch.new_thread('middle')
         tree.branch.new_thread('top')
-        tree.branch.nick = 'bottom'
+        tree.branch._set_nick('bottom')
         return bzrlib.plugins.loom.tree.LoomTreeDecorator(tree)
 
     def test_up_many(self):
@@ -191,12 +193,26 @@
         self.assertEqual(['middle-1', 'bottom-2'], tree.get_parent_ids())
         self.assertEqual(1, len(tree.conflicts()))
 
+    def test_up_many_target_thread(self):
+        loom_tree = self.get_loom_with_three_threads()
+        tree = loom_tree.tree
+        loom_tree.up_many(target_thread='middle')
+        self.assertEqual('middle', tree.branch.nick)
+
+    def test_up_many_target_thread_lower(self):
+        loom_tree = self.get_loom_with_three_threads()
+        tree = loom_tree.tree
+        loom_tree.up_many(target_thread='top')
+        e = self.assertRaises(errors.BzrCommandError,
+                              loom_tree.up_many, target_thread='middle')
+        self.assertEqual('Cannot up-thread to lower thread.', str(e))
+
     def test_revert_loom(self):
         tree = self.get_tree_with_loom(',')
         # ensure we have some stuff to revert
         tree.branch.new_thread('foo')
         tree.branch.new_thread('bar')
-        tree.branch.nick = 'bar'
+        tree.branch._set_nick('bar')
         tree.commit('change something', allow_pointless=True)
         loom_tree = bzrlib.plugins.loom.tree.LoomTreeDecorator(tree)
         loom_tree.revert_loom()
@@ -211,7 +227,7 @@
         # ensure we have some stuff to revert
         tree.branch.new_thread('foo')
         tree.branch.new_thread('bar')
-        tree.branch.nick = 'bar'
+        tree.branch._set_nick('bar')
         tree.commit('change something', allow_pointless=True)
         loom_tree = bzrlib.plugins.loom.tree.LoomTreeDecorator(tree)
         loom_tree.revert_loom(thread='bar')
@@ -228,7 +244,7 @@
         # ensure we have some stuff to revert
         tree.branch.new_thread('foo')
         tree.branch.new_thread('bar')
-        tree.branch.nick = 'bar'
+        tree.branch._set_nick('bar')
         tree.commit('change something', allow_pointless=True)
         loom_tree = bzrlib.plugins.loom.tree.LoomTreeDecorator(tree)
         loom_tree.revert_loom(thread='foo')
 
=== modified file 'tree.py'
--- tree.py	2008-11-24 16:38:16 +0000
+++ tree.py	2010-08-05 18:57:44 +0000
@@ -24,7 +24,10 @@
 __all__ = ['LoomTreeDecorator']
 
 
-from bzrlib import ui
+from bzrlib import (
+    trace,
+    ui,
+    )
 from bzrlib.decorators import needs_write_lock
 import bzrlib.errors
 import bzrlib.revision
@@ -78,7 +81,7 @@
         graph = self.tree.branch.repository.get_graph()
         # special case no-change condition.
         if new_thread_rev == old_thread_rev:
-            self.tree.branch.nick = new_thread_name
+            self.tree.branch._set_nick(new_thread_name)
             return 0
         if new_thread_rev == EMPTY_REVISION:
             new_thread_rev = bzrlib.revision.NULL_REVISION
@@ -87,19 +90,15 @@
         # merge the tree up into the new patch:
         if merge_type is None:
             merge_type = bzrlib.merge.Merge3Merger
-        pb = ui.ui_factory.nested_progress_bar()
         try:
-            try:
-                merge_controller = bzrlib.merge.Merger.from_revision_ids(
-                    pb, self.tree, new_thread_rev, revision_graph=graph)
-            except bzrlib.errors.UnrelatedBranches:
-                raise bzrlib.errors.BzrCommandError('corrupt loom: thread %s'
-                    ' has no common ancestor with thread %s'
-                    % (new_thread_name, threadname))
-            merge_controller.merge_type = merge_type
-            result = merge_controller.do_merge()
-        finally:
-            pb.finished()
+            merge_controller = bzrlib.merge.Merger.from_revision_ids(
+                None, self.tree, new_thread_rev, revision_graph=graph)
+        except bzrlib.errors.UnrelatedBranches:
+            raise bzrlib.errors.BzrCommandError('corrupt loom: thread %s'
+                ' has no common ancestor with thread %s'
+                % (new_thread_name, threadname))
+        merge_controller.merge_type = merge_type
+        result = merge_controller.do_merge()
         # change the tree to the revision of the new thread.
         parent_trees = []
         if new_thread_rev != bzrlib.revision.NULL_REVISION:
@@ -126,20 +125,37 @@
         # change the branch
         self.tree.branch.generate_revision_history(new_thread_rev)
         # update the branch nick.
-        self.tree.branch.nick = new_thread_name
-        bzrlib.trace.note("Moved to thread '%s'." % new_thread_name)
+        self.tree.branch._set_nick(new_thread_name)
+        trace.note("Moved to thread '%s'." % new_thread_name)
+        if (basis_tree is not None and
+            not result and not
+            self.tree.changes_from(basis_tree).has_changed()):
+            trace.note("This thread is now empty, you may wish to "
+                       'run "bzr combine-thread" to remove it.')
         if result != 0:
             return 1
         else:
             return 0
 
-    def up_many(self, merge_type=None):
-        threads = self.branch.get_loom_state().get_threads()
-        top_thread_name = threads[-1][0]
-        while self.branch.nick != top_thread_name:
+    def up_many(self, merge_type=None, target_thread=None):
+        loom_state = self.branch.get_loom_state()
+        threads = loom_state.get_threads()
+        if target_thread is None:
+            target_thread = threads[-1][0]
+            if self.branch.nick == target_thread:
+                raise bzrlib.errors.BzrCommandError(
+                    'Cannot move up from the highest thread.')
+        else:
+            upper_thread_i = loom_state.thread_index(target_thread)
+            lower_thread_i = loom_state.thread_index(self.branch.nick)
+            if lower_thread_i > upper_thread_i:
+                raise bzrlib.errors.BzrCommandError(
+                    "Cannot up-thread to lower thread.")
+        while self.branch.nick != target_thread:
             old_nick = self.branch.nick
-            if self.up_thread(merge_type) != 0:
-                break
+            result = self.up_thread(merge_type)
+            if result != 0:
+                return result
             if len(self.tree.get_parent_ids()) > 1:
                 self.tree.commit('Merge %s into %s' % (old_nick,
                                                        self.branch.nick))
@@ -147,12 +163,11 @@
     @needs_write_lock
     def down_thread(self, name=None):
         """Move to a thread down in the loom.
-        
+
         :param name: If None, use the next lower thread; otherwise the nae of
             the thread to move to.
         """
         self._check_switch()
-        current_revision = self.tree.last_revision()
         threadname = self.tree.branch.nick
         state = self.tree.branch.get_loom_state()
         threads = state.get_threads()
@@ -168,7 +183,7 @@
             index = state.thread_index(name)
             new_thread_rev = threads[index][1]
         assert new_thread_rev is not None
-        self.tree.branch.nick = new_thread_name
+        self.tree.branch._set_nick(new_thread_name)
         if new_thread_rev == old_thread_rev:
             # fast path no-op changes
             bzrlib.trace.note("Moved to thread '%s'." % new_thread_name)
@@ -177,17 +192,30 @@
             new_thread_rev = bzrlib.revision.NULL_REVISION
         if old_thread_rev == EMPTY_REVISION:
             old_thread_rev = bzrlib.revision.NULL_REVISION
-        basis_tree = self.tree.branch.repository.revision_tree(old_thread_rev)
-        to_tree = self.tree.branch.repository.revision_tree(new_thread_rev)
+        repository = self.tree.branch.repository
+        try:
+            basis_tree = self.tree.revision_tree(old_thread_rev)
+        except bzrlib.errors.NoSuchRevisionInTree:
+            basis_tree = repository.revision_tree(old_thread_rev)
+        to_tree = repository.revision_tree(new_thread_rev)
         result = bzrlib.merge.merge_inner(self.tree.branch,
             to_tree,
             basis_tree,
             this_tree=self.tree)
-        self.tree.branch.generate_revision_history(new_thread_rev)
-        self.tree.set_last_revision(new_thread_rev)
+        branch_revno, branch_revision = self.tree.branch.last_revision_info()
+        graph = repository.get_graph()
+        new_thread_revno = graph.find_distance_to_null(new_thread_rev,
+            [(branch_revision, branch_revno)])
+        self.tree.branch.set_last_revision_info(new_thread_revno,
+                                                new_thread_rev)
+        if new_thread_rev == bzrlib.revision.NULL_REVISION:
+            parent_list = []
+        else:
+            parent_list = [(new_thread_rev, to_tree)]
+        self.tree.set_parent_trees(parent_list)
         bzrlib.trace.note("Moved to thread '%s'." % new_thread_name)
         return result
-        
+
     def lock_write(self):
         self.tree.lock_write()
 
 
=== added file 'version.py'
--- version.py	1970-01-01 00:00:00 +0000
+++ version.py	2010-08-05 18:57:44 +0000
@@ -0,0 +1,28 @@
+# Loom, a plugin for bzr to assist in developing focused patches.
+# Copyright (C) 2010 Canonical Limited.
+# 
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License version 2 as published
+# by the Free Software Foundation.
+# 
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+# 
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
+#
+
+"""Versioning information for bzr-loom."""
+
+__all__ = [
+    'bzr_plugin_version',
+    'bzr_minimum_version',
+    'bzr_maximum_version',
+    ]
+
+bzr_plugin_version = (2, 2, 1, 'dev', 0)
+bzr_minimum_version = (2, 2, 0)
+bzr_maximum_version = None