Merge lp:~jelmer/bzr-builddeb/version-as-revisions into lp:bzr-builddeb

[Jelmer Vernooij]

Change the UpstreamSource API to support providing multiple upstream revisions - in case there are multiple components.

[James Westby (james-w)]

review: Approve

=== modified file 'cmds.py'
--- cmds.py	2011-09-09 13:20:42 +0000
+++ cmds.py	2011-09-26 22:30:28 +0000
@@ -556,7 +556,7 @@
                     'entry yourself, review the merge, and then commit.')
 
     def _do_merge(self, tree, tarball_filenames, package, version,
-            current_version, upstream_branch, upstream_revision, merge_type,
+            current_version, upstream_branch, upstream_revisions, merge_type,
             force):
         db = DistributionBranch(tree.branch, tree.branch, tree=tree)
         dbs = DistributionBranchSet()
@@ -565,7 +565,7 @@
                 in tarball_filenames]
         conflicts = db.merge_upstream(tarballs, package, version,
                 current_version, upstream_branch=upstream_branch,
-                upstream_revision=upstream_revision,
+                upstream_revisions=upstream_revisions,
                 merge_type=merge_type, force=force)
         return conflicts
 
@@ -712,15 +712,15 @@
                     raise BzrCommandError("merge-upstream takes only a "
                         "single --revision")
                 upstream_revspec = revision[0]
-                upstream_revision = upstream_revspec.as_revision_id(
-                    upstream_branch)
+                upstream_revisions = { None: upstream_revspec.as_revision_id(
+                    upstream_branch) }
             else:
-                upstream_revision = None
+                upstream_revisions = None
 
-            if version is None and upstream_revision is not None:
+            if version is None and upstream_revisions is not None:
                 # Look up the version from the upstream revision
                 version = upstream_branch_source.get_version(package,
-                    current_version, upstream_revision)
+                    current_version, upstream_revisions)
             elif version is None and primary_upstream_source is not None:
                 version = primary_upstream_source.get_latest_version(
                     package, current_version)
@@ -735,9 +735,9 @@
             assert isinstance(version, str)
             note("Using version string %s." % (version))
             # Look up the revision id from the version string
-            if upstream_revision is None and upstream_branch_source is not None:
+            if upstream_revisions is None and upstream_branch_source is not None:
                 try:
-                    upstream_revision = upstream_branch_source.version_as_revision(
+                    upstream_revisions = upstream_branch_source.version_as_revisions(
                         package, version)
                 except PackageVersionNotPresent:
                     raise BzrCommandError(
@@ -753,10 +753,10 @@
                 v3 = (source_format in [
                     FORMAT_3_0_QUILT, FORMAT_3_0_NATIVE])
                 tarball_filenames = self._get_tarballs(config, tree, package,
-                    version, upstream_branch, upstream_revision, v3,
+                    version, upstream_branch, upstream_revisions, v3,
                     locations)
                 conflicts = self._do_merge(tree, tarball_filenames, package,
-                    version, current_version, upstream_branch, upstream_revision,
+                    version, current_version, upstream_branch, upstream_revisions,
                     merge_type, force)
             if (current_version is not None and
                 Version(current_version) >= Version(version)):
@@ -886,9 +886,9 @@
                             "sure it is tagged as %r." % (last_version,
                                     db.pristine_upstream_source.tag_name(
                                         last_version.upstream_version)))
-                    upstream_tip = db.pristine_upstream_source.version_as_revision(
+                    upstream_tips = db.pristine_upstream_source.version_as_revisions(
                         changelog.package, last_version.upstream_version)
-                    db.extract_upstream_tree(upstream_tip, tempdir)
+                    db.extract_upstream_tree(upstream_tips, tempdir)
                 else:
                     db._create_empty_upstream_tree(tempdir)
                 self.import_many(db, files_list, orig_target)
@@ -966,7 +966,7 @@
             if upstream is not None:
                 # See bug lp:309682
                 upstream.repository.fetch(branch.repository, parents[0])
-            db.extract_upstream_tree(parents[0], tempdir)
+            db.extract_upstream_tree({ None: parents[0] }, tempdir)
         else:
             db._create_empty_upstream_tree(tempdir)
         tree = db.branch.basis_tree()
@@ -983,7 +983,7 @@
         tarballs = [(location, None, md5sum_filename(location))]
         for (component, tag_name, revid) in db.import_upstream_tarballs(
                 tarballs, None, version, parents, upstream_branch=upstream,
-                upstream_revision=upstream_revid):
+                upstream_revisions={ None: upstream_revid }):
             if component is None:
                 self.outf.write('Imported %s as tag:%s.\n' % (
                     location, tag_name))

=== modified file 'import_dsc.py'
--- import_dsc.py	2011-09-09 13:20:42 +0000
+++ import_dsc.py	2011-09-26 22:30:28 +0000
@@ -60,6 +60,7 @@
 
 from bzrlib.plugins.builddeb.bzrtools_import import import_dir
 from bzrlib.plugins.builddeb.errors import (
+    MultipleUpstreamTarballsNotSupported,
     PackageVersionNotPresent,
     UpstreamAlreadyImported,
     UpstreamBranchAlreadyMerged,
@@ -556,6 +557,7 @@
                 tarballs=upstream_tarballs):
             return False
 
+
         up_branch = self.pristine_upstream_branch
         up_branch.lock_read()
         try:
@@ -563,10 +565,14 @@
             other_up_branch = branch.pristine_upstream_branch
             other_up_branch.lock_read()
             try:
+                pristine_upstream_revids = branch.pristine_upstream_source.version_as_revisions(package, version)
+                if pristine_upstream_revids.keys() != [None]:
+                    raise MultipleUpstreamTarballsNotSupported()
+                pristine_upstream_revid = pristine_upstream_revids[None]
                 graph = other_up_branch.repository.get_graph(
                         up_branch.repository)
                 return graph.is_ancestor(up_branch.last_revision(),
-                        branch.pristine_upstream_source.version_as_revision(package, version))
+                        pristine_upstream_revid)
             finally:
                 other_up_branch.unlock()
         finally:
