Merge lp:~jelmer/bzr-builddeb/refactor-upstream-2 into lp:~jelmer/bzr-builddeb/refactor-upstream

[Jelmer Vernooij]

Refactoring of the upstream module - move UpstreamBranchSource into its own module, as well as its support code which is currently spread out across util and merge_upstream.

[James Westby (james-w)]

review: Approve

=== modified file 'cmds.py'
--- cmds.py	2011-01-24 06:23:40 +0000
+++ cmds.py	2011-01-28 23:09:00 +0000
@@ -96,6 +96,8 @@
         StackedUpstreamSource,
         UScanSource,
         UpstreamProvider,
+        )
+from bzrlib.plugins.builddeb.upstream.branch import (
         UpstreamBranchSource,
         )
 from bzrlib.plugins.builddeb.util import (

=== modified file 'merge_upstream.py'
--- merge_upstream.py	2011-01-24 02:16:17 +0000
+++ merge_upstream.py	2011-01-28 23:09:00 +0000
@@ -34,152 +34,9 @@
     # Prior to 0.1.15 the debian module was called debian_bundle
     from debian_bundle.changelog import Version
 
-from bzrlib.errors import InvalidRevisionId
-from bzrlib.revisionspec import RevisionSpec
-
-from bzrlib.plugins.builddeb.util import get_snapshot_revision
-
-
 TAG_PREFIX = "upstream-"
 
 
-def extract_svn_revno(rev):
-    """Extract the Subversion number of a revision from a revision.
-
-    :param rev: Revision object
-    :return: Revision number, None if this was not a Subversion revision or
-         if the revision number could not be determined (bzr-svn not available).
-    """
-    try:
-        from bzrlib.plugins.svn import extract_svn_foreign_revid
-    except ImportError:
-        # No svn support
-        return None
-    else:
-        try:
-            (svn_uuid, branch_path, svn_revno) = extract_svn_foreign_revid(rev)
-        except InvalidRevisionId:
-            return None
-        else:
-            return svn_revno
-
-
-def upstream_version_add_revision(upstream_branch, version_string, revid):
-    """Update the revision in a upstream version string.
-
-    :param branch: Branch in which the revision can be found
-    :param version_string: Original version string
-    :param revid: Revision id of the revision
-    """
-    revno = upstream_branch.revision_id_to_revno(revid)
-
-    if "+bzr" in version_string:
-        return "%s+bzr%d" % (version_string[:version_string.rfind("+bzr")], revno)
-
-    if "~bzr" in version_string:
-        return "%s~bzr%d" % (version_string[:version_string.rfind("~bzr")], revno)
-
-    rev = upstream_branch.repository.get_revision(revid)
-    svn_revno = extract_svn_revno(rev)
-
-    # FIXME: Raise error if +svn/~svn is present and svn_revno is not set?
-    if "+svn" in version_string and svn_revno:
-        return "%s+svn%d" % (version_string[:version_string.rfind("+svn")], svn_revno)
-    if "~svn" in version_string and svn_revno:
-        return "%s~svn%d" % (version_string[:version_string.rfind("~svn")], svn_revno)
-
-    if svn_revno:
-        return "%s+svn%d" % (version_string, svn_revno)
-    else:
-        return "%s+bzr%d" % (version_string, revno)
-
-
-def _upstream_branch_version(revhistory, reverse_tag_dict, package, 
-                            previous_version, add_rev):
-    """Determine the version string of an upstream branch.
-
-    The upstream version is determined from the most recent tag
-    in the upstream branch. If that tag does not point at the last revision, 
-    the revision number is added to it (<version>+bzr<revno>).
-
-    If there are no tags set on the upstream branch, the previous Debian 
-    version is used and combined with the bzr revision number 
-    (usually <version>+bzr<revno>).
-
-    :param revhistory: Branch revision history.
-    :param reverse_tag_dict: Reverse tag dictionary (revid -> list of tags)
-    :param package: Name of package.
-    :param previous_version: Previous upstream version in debian changelog.
-    :param add_rev: Function that can add a revision suffix to a version string.
-    :return: Name of the upstream revision.
-    """
-    if revhistory == []:
-        # No new version to merge
-        return Version(previous_version)
-    for r in reversed(revhistory):
-        if r in reverse_tag_dict:
-            # If there is a newer version tagged in branch, 
-            # convert to upstream version 
-            # return <upstream_version>+bzr<revno>
-            for tag in reverse_tag_dict[r]:
-                upstream_version = upstream_tag_to_version(tag,
-                                                   package=package)
-                if upstream_version is not None:
-                    if r != revhistory[-1]:
-                        upstream_version.upstream_version = add_rev(
-                          upstream_version.upstream_version, revhistory[-1])
-                    return upstream_version
-    return Version(add_rev(previous_version, revhistory[-1]))
-
-
-def upstream_branch_version(upstream_branch, upstream_revision, package,
-        previous_version):
-    """Determine the version string for a revision in an upstream branch.
-
-    :param upstream_branch: The upstream branch object
-    :param upstream_revision: The revision id of the upstream revision
-    :param package: The name of the package
-    :param previous_version: The previous upstream version string
-    :return: Upstream version string for `upstream_revision`.
-    """
-    dotted_revno = upstream_branch.revision_id_to_dotted_revno(upstream_revision)
-    if len(dotted_revno) > 1:
-        revno = -2
-    else:
-        revno = dotted_revno[0]
-    revhistory = upstream_branch.revision_history()
-    previous_revision = get_snapshot_revision(previous_version)
-    if previous_revision is not None:
-        previous_revspec = RevisionSpec.from_string(previous_revision)
-        previous_revno, _ = previous_revspec.in_history(upstream_branch)
-        # Trim revision history - we don't care about any revisions
-        # before the revision of the previous version
-    else:
-        previous_revno = 0
-    revhistory = revhistory[previous_revno:revno+1]
-    return _upstream_branch_version(revhistory,
-            upstream_branch.tags.get_reverse_tag_dict(), package,
-            previous_version,
-            lambda version, revision: upstream_version_add_revision(upstream_branch, version, revision))
-
-
-def upstream_tag_to_version(tag_name, package=None):
-    """Take a tag name and return the upstream version, or None."""
-    if tag_name.startswith(TAG_PREFIX):
-        return Version(tag_name[len(TAG_PREFIX):])
-    if (package is not None and (
-          tag_name.startswith("%s-" % package) or
-          tag_name.startswith("%s_" % package))):
-        return Version(tag_name[len(package)+1:])
-    if tag_name.startswith("release-"):
-        return Version(tag_name[len("release-"):])
-    if tag_name[0] == "v" and tag_name[1].isdigit():
-        return Version(tag_name[1:])
-    if all([c.isdigit() or c in (".", "~") for c in tag_name]):
-        return Version(tag_name)
-    return None
-
-
 def package_version(upstream_version, distribution_name):
     """Determine the package version for a new upstream.
 

=== modified file 'tests/test_config.py'
--- tests/test_config.py	2011-01-10 23:04:04 +0000
+++ tests/test_config.py	2011-01-28 23:09:00 +0000
@@ -79,7 +79,7 @@
 
   def test_no_entry(self):
     self.assertEqual(self.config.merge, False)
-    self.assertEqual(self.config.build_type, BUILD_TYPE_NORMAL)
+    self.assertEqual(self.config.build_type, None)
 
   def test_parse_error(self):
     f = open('invalid.conf', 'wb')

=== modified file 'tests/test_merge_upstream.py'
--- tests/test_merge_upstream.py	2011-01-17 22:18:44 +0000
+++ tests/test_merge_upstream.py	2011-01-28 23:09:00 +0000
@@ -28,118 +28,9 @@
 from bzrlib.tests import TestCase, TestCaseWithTransport
 
 from bzrlib.plugins.builddeb.merge_upstream import (
-        upstream_merge_changelog_line,
-        package_version,
-        _upstream_branch_version,
-        upstream_tag_to_version,
-        upstream_version_add_revision
-        )
-
-
-class TestUpstreamVersionAddRevision(TestCaseWithTransport):
-  """Test that updating the version string works."""
-
-  def setUp(self):
-    super(TestUpstreamVersionAddRevision, self).setUp()
-    self.revnos = {}
-    self.svn_revnos = {"somesvnrev": 45}
-    self.revnos = {"somerev": 42, "somesvnrev": 12}
-    self.repository = self
-
-  def revision_id_to_revno(self, revid):
-    return self.revnos[revid]
-
-  def get_revision(self, revid):
-    rev = Revision(revid)
-    if revid in self.svn_revnos:
-      rev.foreign_revid = ("uuid", "bp", self.svn_revnos[revid])
-    return rev
-
-  def test_update_plus_rev(self):
-    self.assertEquals("1.3+bzr42", 
-        upstream_version_add_revision(self, "1.3+bzr23", "somerev"))
-
-  def test_update_tilde_rev(self):
-    self.assertEquals("1.3~bzr42", 
-        upstream_version_add_revision(self, "1.3~bzr23", "somerev"))
-
-  def test_new_rev(self):
-    self.assertEquals("1.3+bzr42", 
-        upstream_version_add_revision(self, "1.3", "somerev"))
-
-  def test_svn_new_rev(self):
-    self.assertEquals("1.3+svn45", 
-        upstream_version_add_revision(self, "1.3", "somesvnrev"))
-
-  def test_svn_plus_rev(self):
-    self.assertEquals("1.3+svn45", 
-        upstream_version_add_revision(self, "1.3+svn3", "somesvnrev"))
-
-  def test_svn_tilde_rev(self):
-    self.assertEquals("1.3~svn45", 
-        upstream_version_add_revision(self, "1.3~svn800", "somesvnrev"))
-
-
-class TestUpstreamBranchVersion(TestCase):
-  """Test that the upstream version of a branch can be determined correctly.
-  """
-
-  def get_suffix(self, version_string, revid):
-    revno = self.revhistory.index(revid)+1
-    if "bzr" in version_string:
-      return "%sbzr%d" % (version_string.split("bzr")[0], revno)
-    return "%s+bzr%d" % (version_string, revno)
-
-  def test_snapshot_none_existing(self):
-    self.revhistory = ["somerevid"]
-    self.assertEquals(Version("1.2+bzr1"),
-        _upstream_branch_version(self.revhistory, {}, "bla", "1.2", self.get_suffix))
-
-  def test_snapshot_nothing_new(self):
-    self.revhistory = []
-    self.assertEquals(Version("1.2"),
-        _upstream_branch_version(self.revhistory, {}, "bla", "1.2", self.get_suffix))
-
-  def test_new_tagged_release(self):
-    """Last revision is tagged - use as upstream version."""
-    self.revhistory = ["somerevid"]
-    self.assertEquals(Version("1.3"), 
-        _upstream_branch_version(self.revhistory, {"somerevid": ["1.3"]}, "bla", "1.2", self.get_suffix))
-
-  def test_refresh_snapshot_pre(self):
-    self.revhistory = ["oldrevid", "somerevid"]
-    self.assertEquals(Version("1.3~bzr2"), 
-        _upstream_branch_version(self.revhistory, {}, "bla", "1.3~bzr1", self.get_suffix))
-
-  def test_refresh_snapshot_post(self):
-    self.revhistory = ["oldrevid", "somerevid"]
-    self.assertEquals(Version("1.3+bzr2"), 
-        _upstream_branch_version(self.revhistory, {}, "bla", "1.3+bzr1", self.get_suffix))
-
-  def test_new_tag_refresh_snapshot(self):
-    self.revhistory = ["oldrevid", "somerevid", "newrevid"]
-    self.assertEquals(Version("1.3+bzr3"), 
-        _upstream_branch_version(self.revhistory, 
-                                {"somerevid": ["1.3"]}, "bla", "1.2+bzr1", self.get_suffix))
-
-
-class TestUpstreamTagToVersion(TestCase):
-
-  def test_prefix(self):
-    self.assertEquals(Version("5.0"), upstream_tag_to_version("upstream-5.0"))
-
-  def test_gibberish(self):
-    self.assertIs(None, upstream_tag_to_version("blabla"))
-
-  def test_vprefix(self):
-    self.assertEquals(Version("2.0"), upstream_tag_to_version("v2.0"))
-
-  def test_plain(self):
-    self.assertEquals(Version("2.0"), upstream_tag_to_version("2.0"))
-
-  def test_package_prefix(self):
-    self.assertEquals(Version("42.0"), upstream_tag_to_version("bla-42.0", "bla"))
-
+    upstream_merge_changelog_line,
+    package_version,
+    )
 
 class TestPackageVersion(TestCase):
 

=== modified file 'tests/test_upstream.py'
--- tests/test_upstream.py	2011-01-24 05:46:47 +0000
+++ tests/test_upstream.py	2011-01-28 23:09:00 +0000
@@ -25,6 +25,9 @@
 
 import os
 
+from bzrlib.revision import (
+    Revision,
+    )
 from bzrlib.tests import (
     TestCase,
     TestCaseWithTransport,
@@ -40,11 +43,16 @@
 from bzrlib.plugins.builddeb.upstream import (
     AptSource,
     StackedUpstreamSource,
-    UpstreamBranchSource,
     UpstreamProvider,
     UScanSource,
     Version,
     )
+from bzrlib.plugins.builddeb.upstream.branch import (
+    UpstreamBranchSource,
+    _upstream_branch_version,
+    upstream_tag_to_version,
+    upstream_version_add_revision
+    )
 
 
 class MockSources(object):
@@ -328,6 +336,111 @@
         self.assertEquals(revid1, source.version_as_revision("foo", "2.1"))
 
 
+class TestUpstreamBranchVersion(TestCase):
+    """Test that the upstream version of a branch can be determined correctly.
+    """
+
+    def get_suffix(self, version_string, revid):
+        revno = self.revhistory.index(revid)+1
+        if "bzr" in version_string:
+            return "%sbzr%d" % (version_string.split("bzr")[0], revno)
+        return "%s+bzr%d" % (version_string, revno)
+
+    def test_snapshot_none_existing(self):
+      self.revhistory = ["somerevid"]
+      self.assertEquals(Version("1.2+bzr1"),
+          _upstream_branch_version(self.revhistory, {}, "bla", "1.2", self.get_suffix))
+
+    def test_snapshot_nothing_new(self):
+      self.revhistory = []
+      self.assertEquals(Version("1.2"),
+          _upstream_branch_version(self.revhistory, {}, "bla", "1.2", self.get_suffix))
+
+    def test_new_tagged_release(self):
+      """Last revision is tagged - use as upstream version."""
+      self.revhistory = ["somerevid"]
+      self.assertEquals(Version("1.3"), 
+          _upstream_branch_version(self.revhistory, {"somerevid": ["1.3"]}, "bla", "1.2", self.get_suffix))
+
+    def test_refresh_snapshot_pre(self):
+      self.revhistory = ["oldrevid", "somerevid"]
+      self.assertEquals(Version("1.3~bzr2"), 
+          _upstream_branch_version(self.revhistory, {}, "bla", "1.3~bzr1", self.get_suffix))
+
+    def test_refresh_snapshot_post(self):
+      self.revhistory = ["oldrevid", "somerevid"]
+      self.assertEquals(Version("1.3+bzr2"), 
+          _upstream_branch_version(self.revhistory, {}, "bla", "1.3+bzr1", self.get_suffix))
+
+    def test_new_tag_refresh_snapshot(self):
+      self.revhistory = ["oldrevid", "somerevid", "newrevid"]
+      self.assertEquals(Version("1.3+bzr3"), 
+            _upstream_branch_version(self.revhistory, 
+                {"somerevid": ["1.3"]}, "bla", "1.2+bzr1", self.get_suffix))
+
+
+class TestUpstreamTagToVersion(TestCase):
+
+    def test_prefix(self):
+        self.assertEquals(Version("5.0"), upstream_tag_to_version("release-5.0"))
+
+    def test_gibberish(self):
+        self.assertIs(None, upstream_tag_to_version("blabla"))
+
+    def test_vprefix(self):
+        self.assertEquals(Version("2.0"), upstream_tag_to_version("v2.0"))
+
+    def test_plain(self):
+        self.assertEquals(Version("2.0"), upstream_tag_to_version("2.0"))
+
+    def test_package_prefix(self):
+        self.assertEquals(Version("42.0"), upstream_tag_to_version("bla-42.0", "bla"))
+
+
+class TestUpstreamVersionAddRevision(TestCaseWithTransport):
+    """Test that updating the version string works."""
+
+    def setUp(self):
+        super(TestUpstreamVersionAddRevision, self).setUp()
+        self.revnos = {}
+        self.svn_revnos = {"somesvnrev": 45}
+        self.revnos = {"somerev": 42, "somesvnrev": 12}
+        self.repository = self
+
+    def revision_id_to_revno(self, revid):
+        return self.revnos[revid]
+
+    def get_revision(self, revid):
+        rev = Revision(revid)
+        if revid in self.svn_revnos:
+            rev.foreign_revid = ("uuid", "bp", self.svn_revnos[revid])
+        return rev
+
+    def test_update_plus_rev(self):
+        self.assertEquals("1.3+bzr42", 
+          upstream_version_add_revision(self, "1.3+bzr23", "somerev"))
+
+    def test_update_tilde_rev(self):
+        self.assertEquals("1.3~bzr42", 
+          upstream_version_add_revision(self, "1.3~bzr23", "somerev"))
+
+    def test_new_rev(self):
+        self.assertEquals("1.3+bzr42", 
+          upstream_version_add_revision(self, "1.3", "somerev"))
+
+    def test_svn_new_rev(self):
+        self.assertEquals("1.3+svn45", 
+          upstream_version_add_revision(self, "1.3", "somesvnrev"))
+
+    def test_svn_plus_rev(self):
+        self.assertEquals("1.3+svn45", 
+          upstream_version_add_revision(self, "1.3+svn3", "somesvnrev"))
+
+    def test_svn_tilde_rev(self):
+        self.assertEquals("1.3~svn45", 
+            upstream_version_add_revision(self, "1.3~svn800", "somesvnrev"))
+
+
 class _MissingUpstreamProvider(UpstreamProvider):
     """For tests"""
 

=== added directory 'upstream'
=== renamed file 'upstream.py' => 'upstream/__init__.py'
--- upstream.py	2011-01-28 18:17:39 +0000
+++ upstream/__init__.py	2011-01-28 23:09:00 +0000
@@ -30,7 +30,6 @@
     # Prior to 0.1.15 the debian module was called debian_bundle
     from debian_bundle.changelog import Version
 
-from bzrlib.revisionspec import RevisionSpec
 from bzrlib.trace import (
     note,
     warning,
@@ -47,7 +46,6 @@
 from bzrlib.plugins.builddeb.repack_tarball import repack_tarball
 from bzrlib.plugins.builddeb.util import (
     export,
-    get_snapshot_revision,
     tarball_name,
     )
 
@@ -168,63 +166,6 @@
         return True
 
 
-class UpstreamBranchSource(UpstreamSource):
-    """Upstream source that uses the upstream branch.
-
-    :ivar upstream_branch: Branch with upstream sources
-    :ivar upstream_version_map: Map from version strings to revids
-    """
-
-    def __init__(self, upstream_branch, upstream_revision_map=None,
-                 config=None):
-        self.upstream_branch = upstream_branch
-        self.config = config
-        if upstream_revision_map is None:
-            self.upstream_revision_map = {}
-        else:
-            self.upstream_revision_map = upstream_revision_map
-
-    def version_as_revision(self, package, version):
-        if version in self.upstream_revision_map:
-             return self.upstream_revision_map[version]
-        revspec = get_snapshot_revision(version)
-        if revspec is not None:
-            return RevisionSpec.from_string(
-                revspec).as_revision_id(self.upstream_branch)
-        return None
-
-    def get_latest_version(self, package, current_version):
-        return self.get_version(package, current_version,
-            self.upstream_branch.last_revision())
-
-    def get_version(self, package, current_version, revision):
-        from bzrlib.plugins.builddeb.merge_upstream import (
-            upstream_branch_version)
-        version = str(upstream_branch_version(self.upstream_branch,
-            revision, package, current_version))
-        return version
-
-    def fetch_tarball(self, package, version, target_dir):
-        self.upstream_branch.lock_read()
-        try:
-            revid = self.version_as_revision(package, version)
-            if revid is None:
-                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)
-            tarball_base = "%s-%s" % (package, version)
-            rev_tree = self.upstream_branch.repository.revision_tree(revid)
-            export(rev_tree, target_filename, 'tgz', tarball_base)
-        finally:
-            self.upstream_branch.unlock()
-        return target_filename
-
-    def __repr__(self):
-        return "<%s for %r>" % (self.__class__.__name__,
-            self.upstream_branch.base)
-
-
 class GetOrigSourceSource(UpstreamSource):
     """Upstream source that uses the get-orig-source rule in debian/rules."""
 

=== added file 'upstream/branch.py'
--- upstream/branch.py	1970-01-01 00:00:00 +0000
+++ upstream/branch.py	2011-01-28 23:09:00 +0000
@@ -0,0 +1,219 @@
+#    upstream/branch.py -- Upstream branch source provider
+#    Copyright (C) 2010-2011 Canonical Ltd.
+#    Copyright (C) 2009 Jelmer Vernooij
+#
+#    This file is part of bzr-builddeb.
+#
+#    bzr-builddeb is free software; you can redistribute it and/or modify
+#    it under the terms of the GNU General Public License as published by
+#    the Free Software Foundation; either version 2 of the License, or
+#    (at your option) any later version.
+#
+#    bzr-builddeb is distributed in the hope that it will be useful,
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#    GNU General Public License for more details.
+#
+#    You should have received a copy of the GNU General Public License
+#    along with bzr-builddeb; if not, write to the Free Software
+#    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+from bzrlib.errors import InvalidRevisionId
+from bzrlib.revisionspec import RevisionSpec
+from bzrlib.trace import note
+
+from bzrlib.plugins.builddeb.errors import PackageVersionNotPresent
+from bzrlib.plugins.builddeb.upstream import UpstreamSource
+from bzrlib.plugins.builddeb.util import (
+    export,
+    get_snapshot_revision,
+    )
+
+
+def upstream_tag_to_version(tag_name, package=None):
+    """Take a tag name and return the upstream version, or None."""
+    if (package is not None and (
+          tag_name.startswith("%s-" % package) or
+          tag_name.startswith("%s_" % package))):
+        return tag_name[len(package)+1:]
+    if tag_name.startswith("release-"):
+        return tag_name[len("release-"):]
+    if tag_name[0] == "v" and tag_name[1].isdigit():
+        return tag_name[1:]
+    if all([c.isdigit() or c in (".", "~") for c in tag_name]):
+        return tag_name
+    return None
+
+
+def _upstream_branch_version(revhistory, reverse_tag_dict, package,
+                            previous_version, add_rev):
+    """Determine the version string of an upstream branch.
+
+    The upstream version is determined from the most recent tag
+    in the upstream branch. If that tag does not point at the last revision,
+    the revision number is added to it (<version>+bzr<revno>).
+
+    If there are no tags set on the upstream branch, the previous Debian
+    version is used and combined with the bzr revision number
+    (usually <version>+bzr<revno>).
+
+    :param revhistory: Branch revision history.
+    :param reverse_tag_dict: Reverse tag dictionary (revid -> list of tags)
+    :param package: Name of package.
+    :param previous_version: Previous upstream version in debian changelog.
+    :param add_rev: Function that can add a revision suffix to a version string.
+    :return: Name of the upstream revision.
+    """
+    if revhistory == []:
+        # No new version to merge
+        return previous_version
+    for r in reversed(revhistory):
+        if r in reverse_tag_dict:
+            # If there is a newer version tagged in branch,
+            # convert to upstream version
+            # return <upstream_version>+bzr<revno>
+            for tag in reverse_tag_dict[r]:
+                upstream_version = upstream_tag_to_version(tag,
+                                                   package=package)
+                if upstream_version is not None:
+                    if r != revhistory[-1]:
+                        upstream_version = add_rev(
+                          upstream_version, revhistory[-1])
+                    return upstream_version
+    return add_rev(previous_version, revhistory[-1])
+
+
+def extract_svn_revno(rev):
+    """Extract the Subversion number of a revision from a revision.
+
+    :param rev: Revision object
+    :return: Revision number, None if this was not a Subversion revision or
+         if the revision number could not be determined (bzr-svn not available).
+    """
+    try:
+        from bzrlib.plugins.svn import extract_svn_foreign_revid
+    except ImportError:
+        # No svn support
+        return None
+    else:
+        try:
+            (svn_uuid, branch_path, svn_revno) = extract_svn_foreign_revid(rev)
+        except InvalidRevisionId:
+            return None
+        else:
+            return svn_revno
+
+
+def upstream_version_add_revision(upstream_branch, version_string, revid):
+    """Update the revision in a upstream version string.
+
+    :param branch: Branch in which the revision can be found
+    :param version_string: Original version string
+    :param revid: Revision id of the revision
+    """
+    revno = upstream_branch.revision_id_to_revno(revid)
+
+    if "+bzr" in version_string:
+        return "%s+bzr%d" % (version_string[:version_string.rfind("+bzr")], revno)
+
+    if "~bzr" in version_string:
+        return "%s~bzr%d" % (version_string[:version_string.rfind("~bzr")], revno)
+
+    rev = upstream_branch.repository.get_revision(revid)
+    svn_revno = extract_svn_revno(rev)
+
+    # FIXME: Raise error if +svn/~svn is present and svn_revno is not set?
+    if "+svn" in version_string and svn_revno:
+        return "%s+svn%d" % (version_string[:version_string.rfind("+svn")], svn_revno)
+    if "~svn" in version_string and svn_revno:
+        return "%s~svn%d" % (version_string[:version_string.rfind("~svn")], svn_revno)
+
+    if svn_revno:
+        return "%s+svn%d" % (version_string, svn_revno)
+    else:
+        return "%s+bzr%d" % (version_string, revno)
+
+
+def upstream_branch_version(upstream_branch, upstream_revision, package,
+        previous_version):
+    """Determine the version string for a revision in an upstream branch.
+
+    :param upstream_branch: The upstream branch object
+    :param upstream_revision: The revision id of the upstream revision
+    :param package: The name of the package
+    :param previous_version: The previous upstream version string
+    :return: Upstream version string for `upstream_revision`.
+    """
+    dotted_revno = upstream_branch.revision_id_to_dotted_revno(upstream_revision)
+    if len(dotted_revno) > 1:
+        revno = -2
+    else:
+        revno = dotted_revno[0]
+    revhistory = upstream_branch.revision_history()
+    previous_revision = get_snapshot_revision(previous_version)
+    if previous_revision is not None:
+        previous_revspec = RevisionSpec.from_string(previous_revision)
+        previous_revno, _ = previous_revspec.in_history(upstream_branch)
+        # Trim revision history - we don't care about any revisions
+        # before the revision of the previous version
+    else:
+        previous_revno = 0
+    revhistory = revhistory[previous_revno:revno+1]
+    return _upstream_branch_version(revhistory,
+            upstream_branch.tags.get_reverse_tag_dict(), package,
+            previous_version,
+            lambda version, revision: upstream_version_add_revision(upstream_branch, version, revision))
+
+
+class UpstreamBranchSource(UpstreamSource):
+    """Upstream source that uses the upstream branch.
+
+    :ivar upstream_branch: Branch with upstream sources
+    :ivar upstream_version_map: Map from version strings to revids
+    """
+
+    def __init__(self, upstream_branch, upstream_revision_map=None,
+                 config=None):
+        self.upstream_branch = upstream_branch
+        self.config = config
+        if upstream_revision_map is None:
+            self.upstream_revision_map = {}
+        else:
+            self.upstream_revision_map = upstream_revision_map
+
+    def version_as_revision(self, package, version):
+        if version in self.upstream_revision_map:
+             return self.upstream_revision_map[version]
+        revspec = get_snapshot_revision(version)
+        if revspec is not None:
+            return RevisionSpec.from_string(
+                revspec).as_revision_id(self.upstream_branch)
+        return None
+
+    def get_latest_version(self, package, current_version):
+        return self.get_version(package, current_version,
+            self.upstream_branch.last_revision())
+
+    def get_version(self, package, current_version, revision):
+        return upstream_branch_version(self.upstream_branch,
+            revision, package, current_version)
+
+    def fetch_tarball(self, package, version, target_dir):
+        self.upstream_branch.lock_read()
+        try:
+            revid = self.version_as_revision(package, version)
+            if revid is None:
+                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)
+            tarball_base = "%s-%s" % (package, version)
+            rev_tree = self.upstream_branch.repository.revision_tree(revid)
+            export(rev_tree, target_filename, 'tgz', tarball_base)
+        finally:
+            self.upstream_branch.unlock()
+        return target_filename
+
+    def __repr__(self):
+        return "<%s for %r>" % (self.__class__.__name__,
+            self.upstream_branch.base)