Merge lp:~jelmer/bzr-builddeb/multiple-upstream-tarballs-pt5 into lp:bzr-builddeb

[Jelmer Vernooij]

More work on support for multiple upstream tarballs.

Rename fetch_tarball -> fetch_tarballs as it can fetch multiple tarballs.

Some refactoring in import_dsc:

 * Remove has_upstream_version which was trivial
 * Pull some duplicate code into can_pull_upstream_from_branch

Pass component further down in some more places, including tarball_filename.

[James Westby (james-w)]

review: Approve

=== modified file 'cmds.py'
--- cmds.py	2011-06-24 10:51:46 +0000
+++ cmds.py	2011-06-27 10:36:00 +0000
@@ -577,7 +577,7 @@
             if v3:
                 if location.endswith(".tar.bz2") or location.endswith(".tbz2"):
                     format = "bz2"
-            dest_name = tarball_name(package, version, format=format)
+            dest_name = tarball_name(package, version, None, format=format)
             tarball_filename = os.path.join(orig_dir, dest_name)
             try:
                 repack_tarball(location, dest_name, target_dir=orig_dir,
@@ -745,7 +745,7 @@
                         (version, upstream_branch_source))
             if need_upstream_tarball:
                 target_dir = tempfile.mkdtemp() # FIXME: Cleanup?