@@ -680,7 +686,11 @@
         :param version: the upstream version string
         """
         assert isinstance(version, str)
-        pull_revision = pull_branch.pristine_upstream_source.version_as_revision(package, version)
+        pull_revisions = pull_branch.pristine_upstream_source.version_as_revisions(
+            package, version)
+        if pull_revisions.keys() != [None]:
+            raise MultipleUpstreamTarballsNotSupported()
+        pull_revision = pull_revisions[None]
         mutter("Pulling upstream part of %s from revision %s" % \
                 (version, pull_revision))
         assert self.pristine_upstream_tree is not None, \
@@ -774,12 +784,17 @@
                     break
         real_parents = [p[2] for p in parents]
         if need_upstream_parent:
-            parent_revid = self.pristine_upstream_source.version_as_revision(package,
+            upstream_revids = self.pristine_upstream_source.version_as_revisions(package,
                 version.upstream_version, tarballs)
-            if len(parents) > 0:
-                real_parents.insert(1, parent_revid)
-            else:
-                real_parents = [parent_revid]
+            def key(a):
+                if a is None:
+                    return None
+                return a
+            for component in sorted(upstream_revids.keys(), key=key):
+                if len(real_parents) > 0:
+                    real_parents.insert(1, upstream_revids[component])
+                else:
+                    real_parents = [upstream_revids[component]]
         return real_parents
 
     def _fetch_upstream_to_branch(self, revid):
@@ -793,7 +808,7 @@
 
     def import_upstream(self, upstream_part, package, version, upstream_parents,
             upstream_tarballs, upstream_branch=None,
-            upstream_revision=None, timestamp=None, author=None,
+            upstream_revisions=None, timestamp=None, author=None,
             file_ids_from=None):
         """Import an upstream part on to the upstream branch.
 
@@ -821,18 +836,23 @@
         other_branches = self.get_other_branches()
         ret = []
         for (tarball, component, md5) in upstream_tarballs:
+            if upstream_revisions is not None:
+                revid = upstream_revisions[component]
+            else:
+                revid = None
             upstream_trees = [o.pristine_upstream_branch.basis_tree()
                 for o in other_branches]
             target_tree = None
             if upstream_branch is not None:
-                if upstream_revision is None:
-                    upstream_revision = upstream_branch.last_revision()
+                if revid is None:
+                    # FIXME: This is wrong for component tarballs
+                    revid = upstream_branch.last_revision()
                 self.pristine_upstream_branch.fetch(upstream_branch,
-                        last_revision=upstream_revision)
+                        last_revision=revid)
                 upstream_branch.tags.merge_to(self.pristine_upstream_branch.tags)
-                upstream_parents.append(upstream_revision)
+                upstream_parents.append(revid)
                 target_tree = self.pristine_upstream_branch.repository.revision_tree(
-                            upstream_revision)
+                            revid)
             if file_ids_from is not None:
                 upstream_trees = file_ids_from + upstream_trees
             if self.tree:
