Merge lp:~mhammond/bzr/update-r into lp:~bzr/bzr/trunk-old

[Mark Hammond]

=== modified file 'NEWS'
--- NEWS	2009-03-24 12:15:01 +0000
+++ NEWS	2009-03-24 21:35:49 +0000
@@ -1,5 +1,6 @@
 ====================
 Bazaar Release Notes
+<<<<<<< TREE
 ====================
 
 
@@ -1944,6 +1945,68 @@
 * Fix a regression in knit => pack fetching.  We had a logic
   inversion, causing the fetch to insert fulltexts in random order,
   rather than preserving deltas.  (John Arbash Meinel, #256757)
+=======
+--------------------
+
+.. contents::
+
+IN DEVELOPMENT
+--------------
+
+  CHANGES:
+
+    * ``bzr export`` can now export a subdirectory of a project.
+      (Robert Collins)
+
+    * ``bzr rm`` will now scan for files that are missing and remove just
+      them automatically, much as ``bzr add`` scans for new files that
+      are not ignored and adds them automatically. (Robert Collins)
+
+  IMPROVEMENTS:
+
+    * ``bzr init`` and ``bzr init-repo`` will now print out the same as
+      ``bzr info`` if it completed successfully.
+      (Marius Kruger)
+
+    * ``bzr uncommit`` logs the old tip revision id, and displays how to
+      restore the branch to that tip using ``bzr pull``.  This allows you
+      to recover if you realize you uncommitted the wrong thing.
+      (John Arbash Meinel)
+
+    * ``bzr update`` now takes a ``--revision`` argument. This lets you
+      change the revision of the working tree to any revision in the
+      ancestry of the current or master branch. (Matthieu Moy, #45719)
+
+  BUG FIXES:
+
+    * ``bzr rm`` is now aliased to ``bzr del`` for the convenience of svn
+      users. (Robert Collins, #205416)
+
+    * ``WorkingTree4`` trees will now correctly report missing-and-new
+      paths in the output of ``iter_changes``. (Robert Collins)
+
+  API CHANGES:
+
+    * Exporters now take 4 parameters. (Robert Collins)
+
+    * ``Tree.iter_changes`` will now return False for the content change
+      field when a file is missing in the basis tree and not present in
+      the target tree. Previously it returned True unconditionally.
+      (Robert Collins)
+
+  TESTING:
+
+    * ``addCleanup`` now takes ``*arguments`` and ``**keyword_arguments``
+      which are then passed to the cleanup callable as it is run. In
+      addition, addCleanup no longer requires that the callables passed to
+      it be unique. (Jonathan Lange)
+
+  INTERNALS:
+
+    * ``bzrlib.diff.DiffTree.show_diff`` now skips changes where the kind
+      is unknown in both source and target.
+      (Robert Collins, Aaron Bentley)
+>>>>>>> MERGE-SOURCE
 
 
 bzr 1.6rc3 2008-08-14
 
=== modified file 'bzrlib/builtins.py'
--- bzrlib/builtins.py	2009-03-24 12:15:01 +0000
+++ bzrlib/builtins.py	2009-03-24 21:35:49 +0000
@@ -1239,12 +1239,17 @@
 
     _see_also = ['pull', 'working-trees', 'status-flags']
     takes_args = ['dir?']
+    takes_options = ['revision']
     aliases = ['up']
 
-    def run(self, dir='.'):
+    def run(self, dir='.', revision=None):
+        if revision is not None and len(revision) != 1:
+            raise errors.BzrCommandError(
+                        "bzr update --revision takes exactly one revision")
         tree = WorkingTree.open_containing(dir)[0]
+        branch = tree.branch
         possible_transports = []
-        master = tree.branch.get_master_branch(
+        master = branch.get_master_branch(
             possible_transports=possible_transports)
         if master is not None:
             tree.lock_write()
@@ -1252,6 +1257,7 @@
             tree.lock_tree_write()
         try:
             existing_pending_merges = tree.get_parent_ids()[1:]
+<<<<<<< TREE
             last_rev = _mod_revision.ensure_null(tree.last_revision())
             if last_rev == _mod_revision.ensure_null(
                 tree.branch.last_revision()):
@@ -1267,6 +1273,44 @@
                 view_info=view_info), possible_transports=possible_transports)
             revno = tree.branch.revision_id_to_revno(
                 _mod_revision.ensure_null(tree.last_revision()))
+=======
+            # potentially get new revisions from the master branch.
+            # needed for the case where -r N is given, with N not yet
+            # in the local branch for a heavyweight checkout.
+            if revision is not None:
+                try:
+                    rev = revision[0].in_history(branch).rev_id
+                    # no need to run branch.update()
+                    old_tip = None
+                except (errors.NoSuchRevision, errors.InvalidRevisionSpec):
+                    # revision was not there, but is maybe in the master.
+                    old_tip = branch.update(possible_transports)
+                    rev = revision[0].in_history(branch).rev_id
+            else:
+                if master is None:
+                    old_tip = None
+                else:
+                    old_tip = branch.update(possible_transports)
+                rev = branch.last_revision()
+            if rev == _mod_revision.ensure_null(tree.last_revision()):
+                revno = branch.revision_id_to_revno(rev)
+                note("Tree is up to date at revision %d." % (revno,))
+                return 0
+            try:
+                conflicts = tree.update(
+                    delta._ChangeReporter(unversioned_filter=tree.is_ignored),
+                    possible_transports=possible_transports,
+                    revision=rev,
+                    old_tip=old_tip)
+            except errors.NoSuchRevision, e:
+                raise errors.BzrCommandError(
+                                      "branch has no revision %s\n"
+                                      "bzr update --revision only works"
+                                      " for a revision in the branch history"
+                                      % (e.revision))
+            revno = branch.revision_id_to_revno(
+                _mod_revision.ensure_null(rev))
+>>>>>>> MERGE-SOURCE
             note('Updated to revision %d.' % (revno,))
             if tree.get_parent_ids()[1:] != existing_pending_merges:
                 note('Your local commits will now show as pending merges with '
 
=== modified file 'bzrlib/tests/blackbox/test_update.py'
--- bzrlib/tests/blackbox/test_update.py	2009-03-23 14:59:43 +0000
+++ bzrlib/tests/blackbox/test_update.py	2009-03-24 21:35:49 +0000
@@ -209,3 +209,74 @@
                                                    lightweight=True)
         tree.commit('empty commit')
         self.run_bzr('update checkout')
+
+    def test_update_dash_r(self):
+        # Test that 'bzr update' works correctly when you have
+        # an update in the master tree, and a lightweight checkout
+        # which has merged another branch
+        master = self.make_branch_and_tree('master')
+        os.chdir('master')
+        self.build_tree(['./file1'])
+        master.add(['file1'])
+        master.commit('one', rev_id='m1')
+        self.build_tree(['./file2'])
+        master.add(['file2'])
+        master.commit('two', rev_id='m2')
+
+        out, err = self.run_bzr('update -r 1')
+        self.assertEqual('', out)
+        self.assertEqual('-D  file2\nAll changes applied successfully.\n'
+                         'Updated to revision 1.\n', err)
+        self.failUnlessExists('./file1')
+        self.failIfExists('./file2')
+        # hrm - the below doesn't look correct for all formats...
+        #self.check_file_contents('.bzr/checkout/last-revision',
+        #                         'm1')
+
+    def test_update_dash_r_outside_history(self):
+        # Test that 'bzr update' works correctly when you have
+        # an update in the master tree, and a lightweight checkout
+        # which has merged another branch
+        master = self.make_branch_and_tree('master')
+        self.build_tree(['master/file1'])
+        master.add(['file1'])
+        master.commit('one', rev_id='m1')
+
+        # Create a second branch, with an extra commit
+        other = master.bzrdir.sprout('other').open_workingtree()
+        self.build_tree(['other/file2'])
+        other.add(['file2'])
+        other.commit('other2', rev_id='o2')
+
+        os.chdir('master')
+        self.run_bzr('merge ../other')
+        master.commit('merge', rev_id='merge')
+
+        out, err = self.run_bzr('update -r revid:o2',
+                                retcode=3)
+        self.assertEqual('', out)
+        self.assertEqual('bzr: ERROR: branch has no revision o2\n'
+                         'bzr update --revision only works'
+                         ' for a revision in the branch history\n',
+                         err)
+
+    def test_update_dash_r_in_master(self):
+        # Test that 'bzr update' works correctly when you have
+        # an update in the master tree,
+        master = self.make_branch_and_tree('master')
+        self.build_tree(['master/file1'])
+        master.add(['file1'])
+        master.commit('one', rev_id='m1')
+
+        self.run_bzr('checkout master checkout')
+
+        # add a revision in the master.
+        self.build_tree(['master/file2'])
+        master.add(['file2'])
+        master.commit('two', rev_id='m2')
+
+        os.chdir('checkout')
+        out, err = self.run_bzr('update -r revid:m2')
+        self.assertEqual('', out)
+        self.assertEqual('+N  file2\nAll changes applied successfully.\n'
+                         'Updated to revision 2.\n', err)
 
=== modified file 'bzrlib/workingtree.py'
--- bzrlib/workingtree.py	2009-03-23 14:59:43 +0000
+++ bzrlib/workingtree.py	2009-03-24 21:35:49 +0000
@@ -2134,7 +2134,10 @@
         """
         raise NotImplementedError(self.unlock)
 
-    def update(self, change_reporter=None, possible_transports=None):
+    _marker = object()
+
+    def update(self, change_reporter=None, possible_transports=None,
+               revision=None, old_tip=_marker):
         """Update a working tree along its branch.
 
         This will update the branch if its bound too, which means we have
@@ -2158,10 +2161,16 @@
         - Merge current state -> basis tree of the master w.r.t. the old tree
           basis.
         - Do a 'normal' merge of the old branch basis if it is relevant.
+
+        :param revision: The target revision to update to. Must be in the
+            revision history.
+        :param old_tip: If branch.update() has already been run, the value it
+            returned (old tip of the branch or None). _marker is used
+            otherwise.
         """
         if self.branch.get_bound_location() is not None:
             self.lock_write()
-            update_branch = True
+            update_branch = (old_tip is self._marker)
         else:
             self.lock_tree_write()
             update_branch = False
@@ -2169,13 +2178,14 @@
             if update_branch:
                 old_tip = self.branch.update(possible_transports)
             else:
-                old_tip = None
-            return self._update_tree(old_tip, change_reporter)
+                if old_tip is self._marker:
+                    old_tip = None
+            return self._update_tree(old_tip, change_reporter, revision)
         finally:
             self.unlock()
 
     @needs_tree_write_lock
-    def _update_tree(self, old_tip=None, change_reporter=None):
+    def _update_tree(self, old_tip=None, change_reporter=None, revision=None):
         """Update a tree to the master branch.
 
         :param old_tip: if supplied, the previous tip revision the branch,
@@ -2196,12 +2206,17 @@
             last_rev = self.get_parent_ids()[0]
         except IndexError:
             last_rev = _mod_revision.NULL_REVISION
-        if last_rev != _mod_revision.ensure_null(self.branch.last_revision()):
-            # merge tree state up to new branch tip.
+        if revision is None:
+            revision = self.branch.last_revision()
+        else:
+            if revision not in self.branch.revision_history():
+                raise errors.NoSuchRevision(self.branch, revision)
+        if last_rev != _mod_revision.ensure_null(revision):
+            # merge tree state up to specified revision.
             basis = self.basis_tree()
             basis.lock_read()
             try:
-                to_tree = self.branch.basis_tree()
+                to_tree = self.branch.repository.revision_tree(revision)
                 if basis.inventory.root is None:
                     self.set_root_id(to_tree.get_root_id())
                     self.flush()
@@ -2211,14 +2226,15 @@
                                       basis,
                                       this_tree=self,
                                       change_reporter=change_reporter)
+                self.set_last_revision(revision)
             finally:
                 basis.unlock()
             # TODO - dedup parents list with things merged by pull ?
             # reuse the tree we've updated to to set the basis:
-            parent_trees = [(self.branch.last_revision(), to_tree)]
+            parent_trees = [(revision, to_tree)]
             merges = self.get_parent_ids()[1:]
             # Ideally we ask the tree for the trees here, that way the working
-            # tree can decide whether to give us teh entire tree or give us a
+            # tree can decide whether to give us the entire tree or give us a
             # lazy initialised tree. dirstate for instance will have the trees
             # in ram already, whereas a last-revision + basis-inventory tree
             # will not, but also does not need them when setting parents.
@@ -2251,8 +2267,7 @@
             #       should be able to remove this extra flush.
             self.flush()
             graph = self.branch.repository.get_graph()
-            base_rev_id = graph.find_unique_lca(self.branch.last_revision(),
-                                                old_tip)
+            base_rev_id = graph.find_unique_lca(revision, old_tip)
             base_tree = self.branch.repository.revision_tree(base_rev_id)
             other_tree = self.branch.repository.revision_tree(old_tip)
             result += merge.merge_inner(