-                locations = primary_upstream_source.fetch_tarball(
+                locations = primary_upstream_source.fetch_tarballs(
                     package, version, target_dir)
                 source_format = get_source_format(tree)
                 v3 = (source_format in [

=== modified file 'dh_make.py'
--- dh_make.py	2011-06-23 10:29:54 +0000
+++ dh_make.py	2011-06-27 10:36:00 +0000
@@ -62,7 +62,7 @@
     if use_v3:
         if tarball.endswith(".tar.bz2") or tarball.endswith(".tbz2"):
             format = "bz2"
-    dest_name = util.tarball_name(package_name, version, format=format)
+    dest_name = util.tarball_name(package_name, version, None, format=format)
     trace.note("Fetching tarball")
     repack_tarball(tarball, dest_name, target_dir=orig_dir,
             force_gz=not use_v3)

=== modified file 'import_dsc.py'
--- import_dsc.py	2011-06-23 21:34:52 +0000
+++ import_dsc.py	2011-06-27 10:36:00 +0000
@@ -60,6 +60,7 @@
 
 from bzrlib.plugins.builddeb.bzrtools_import import import_dir
 from bzrlib.plugins.builddeb.errors import (
+    PackageVersionNotPresent,
     UpstreamAlreadyImported,
     UpstreamBranchAlreadyMerged,
     )
@@ -321,23 +322,6 @@
             return True
         return False
 
-    def has_upstream_version(self, package, version, tarballs=None):
-        """Whether this branch contains the upstream version specified.
-
-        The version must be judged present by having the appropriate tag
-        in the upstream branch. If the md5 argument is not None then the
-        string passed must the the md5sum that is associated with the
-        revision pointed to by the tag.
-
-        :param version: a upstream version number to look for in the upstream 
-            branch.
-        :param tarballs: list of upstream tarballs that should be present,
-            tuples of filename and md5sum
-        :return: True if the upstream branch contains the specified upstream
-            version of the package. False otherwise.
-        """
-        return self.pristine_upstream_source.has_version(package, version, tarballs)
-
     def contained_versions(self, versions):
         """Splits a list of versions depending on presence in the branch.
 
@@ -574,6 +558,35 @@
         finally:
             self.branch.unlock()
 
+    def can_pull_upstream_from_branch(self, branch, package, version,
+            upstream_tarballs=None):
+        """Check if a version can be pulled from another branch into this one.
+
+        :param branch: Branch with upstream version
+        :param package: Package name
+        :param version: Package version
+        :param upstream_tarballs: Required upstream tarballs (optional)
+        """
+        if not branch.pristine_upstream_source.has_version(package, version,
+                tarballs=upstream_tarballs):
+            return False
+
+        up_branch = self.pristine_upstream_branch
+        up_branch.lock_read()
+        try:
+            # Check that they haven't diverged
+            other_up_branch = branch.pristine_upstream_branch
+            other_up_branch.lock_read()
+            try:
+                graph = other_up_branch.repository.get_graph(
+                        up_branch.repository)
+                return graph.is_ancestor(up_branch.last_revision(),
+                        branch.revid_of_upstream_version(package, version))
+            finally:
+                other_up_branch.unlock()
+        finally:
+            up_branch.unlock()
+
     def branch_to_pull_upstream_from(self, package, version, upstream_tarballs):
         """Checks whether this upstream is a pull from a lesser branch.
 
@@ -591,40 +604,15 @@
             if that is what should be done, otherwise None.
         """
         assert isinstance(version, str)
-        up_branch = self.pristine_upstream_branch
-        up_branch.lock_read()
-        try:
-            for branch in reversed(self.get_lesser_branches()):
-                if branch.has_upstream_version(package, version,
-                        tarballs=upstream_tarballs):
-                    # Check that they haven't diverged
-                    other_up_branch = branch.pristine_upstream_branch
-                    other_up_branch.lock_read()
-                    try:
-                        graph = other_up_branch.repository.get_graph(
-                                up_branch.repository)
-                        if graph.is_ancestor(up_branch.last_revision(),
-                                branch.revid_of_upstream_version(package, version)):
-                            return branch
-                    finally:
-                        other_up_branch.unlock()
-            for branch in self.get_greater_branches():
-                if branch.has_upstream_version(package, version,
-                        tarballs=upstream_tarballs):
-                    # Check that they haven't diverged
-                    other_up_branch = branch.pristine_upstream_branch
-                    other_up_branch.lock_read()
-                    try:
-                        graph = other_up_branch.repository.get_graph(
-                                up_branch.repository)
-                        if graph.is_ancestor(up_branch.last_revision(),
-                                branch.revid_of_upstream_version(package, version)):
-                            return branch
-                    finally:
-                        other_up_branch.unlock()
-            return None
-        finally:
-            up_branch.unlock()
+        for branch in reversed(self.get_lesser_branches()):
+            if self.can_pull_upstream_from_branch(branch, package, version,
+                    upstream_tarballs):
+                return branch
+        for branch in self.get_greater_branches():
+            if self.can_pull_upstream_from_branch(branch, package, version,
+                    upstream_tarballs):
+                return branch
+        return None
 
     def get_parents(self, versions):
         """Return the list of parents for a specific version.
@@ -710,10 +698,9 @@
         pull_revision = pull_branch.revid_of_upstream_version(package, version)
         mutter("Pulling upstream part of %s from revision %s" % \
                 (version, pull_revision))
-        up_pull_branch = pull_branch.pristine_upstream_branch
         assert self.pristine_upstream_tree is not None, \
             "Can't pull upstream with no tree"
-        self.pristine_upstream_tree.pull(up_pull_branch,
+        self.pristine_upstream_tree.pull(pull_branch.pristine_upstream_branch,
                 stop_revision=pull_revision)
         self.pristine_upstream_source.tag_version(version, pull_revision)
         self.branch.fetch(self.pristine_upstream_branch, last_revision=pull_revision)
@@ -746,8 +733,8 @@
         assert self.tree is not None, "Can't pull branch with no tree"
         self.tree.pull(pull_branch.branch, stop_revision=pull_revision)
         self.tag_version(version, revid=pull_revision)
-        if not native and not self.has_upstream_version(package, version.upstream_version):
-            if pull_branch.has_upstream_version(package, version.upstream_version):
+        if not native and not self.pristine_upstream_source.has_version(package, version.upstream_version):
+            if pull_branch.pristine_upstream_source.has_version(package, version.upstream_version):
                 self.pull_upstream_from_branch(pull_branch, 
                     package, version.upstream_version)
             else:
@@ -1066,7 +1053,7 @@
             # upstream as a non-native version (i.e. it wasn't a mistaken
             # native -2 version), then we want to add an extra parent.
             if (self.is_version_native(last_contained_version)
-                and not self.has_upstream_version(package,
+                and not self.pristine_upstream_source.has_version(package,
                     last_contained_version.upstream_version)):
                 revid = self.revid_of_version(last_contained_version)
                 parents.append(revid)
@@ -1131,7 +1118,8 @@
             # We need to import at least the diff, possibly upstream.
             # Work out if we need the upstream part first.
             imported_upstream = False
-            if not self.pristine_upstream_source.has_version(package, version.upstream_version):
+            if not self.pristine_upstream_source.has_version(package,
+                    version.upstream_version):
                 up_pull_branch = \
                     self.branch_to_pull_upstream_from(package, version.upstream_version,
                             upstream_tarballs)
@@ -1342,16 +1330,16 @@
     def _export_previous_upstream_tree(self, package, previous_version, tempdir):
         assert isinstance(previous_version, str), \
             "Should pass upstream version as str, not Version."
-        if self.pristine_upstream_source.has_version(package, previous_version):
+        try:
             upstream_tip = self.pristine_upstream_source.version_as_revision(
                     package, previous_version)
-            self.extract_upstream_tree(upstream_tip, tempdir)
-        else:
+        except PackageVersionNotPresent:
             raise BzrCommandError("Unable to find the tag for the "
                     "previous upstream version, %s, in the branch: "
                     "%s" % (
                 previous_version,
                 self.pristine_upstream_source.tag_name(previous_version)))
+        self.extract_upstream_tree(upstream_tip, tempdir)
 
     def merge_upstream(self, tarball_filenames, package, version, previous_version,
             upstream_branch=None, upstream_revision=None, merge_type=None,

=== modified file 'tests/test_import_dsc.py'
--- tests/test_import_dsc.py	2011-06-23 15:33:44 +0000
+++ tests/test_import_dsc.py	2011-06-27 10:36:00 +0000
@@ -168,30 +168,30 @@
         self.assertFalse(db.has_version(version, self.fake_md5_1))
         self.assertFalse(db.has_version(version, self.fake_md5_2))
 
-    def test_has_upstream_version(self):
+    def test_pristine_upstream_source_has_version(self):
         db = self.db1
         version = "0.1"
-        self.assertFalse(db.has_upstream_version("package", version))
-        self.assertFalse(db.has_upstream_version("package", version,
+        self.assertFalse(db.pristine_upstream_source.has_version("package", version))
+        self.assertFalse(db.pristine_upstream_source.has_version("package", version,
             [("foo.tar.gz", None, self.fake_md5_1)]))
         self.do_commit_with_md5(self.up_tree1, "one", self.fake_md5_1)
         db.tag_upstream_version(version)
-        self.assertTrue(db.has_upstream_version("package", version))
-        self.assertTrue(db.has_upstream_version("package",
+        self.assertTrue(db.pristine_upstream_source.has_version("package", version))
+        self.assertTrue(db.pristine_upstream_source.has_version("package",
             version, [("foo.tar.gz", None, self.fake_md5_1)]))
-        self.assertFalse(db.has_upstream_version("package", version,
+        self.assertFalse(db.pristine_upstream_source.has_version("package", version,
             [("foo.tar.gz", None, self.fake_md5_2)]))
         version = "0.1"
-        self.assertTrue(db.has_upstream_version("package", version))
-        self.assertTrue(db.has_upstream_version("package", version,
+        self.assertTrue(db.pristine_upstream_source.has_version("package", version))
+        self.assertTrue(db.pristine_upstream_source.has_version("package", version,
             [("foo.tar.gz", None, self.fake_md5_1)]))
-        self.assertFalse(db.has_upstream_version("package", version,
+        self.assertFalse(db.pristine_upstream_source.has_version("package", version,
             [("foo.tar.gz", None, self.fake_md5_2)]))
         version = "0.2"
-        self.assertFalse(db.has_upstream_version("package", version))
-        self.assertFalse(db.has_upstream_version("package", version,
+        self.assertFalse(db.pristine_upstream_source.has_version("package", version))
+        self.assertFalse(db.pristine_upstream_source.has_version("package", version,
             [("foo.tar.gz", None, self.fake_md5_1)]))
-        self.assertFalse(db.has_upstream_version("package", version,
+        self.assertFalse(db.pristine_upstream_source.has_version("package", version,
             [("foo.tar.gz", None, self.fake_md5_2)]))
 
     def test_revid_of_version(self):

=== modified file 'tests/test_merge_package.py'
--- tests/test_merge_package.py	2011-06-15 10:03:47 +0000
+++ tests/test_merge_package.py	2011-06-27 10:36:00 +0000
@@ -120,10 +120,10 @@
         v3 = "1.2"
         v4 = "1.10"
         db1 = DistributionBranch(ubup.branch, ubup.branch)
-        self.assertEqual(db1.has_upstream_version("package", v3), True)
+        self.assertEqual(db1.pristine_upstream_source.has_version("package", v3), True)
         # This version is in the diverged debian upstream tree and will
         # hence not be present in the target ubuntu packaging branch.
-        self.assertEqual(db1.has_upstream_version("package", v4), False)
+        self.assertEqual(db1.pristine_upstream_source.has_version("package", v4), False)
 
         # The ubuntu upstream branch tip.
         ubuu_tip = ubuu.branch.revision_history()[-1]
@@ -143,11 +143,11 @@
 
         # Check the versions present in the tree with the fixed ancestry.
         db2 = DistributionBranch(ubup.branch, ubup.branch)
-        self.assertEqual(db2.has_upstream_version("package", v3), True)
+        self.assertEqual(db2.pristine_upstream_source.has_version("package", v3), True)
         # The ancestry has been fixed and the missing debian upstream
         # version should now be present in the target ubuntu packaging
         # branch.
-        self.assertEqual(db2.has_upstream_version("package", v4), True)
+        self.assertEqual(db2.pristine_upstream_source.has_version("package", v4), True)
 
         # Now let's take a look at the fixed ubuntu packaging branch.
         ubup_tip_post_fix = ubup.branch.revision_history()[-1]

=== modified file 'tests/test_upstream.py'
--- tests/test_upstream.py	2011-06-15 18:44:09 +0000
+++ tests/test_upstream.py	2011-06-27 10:36:00 +0000
@@ -164,7 +164,7 @@
         apt_pkg = MockAptPkg(sources)
         src = AptSource()
         src._run_apt_source = caller.call
-        self.assertRaises(PackageVersionNotPresent, src.fetch_tarball,
+        self.assertRaises(PackageVersionNotPresent, src.fetch_tarballs,
             "apackage", "0.2", "target", _apt_pkg=apt_pkg)
         self.assertEqual(1, apt_pkg.init_called_times)
         self.assertEqual(1, apt_pkg.get_pkg_source_records_called_times)
@@ -180,7 +180,7 @@
         apt_pkg = MockAptPkg(sources)
         src = AptSource()
         src._run_apt_source = caller.call
-        self.assertRaises(PackageVersionNotPresent, src.fetch_tarball,
+        self.assertRaises(PackageVersionNotPresent, src.fetch_tarballs,
             "apackage", "0.2", "target", _apt_pkg=apt_pkg)
         self.assertEqual(1, apt_pkg.init_called_times)
         self.assertEqual(1, apt_pkg.get_pkg_source_records_called_times)
@@ -198,7 +198,7 @@
         apt_pkg = MockAptPkg(sources)
         src = AptSource()
         src._run_apt_source = caller.call
-        paths = src.fetch_tarball("apackage", "0.2", "target",
+        paths = src.fetch_tarballs("apackage", "0.2", "target",
             _apt_pkg=apt_pkg)
         self.assertEquals(paths, [
             "target/apackage_0.2.orig.tar.bz2",
@@ -212,7 +212,7 @@
         apt_pkg = MockAptPkg(sources)
         src = AptSource()
         src._run_apt_source = caller.call
-        paths = src.fetch_tarball("apackage", "0.2", "target",
+        paths = src.fetch_tarballs("apackage", "0.2", "target",
             _apt_pkg=apt_pkg)
         self.assertEquals(paths, ["target/apackage_0.2.orig.tar.bz2"])
 
@@ -224,7 +224,7 @@
         apt_pkg = MockAptPkg(sources)
         src = AptSource()
         src._run_apt_source = caller.call
-        paths = src.fetch_tarball("apackage", "0.2", "target",
+        paths = src.fetch_tarballs("apackage", "0.2", "target",
             _apt_pkg=apt_pkg)
         self.assertEquals(paths, ["target/apackage_0.2.orig.tar.gz"])
         self.assertEqual(1, apt_pkg.init_called_times)
@@ -246,7 +246,7 @@
         apt_pkg = MockAptPkg(sources)
         src = AptSource()
         src._run_apt_source = caller.call
-        self.assertRaises(PackageVersionNotPresent, src.fetch_tarball,
+        self.assertRaises(PackageVersionNotPresent, src.fetch_tarballs,
             "apackage", "0.2", "target",
             _apt_pkg=apt_pkg)
         self.assertEqual(1, apt_pkg.init_called_times)
@@ -268,7 +268,7 @@
         apt_pkg = MockAptPkg(sources)
         src = AptSource()
         src._run_apt_source = caller.call
-        self.assertRaises(PackageVersionNotPresent, src.fetch_tarball,
+        self.assertRaises(PackageVersionNotPresent, src.fetch_tarballs,
             "apackage", "0.2", "target", _apt_pkg=apt_pkg)
         self.assertEqual(1, apt_pkg.init_called_times)
         self.assertEqual(1, apt_pkg.get_pkg_source_records_called_times)
@@ -288,11 +288,11 @@
     def get_latest_version(self, package, current_version):
         return self._latest
 
-    def fetch_tarball(self, package, version, target_dir):
+    def fetch_tarballs(self, package, version, target_dir):
         self._specific_versions.append((package, version, target_dir))
         if not self._succeed:
             raise PackageVersionNotPresent(package, version, self)
-        return [self._tarball_path(package, version, target_dir)]
+        return [self._tarball_path(package, version, None, target_dir)]
 
     def __repr__(self):
         return "%s()" % self.__class__.__name__
@@ -300,12 +300,12 @@
 
 class StackedUpstreamSourceTests(TestCase):
 
-    def test_fetch_tarball_first_wins(self):
+    def test_fetch_tarballs_first_wins(self):
         a = RecordingSource(False)
         b = RecordingSource(True)
         c = RecordingSource(False)
         stack = StackedUpstreamSource([a, b, c])
-        stack.fetch_tarball("mypkg", "1.0", "bla")
+        stack.fetch_tarballs("mypkg", "1.0", "bla")
         self.assertEquals([("mypkg", "1.0", "bla")], b._specific_versions)
         self.assertEquals([("mypkg", "1.0", "bla")], a._specific_versions)
         self.assertEquals([], c._specific_versions)
@@ -327,7 +327,7 @@
         b = RecordingSource(False)
         stack = StackedUpstreamSource([a, b])
         self.assertRaises(PackageVersionNotPresent,
-                stack.fetch_tarball, "pkg", "1.0", "bla")
+                stack.fetch_tarballs, "pkg", "1.0", "bla")
         self.assertEquals([("pkg", "1.0", "bla")], b._specific_versions)
         self.assertEquals([("pkg", "1.0", "bla")], a._specific_versions)
 
@@ -387,21 +387,21 @@
         super(UpstreamBranchSourceTests, self).setUp()
         self.tree = self.make_branch_and_tree('.')
 
-    def test_fetch_tarball(self):
+    def test_fetch_tarballs(self):
         self.tree.commit("msg")
         self.tree.branch.tags.set_tag("1.0", self.tree.branch.last_revision())
         source = UpstreamBranchSource(self.tree.branch,
             {"1.0": self.tree.branch.last_revision()})
         os.mkdir("mydir")
         self.assertEquals(["mydir/foo_1.0.orig.tar.gz"],
-            source.fetch_tarball("foo", "1.0", "mydir"))
+            source.fetch_tarballs("foo", "1.0", "mydir"))
         self.assertPathExists("mydir/foo_1.0.orig.tar.gz")
 
-    def test_fetch_tarball_not_found(self):
+    def test_fetch_tarballs_not_found(self):
         source = UpstreamBranchSource(self.tree.branch)
         self.tree.commit("msg")
         self.assertRaises(PackageVersionNotPresent,
-            source.fetch_tarball, "foo", "1.0", "mydir")
+            source.fetch_tarballs, "foo", "1.0", "mydir")
 
     def test_get_latest_version(self):
         self.tree.commit("msg")
@@ -452,7 +452,7 @@
         super(LazyUpstreamBranchSourceTests, self).setUp()
         self.tree = self.make_branch_and_tree('.')
 
-    def test_fetch_tarball(self):
+    def test_fetch_tarballs(self):
         self.tree.commit("msg")
         self.tree.branch.tags.set_tag("1.0", self.tree.branch.last_revision())
         source = LazyUpstreamBranchSource(self.tree.branch.base,
@@ -460,16 +460,16 @@
         self.assertIs(None, source._upstream_branch)
         os.mkdir("mydir")
         self.assertEquals(["mydir/foo_1.0.orig.tar.gz"],
-            source.fetch_tarball("foo", "1.0", "mydir"))
+            source.fetch_tarballs("foo", "1.0", "mydir"))
         self.assertPathExists("mydir/foo_1.0.orig.tar.gz")
         self.assertIsNot(None, source._upstream_branch)
 
-    def test_fetch_tarball_not_found(self):
+    def test_fetch_tarballs_not_found(self):
         source = LazyUpstreamBranchSource(self.tree.branch.base)
         self.assertIs(None, source._upstream_branch)
         self.tree.commit("msg")
         self.assertRaises(PackageVersionNotPresent,
-            source.fetch_tarball, "foo", "1.0", "mydir")
+            source.fetch_tarballs, "foo", "1.0", "mydir")
         self.assertIsNot(None, source._upstream_branch)
 
     def test_get_latest_version(self):
@@ -675,13 +675,18 @@
                 "upstream-" + upstream_v_no)
 
     def test_tag_name_distro(self):
-        self.assertEquals(self.source.tag_name("0.3", "ubuntu"),
+        self.assertEquals(self.source.tag_name("0.3", distro="ubuntu"),
                 "upstream-ubuntu-0.3")
 
     def test_version(self):
         self.assertEquals(['upstream-3.3', 'upstream-debian-3.3',
             'upstream-ubuntu-3.3', 'upstream/3.3'],
-            self.source.possible_tag_names("3.3"))
+            self.source.possible_tag_names("3.3", component=None))
+
+    def test_version_component(self):
+        self.assertEquals(['upstream-3.3/extlib', 'upstream-debian-3.3/extlib',
+            'upstream-ubuntu-3.3/extlib'],
+            self.source.possible_tag_names("3.3", component="extlib"))
 
     def test_pristine_tar_format_gz(self):
         rev = Revision("myrevid")
@@ -734,30 +739,30 @@
         source = TarfileSource("foo-1.0.tar.gz")
         self.assertEquals("1.0", source.get_latest_version("foo", "0.9"))
 
-    def test_fetch_tarball(self):
+    def test_fetch_tarballs(self):
         source = TarfileSource("foo-1.0.tar.gz", "1.0")
         os.mkdir("bar")
         self.assertEquals(["bar/foo_1.0.orig.tar.gz"],
-            source.fetch_tarball("foo", "1.0", "bar"))
+            source.fetch_tarballs("foo", "1.0", "bar"))
         self.assertPathExists("bar/foo_1.0.orig.tar.gz")
 
-    def test_fetch_tarball_repack(self):
+    def test_fetch_tarballs_repack(self):
         zf = zipfile.ZipFile("bla-2.0.zip", "w")
         zf.writestr('avoid', 'empty zip to make the repacker happy\n')
         zf.close()
         source = TarfileSource("bla-2.0.zip", "2.0")
         os.mkdir("bar")
         self.assertEquals(["bar/foo_2.0.orig.tar.gz"],
-            source.fetch_tarball("foo", "2.0", "bar"))
+            source.fetch_tarballs("foo", "2.0", "bar"))
         self.assertPathExists("bar/foo_2.0.orig.tar.gz")
 
-    def test_fetch_tarball_not_present(self):
+    def test_fetch_tarballs_not_present(self):
         source = TarfileSource("foo-1.0.tar.gz", "1.0")
         os.mkdir("bar")
         self.assertRaises(PackageVersionNotPresent,
-            source.fetch_tarball, "foo", "0.9", "bar")
+            source.fetch_tarballs, "foo", "0.9", "bar")
 
-    def test_fetch_tarball_bz2(self):
+    def test_fetch_tarballs_bz2(self):
         tar = tarfile.open("foo-1.0.tar.bz2", "w:bz2")
         tar.close()
         # verify this is a bzip2 file
@@ -765,7 +770,7 @@
         source = TarfileSource("foo-1.0.tar.bz2", "1.0")
         os.mkdir("bar")
         self.assertEquals(["bar/foo_1.0.orig.tar.gz"],
-            source.fetch_tarball("foo", "1.0", "bar"))
+            source.fetch_tarballs("foo", "1.0", "bar"))
         self.assertPathExists("bar/foo_1.0.orig.tar.gz")
         gzip.open("bar/foo_1.0.orig.tar.gz").close()
 

=== modified file 'tests/test_util.py'
--- tests/test_util.py	2011-06-16 11:11:36 +0000
+++ tests/test_util.py	2011-06-27 10:36:00 +0000
@@ -271,14 +271,16 @@
 class TarballNameTests(TestCase):
 
     def test_tarball_name(self):
-        self.assertEqual(tarball_name("package", "0.1"),
-                "package_0.1.orig.tar.gz")
-        self.assertEqual(tarball_name("package", Version("0.1")),
-                "package_0.1.orig.tar.gz")
-        self.assertEqual(tarball_name("package", Version("0.1"),
+        self.assertEqual(tarball_name("package", "0.1", None),
+                "package_0.1.orig.tar.gz")
+        self.assertEqual(tarball_name("package", Version("0.1"), None),
+                "package_0.1.orig.tar.gz")
+        self.assertEqual(tarball_name("package", Version("0.1"), None,
                     format='bz2'), "package_0.1.orig.tar.bz2")
-        self.assertEqual(tarball_name("package", Version("0.1"),
+        self.assertEqual(tarball_name("package", Version("0.1"), None,
                     format='lzma'), "package_0.1.orig.tar.lzma")
+        self.assertEqual(tarball_name("package", Version("0.1"), "la",
+                    format='lzma'), "package_0.1.orig-la.tar.lzma")
 
 
 class SuiteToDistributionTests(TestCase):

=== modified file 'upstream/__init__.py'
--- upstream/__init__.py	2011-06-17 01:37:55 +0000
+++ upstream/__init__.py	2011-06-27 10:36:00 +0000
@@ -81,7 +81,7 @@
         """
         raise NotImplementedError(self.has_version)
 
-    def fetch_tarball(self, package, version, target_dir):
+    def fetch_tarballs(self, package, version, target_dir):
         """Fetch the source tarball for a particular version.
 
         :param package: Name of the package
@@ -89,17 +89,17 @@
         :param target_dir: Directory in which to store the tarball
         :return: Paths of the fetched tarballs
         """
-        raise NotImplementedError(self.fetch_tarball)
+        raise NotImplementedError(self.fetch_tarballs)
 
-    def _tarball_path(self, package, version, target_dir, format=None):
-        return os.path.join(target_dir, tarball_name(package, version,
+    def _tarball_path(self, package, version, component, target_dir, format=None):
+        return os.path.join(target_dir, tarball_name(package, version, component,
                     format=format))
 
 
 class AptSource(UpstreamSource):
     """Upstream source that uses apt-source."""
 
-    def fetch_tarball(self, package, upstream_version, target_dir, 
+    def fetch_tarballs(self, package, upstream_version, target_dir, 
             _apt_pkg=None):
         if _apt_pkg is None:
             import apt_pkg
@@ -184,7 +184,7 @@
         note("get-orig-source did not create file with prefix %s", prefix)
         return None
 
-    def fetch_tarball(self, package, version, target_dir):
+    def fetch_tarballs(self, package, version, target_dir):
         if self.larstiq:
             rules_name = 'rules'
         else:
@@ -266,7 +266,7 @@
             os.unlink(tempfilename)
         return self._xml_report_extract_upstream_version(stdout)
 
-    def fetch_tarball(self, package, version, target_dir):
+    def fetch_tarballs(self, package, version, target_dir):
         note("Using uscan to look for the upstream tarball.")
         try:
             tempfilename = self._export_watchfile()
@@ -285,7 +285,8 @@
         if r != 0:
             note("uscan could not find the needed tarball.")
             raise PackageVersionNotPresent(package, version, self)
-        return [self._tarball_path(package, version, target_dir)]
+        # FIXME: What about the other component tarballs?
+        return [self._tarball_path(package, version, None, target_dir)]
 
 
 class SelfSplitSource(UpstreamSource):
@@ -308,10 +309,10 @@
         finally:
             shutil.rmtree(tmpdir)
 
-    def fetch_tarball(self, package, version, target_dir):
+    def fetch_tarballs(self, package, version, target_dir):
         note("Using the current branch without the 'debian' directory "
                 "to create the tarball")
-        tarball_path = self._tarball_path(package, version, target_dir)
+        tarball_path = self._tarball_path(package, version, None, target_dir)
         self._split(package, version, tarball_path)
         return [tarball_path]
 
@@ -328,10 +329,10 @@
     def __repr__(self):
         return "%s(%r)" % (self.__class__.__name__, self._sources)
 
-    def fetch_tarball(self, package, version, target_dir):
+    def fetch_tarballs(self, package, version, target_dir):
         for source in self._sources:
             try:
-                paths = source.fetch_tarball(package, version, target_dir)
+                paths = source.fetch_tarballs(package, version, target_dir)
             except PackageVersionNotPresent:
                 pass
             else:
@@ -402,7 +403,7 @@
             if not os.path.exists(self.store_dir):
                 os.makedirs(self.store_dir)
             try:
-                paths = self.source.fetch_tarball(self.package,
+                paths = self.source.fetch_tarballs(self.package,
                     self.version, self.store_dir)
             except PackageVersionNotPresent:
                 raise MissingUpstreamTarball(self.package, self.version)
@@ -476,7 +477,7 @@
         self.path = path
         self.version = version
 
-    def fetch_tarball(self, package, version, target_dir):
+    def fetch_tarballs(self, package, version, target_dir):
         if version != self.version:
             raise PackageVersionNotPresent(package, version, self)
         dest_name = tarball_name(package, version)
@@ -521,7 +522,7 @@
         else:
             self.project = project
 
-    def fetch_tarball(self, package, version, target_dir):
+    def fetch_tarballs(self, package, version, target_dir):
         release = self.project.getRelease(version=version)
         if release is None:
             raise PackageVersionNotPresent(package, version, self)

=== modified file 'upstream/branch.py'
--- upstream/branch.py	2011-06-14 12:26:21 +0000
+++ upstream/branch.py	2011-06-27 10:36:00 +0000
@@ -254,7 +254,7 @@
         finally:
             self.upstream_branch.unlock()
 
-    def fetch_tarball(self, package, version, target_dir):
+    def fetch_tarballs(self, package, version, target_dir):
         self.upstream_branch.lock_read()
         try:
             revid = self.version_as_revision(package, version)
@@ -262,7 +262,7 @@
                 raise PackageVersionNotPresent(package, version, self)
             note("Exporting upstream branch revision %s to create the tarball",
                  revid)
-            target_filename = self._tarball_path(package, version, target_dir)
+            target_filename = self._tarball_path(package, version, None, target_dir)
             tarball_base = "%s-%s" % (package, version)
             rev_tree = self.upstream_branch.repository.revision_tree(revid)
             export(rev_tree, target_filename, 'tgz', tarball_base)

=== modified file 'upstream/pristinetar.py'
--- upstream/pristinetar.py	2011-06-23 21:41:36 +0000
+++ upstream/pristinetar.py	2011-06-27 10:36:00 +0000
@@ -118,19 +118,25 @@
     def __repr__(self):
         return "<%s at %s>" % (self.__class__.__name__, self.branch.base)
 
-    def tag_name(self, version, distro=None):
+    def tag_name(self, version, component=None, distro=None):
         """Gets the tag name for the upstream part of version.
 
         :param version: the Version object to extract the upstream
             part of the version number from.
+        :param component: Name of the component (None for base)
+        :param distro: Optional distribution name
         :return: a String with the name of the tag.
         """
         assert isinstance(version, str)
         if distro is None:
-            return "upstream-" + version
-        return "upstream-%s-%s" % (distro, version)
+            name = "upstream-" + version
+        else:
+            name = "upstream-%s-%s" % (distro, version)
+        if component is not None:
+            name += "/%s" % component
+        return name
 
-    def tag_version(self, version, revid):
+    def tag_version(self, version, revid, component=None):
         """Tags the upstream branch's last revision with an upstream version.
 
         Sets a tag on the last revision of the upstream branch and on the main
@@ -139,12 +145,14 @@
 
         :param version: the upstream part of the version number to derive the 
             tag name from.
+        :param component: name of the component that is being imported
+            (None for base)
         :param revid: the revid to associate the tag with, or None for the
             tip of self.pristine_upstream_branch.
         :return The tag name, revid of the added tag.
         """
         assert isinstance(version, str)
-        tag_name = self.tag_name(version)
+        tag_name = self.tag_name(version, component=component)
         self.branch.tags.set_tag(tag_name, revid)
         return tag_name, revid
 
@@ -163,21 +171,28 @@
         revprops = {}
         if md5 is not None:
             revprops["deb-md5"] = md5
-            delta_revprops = self.create_delta_revprops(tree, tarball)
-            revprops.update(delta_revprops)
+            delta = self.make_pristine_tar_delta(tree, tarball)
+            uuencoded = standard_b64encode(delta)
+            if tarball.endswith(".tar.bz2"):
+                revprops["deb-pristine-delta-bz2"] = uuencoded
+            else:
+                revprops["deb-pristine-delta"] = uuencoded
         if author is not None:
             revprops['authors'] = author
         timezone = None
         if timestamp is not None:
             timezone = timestamp[1]
             timestamp = timestamp[0]
-        revid = tree.commit("Import upstream version %s" % (version,),
-                revprops=revprops, timestamp=timestamp, timezone=timezone)
+        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)
         return tag_name, revid
 
-    def fetch_tarball(self, package, version, target_dir):
-        revid = self.version_as_revision(package, version)
+    def fetch_component_tarball(self, package, version, component, target_dir):
+        revid = self.version_component_as_revision(package, version, component)
         try:
             rev = self.branch.repository.get_revision(revid)
         except NoSuchRevision:
@@ -187,7 +202,7 @@
             format = self.pristine_tar_format(rev)
         else:
             format = 'gz'
-        target_filename = self._tarball_path(package, version,
+        target_filename = self._tarball_path(package, version, component,
                                              target_dir, format=format)
         try:
             self.reconstruct_pristine_tar(revid, package, version, target_filename)
@@ -195,9 +210,12 @@
             raise PackageVersionNotPresent(package, version, self)
         except PerFileTimestampsNotSupported:
             raise PackageVersionNotPresent(package, version, self)
-        return [target_filename]
-
-    def _has_version(self, tag_name, tarballs=None):
+        return target_filename
+
+    def fetch_tarballs(self, package, version, target_dir):
+        return [self.fetch_component_tarball(package, version, None, target_dir)]
+
+    def _has_version_component(self, tag_name, md5=None):
         if not self.branch.tags.has_tag(tag_name):
             return False
         revid = self.branch.tags.lookup_tag(tag_name)
@@ -208,11 +226,8 @@
                 return False
         finally:
             self.branch.unlock()
-        if tarballs is None:
+        if md5 is None:
             return True
-        if len(tarballs) != 1:
-            raise MultipleUpstreamTarballsNotSupported()
-        (filename, component, md5) = tarballs[0]
         rev = self.branch.repository.get_revision(revid)
         try:
             return rev.properties['deb-md5'] == md5
@@ -222,29 +237,49 @@
             return True
 
     def version_as_revision(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])
+
+    def version_component_as_revision(self, package, version, component, tarballs=None):
         assert isinstance(version, str)
-        for tag_name in self.possible_tag_names(version):
-            if self._has_version(tag_name, tarballs):
+        for tag_name in self.possible_tag_names(version, component=component):
+            if self._has_version_component(tag_name, tarballs):
                 return self.branch.tags.lookup_tag(tag_name)
-        tag_name = self.tag_name(version)
+        tag_name = self.tag_name(version, component=component)
         try:
             return self.branch.tags.lookup_tag(tag_name)
         except NoSuchTag:
             raise PackageVersionNotPresent(package, version, self)
 
     def has_version(self, package, version, tarballs=None):
+        if tarballs is None:
+            return self.has_version_component(package, version, component=None)
+        elif len(tarballs) > 1:
+            raise MultipleUpstreamTarballsNotSupported()
+        else:
+            return self.has_version_component(package, version, tarballs[0][1],
+                    tarballs[0][2])
+
+    def has_version_component(self, package, version, component, md5=None):
         assert isinstance(version, str), str(type(version))
-        for tag_name in self.possible_tag_names(version):
-            if self._has_version(tag_name, tarballs=tarballs):
+        for tag_name in self.possible_tag_names(version, component=component):
+            if self._has_version_component(tag_name, md5=md5):
                 return True
         return False
 
-    def possible_tag_names(self, version):
+    def possible_tag_names(self, version, component):
         assert isinstance(version, str)
-        tags = [self.tag_name(version),
-                self.tag_name(version, distro="debian"),
-                self.tag_name(version, distro="ubuntu"),
-                "upstream/%s" % version]
+        tags = [self.tag_name(version, component=component),
+                self.tag_name(version, component=component, distro="debian"),
+                self.tag_name(version, component=component, distro="ubuntu"),
+                ]
+        if component is None:
+            # compatibility with git-buildpackage
+            tags += ["upstream/%s" % version]
         return tags
 
     def has_pristine_tar_delta(self, rev):
@@ -302,19 +337,3 @@
             return make_pristine_tar_delta(dest, tarball_path)
         finally:
             shutil.rmtree(tmpdir)
-
-    def create_delta_revprops(self, tree, tarball):
-        """Create the revision properties with the pristine tar delta.
-
-        :param tree: Bazaar Tree to diff against
-        :param tarball: The pristine tarball
-        :return: Dictionary with extra revision properties
-        """
-        ret = {}
-        delta = self.make_pristine_tar_delta(tree, tarball)
-        uuencoded = standard_b64encode(delta)
-        if tarball.endswith(".tar.bz2"):
-            ret["deb-pristine-delta-bz2"] = uuencoded
-        else:
-            ret["deb-pristine-delta"] = uuencoded
-        return ret

=== modified file 'util.py'
--- util.py	2011-06-15 19:09:24 +0000
+++ util.py	2011-06-27 10:36:00 +0000
@@ -209,19 +209,22 @@
         return changes
 
 
-def tarball_name(package, version, format=None):
+def tarball_name(package, version, component=None, format=None):
     """Return the name of the .orig.tar.gz for the given package and version.
 
     :param package: the name of the source package.
     :param version: the upstream version of the package.
+    :param component: Component name (None for base)
     :param format: the format for the tarball. If None then 'gz' will be
          used. You probably want on of 'gz', 'bz2', or 'lzma'.
     :return: a string that is the name of the upstream tarball to use.
     """
     if format is None:
         format = 'gz'
-    return "%s_%s.orig.tar.%s" % (package, str(version), format)
-
+    name = "%s_%s.orig" % (package, str(version))
+    if component is not None:
+        name += "-" + component
+    return "%s.tar.%s" % (name, format)
 
 
 def suite_to_distribution(suite):