@@ -858,15 +878,16 @@
             finally:
                 self_tree.unlock()
             (tag, revid) = self.pristine_upstream_source.import_component_tarball(
-                package, version, self.pristine_upstream_tree, upstream_parents, component,
-                md5, tarball, author=author, timestamp=timestamp)
+                package, version, self.pristine_upstream_tree, upstream_parents,
+                component, md5, tarball, author=author, timestamp=timestamp)
+            self.pristine_upstream_branch.generate_revision_history(revid)
             ret.append((component, tag, revid))
             self.branch.fetch(self.pristine_upstream_branch)
             self.branch.tags.set_tag(tag, revid)
         return ret
 
     def import_upstream_tarballs(self, tarballs, package, version, parents,
-        upstream_branch=None, upstream_revision=None):
+        upstream_branch=None, upstream_revisions=None):
         """Import an upstream part to the upstream branch.
 
         :param tarballs: List of tarballs / components to extract
@@ -876,7 +897,7 @@
             parents.
         :param upstream_branch: An upstream branch to associate with the
             tarball.
-        :param upstream_revision: Upstream revision id
+        :param upstream_revisions: Upstream revision ids dictionary
         :param md5sum: hex digest of the md5sum of the tarball, if known.
         :return: list with (component, tag, revid) tuples
         """
@@ -885,7 +906,7 @@
             return self.import_upstream(tarball_dir, package, version, parents,
                 tarballs,
                 upstream_branch=upstream_branch,
-                upstream_revision=upstream_revision)
+                upstream_revisions=upstream_revisions)
         finally:
             shutil.rmtree(tarball_dir)
 
@@ -1052,8 +1073,11 @@
                 pull_branch = pull_parents[1][0]
                 pull_version = pull_parents[1][1]
             if not pull_branch.is_version_native(pull_version):
-                pull_revid = pull_branch.pristine_upstream_source.version_as_revision(
+                pull_revids = pull_branch.pristine_upstream_source.version_as_revisions(
                     package, pull_version.upstream_version)
+                if pull_revids.keys() != [None]:
+                    raise MultipleUpstreamTarballsNotSupported()
+                pull_revid = pull_revids[None]
                 mutter("Initialising upstream from %s, version %s",
                     str(pull_branch), str(pull_version))
                 parents.append(pull_revid)
@@ -1245,16 +1269,16 @@
         finally:
             extractor.cleanup()
 
-    def extract_upstream_tree(self, upstream_tip, basedir):
+    def extract_upstream_tree(self, upstream_tips, basedir):
         """Extract upstream_tip to a tempdir as a working tree."""
         # TODO: should stack rather than trying to use the repository,
         # as that will be more efficient.
-        # TODO: remove the _extract_upstream_tree alias below.
         to_location = os.path.join(basedir, "upstream")
         # Use upstream_branch if it has been set, otherwise self.branch.
         source_branch = self.pristine_upstream_branch or self.branch
+        assert upstream_tips.keys() == [None]
         dir_to = source_branch.bzrdir.sprout(to_location,
-                revision_id=upstream_tip,
+                revision_id=upstream_tips[None],
                 accelerator_tree=self.tree)
         try:
             self.pristine_upstream_tree = dir_to.open_workingtree()
@@ -1263,8 +1287,6 @@
             self.pristine_upstream_tree = dir_to.create_workingtree()
         self.pristine_upstream_branch = self.pristine_upstream_tree.branch
 
-    _extract_upstream_tree = extract_upstream_tree
-
     def _create_empty_upstream_tree(self, basedir):
         to_location = os.path.join(basedir, "upstream")
         to_transport = get_transport(to_location)
@@ -1314,7 +1336,7 @@
         assert isinstance(previous_version, str), \
             "Should pass upstream version as str, not Version."
         try:
-            upstream_tip = self.pristine_upstream_source.version_as_revision(
+            upstream_tips = self.pristine_upstream_source.version_as_revisions(
                     package, previous_version)
         except PackageVersionNotPresent:
             raise BzrCommandError("Unable to find the tag for the "
@@ -1322,10 +1344,16 @@
                     "%s" % (
                 previous_version,
                 self.pristine_upstream_source.tag_name(previous_version)))
-        self.extract_upstream_tree(upstream_tip, tempdir)
+        self.extract_upstream_tree(upstream_tips, tempdir)
+
+    def has_merged_upstream_revisions(self, this_revision, upstream_repository, upstream_revisions):
+        graph = self.branch.repository.get_graph(
+            other_repository=upstream_repository)
+        return all(graph.is_ancestor(upstream_revision, this_revision)
+                for upstream_revision in upstream_revisions.values())
 
     def merge_upstream(self, tarball_filenames, package, version, previous_version,
-            upstream_branch=None, upstream_revision=None, merge_type=None,
+            upstream_branch=None, upstream_revisions=None, merge_type=None,
             force=False):
         assert isinstance(version, str), \
             "Should pass version as str not %s" % str(type(version))
@@ -1344,12 +1372,10 @@
                 upstream_branch.lock_read()
             try:
                 if upstream_branch is not None:
-                    if upstream_revision is None:
-                        upstream_revision = upstream_branch.last_revision()
-                    graph = self.branch.repository.get_graph(
-                            other_repository=upstream_branch.repository)
-                    if not force and graph.is_ancestor(upstream_revision,
-                            self.branch.last_revision()):
+                    if upstream_revisions is None:
+                        upstream_revisions = { None: upstream_branch.last_revision() }
+                    if (not force and
+                        self.has_merged_upstream_revisions(self.branch.last_revision(), upstream_branch.repository, upstream_revisions)):
                         raise UpstreamBranchAlreadyMerged
                 upstream_tarballs = [
                     (os.path.abspath(fn), component, md5sum_filename(fn)) for
@@ -1364,7 +1390,7 @@
                     for (component, tag, revid) in self.import_upstream(tarball_dir,
                             package, version, parents, upstream_tarballs=upstream_tarballs,
                             upstream_branch=upstream_branch,
-                            upstream_revision=upstream_revision):
+                            upstream_revisions=upstream_revisions):
                         self._fetch_upstream_to_branch(revid)
                 finally:
                     shutil.rmtree(tarball_dir)

=== modified file 'merge_package.py'
--- merge_package.py	2011-06-15 13:21:22 +0000
+++ merge_package.py	2011-09-26 22:30:28 +0000
@@ -31,7 +31,9 @@
     from debian_bundle.changelog import Version
 
 from bzrlib.plugins.builddeb.errors import (
-    SharedUpstreamConflictsWithTargetPackaging)
+    MultipleUpstreamTarballsNotSupported,
+    SharedUpstreamConflictsWithTargetPackaging,
+    )
 from bzrlib.plugins.builddeb.import_dsc import DistributionBranch
 from bzrlib.plugins.builddeb.util import find_changelog
 
@@ -59,8 +61,11 @@
     for branch in (source, target):
         db = DistributionBranch(branch, branch)
         uver = _latest_version(branch).upstream_version
-        results.append((Version(uver),
-                    db.pristine_upstream_source.version_as_revision(None, uver)))
+        upstream_revids = db.pristine_upstream_source.version_as_revisions(None, uver)
+        if upstream_revids.keys() != [None]:
+            raise MultipleUpstreamTarballsNotSupported()
+        upstream_revid = upstream_revids[None]
+        results.append((Version(uver), upstream_revid))
 
     return results
 
@@ -136,7 +141,7 @@
             try:
                 # Extract the merge target's upstream tree into a temporary
                 # directory.
-                db.extract_upstream_tree(ut_revid, tempdir)
+                db.extract_upstream_tree({None: ut_revid}, tempdir)
                 tmp_target_utree = db.pristine_upstream_tree
 
                 # Merge upstream branch tips to obtain a shared upstream parent.

=== modified file 'tests/test_import_dsc.py'
--- tests/test_import_dsc.py	2011-09-09 13:20:42 +0000
+++ tests/test_import_dsc.py	2011-09-26 22:30:28 +0000
@@ -213,14 +213,15 @@
         db.tag_version(version)
         self.assertEqual(db.revid_of_version(version), revid)
 
-    def test_upstream_version_as_revid(self):
+    def test_upstream_versions_as_revid(self):
         db = self.db1
         tree = self.up_tree1
         version = "0.1"
         revid = tree.commit("one")
         db.tag_upstream_version(version)
         self.assertEqual(
-            db.pristine_upstream_source.version_as_revision("package", version), revid)
+            db.pristine_upstream_source.version_as_revisions("package", version), 
+            { None: revid })
 
     def test_contained_versions(self):
         db = self.db1
@@ -710,8 +711,8 @@
         self.assertEqual(self.tree2.branch.last_revision(), revid)
         self.assertEqual(self.up_tree2.branch.last_revision(), up_revid)
         self.assertEqual(self.db2.revid_of_version(version), revid)
-        self.assertEqual(self.db2.pristine_upstream_source.version_as_revision(
-            "package", version.upstream_version), up_revid)
+        self.assertEqual(self.db2.pristine_upstream_source.version_as_revisions(
+            "package", version.upstream_version), {None: up_revid})
 
     def test_pull_from_lesser_branch_with_upstream(self):
         version = Version("0.1-1")
@@ -726,8 +727,8 @@
         self.assertEqual(self.tree2.branch.last_revision(), revid)
         self.assertEqual(self.up_tree2.branch.last_revision(), up_revid)
         self.assertEqual(self.db2.revid_of_version(version), revid)
-        self.assertEqual(self.db2.pristine_upstream_source.version_as_revision(
-            "package", version.upstream_version), up_revid)
+        self.assertEqual(self.db2.pristine_upstream_source.version_as_revisions(
+            "package", version.upstream_version), {None: up_revid})
 
     def test_pull_upstream_from_branch(self):
         version = "0.1"
@@ -737,8 +738,9 @@
         self.assertNotEqual(self.up_tree2.branch.last_revision(), up_revid)
         self.db2.pull_upstream_from_branch(self.db1, "package", version)
         self.assertEqual(self.up_tree2.branch.last_revision(), up_revid)
-        self.assertEqual(self.db2.pristine_upstream_source.version_as_revision("package", version),
-                up_revid)
+        self.assertEqual(
+            self.db2.pristine_upstream_source.version_as_revisions("package", version),
+            {None: up_revid})
 
     def check_changes(self, changes, added=[], removed=[], modified=[],
                       renamed=[]):
@@ -794,8 +796,8 @@
         branch = tree.branch
         rh = branch.revision_history()
         self.assertEqual(len(rh), 1)
-        self.assertEqual(self.db1.pristine_upstream_source.version_as_revision(
-            "package", version.upstream_version), rh[0])
+        self.assertEqual(self.db1.pristine_upstream_source.version_as_revisions(
+            "package", version.upstream_version), {None: rh[0]})
         rev = branch.repository.get_revision(rh[0])
         self.assertEqual(rev.message,
                 "Import upstream version %s" % str(version.upstream_version))
@@ -833,7 +835,9 @@
         rh = branch.revision_history()
         self.assertEqual(len(rh), 2)
         self.assertEqual(
-            self.db1.pristine_upstream_source.version_as_revision("package", version2.upstream_version), rh[1])
+            self.db1.pristine_upstream_source.version_as_revisions(
+                "package", version2.upstream_version),
+            {None: rh[1]})
         rev = branch.repository.get_revision(rh[1])
         self.assertEqual(rev.message,
                 "Import upstream version %s" % str(version2.upstream_version))
@@ -864,8 +868,8 @@
         branch = tree.branch
         rh = branch.revision_history()
         self.assertEqual(len(rh), 1)
-        self.assertEqual(self.db1.pristine_upstream_source.version_as_revision(
-            "package", version.upstream_version), rh[0])
+        self.assertEqual(self.db1.pristine_upstream_source.version_as_revisions(
+            "package", version.upstream_version), {None: rh[0]})
         rev = branch.repository.get_revision(rh[0])
         self.assertEqual(rev.message,
                 "Import upstream version %s" % str(version.upstream_version))
@@ -892,8 +896,8 @@
         branch = tree.branch
         rh = branch.revision_history()
         self.assertEqual(len(rh), 1)
-        self.assertEqual(self.db1.pristine_upstream_source.version_as_revision(
-            "package", version.upstream_version), rh[0])
+        self.assertEqual(self.db1.pristine_upstream_source.version_as_revisions(
+            "package", version.upstream_version), {None: rh[0]})
         rev = branch.repository.get_revision(rh[0])
         self.assertEqual(rev.message,
                 "Import upstream version %s" % str(version.upstream_version))
@@ -941,8 +945,8 @@
         branch = tree.branch
         rh = branch.revision_history()
         self.assertEqual(len(rh), 1)
-        self.assertEqual(self.db1.pristine_upstream_source.version_as_revision(
-            "package", version.upstream_version), rh[0])
+        self.assertEqual(self.db1.pristine_upstream_source.version_as_revisions(
+            "package", version.upstream_version), {None: rh[0]})
         rev = branch.repository.get_revision(rh[0])
         self.assertEqual(rev.message,
                 "Import upstream version %s" % str(version.upstream_version))
@@ -1381,8 +1385,9 @@
         self.assertEqual(self.db1.revid_of_version(version2), rh1[2])
         self.assertEqual(self.db1.revid_of_version(version3), rh1[3])
         self.assertEqual(
-            self.db1.pristine_upstream_source.version_as_revision("package", version1.upstream_version),
-            up_rh1[0])
+            self.db1.pristine_upstream_source.version_as_revisions(
+                "package", version1.upstream_version),
+            {None: up_rh1[0]})
         self.tree1.lock_read()
         self.addCleanup(self.tree1.unlock)
         self.assertFalse(self.db1.is_version_native(version1))
@@ -1434,11 +1439,13 @@
         self.assertEqual(self.db1.revid_of_version(version2), rh1[2])
         self.assertEqual(self.db1.revid_of_version(version3), rh1[3])
         self.assertEqual(
-            self.db1.pristine_upstream_source.version_as_revision("package", version1.upstream_version),
-            up_rh1[0])
+            self.db1.pristine_upstream_source.version_as_revisions("package",
+                version1.upstream_version),
+            {None: up_rh1[0]})
         self.assertEqual(
-            self.db1.pristine_upstream_source.version_as_revision("package", version3.upstream_version),
-            up_rh1[1])
+            self.db1.pristine_upstream_source.version_as_revisions("package",
+                version3.upstream_version),
+            {None: up_rh1[1]})
         self.tree1.lock_read()
         self.addCleanup(self.tree1.unlock)
         self.assertFalse(self.db1.is_version_native(version1))
@@ -1489,11 +1496,13 @@
         self.assertEqual(self.db1.revid_of_version(version2), rh1[2])
         self.assertEqual(self.db1.revid_of_version(version3), rh1[3])
         self.assertEqual(
-            self.db1.pristine_upstream_source.version_as_revision("package", version1.upstream_version),
-            up_rh1[0])
+            self.db1.pristine_upstream_source.version_as_revisions("package",
+                version1.upstream_version),
+            { None: up_rh1[0] })
         self.assertEqual(
-            self.db1.pristine_upstream_source.version_as_revision("package", version3.upstream_version),
-            up_rh1[1])
+            self.db1.pristine_upstream_source.version_as_revisions("package",
+                version3.upstream_version),
+            { None: up_rh1[1] })
         self.tree1.lock_read()
         self.addCleanup(self.tree1.unlock)
         self.assertFalse(self.db1.is_version_native(version1))
@@ -1604,7 +1613,7 @@
             tf.close()
         conflicts = db.merge_upstream([(tarball_filename, None)], "foo", "0.2", "0.1",
             upstream_branch=upstream_tree.branch,
-            upstream_revision=upstream_rev)
+            upstream_revisions={None: upstream_rev})
         self.assertEqual(0,  conflicts)
 
     def test_merge_upstream_initial_with_removed_debian(self):
@@ -1644,7 +1653,7 @@
             tf.close()
         conflicts = db.merge_upstream([(tarball_filename, None)], "foo", "0.2", "0.1",
             upstream_branch=upstream_tree.branch,
-            upstream_revision=upstream_rev)
+            upstream_revisions={None: upstream_rev})
         # ./debian conflicts.
         self.assertEqual(3,  conflicts)
 
@@ -1686,7 +1695,7 @@
         db.merge_upstream([(builder.tar_name(), None)], "package", str(version2),
             version1.upstream_version,
             upstream_branch=upstream_tree.branch,
-            upstream_revision=upstream_rev)
+            upstream_revisions={None: upstream_rev})
         rh1 = tree.branch.revision_history()
         self.assertEqual(2, len(rh1))
         packaging_upstream_tip = tree.get_parent_ids()[1]
@@ -1765,7 +1774,7 @@
             version2.upstream_version,
             version1.upstream_version,
             upstream_branch=upstream_tree.branch,
-            upstream_revision=upstream_rev2)
+            upstream_revisions={None: upstream_rev2})
         self.assertEqual("a-id", tree.path2id("b"))
 
     def test_merge_upstream_rename_on_top(self):
@@ -1802,7 +1811,7 @@
             version2.upstream_version,
             version1.upstream_version,
             upstream_branch=upstream_tree.branch,
-            upstream_revision=upstream_rev2)
+            upstream_revisions={None:upstream_rev2})
         self.assertEqual("a-id", tree.path2id("b"))
 
     def test_merge_upstream_rename_in_packaging_branch(self):

=== modified file 'tests/test_upstream.py'
--- tests/test_upstream.py	2011-09-09 13:20:42 +0000
+++ tests/test_upstream.py	2011-09-26 22:30:28 +0000
@@ -432,6 +432,20 @@
         self.tree.commit("msg")
         self.assertEquals("2.1+bzr2", source.get_latest_version("foo", "1.0"))
 
+    def test_version_as_revisions(self):
+        revid1 = self.tree.commit("msg")
+        self.tree.branch.tags.set_tag("2.1", self.tree.branch.last_revision())
+        config = DebBuildConfig(
+            [('user.conf', True), ('default.conf', False)],
+            branch=self.tree.branch)
+        source = UpstreamBranchSource(self.tree.branch,
+            {"2.1": self.tree.branch.last_revision()},
+            config=config)
+        revid2 = self.tree.commit("msg")
+        self.assertEquals(revid2,
+            source.version_as_revision("foo", "2.1+bzr2"))
+        self.assertEquals({None: revid1}, source.version_as_revisions("foo", "2.1"))
+
     def test_version_as_revision(self):
         revid1 = self.tree.commit("msg")
         self.tree.branch.tags.set_tag("2.1", self.tree.branch.last_revision())
@@ -766,14 +780,31 @@
         rev.properties["deb-pristine-delta"] = standard_b64encode("bla")
         self.assertEquals("bla", self.source.pristine_tar_delta(rev))
 
-    def test_version_as_revision_missing(self):
+    def test_version_as_revisions_missing(self):
         self.assertRaises(PackageVersionNotPresent,
-            self.source.version_as_revision, None, "1.2")
-
-    def test_version_as_revision(self):
-        revid1 = self.tree.commit("msg")
-        self.tree.branch.tags.set_tag("upstream-2.1", revid1)
-        self.assertEquals(revid1, self.source.version_as_revision(None, "2.1"))
+            self.source.version_as_revisions, None, "1.2")
+
+    def test_version_as_revisions_single(self):
+        revid1 = self.tree.commit("msg")
+        self.tree.branch.tags.set_tag("upstream-2.1", revid1)
+        self.assertEquals({None: revid1},
+            self.source.version_as_revisions(None, "2.1"))
+
+    def test_version_component_as_revision(self):
+        revid1 = self.tree.commit("msg")
+        self.tree.branch.tags.set_tag("upstream-2.1/lib", revid1)
+        self.assertEquals(revid1,
+            self.source.version_component_as_revision(None, "2.1", "lib"))
+
+    def test_version_as_revisions(self):
+        revid1 = self.tree.commit("msg")
+        revid2 = self.tree.commit("msg")
+        self.tree.branch.tags.set_tag("upstream-2.1", revid1)
+        self.tree.branch.tags.set_tag("upstream-2.1/lib", revid2)
+        self.assertEquals({ None: revid1, "lib": revid2 },
+                self.source.version_as_revisions(None, "2.1", [
+            ("upstream_2.1.orig.tar.gz", None, "somemd5sum"),
+            ("upstream_2.1.orig-lib.tar.gz", "lib", "othermd5sum")]))
 
 
 class TarfileSourceTests(TestCaseWithTransport):

=== modified file 'upstream/__init__.py'
--- upstream/__init__.py	2011-09-07 20:11:50 +0000
+++ upstream/__init__.py	2011-09-26 22:30:28 +0000
@@ -75,15 +75,16 @@
         """
         raise NotImplementedError(self.get_latest_version)
 
-    def version_as_revision(self, package, version):
-        """Lookup the revision id for a particular version.
+    def version_as_revisions(self, package, version, tarballs=None):
+        """Lookup the revision ids for a particular version.
 
         :param package: Package name
-        :package version: Version string
+        :param version: Version string
         :raise PackageVersionNotPresent: When the specified version was not
             found
+        :return: dictionary mapping component names to revision ids
         """
-        raise NotImplementedError(self.version_as_revision)
+        raise NotImplementedError(self.version_as_revisions)
 
     def has_version(self, package, version, md5=None):
         """Check whether this upstream source contains a particular package.

=== modified file 'upstream/branch.py'
--- upstream/branch.py	2011-06-26 21:02:48 +0000
+++ upstream/branch.py	2011-09-26 22:30:28 +0000
@@ -28,7 +28,10 @@
 from bzrlib.revisionspec import RevisionSpec
 from bzrlib.trace import note
 
-from bzrlib.plugins.builddeb.errors import PackageVersionNotPresent
+from bzrlib.plugins.builddeb.errors import (
+    MultipleUpstreamTarballsNotSupported,
+    PackageVersionNotPresent,
+    )
 from bzrlib.plugins.builddeb.upstream import UpstreamSource
 from bzrlib.plugins.builddeb.util import (
     export,
@@ -228,7 +231,7 @@
         else:
             self.upstream_revision_map = upstream_revision_map
 
-    def version_as_revision(self, package, version):
+    def version_as_revision(self, package, version, tarballs=None):
         assert isinstance(version, str)
         if version in self.upstream_revision_map:
             revspec = self.upstream_revision_map[version]
@@ -242,6 +245,13 @@
                 raise PackageVersionNotPresent(package, version, self)
         raise PackageVersionNotPresent(package, version, self)
 
+    def version_as_revisions(self, package, version, tarballs=None):
+        # FIXME: Support multiple upstream locations if there are multiple
+        # components
+        if tarballs is not None and tarballs.keys() != [None]:
+            raise MultipleUpstreamTarballsNotSupported()
+        return { None: self.version_as_revision(package, version, tarballs) }
+
     def get_latest_version(self, package, current_version):
         return self.get_version(package, current_version,
             self.upstream_branch.last_revision())

=== modified file 'upstream/pristinetar.py'
--- upstream/pristinetar.py	2011-09-09 13:20:42 +0000
+++ upstream/pristinetar.py	2011-09-26 22:30:28 +0000
@@ -39,13 +39,17 @@
     subprocess_setup,
     )
 
-from bzrlib import osutils
+from bzrlib import (
+    osutils,
+    revision as _mod_revision,
+    )
 from bzrlib.errors import (
     BzrError,
     NoSuchRevision,
     NoSuchTag,
     )
 from bzrlib.trace import (
+    mutter,
     note,
     warning,
     )
@@ -166,32 +170,43 @@
         :param parent_ids: Parent revisions
         :param tarballs: List of (path, component, md5)
         :param timestamp: Optional timestamp for new commits
-        :param author: Optional author for new commits
+        :param author: Optional author for new commitscopmone
         :return: List of tuples with (component, tag, revid)
         """
         ret = []
+        component_paths = [cp for (_, cp, _) in tarballs if cp is not None]
         for (tarball, component, md5) in tarballs:
+            if component is None:
+                exclude = component_paths
+            else:
+                exclude = []
             (tag, revid) = self.import_component_tarball(
-                package, version, tree, parent_ids, component,
-                md5, tarball, author=author, timestamp=timestamp)
+                    package, version, tree, parent_ids, component,
+                    md5, tarball, author=author, timestamp=timestamp,
+                    exclude=exclude)
             ret.append((component, tag, revid))
+        # FIXME: Handle multiple components
+        tree.branch.generate_revision_history(revid)
         return ret
 
     def import_component_tarball(self, package, version, tree, parent_ids,
-            component=None, md5=None, tarball=None, author=None, timestamp=None):
+            component=None, md5=None, tarball=None, author=None, timestamp=None,
+            subdir=None, exclude=None):
         """Import a tarball.
 
         :param package: Package name
         :param version: Upstream version
         :param component: Component name (None for base)
+        :param exclude: Exclude directories
         """
-        if component is not None:
-            raise BzrError("Importing non-base tarballs not yet supported")
-        tree.set_parent_ids(parent_ids)
+        if exclude is not None or subdir is not None:
+            raise NotImplementedError
+        if exclude is None:
+            exclude = []
         revprops = {}
         if md5 is not None:
             revprops["deb-md5"] = md5
-            delta = self.make_pristine_tar_delta(tree, tarball)
+            delta = self.make_pristine_tar_delta(tree, tarball, subdir=subdir)
             uuencoded = standard_b64encode(delta)
             if tarball.endswith(".tar.bz2"):
                 revprops["deb-pristine-delta-bz2"] = uuencoded
@@ -208,9 +223,31 @@
         message = "Import upstream version %s" % (version,)
         if component is not None:
             message += ", component %s" % component
-        revid = tree.commit(message, revprops=revprops, timestamp=timestamp,
-            timezone=timezone)
-        tag_name, _ = self.tag_version(version, revid=revid)
+        if len(parent_ids) == 0:
+            base_revid = _mod_revision.NULL_REVISION
+        else:
+            base_revid = parent_ids[0]
+        basis_tree = tree.branch.repository.revision_tree(base_revid)
+        tree.lock_write()
+        try:
+            builder = tree.branch.get_commit_builder(parents=parent_ids,
+                revprops=revprops, timestamp=timestamp, timezone=timezone)
+            builder.will_record_deletes()
+            try:
+                list(builder.record_iter_changes(tree, base_revid,
+                    tree.iter_changes(basis_tree)))
+                builder.finish_inventory()
+            except:
+                builder.abort()
+                raise
+            revid = builder.commit(message)
+            tag_name, _ = self.tag_version(version, revid=revid, component=component)
+            tree.update_basis_by_delta(revid, builder.get_basis_delta())
+        finally:
+            tree.unlock()
+        mutter(
+            'imported %s version %s component %r as revid %s, tagged %s',
+            package, version, component, revid, tag_name)
         return tag_name, revid
 
     def fetch_component_tarball(self, package, version, component, target_dir):
@@ -256,14 +293,16 @@
                 "revision %s", revid)
             return True
 
-    def version_as_revision(self, package, version, tarballs=None):
+    def version_as_revisions(self, package, version, tarballs=None):
         if tarballs is None:
-            return self.version_component_as_revision(package, version, component=None)
-        elif len(tarballs) > 1:
-            raise MultipleUpstreamTarballsNotSupported()
-        else:
-            return self.version_component_as_revision(package, version, tarballs[0][1],
-                tarballs[0][2])
+            # FIXME: What if there are multiple tarballs?
+            return {
+                None: self.version_component_as_revision(package, version, component=None) }
+        ret = {}
+        for (tarball, component, md5) in tarballs:
+            ret[component] = self.version_component_as_revision(
+                package, version, component, md5)
+        return ret
 
     def version_component_as_revision(self, package, version, component, md5=None):
         assert isinstance(version, str)
@@ -359,7 +398,7 @@
         finally:
             shutil.rmtree(tmpdir)
 
-    def make_pristine_tar_delta(self, tree, tarball_path):
+    def make_pristine_tar_delta(self, tree, tarball_path, subdir=None):
         tmpdir = tempfile.mkdtemp(prefix="builddeb-pristine-")
         try:
             dest = os.path.join(tmpdir, "orig")
@@ -367,7 +406,7 @@
             try:
                 for (dp, ie) in tree.inventory.iter_entries():
                     ie._read_tree_state(dp, tree)
-                export(tree, dest, format='dir')
+                export(tree, dest, format='dir', subdir=subdir)
             finally:
                 tree.unlock()
             return make_pristine_tar_delta(dest, tarball_path)