Merge lp:~jelmer/bzr-builddeb/709263-previous-to-pocket into lp:~jelmer/bzr-builddeb/recommend-lplib

[Jelmer Vernooij]

Fix builds where the previous upload was to a pocket.

[James Westby (james-w)]

Hi,

are you sure this is the proposal you intended to make? The diff is huge.

Thanks,

James

[lp:~jelmer/bzr-builddeb/709263-previous-to-pocket]

495. By Jelmer Vernooij on 2011-01-28

Merge support for building package where previous upload was to a non-release pocket.

496. By Jelmer Vernooij on 2011-01-28

Merge refactoring of get_export_upstream_revision to take an upstream version string rather than a Version object.

497. By Jelmer Vernooij on 2011-01-28

Merge rename of get_specific_version to fetch_tall and returning of tarball path.

498. By Jelmer Vernooij on 2011-01-28

Merge change of get_latest_version to return latest version string rather than fetching tarball.

499. By Jelmer Vernooij on 2011-01-29

Merge fix to allow version argument to be optional.

500. By Jelmer Vernooij on 2011-01-29

Merge support for using 'bzr merge-upstream' in merge mode.

501. By Jelmer Vernooij on 2011-01-29

Quick fix for merge-upstream command logic.

I'll work on more tests for this code.

502. By Jelmer Vernooij on 2011-01-29

Merge support for preserving epochs.

503. By Jelmer Vernooij on 2011-01-30

'bzr merge-upstream' now errors out if the upstream version has already been merged.

Previously it would happily update the changelog with newer versions when the
branch was being used in 'merge' mode.

504. By Jelmer Vernooij on 2011-01-30

Prevent merge of old upstream version in merge-upstream. LP: #567742

Unmerged revisions

504. By Jelmer Vernooij on 2011-01-30

Prevent merge of old upstream version in merge-upstream. LP: #567742

503. By Jelmer Vernooij on 2011-01-30

'bzr merge-upstream' now errors out if the upstream version has already been merged.

Previously it would happily update the changelog with newer versions when the
branch was being used in 'merge' mode.

502. By Jelmer Vernooij on 2011-01-29

Merge support for preserving epochs.

501. By Jelmer Vernooij on 2011-01-29

Quick fix for merge-upstream command logic.

I'll work on more tests for this code.

500. By Jelmer Vernooij on 2011-01-29

Merge support for using 'bzr merge-upstream' in merge mode.

499. By Jelmer Vernooij on 2011-01-29

Merge fix to allow version argument to be optional.

498. By Jelmer Vernooij on 2011-01-28

Merge change of get_latest_version to return latest version string rather than fetching tarball.

497. By Jelmer Vernooij on 2011-01-28

Merge rename of get_specific_version to fetch_tall and returning of tarball path.

496. By Jelmer Vernooij on 2011-01-28

Merge refactoring of get_export_upstream_revision to take an upstream version string rather than a Version object.

495. By Jelmer Vernooij on 2011-01-28

Merge support for building package where previous upload was to a non-release pocket.

=== added file '.bzrignore'
--- .bzrignore	1970-01-01 00:00:00 +0000
+++ .bzrignore	2011-01-28 14:24:44 +0000
@@ -0,0 +1,1 @@
+.testrepository

=== added file '.testr.conf'
--- .testr.conf	1970-01-01 00:00:00 +0000
+++ .testr.conf	2011-01-28 14:24:44 +0000
@@ -0,0 +1,4 @@
+[DEFAULT]
+# not quite ideal, because 'all tests' is too many, and 'just builddeb' is too few.
+test_command=bzr selftest --subunit $IDOPTION
+test_id_option=--load-list $IDFILE

=== modified file 'README'
--- README	2009-03-02 22:06:20 +0000
+++ README	2011-01-28 14:24:44 +0000
@@ -18,16 +18,14 @@
 ------------
 
 This plugin requires `python-debian`_ (at least version 0.1.11),
-and a version of bzr at least 1.2. It also requires the
-`bzrtools`_ plugin to be installed. These are available in Debian
+and a version of bzr at least 2.1. These are available in Debian
 (though maybe not at the required versions for a development version
- of builddeb).
+of builddeb).
 
 .. _python-debian: http://bzr.debian.org/pkg-python-debian/trunk/
-.. _bzrtools: https://launchpad.net/bzrtools
 
 This plugin can be installed in two ways. As you are probably using a Debian
-system you can probably just use the debian packages. The other way is to 
+system you can probably just use the Debian packages. The other way is to 
 branch it in to ``~/.bazaar/plugins/builddeb``, i.e::
 
   bzr branch http://jameswestby.net/bzr/bzr-builddeb/ \
@@ -262,7 +260,7 @@
   $ bzr ci
 
 There are two options when you want to build a Debian package, whether
-it is a native package or not. Most packages are non-native so I will desribe
+it is a native package or not. Most packages are non-native so I will describe
 that first.
 
 To create a non-native package you need an upstream tarball to build against.

=== modified file '__init__.py'
--- __init__.py	2009-07-26 15:51:02 +0000
+++ __init__.py	2011-01-28 14:24:44 +0000
@@ -25,21 +25,44 @@
 
 import os
 
-from bzrlib import msgeditor
+import bzrlib
+from bzrlib import (
+    branch as _mod_branch,
+    errors,
+    merge,
+    msgeditor,
+    )
 from bzrlib.commands import plugin_cmds
+from bzrlib.config import config_dir
 from bzrlib.directory_service import directories
 
 from info import (
     bzr_plugin_version as version_info,
     )
 
+
+if getattr(merge, 'ConfigurableFileMerger', None) is None:
+    raise ImportError(
+        'need at least bzr 2.1.0rc2 (you use %r)', bzrlib.version_info)
+else:
+    def changelog_merge_hook_factory(merger):
+        from bzrlib.plugins.builddeb import merge_changelog
+        return merge_changelog.ChangeLogFileMerge(merger)
+
+    merge.Merger.hooks.install_named_hook(
+        'merge_file_content', changelog_merge_hook_factory,
+        'Debian Changelog file merge')
+
+
 commands = {
-        "test_builddeb": [],
+        "bd_do": [],
         "builddeb": ["bd"],
+        "dh_make": ["dh_make"],
+        "import_dsc": [],
+        "import_upstream": [],
+        "mark_uploaded": [],
+        "merge_package": [],
         "merge_upstream": ["mu"],
-        "import_dsc": [],
-        "bd_do": [],
-        "mark_uploaded": []
         }
 
 for command, aliases in commands.iteritems():
@@ -48,7 +71,8 @@
 
 builddeb_dir = '.bzr-builddeb'
 default_conf = os.path.join(builddeb_dir, 'default.conf')
-global_conf = os.path.expanduser('~/.bazaar/builddeb.conf')
+def global_conf():
+    return os.path.join(config_dir(), 'builddeb.conf')
 local_conf = os.path.join(builddeb_dir, 'local.conf')
 
 default_build_dir = '../build-area'
@@ -94,7 +118,9 @@
         for group in sequencematcher(None, old_text,
                 new_text).get_grouped_opcodes(0):
             j1, j2 = group[0][3], group[-1][4]
-            changes += new_text[j1:j2]
+            for line in new_text[j1:j2]:
+                if line.startswith("  "):
+                    changes.append(line)
     if not changes:
         return start_message
     from bzrlib.plugins.builddeb.util import strip_changelog_message
@@ -108,26 +134,55 @@
         "the commit message")
 
 
+def debian_tag_name(branch, revid):
+    from bzrlib.plugins.builddeb.config import BUILD_TYPE_MERGE
+    from bzrlib.plugins.builddeb.errors import MissingChangelogError
+    from bzrlib.plugins.builddeb.import_dsc import (DistributionBranch,
+        DistributionBranchSet)
+    from bzrlib.plugins.builddeb.util import (debuild_config, find_changelog)
+    t = branch.repository.revision_tree(revid)
+    config = debuild_config(t, False)
+    try:
+        (changelog, larstiq) = find_changelog(t, config.build_type == BUILD_TYPE_MERGE)
+    except MissingChangelogError:
+        # Not a debian package
+        return None
+    if changelog.distributions == 'UNRELEASED':
+        # The changelog still targets 'UNRELEASED', so apparently hasn't been 
+        # uploaded. XXX: Give a warning of some sort here?
+        return None
+    db = DistributionBranch(branch, None)
+    dbs = DistributionBranchSet()
+    dbs.add_branch(db)
+    return db.tag_name(changelog.version)
+
+
+try:
+    _mod_branch.Branch.hooks.install_named_hook("automatic_tag_name",
+         debian_tag_name,
+         "Automatically determine tag names from Debian version")
+except errors.UnknownHook:
+    pass # bzr < 2.2 doesn't have this hook.
+
+
 try:
     from bzrlib.revisionspec import revspec_registry
-    revspec_registry.register_lazy("package:", "bzrlib.plugins.builddeb.revspec", "RevisionSpec_package")
+    revspec_registry.register_lazy("package:",
+        "bzrlib.plugins.builddeb.revspec", "RevisionSpec_package")
 except ImportError:
     from bzrlib.revisionspec import SPEC_TYPES
     from bzrlib.plugins.builddeb.revspec import RevisionSpec_package
     SPEC_TYPES.append(RevisionSpec_package)
 
-
-def test_suite():
-    from unittest import TestSuite
-    from bzrlib.plugins.builddeb import tests
-    result = TestSuite()
-    result.addTest(tests.test_suite())
-    return result
-
-
-if __name__ == '__main__':
-    print ("This is a Bazaar plugin. Copy this directory to ~/.bazaar/plugins "
-            "to use it.\n")
-    import unittest
-    runner = unittest.TextTestRunner()
-    runner.run(test_suite())
+try:
+    from bzrlib.tag import tag_sort_methods
+except ImportError:
+    pass # bzr tags --sort= can not be extended
+else:
+    tag_sort_methods.register_lazy("debversion",
+        "bzrlib.plugins.builddeb.tagging", "sort_debversion",
+        "Sort like Debian versions.")
+
+
+def load_tests(standard_tests, module, loader):
+    return loader.loadTestsFromModuleNames(['bzrlib.plugins.builddeb.tests'])

=== modified file 'builder.py'
--- builder.py	2009-07-15 20:48:37 +0000
+++ builder.py	2011-01-28 14:24:44 +0000
@@ -19,11 +19,10 @@
 #
 
 import shutil
-import signal
 import subprocess
 import os
 
-from bzrlib.trace import info
+from bzrlib.trace import note
 
 from bzrlib.plugins.builddeb.errors import (
                     NoSourceDirError,
@@ -31,16 +30,10 @@
                     )
 from bzrlib.plugins.builddeb.util import (
         get_parent_dir,
+        subprocess_setup,
         )
 
 
-def subprocess_setup():
-    # Python installs a SIGPIPE handler by default. This is usually not what
-    # non-Python subprocesses expect.
-    # Many, many thanks to Colin Watson
-    signal.signal(signal.SIGPIPE, signal.SIG_DFL)
-
-
 class DebBuild(object):
     """The object that does the building work."""
 
@@ -69,10 +62,10 @@
             os.makedirs(parent_dir)
         if os.path.exists(self.target_dir):
             if not self.use_existing:
-                info("Purging the build dir: %s", self.target_dir)
+                note("Purging the build dir: %s", self.target_dir)
                 shutil.rmtree(self.target_dir)
             else:
-                info("Not purging build dir as requested: %s",
+                note("Not purging build dir as requested: %s",
                         self.target_dir)
         else:
             if self.use_existing:
@@ -83,7 +76,7 @@
 
     def build(self):
         """This builds the package using the supplied command."""
-        info("Building the package in %s, using %s", self.target_dir,
+        note("Building the package in %s, using %s", self.target_dir,
                 self.builder)
         proc = subprocess.Popen(self.builder, shell=True, cwd=self.target_dir,
                 preexec_fn=subprocess_setup)
@@ -93,5 +86,5 @@
 
     def clean(self):
         """This removes the build directory."""
-        info("Cleaning build dir: %s", self.target_dir)
+        note("Cleaning build dir: %s", self.target_dir)
         shutil.rmtree(self.target_dir)

=== added file 'bzrtools_bzrtools.py'
--- bzrtools_bzrtools.py	1970-01-01 00:00:00 +0000
+++ bzrtools_bzrtools.py	2011-01-28 14:24:44 +0000
@@ -0,0 +1,30 @@
+# This file is a small part of bzrtools' own bzrtools.py
+# The parts copied last changed in bzrtools 1.13.0.
+
+# Copyright (C) 2005, 2006, 2007 Aaron Bentley <[e-mail]>
+# Copyright (C) 2007 John Arbash Meinel
+#
+#    This program 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.
+#
+#    This program is distributed in the hope that it will be useful,
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#    GNU General Public License for more details.
+#
+#    You should have received a copy of the GNU General Public License
+#    along with this program; if not, write to the Free Software
+#    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+from bzrlib import urlutils
+from bzrlib.transport import get_transport
+
+
+def open_from_url(location):
+    location = urlutils.normalize_url(location)
+    dirname, basename = urlutils.split(location)
+    if location.endswith('/') and not basename.endswith('/'):
+        basename += '/'
+    return get_transport(dirname).get(basename)

=== added file 'bzrtools_import.py'
--- bzrtools_import.py	1970-01-01 00:00:00 +0000
+++ bzrtools_import.py	2011-01-28 14:24:44 +0000
@@ -0,0 +1,409 @@
+# This file is a modified copy of bzrtools' upstream_import.py, last changed in
+# bzrtools 1.14.0.
+
+"""Import upstream source into a branch"""
+
+import errno
+import os
+from StringIO import StringIO
+import stat
+import tarfile
+import zipfile
+
+from bzrlib import generate_ids
+from bzrlib.bzrdir import BzrDir
+from bzrlib.errors import NoSuchFile, BzrCommandError, NotBranchError
+from bzrlib.osutils import (pathjoin, isdir, file_iterator, basename,
+                            file_kind, splitpath, normpath)
+from bzrlib.trace import warning
+from bzrlib.transform import TreeTransform, resolve_conflicts, cook_conflicts
+from bzrlib.workingtree import WorkingTree
+from bzrlib.plugins.builddeb.bzrtools_bzrtools import open_from_url
+from bzrlib.plugins.builddeb.errors import UnknownType
+
+class ZipFileWrapper(object):
+
+    def __init__(self, fileobj, mode):
+        self.zipfile = zipfile.ZipFile(fileobj, mode)
+
+    def getmembers(self):
+        for info in self.zipfile.infolist():
+            yield ZipInfoWrapper(self.zipfile, info)
+
+    def extractfile(self, infowrapper):
+        return StringIO(self.zipfile.read(infowrapper.name))
+
+    def add(self, filename):
+        if isdir(filename):
+            self.zipfile.writestr(filename+'/', '')
+        else:
+            self.zipfile.write(filename)
+
+    def close(self):
+        self.zipfile.close()
+
+
+class ZipInfoWrapper(object):
+
+    def __init__(self, zipfile, info):
+        self.info = info
+        self.type = None
+        self.name = info.filename
+        self.zipfile = zipfile
+        self.mode = 0666
+
+    def isdir(self):
+        # Really? Eeeew!
+        return bool(self.name.endswith('/'))
+
+    def isreg(self):
+        # Really? Eeeew!
+        return not self.isdir()
+
+
+files_to_ignore = set(
+    ['.shelf', '.bzr', '.bzr.backup', '.bzrtags',
+     '.bzr-builddeb'])
+
+
+class DirWrapper(object):
+    def __init__(self, fileobj, mode='r'):
+        assert mode == 'r', mode
+        self.root = os.path.realpath(fileobj.read())
+
+    def __repr__(self):
+        return 'DirWrapper(%r)' % self.root
+
+    def getmembers(self, subdir=None):
+        if subdir is not None:
+            mydir = pathjoin(self.root, subdir)
+        else:
+            mydir = self.root
+        for child in os.listdir(mydir):
+            if subdir is not None:
+                child = pathjoin(subdir, child)
+            fi = FileInfo(self.root, child)
+            yield fi
+            if fi.isdir():
+                for v in self.getmembers(child):
+                    yield v
+
+    def extractfile(self, member):
+        return open(member.fullpath)
+
+
+class FileInfo(object):
+
+    def __init__(self, root, filepath):
+        self.fullpath = pathjoin(root, filepath)
+        self.root = root
+        if filepath != '':
+            self.name = pathjoin(basename(root), filepath)
+        else:
+            self.name = basename(root)
+        self.type = None
+        stat = os.lstat(self.fullpath)
+        self.mode = stat.st_mode
+        if self.isdir():
+            self.name += '/'
+
+    def __repr__(self):
+        return 'FileInfo(%r)' % self.name
+
+    def isreg(self):
+        return stat.S_ISREG(self.mode)
+
+    def isdir(self):
+        return stat.S_ISDIR(self.mode)
+
+    def issym(self):
+        if stat.S_ISLNK(self.mode):
+            self.linkname = os.readlink(self.fullpath)
+            return True
+        else:
+            return False
+
+
+def top_path(path):
+    """Return the top directory given in a path."""
+    components = splitpath(normpath(path))
+    if len(components) > 0:
+        return components[0]
+    else:
+        return ''
+
+
+def common_directory(names):
+    """Determine a single directory prefix from a list of names"""
+    prefixes = set()
+    prefixes.update(map(top_path, names))
+    if '' in prefixes:
+        prefixes.remove('')
+    if len(prefixes) != 1:
+        return None
+    prefix = prefixes.pop()
+    if prefix == '':
+        return None
+    return prefix
+
+
+def do_directory(tt, trans_id, tree, relative_path, path):
+    if isdir(path) and tree.path2id(relative_path) is not None:
+        tt.cancel_deletion(trans_id)
+    else:
+        tt.create_directory(trans_id)
+
+
+def add_implied_parents(implied_parents, path):
+    """Update the set of implied parents from a path"""
+    parent = os.path.dirname(path)
+    if parent in implied_parents:
+        return
+    implied_parents.add(parent)
+    add_implied_parents(implied_parents, parent)
+
+
+def names_of_files(tar_file):
+    for member in tar_file.getmembers():
+        if member.type != "g":
+            yield member.name
+
+
+def should_ignore(relative_path):
+    parts = splitpath(relative_path)
+    if not parts:
+        return False
+    for part in parts:
+        if part in files_to_ignore:
+            return True
+        if part.endswith(',v'):
+            return True
+
+
+def import_tar(tree, tar_input, file_ids_from=None, target_tree=None):
+    """Replace the contents of a working directory with tarfile contents.
+    The tarfile may be a gzipped stream.  File ids will be updated.
+    """
+    tar_file = tarfile.open('lala', 'r', tar_input)
+    import_archive(tree, tar_file, file_ids_from=file_ids_from,
+            target_tree=target_tree)
+
+def import_zip(tree, zip_input, file_ids_from=None, target_tree=None):
+    zip_file = ZipFileWrapper(zip_input, 'r')
+    import_archive(tree, zip_file, file_ids_from=file_ids_from,
+            target_tree=target_tree)
+
+def import_dir(tree, dir, file_ids_from=None, target_tree=None):
+    dir_input = StringIO(dir)
+    dir_file = DirWrapper(dir_input)
+    import_archive(tree, dir_file, file_ids_from=file_ids_from,
+            target_tree=target_tree)
+
+def import_archive(tree, archive_file, file_ids_from=None, target_tree=None):
+    if file_ids_from is None:
+        file_ids_from = []
+    for other_tree in file_ids_from:
+        other_tree.lock_read()
+    try:
+        return _import_archive(tree, archive_file, file_ids_from,
+                target_tree=target_tree)
+    finally:
+        for other_tree in file_ids_from:
+            other_tree.unlock()
+
+def _get_paths_to_process(archive_file, prefix, implied_parents):
+    to_process = set()
+    for member in archive_file.getmembers():
+        if member.type == 'g':
+            # type 'g' is a header
+            continue
+        relative_path = member.name
+        relative_path = normpath(relative_path)
+        relative_path = relative_path.lstrip('/')
+        if prefix is not None:
+            relative_path = relative_path[len(prefix)+1:]
+            relative_path = relative_path.rstrip('/')
+        if relative_path == '' or relative_path == '.':
+            continue
+        if should_ignore(relative_path):
+            continue
+        add_implied_parents(implied_parents, relative_path)
+        to_process.add((relative_path, member))
+    return to_process
+
+
+def _import_archive(tree, archive_file, file_ids_from, target_tree=None):
+    prefix = common_directory(names_of_files(archive_file))
+    tt = TreeTransform(tree)
+    try:
+        removed = set()
+        for path, entry in tree.inventory.iter_entries():
+            if entry.parent_id is None:
+                continue
+            trans_id = tt.trans_id_tree_path(path)
+            tt.delete_contents(trans_id)
+            removed.add(path)
+
+        added = set()
+        implied_parents = set()
+        seen = set()
+        to_process = _get_paths_to_process(archive_file, prefix,
+                implied_parents)
+        renames = {}
+
+        # First we find the renames
+        other_trees = file_ids_from[:]
+        if target_tree is not None:
+            other_trees.insert(0, target_tree)
+        for other_tree in other_trees:
+            for relative_path, member in to_process:
+                trans_id = tt.trans_id_tree_path(relative_path)
+                existing_file_id = tt.tree_file_id(trans_id)
+                target_id = other_tree.path2id(relative_path)
+                if (target_id is not None
+                    and target_id != existing_file_id
+                    and target_id not in renames):
+                    renames[target_id] = relative_path
+
+        # The we do the work
+        for relative_path, member in to_process:
+            trans_id = tt.trans_id_tree_path(relative_path)
+            added.add(relative_path.rstrip('/'))
+            # To handle renames, we need to not use the preserved file id, rather
+            # we need to lookup the file id in target_tree, if there is one. If
+            # there isn't, we should use the one in the current tree, and failing
+            # that we will allocate one. In this importer we want the
+            # target_tree to be authoritative about id2path, which is why we
+            # consult it first.
+            existing_file_id = tt.tree_file_id(trans_id)
+            # If we find an id that we know we are going to assign to
+            # different path as it has been renamed in one of the
+            # file_ids_from trees then we ignore the one in this tree.
+            if existing_file_id in renames:
+                if relative_path != renames[existing_file_id]:
+                    existing_file_id = None
+            found_file_id = None
+            if target_tree is not None:
+                found_file_id = target_tree.path2id(relative_path)
+                if found_file_id in renames:
+                    if renames[found_file_id] != relative_path:
+                        found_file_id = None
+            if found_file_id is None and existing_file_id is None:
+                for other_tree in file_ids_from:
+                    found_file_id = other_tree.path2id(relative_path)
+                    if found_file_id is not None:
+                        if found_file_id in renames:
+                            if renames[found_file_id] != relative_path:
+                                found_file_id = None
+                                continue
+                        break
+            if (found_file_id is not None
+                and found_file_id != existing_file_id):
+                # Found a specific file id in one of the source trees
+                tt.version_file(found_file_id, trans_id)
+                if existing_file_id is not None:
+                    # We need to remove the existing file so it can be
+                    # replaced by the file (and file id) from the
+                    # file_ids_from tree.
+                    tt.delete_versioned(trans_id)
+                trans_id = tt.trans_id_file_id(found_file_id)
+
+            if not found_file_id and not existing_file_id:
+                # No file_id in any of the source trees and no file id in the base
+                # tree.
+                name = basename(member.name.rstrip('/'))
+                file_id = generate_ids.gen_file_id(name)
+                tt.version_file(file_id, trans_id)
+            path = tree.abspath(relative_path)
+            if member.name in seen:
+                if tt.final_kind(trans_id) == 'file':
+                    tt.set_executability(None, trans_id)
+                tt.cancel_creation(trans_id)
+            seen.add(member.name)
+            if member.isreg():
+                tt.create_file(file_iterator(archive_file.extractfile(member)),
+                               trans_id)
+                executable = (member.mode & 0111) != 0
+                tt.set_executability(executable, trans_id)
+            elif member.isdir():
+                do_directory(tt, trans_id, tree, relative_path, path)
+            elif member.issym():
+                tt.create_symlink(member.linkname, trans_id)
+            else:
+                raise UnknownType(relative_path)
+
+        for relative_path in implied_parents.difference(added):
+            if relative_path == "":
+                continue
+            trans_id = tt.trans_id_tree_path(relative_path)
+            path = tree.abspath(relative_path)
+            do_directory(tt, trans_id, tree, relative_path, path)
+            if tt.tree_file_id(trans_id) is None:
+                found = False
+                for other_tree in file_ids_from:
+                    other_tree.lock_read()
+                    try:
+                        if other_tree.has_filename(relative_path):
+                            file_id = other_tree.path2id(relative_path)
+                            if file_id is not None:
+                                tt.version_file(file_id, trans_id)
+                                found = True
+                                break
+                    finally:
+                        other_tree.unlock()
+                if not found:
+                    # Should this really use the trans_id as the
+                    # file_id?
+                    tt.version_file(trans_id, trans_id)
+            added.add(relative_path)
+
+        for path in removed.difference(added):
+            tt.unversion_file(tt.trans_id_tree_path(path))
+
+        for conflict in cook_conflicts(resolve_conflicts(tt), tt):
+            warning(conflict)
+        tt.apply()
+    finally:
+        tt.finalize()
+
+
+def do_import(source, tree_directory=None):
+    """Implementation of import command.  Intended for UI only"""
+    if tree_directory is not None:
+        try:
+            tree = WorkingTree.open(tree_directory)
+        except NotBranchError:
+            if not os.path.exists(tree_directory):
+                os.mkdir(tree_directory)
+            branch = BzrDir.create_branch_convenience(tree_directory)
+            tree = branch.bzrdir.open_workingtree()
+    else:
+        tree = WorkingTree.open_containing('.')[0]
+    tree.lock_write()
+    try:
+        if tree.changes_from(tree.basis_tree()).has_changed():
+            raise BzrCommandError("Working tree has uncommitted changes.")
+
+        if (source.endswith('.tar') or source.endswith('.tar.gz') or
+            source.endswith('.tar.bz2')) or source.endswith('.tgz'):
+            try:
+                tar_input = open_from_url(source)
+                if source.endswith('.bz2'):
+                    tar_input = StringIO(tar_input.read().decode('bz2'))
+            except IOError, e:
+                if e.errno == errno.ENOENT:
+                    raise NoSuchFile(source)
+            try:
+                import_tar(tree, tar_input)
+            finally:
+                tar_input.close()
+        elif source.endswith('.zip'):
+            import_zip(tree, open_from_url(source))
+        elif file_kind(source) == 'directory':
+            s = StringIO(source)
+            s.seek(0)
+            import_dir(tree, s)
+        else:
+            raise BzrCommandError('Unhandled import source')
+    finally:
+        tree.unlock()

=== modified file 'changes.py'
--- changes.py	2009-03-16 15:52:52 +0000
+++ changes.py	2011-01-28 14:24:44 +0000
@@ -21,7 +21,11 @@
 import commands
 import os
 
-from debian_bundle import deb822
+try:
+  from debian import deb822
+except ImportError:
+  # Prior to 0.1.15 the debian module was called debian_bundle
+  from debian_bundle import deb822
 
 from bzrlib.trace import mutter
 
@@ -37,15 +41,15 @@
     >>> c = DebianChanges('bzr-builddeb', '0.1-1', file_dir, 'i386')
     >>> fs = c.files()
     >>> f = fs[0]
-    >>> f['name']
+    >>> str(f['name'])
     'bzr-builddeb_0.1-1.dsc'
-    >>> f['priority']
+    >>> str(f['priority'])
     'optional'
-    >>> f['section']
+    >>> str(f['section'])
     'devel'
-    >>> f['size']
+    >>> str(f['size'])
     '290'
-    >>> f['md5sum']
+    >>> str(f['md5sum'])
     'b4c9b646c741f531dd8349db83c77cae'
     """
     if arch is None:

=== modified file 'cmds.py'
--- cmds.py	2009-07-26 18:21:49 +0000
+++ cmds.py	2011-01-28 14:24:44 +0000
@@ -28,7 +28,11 @@
 import tempfile
 import urlparse
 
-from debian_bundle.changelog import Version
+try:
+    from debian.changelog import Version
+except ImportError:
+    # Prior to 0.1.15 the debian module was called debian_bundle
+    from debian_bundle.changelog import Version
 
 from bzrlib import (
     urlutils,
@@ -36,32 +40,37 @@
 from bzrlib.branch import Branch
 from bzrlib.bzrdir import BzrDir
 from bzrlib.commands import Command
-from bzrlib.errors import (BzrCommandError,
-                           NoWorkingTree,
-                           NotBranchError,
-                           FileExists,
-                           )
-from bzrlib.export import export
+from bzrlib.errors import (
+    BzrCommandError,
+    FileExists,
+    NotBranchError,
+    NoWorkingTree,
+    )
 from bzrlib.option import Option
 from bzrlib.revisionspec import RevisionSpec
-from bzrlib.trace import info, warning
-from bzrlib.transport import get_transport
+from bzrlib.tag import _merge_tags_if_possible
+from bzrlib.trace import note, warning
 from bzrlib.workingtree import WorkingTree
 
 from bzrlib.plugins.builddeb import (
     default_build_dir,
     default_orig_dir,
     default_result_dir,
-    default_conf,
-    local_conf,
-    global_conf,
-    test_suite,
+    dh_make,
     )
 from bzrlib.plugins.builddeb.builder import (
                      DebBuild,
                      )
-from bzrlib.plugins.builddeb.config import DebBuildConfig
-from bzrlib.plugins.builddeb.errors import BuildFailedError
+from bzrlib.plugins.builddeb.config import (
+    BUILD_TYPE_MERGE,
+    BUILD_TYPE_NATIVE,
+    BUILD_TYPE_NORMAL,
+    BUILD_TYPE_SPLIT,
+    )
+from bzrlib.plugins.builddeb.errors import (
+    BuildFailedError,
+    NoPreviousUpload,
+    )
 from bzrlib.plugins.builddeb.hooks import run_hook
 from bzrlib.plugins.builddeb.import_dsc import (
         DistributionBranch,
@@ -69,23 +78,38 @@
         DscCache,
         DscComp,
         )
+from bzrlib.plugins.builddeb.merge_package import fix_ancestry_as_needed
 from bzrlib.plugins.builddeb.source_distiller import (
         FullSourceDistiller,
         MergeModeDistiller,
         NativeSourceDistiller,
         )
+from bzrlib.plugins.builddeb.tagging import (
+        is_upstream_tag,
+        upstream_tag_version,
+        )
 from bzrlib.plugins.builddeb.upstream import (
+        AptSource,
+        GetOrigSourceSource,
+        PristineTarSource,
+        SelfSplitSource,
+        UScanSource,
         UpstreamProvider,
         UpstreamBranchSource,
-        get_upstream_sources,
         )
-from bzrlib.plugins.builddeb.util import (find_changelog,
+from bzrlib.plugins.builddeb.util import (
+        debuild_config,
+        dget_changes,
+        find_changelog,
+        find_last_distribution,
+        find_previous_upload,
         get_export_upstream_revision,
-        find_last_distribution,
+        guess_build_type,
         lookup_distribution,
-        suite_to_distribution,
+        open_file,
+        open_file_via_transport,
         tarball_name,
-        dget_changes,
+        tree_contains_upstream_source,
         )
 
 dont_purge_opt = Option('dont-purge',
@@ -111,36 +135,6 @@
 export_upstream_revision_opt = Option('export-upstream-revision',
     help="Select the upstream revision that will be exported.",
     type=str)
-no_user_conf_opt = Option('no-user-config',
-    help="Stop builddeb from reading the user's config file. Used mainly "
-    "for tests.")
-
-
-def debuild_config(tree, working_tree, no_user_config):
-    """Obtain the Debuild configuration object.
-
-    :param tree: A Tree object, can be a WorkingTree or RevisionTree.
-    :param working_tree: Whether the tree is a working tree.
-    :param no_user_config: Whether to skip the user configuration
-    """
-    config_files = []
-    user_config = None
-    if (working_tree and tree.has_filename(local_conf)):
-        if tree.path2id(local_conf) is None:
-            config_files.append((tree.get_file_byname(local_conf), True,
-                        "local.conf"))
-        else:
-            warning('Not using configuration from %s as it is versioned.')
-    if not no_user_config:
-        config_files.append((global_conf, True))
-        user_config = global_conf
-    if tree.path2id(default_conf):
-        config_files.append((tree.get_file(tree.path2id(default_conf)), False,
-                    "default.conf"))
-    config = DebBuildConfig(config_files, tree=tree)
-    config.set_user_config(user_config)
-    return config
-
 
 class cmd_builddeb(Command):
     """Builds a Debian package from a branch.
@@ -200,6 +194,9 @@
                         short_name='S')
     result_compat_opt = Option('result', help="Present only for compatibility "
             "with bzr-builddeb <= 2.0. Use --result-dir instead.")
+    package_merge_opt = Option('package-merge', help="Build using the "
+            "appropriate -v and -sa options for merging in the changes from "
+            "another source.")
     takes_args = ['branch_or_build_options*']
     aliases = ['bd']
     takes_options = [working_tree_opt, export_only_opt,
@@ -208,20 +205,18 @@
         export_upstream_opt, export_upstream_revision_opt,
         quick_opt, reuse_opt, native_opt,
         source_opt, 'revision',
-        no_user_conf_opt, result_compat_opt]
+        result_compat_opt, package_merge_opt]
 
     def _get_tree_and_branch(self, location):
         if location is None:
             location = "."
         is_local = urlparse.urlsplit(location)[0] in ('', 'file')
-        if is_local:
-            os.chdir(location)
         tree, branch, relpath = BzrDir.open_containing_tree_or_branch(location)
         return tree, branch, is_local
 
     def _get_build_tree(self, revision, tree, branch):
         if revision is None and tree is not None:
-            info("Building using working tree")
+            note("Building using working tree")
             working_tree = True
         else:
             if revision is None:
@@ -231,30 +226,19 @@
             else:
                 raise BzrCommandError('bzr builddeb --revision takes exactly one '
                                       'revision specifier.')
-            info("Building branch from revision %s", revid)
+            note("Building branch from revision %s", revid)
             tree = branch.repository.revision_tree(revid)
             working_tree = False
         return tree, working_tree
 
-    def _build_type(self, config, merge, native, split):
-        if not merge:
-            merge = config.merge
+    def _build_type(self, merge, native, split):
         if merge:
-            info("Running in merge mode")
-            native = False
-            split = False
-        else:
-            if not native:
-                native = config.native
-            if native:
-                info("Running in native mode")
-                split = False
-            else:
-                if not split:
-                    split = config.split
-                if split:
-                    info("Running in split mode")
-        return merge, native, split
+            return BUILD_TYPE_MERGE
+        if native:
+            return BUILD_TYPE_NATIVE
+        if split:
+            return BUILD_TYPE_SPLIT
+        return None
 
     def _get_build_command(self, config, builder, quick, build_options):
         if builder is None:
@@ -270,26 +254,26 @@
             builder += " " + " ".join(build_options)
         return builder
 
-    def _get_dirs(self, config, is_local, result_dir, result, build_dir, orig_dir):
-        if result_dir is None:
-            result_dir = result
-        if result_dir is None:
-            if is_local:
-                result_dir = config.result_dir
-            else:
-                result_dir = config.user_result_dir
-        if result_dir is not None:
-            result_dir = os.path.realpath(result_dir)
-        if build_dir is None:
-            if is_local:
-                build_dir = config.build_dir or default_build_dir
-            else:
-                build_dir = config.user_build_dir or 'build-area'
-        if orig_dir is None:
-            if is_local:
-                orig_dir = config.orig_dir or default_orig_dir
-            else:
-                orig_dir = config.user_orig_dir or 'build-area'
+    def _get_dirs(self, config, branch, is_local, result_dir, build_dir, orig_dir):
+        def _get_dir(supplied, if_local, if_not):
+            if supplied is None:
+                if is_local:
+                    supplied = if_local
+                else:
+                    supplied = if_not
+            if supplied is not None:
+                if is_local:
+                    supplied = os.path.join(
+                            urlutils.local_path_from_url(branch.base),
+                            supplied)
+                    supplied = os.path.realpath(supplied)
+            return supplied
+
+        result_dir = _get_dir(result_dir, config.result_dir, config.user_result_dir)
+        build_dir = _get_dir(build_dir, config.build_dir or default_build_dir,
+                config.user_build_dir or 'build-area')
+        orig_dir = _get_dir(orig_dir, config.orig_dir or default_orig_dir,
+                config.user_orig_dir or 'build-area')
         return result_dir, build_dir, orig_dir
 
     def _branch_and_build_options(self, branch_or_build_options_list,
@@ -341,45 +325,81 @@
     def run(self, branch_or_build_options_list=None, verbose=False,
             working_tree=False,
             export_only=False, dont_purge=False, use_existing=False,
-            result_dir=None, builder=None, merge=False, build_dir=None,
+            result_dir=None, builder=None, merge=None, build_dir=None,
             export_upstream=None, export_upstream_revision=None,
             orig_dir=None, split=None,
-            quick=False, reuse=False, native=False,
-            source=False, revision=None, no_user_config=False, result=None):
+            quick=False, reuse=False, native=None,
+            source=False, revision=None, result=None, package_merge=None):
         if result is not None:
             warning("--result is deprected, use --result-dir instead")
         branch, build_options, source = self._branch_and_build_options(
                 branch_or_build_options_list, source)
         tree, branch, is_local = self._get_tree_and_branch(branch)
         tree, working_tree = self._get_build_tree(revision, tree, branch)
+
+        if len(tree.conflicts()) > 0:
+            raise BzrCommandError(
+                "There are conflicts in the working tree. "
+                "You must resolve these before building.")
+
         tree.lock_read()
         try:
-            config = debuild_config(tree, working_tree, no_user_config)
+            config = debuild_config(tree, working_tree)
             if reuse:
-                info("Reusing existing build dir")
+                note("Reusing existing build dir")
                 dont_purge = True
                 use_existing = True
-            merge, native, split = self._build_type(config, merge, native, split)
-            if (not merge and not native and not split and
-                tree.inventory.root.children.keys() == ["debian"]):
-                # Default to merge mode if there's only a debian/ directory
-                merge = True
+            build_type = self._build_type(merge, native, split)
+            if build_type is None:
+                build_type = config.build_type
+            contains_upstream_source = tree_contains_upstream_source(tree)
+            (changelog, larstiq) = find_changelog(tree, not contains_upstream_source)
+            try:
+                prev_version = find_previous_upload(tree, not contains_upstream_source)
+            except NoPreviousUpload:
+                prev_version = None
+            if build_type is None:
+                build_type = guess_build_type(tree, changelog.version,
+                    contains_upstream_source)
+
+            note("Building package in %s mode" % build_type)
+
+            if package_merge:
+                build_options.append("-v%s" % str(prev_version))
+                if (prev_version.upstream_version
+                        != changelog.version.upstream_version
+                        or prev_version.epoch != changelog.version.epoch):
+                    build_options.append("-sa")
             build_cmd = self._get_build_command(config, builder, quick,
                     build_options)
-            (changelog, larstiq) = find_changelog(tree, merge)
-            result_dir, build_dir, orig_dir = self._get_dirs(config, is_local,
-                    result_dir, result, build_dir, orig_dir)
-
-            upstream_branch, upstream_revision = \
-                    self._get_upstream_branch(merge, export_upstream,
-                            export_upstream_revision, config,
-                            changelog.version)
-
-            upstream_provider = UpstreamProvider(
-                    changelog.package, changelog.version,
-                    orig_dir, get_upstream_sources(tree, branch,
-                    larstiq=larstiq, upstream_branch=upstream_branch,
-                    upstream_revision=upstream_revision, allow_split=split))
+            result_dir, build_dir, orig_dir = self._get_dirs(config, branch,
+                    is_local, result_dir or result, build_dir, orig_dir)
+
+            upstream_sources = [
+                PristineTarSource(tree, branch),
+                AptSource(),
+                ]
+            if merge:
+                upstream_branch, upstream_revision = self._get_upstream_branch(
+                    merge, export_upstream, export_upstream_revision, config,
+                    changelog.version)
+                if upstream_branch is not None:
+                    upstream_sources.append(UpstreamBranchSource(
+                            upstream_branch,
+                            {changelog.version.upstream_version:
+                            upstream_revision}))
+            elif not native and config.upstream_branch:
+                upstream_branch = Branch.open(config.upstream_branch)
+                upstream_sources.append(UpstreamBranchSource(upstream_branch))
+            upstream_sources.extend([
+                GetOrigSourceSource(tree, larstiq), 
+                UScanSource(tree, larstiq),
+                ])
+            if split:
+                upstream_sources.append(SelfSplitSource(tree))
+ 
+            upstream_provider = UpstreamProvider(changelog.package,
+                changelog.version, orig_dir, upstream_sources)
 
             if merge:
                 distiller_cls = MergeModeDistiller
@@ -414,15 +434,24 @@
                         'dpkg-architecture -qDEB_BUILD_ARCH')
                     if status > 0:
                         raise BzrCommandError("Could not find the build architecture")
+                non_epoch_version = changelog.version.upstream_version
+                if changelog.version.debian_version is not None:
+                    non_epoch_version += "-%s" % changelog.version.debian_version
                 changes = "%s_%s_%s.changes" % (changelog.package,
-                        str(changelog.version), arch)
+                        non_epoch_version, arch)
                 changes_path = os.path.join(build_dir, changes)
                 if not os.path.exists(changes_path):
                     if result_dir is not None:
                         raise BzrCommandError("Could not find the .changes "
                                 "file from the build: %s" % changes_path)
                 else:
-                    target_dir = result_dir or default_result_dir
+                    if is_local:
+                        target_dir = result_dir or default_result_dir
+                        target_dir = os.path.join(
+                                urlutils.local_path_from_url(branch.base),
+                                target_dir)
+                    else:
+                        target_dir = "."
                     if not os.path.exists(target_dir):
                         os.makedirs(target_dir)
                     dget_changes(changes_path, target_dir)
@@ -438,59 +467,225 @@
 
     You must supply the source to import from, and the version number of the
     new release. The source can be a .tar.gz, .tar, .tar.bz2, .tgz or .zip
-    archive, or a directory. The source may also be a remote file.
+    archive, or a directory. The source may also be a remote file described by
+    a URL.
 
     You must supply the version number of the new upstream release
-    using --version.
+    using --version, unless you're importing from an upstream branch, in which
+    case it can be guessed from that.
 
     The distribution this version is targetted at can be specified with
-    --distribution. This will be used to guess the version number, so you
-    can always correct it in the changelog.
+    --distribution. This will be used to guess the version number suffix
+    that you want, but you can always correct it in the resulting
+    debian/changelog.
 
     If there is no debian changelog in the branch to retrieve the package
     name from then you must pass the --package option. If this version
     will change the name of the source package then you can use this option
     to set the new name.
+
+    examples::
+
+        bzr merge-upstream --version 0.2 \
+            http://example.org/releases/scruff-0.2.tar.gz
+
+    If you are merging a branch as well as the tarball then you can
+    specify the branch after the tarball, along with -r to specify the
+    revision of that branch to take::
+
+        bzr merge-upstream --version 0.2 \
+            http://example.org/releases/scruff-0.2.tar.gz \
+            http://scruff.org/bzr/scruff.dev -r tag:0.2
+
+    If there is no upstream release tarball, and you want bzr-builddeb to
+    create the tarball for you::
+
+        bzr merge-upstream --version 0.2 http://scruff.org/bzr/scruff.dev
+
+    Note that the created tarball is just the same as the contents of
+    the branch at the specified revision. If you wish to have something
+    different, for instance the results of running "make dist", then you
+    should create the tarball first, and pass it to the command as in
+    the second example.
     """
     takes_args = ['location?', 'upstream_branch?']
     aliases = ['mu']
 
     package_opt = Option('package', help="The name of the source package.",
                          type=str)
-    version_opt = Option('version', help="The version number of this release.",
-                         type=str)
+    version_opt = Option('version',
+        help="The upstream version number of this release, for example "
+        "\"0.2\".", type=str)
     distribution_opt = Option('distribution', help="The distribution that "
             "this release is targetted at.", type=str)
     directory_opt = Option('directory',
                            help='Working tree into which to merge.',
                            short_name='d', type=unicode)
-
-    takes_options = [package_opt, no_user_conf_opt, version_opt,
-            distribution_opt, directory_opt, 'revision', 'merge-type']
-
-    def _update_changelog(self, tree, version, distribution_name, changelog,
-            package):
-        from bzrlib.plugins.builddeb.merge_upstream import package_version
-        if "~bzr" in str(version) or "+bzr" in str(version):
-            entry_description = "New upstream snapshot."
-        else:
-            entry_description = "New upstream release."
-        proc = subprocess.Popen(["/usr/bin/dch", "-v",
-                str(package_version(version, distribution_name)),
-                "-D", "UNRELEASED", "--release-heuristic", "changelog",
-                entry_description], cwd=tree.basedir)
-        proc.wait()
-        if proc.returncode != 0:
+    last_version_opt = Option('last-version',
+                              help='The full version of the last time '
+                              'upstream was merged.', type=str)
+    force_opt = Option('force',
+                       help=('Force a merge even if the upstream branch '
+                             'has not changed.'))
+    v3_opt = Option('v3', help='Use dpkg-source format v3.')
+
+
+    takes_options = [package_opt, version_opt,
+            distribution_opt, directory_opt, last_version_opt,
+            force_opt, v3_opt, 'revision', 'merge-type']
+
+
+    def _add_changelog_entry(self, tree, package, version, distribution_name,
+            changelog):
+        from bzrlib.plugins.builddeb.merge_upstream import (
+            changelog_add_new_version)
+        if not changelog_add_new_version(tree, version, distribution_name,
+                changelog, package):
             raise BzrCommandError('Adding a new changelog stanza after the '
-                    'merge had completed failed. Add the new changelog entry '
-                    'yourself, review the merge, and then commit.')
-
-    def run(self, location=None, upstream_branch=None, version=None, distribution=None,
-            package=None, no_user_config=None, directory=".", revision=None,
-            merge_type=None):
-        from bzrlib.plugins.builddeb.errors import MissingChangelogError
+                    'merge had completed failed. Add the new changelog '
+                    'entry yourself, review the merge, and then commit.')
+
+    def _do_merge(self, tree, tarball_filename, version, current_version,
+            upstream_branch, upstream_revision, merge_type, force):
+        db = DistributionBranch(tree.branch, None, tree=tree)
+        dbs = DistributionBranchSet()
+        dbs.add_branch(db)
+        conflicts = db.merge_upstream(tarball_filename, version,
+                current_version, upstream_branch=upstream_branch,
+                upstream_revision=upstream_revision,
+                merge_type=merge_type, force=force)
+        return conflicts
+
+    def _export_tarball(self, package, version, orig_dir, upstream_branch,
+            upstream_revision):
+        # TODO: a way to use bz2 on export
+        dest_name = tarball_name(package, version)
+        tarball_filename = os.path.join(orig_dir, dest_name)
+        upstream = UpstreamBranchSource(upstream_branch,
+                {version: upstream_revision})
+        upstream.get_specific_version(package, version, orig_dir)
+        return tarball_filename
+
+    def _fetch_tarball(self, package, version, orig_dir, location, v3):
         from bzrlib.plugins.builddeb.repack_tarball import repack_tarball
-        from bzrlib.plugins.builddeb.merge_upstream import upstream_branch_version
+        format = None
+        if v3:
+            if (location.endswith(".tar.bz2")
+                    or location.endswith(".tbz2")):
+                format = "bz2"
+        dest_name = tarball_name(package, version, format=format)
+        tarball_filename = os.path.join(orig_dir, dest_name)
+        try:
+            repack_tarball(location, dest_name, target_dir=orig_dir,
+                    force_gz=not v3)
+        except FileExists:
+            raise BzrCommandError("The target file %s already exists, and is either "
+                                  "different to the new upstream tarball, or they "
+                                  "are of different formats. Either delete the target "
+                                  "file, or use it as the argument to import."
+                                  % dest_name)
+        return tarball_filename
+
+    def _get_tarball(self, config, tree, package, version, upstream_branch,
+            upstream_revision, no_tarball, v3, location):
+        orig_dir = config.orig_dir or default_orig_dir
+        orig_dir = os.path.join(tree.basedir, orig_dir)
+        if not os.path.exists(orig_dir):
+            os.makedirs(orig_dir)
+        if upstream_branch and no_tarball:
+            tarball_filename = self._export_tarball(package, version,
+                orig_dir, upstream_branch, upstream_revision)
+        else:
+            tarball_filename = self._fetch_tarball(package, version, orig_dir,
+                location, v3)
+        return tarball_filename
+
+    def _get_version(self, version, package, no_tarball, upstream_branch,
+            upstream_revision, current_version):
+        from bzrlib.plugins.builddeb.merge_upstream import (
+            upstream_branch_version)
+        if version is None:
+            if upstream_branch and no_tarball:
+                version = str(upstream_branch_version(upstream_branch,
+                        upstream_revision, package,
+                        current_version))
+                note("Using version string %s for upstream branch." % (version))
+            else:
+                raise BzrCommandError("You must specify the "
+                        "version number using --version.")
+        return version
+
+    def _get_upstream_revision(self, upstream_branch, revision):
+        upstream_revision = None
+        if upstream_branch is not None:
+            if revision is not None:
+                if len(revision) > 1:
+                    raise BzrCommandError("merge-upstream takes only a single --revision")
+                upstream_revspec = revision[0]
+                upstream_revision = upstream_revspec.as_revision_id(upstream_branch)
+            else:
+                upstream_revision = upstream_branch.last_revision()
+        return upstream_revision
+
+    def _get_upstream_branch(self, location, upstream_branch, revision):
+        no_tarball = False
+        if upstream_branch is None:
+            try:
+                upstream_branch = Branch.open(location)
+                no_tarball = True
+            except NotBranchError:
+                upstream_branch = None
+                if revision is not None:
+                    raise BzrCommandError("--revision is not allowed when"
+                            " merging only a tarball")
+        else:
+            upstream_branch = Branch.open(upstream_branch)
+        return no_tarball, upstream_branch
+
+    def _get_changelog_info(self, tree, last_version, package, distribution):
+        from bzrlib.plugins.builddeb.errors import MissingChangelogError
+        changelog = None
+        current_version = last_version
+        try:
+            changelog = find_changelog(tree, False, max_blocks=2)[0]
+            if last_version is None:
+                current_version = changelog.version.upstream_version
+            if package is None:
+                package = changelog.package
+            if distribution is None:
+                distribution = find_last_distribution(changelog)
+                if distribution is not None:
+                    note("Using distribution %s" % distribution)
+        except MissingChangelogError:
+            pass
+        if distribution is None:
+            note("No distribution specified, and no changelog, "
+                    "assuming 'debian'")
+            distribution = "debian"
+        if package is None:
+            raise BzrCommandError("You did not specify --package, and "
+                    "there is no changelog from which to determine the "
+                    "package name, which is needed to know the name to "
+                    "give the .orig.tar.gz. Please specify --package.")
+        distribution = distribution.lower()
+        distribution_name = lookup_distribution(distribution)
+        if distribution_name is None:
+            raise BzrCommandError("Unknown target distribution: %s" \
+                        % distribution)
+        return current_version, package, distribution, distribution_name, changelog
+
+    def _get_upstream_location(self, location, config):
+        if location is None:
+            if config.upstream_branch is not None:
+                location = config.upstream_branch
+            else:
+                raise BzrCommandError("No location specified to merge")
+        return location
+
+    def run(self, location=None, upstream_branch=None, version=None,
+            distribution=None, package=None,
+            directory=".", revision=None, merge_type=None,
+            last_version=None, force=None, v3=None):
         tree, _ = WorkingTree.open_containing(directory)
         tree.lock_write()
         try:
@@ -499,120 +694,39 @@
                 raise BzrCommandError("There are uncommitted changes in the "
                         "working tree. You must commit before using this "
                         "command.")
-            config = debuild_config(tree, tree, no_user_config)
-            if config.merge:
+            config = debuild_config(tree, tree)
+            if config.build_type == BUILD_TYPE_MERGE:
                 raise BzrCommandError("Merge upstream in merge mode is not "
                         "yet supported.")
-            if config.native:
+            if config.build_type == BUILD_TYPE_NATIVE:
                 raise BzrCommandError("Merge upstream in native mode is not "
                         "yet supported.")
 
-            if location is None:
-                if config.upstream_branch is not None:
-                    location = config.upstream_branch
-                else:
-                    raise BzrCommandError("No location specified to merge")
-            changelog = None
-            try:
-                changelog = find_changelog(tree, False, max_blocks=2)[0]
-                current_version = changelog.version
-                if package is None:
-                    package = changelog.package
-                if distribution is None:
-                    distribution = find_last_distribution(changelog)
-                    if distribution is not None:
-                        info("Using distribution %s" % distribution)
-            except MissingChangelogError:
-                current_version = None
-            if distribution is None:
-                info("No distribution specified, and no changelog, "
-                        "assuming 'debian'")
-                distribution = "debian"
-
-            if package is None:
-                raise BzrCommandError("You did not specify --package, and "
-                        "there is no changelog from which to determine the "
-                        "package name, which is needed to know the name to "
-                        "give the .orig.tar.gz. Please specify --package.")
-
-            no_tarball = False
-            if upstream_branch is None:
-                try:
-                    upstream_branch = Branch.open(location)
-                    no_tarball = True
-                except NotBranchError:
-                    upstream_branch = None
-            else:
-                upstream_branch = Branch.open(upstream_branch)
-
-            distribution = distribution.lower()
-            distribution_name = lookup_distribution(distribution)
-            if distribution_name is None:
-                raise BzrCommandError("Unknown target distribution: %s" \
-                            % distribution)
-
-            upstream_revision = None
-            if upstream_branch:
-                if revision is not None:
-                    if len(revision) > 1:
-                        raise BzrCommandError("merge-upstream takes only a single --revision")
-                    upstream_revspec = revision[0]
-                    upstream_revision = upstream_revspec.as_revision_id(upstream_branch)
-                else:
-                    upstream_revision = upstream_branch.last_revision()
-
-            if no_tarball and revision is not None:
-                raise BzrCommandError("--revision is not allowed when merging a tarball")
-
-            if version is None:
-                if upstream_branch and no_tarball:
-                    version = upstream_branch_version(upstream_branch,
-                            upstream_revision, package,
-                            current_version.upstream_version)
-                    info("Using version string %s for upstream branch." % (version))
-                else:
-                    raise BzrCommandError("You must specify the "
-                            "version number using --version.")
-
-            version = Version(version)
-            orig_dir = config.orig_dir or default_orig_dir
-            orig_dir = os.path.join(tree.basedir, orig_dir)
-            if not os.path.exists(orig_dir):
-                os.makedirs(orig_dir)
-            dest_name = tarball_name(package, version.upstream_version)
-            tarball_filename = os.path.join(orig_dir, dest_name)
-
-            if upstream_branch and no_tarball:
-                upstream = UpstreamBranchSource(upstream_branch, 
-                        upstream_revision)
-                upstream.get_specific_version(package, version.upstream_version,
-                        orig_dir)
-            else:
-                try:
-                    repack_tarball(location, dest_name, target_dir=orig_dir)
-                except FileExists:
-                    raise BzrCommandError("The target file %s already exists, and is either "
-                                          "different to the new upstream tarball, or they "
-                                          "are of different formats. Either delete the target "
-                                          "file, or use it as the argument to import."
-                                          % dest_name)
-            db = DistributionBranch(tree.branch, None, tree=tree)
-            dbs = DistributionBranchSet()
-            dbs.add_branch(db)
-            conflicts = db.merge_upstream(tarball_filename, version,
-                    current_version, upstream_branch=upstream_branch,
-                    upstream_revision=upstream_revision,
-                    merge_type=merge_type)
-
-            self._update_changelog(tree, version, distribution_name, changelog,
-                    package)
+            location = self._get_upstream_location(location, config)
+            (current_version, package, distribution, distribution_name,
+             changelog) = self._get_changelog_info( tree, last_version,
+                 package, distribution)
+            no_tarball, upstream_branch = self._get_upstream_branch(
+                location, upstream_branch, revision)
+            upstream_revision = self._get_upstream_revision(upstream_branch,
+                revision)
+            version = self._get_version(version, package, no_tarball,
+                upstream_branch, upstream_revision, current_version)
+            tarball_filename = self._get_tarball(config, tree, package,
+                version, upstream_branch, upstream_revision, no_tarball, v3,
+                location)
+            conflicts = self._do_merge(tree, tarball_filename, version,
+                current_version, upstream_branch, upstream_revision,
+                merge_type, force)
+            self._add_changelog_entry(tree, package, version,
+                distribution_name, changelog)
         finally:
             tree.unlock()
-        info("The new upstream version has been imported.")
+        note("The new upstream version has been imported.")
         if conflicts:
-            info("You should now resolve the conflicts, review the changes, and then commit.")
+            note("You should now resolve the conflicts, review the changes, and then commit.")
         else:
-            info("You should now review the changes and then commit.")
+            note("You should now review the changes and then commit.")
 
 
 class cmd_import_dsc(Command):
@@ -641,8 +755,7 @@
     takes_args = ['files*']
 
     filename_opt = Option('file', help="File containing URIs of source "
-                          "packages to import.", type=str, argname="filename",
-                          short_name='F')
+                          "packages to import.", type=str, short_name='F')
 
     takes_options = [filename_opt]
 
@@ -654,7 +767,7 @@
         for dscname in files_list:
             dsc = cache.get_dsc(dscname)
             def get_dsc_part(from_transport, filename):
-                from_f = from_transport.get(filename)
+                from_f = open_file_via_transport(filename, from_transport)
                 contents = from_f.read()
                 to_f = open(os.path.join(orig_target, filename), 'wb')
                 try:
@@ -669,7 +782,7 @@
                 get_dsc_part(from_transport, name)
             db.import_package(os.path.join(orig_target, filename))
 
-    def run(self, files_list, filename=None):
+    def run(self, files_list, file=None):
         from bzrlib.plugins.builddeb.errors import MissingChangelogError
         try:
             tree = WorkingTree.open_containing('.')[0]
@@ -683,20 +796,20 @@
                         "command")
             if files_list is None:
                 files_list = []
-            if filename is not None:
-                if isinstance(filename, unicode):
-                    filename = filename.encode('utf-8')
-                base_dir, path = urlutils.split(filename)
-                sources_file = get_transport(base_dir).get(path)
+            if file is not None:
+                if isinstance(file, unicode):
+                    file = file.encode('utf-8')
+                sources_file = open_file(file)
                 for line in sources_file:
-                    line.strip()
-                    files_list.append(line)
+                    line = line.strip()
+                    if len(line) > 0:
+                        files_list.append(line)
             if len(files_list) < 1:
                 raise BzrCommandError("You must give the location of at least one "
                                       "source package to install, or use the "
                                       "--file option.")
-            config = debuild_config(tree, tree, False)
-            if config.merge:
+            config = debuild_config(tree, tree)
+            if config.build_type == BUILD_TYPE_MERGE:
                 raise BzrCommandError("import-dsc in merge mode is not "
                         "yet supported.")
             orig_dir = config.orig_dir or default_orig_dir
@@ -715,13 +828,14 @@
                 if last_version is not None:
                     if not db.has_upstream_version_in_packaging_branch(
                             last_version.upstream_version):
-                        raise BzrCommandError("Unable to find the tag for "
-                                "the previous upstream version, %s, in the "
-                                "branch: %s" % (last_version,
-                                    db.upstream_tag_name(last_version)))
-                    upstream_tip = db._revid_of_upstream_version_from_branch(
-                            last_version)
-                    db._extract_upstream_tree(upstream_tip, tempdir)
+                        raise BzrCommandError("Unable to find the tag for the "
+                            "previous upstream version, %s, in the branch: %s."
+                            " Consider importing it via import-dsc or "
+                            "import-upstream." % (last_version,
+                                    db.upstream_tag_name(last_version.upstream_version)))
+                    upstream_tip = db.revid_of_upstream_version_from_branch(
+                            last_version.upstream_version)
+                    db.extract_upstream_tree(upstream_tip, tempdir)
                 else:
                     db._create_empty_upstream_tree(tempdir)
                 self.import_many(db, files_list, orig_target)
@@ -731,6 +845,96 @@
             tree.unlock()
 
 
+class cmd_import_upstream(Command):
+    """Imports an upstream tarball.
+
+    This will import an upstream tarball in to your branch, but not modify the
+    working tree. Use merge-upstream if you wish to directly merge the new
+    upstream version in to your tree.
+
+    The imported revision can be accessed using the tag name that will be
+    reported at the end of a successful operation. The revision will include
+    the pristine-tar data that will allow other commands to recreate the
+    tarball when needed.
+
+    For instance::
+
+        $ bzr import-upstream 1.2.3 ../package_1.2.3.orig.tar.gz
+
+    If upstream is packaged in bzr, you should provide the upstream branch
+    whose tip commit is the closest match to the tarball::
+
+        $ bzr import-upstream 1.2.3 ../package_1.2.3.orig.tar.gz ../upstream
+
+    After doing this, commands that assume there is an upstream tarball, like
+    'bzr builddeb' will be able to recreate the one provided at import-upstream
+    time, meaning that you don't need to distribute the tarball in addition to
+    the branch.
+
+    If you want to manually merge with the imported upstream, you can do::
+
+        $ bzr merge . -r tag:upstream-1.2.3
+
+    The imported revision will have file ids taken from your branch, the
+    upstream branch, or previous tarball imports as necessary. In addition
+    the parents of the new revision will be the previous upstream tarball
+    import and the tip of the upstream branch if you supply one.
+    """
+
+    takes_options = ['revision']
+
+    takes_args = ['version', 'location', 'upstream_branch?']
+
+    def run(self, version, location, upstream_branch=None, revision=None):
+        # TODO: search for similarity etc.
+        version = version.encode('utf8')
+        branch, _ = Branch.open_containing('.')
+        if upstream_branch is None:
+            upstream = None
+        else:
+            upstream = Branch.open(upstream_branch)
+        branch.lock_write() # we will be adding a tag here.
+        self.add_cleanup(branch.unlock)
+        tempdir = tempfile.mkdtemp(
+            dir=branch.bzrdir.root_transport.clone('..').local_abspath('.'))
+        self.add_cleanup(shutil.rmtree, tempdir)
+        db = DistributionBranch(branch, upstream_branch=upstream)
+        if db.has_upstream_version_in_packaging_branch(version):
+            raise BzrCommandError("Version %s is already present." % version)
+        tagged_versions = {}
+        for tag_name, tag_revid in branch.tags.get_tag_dict().iteritems():
+            if not is_upstream_tag(tag_name):
+                continue
+            tag_version = Version(upstream_tag_version(tag_name))
+            tagged_versions[tag_version] = tag_revid
+        tag_order = sorted(tagged_versions.keys())
+        if tag_order:
+            parents = [tagged_versions[tag_order[-1]]]
+        else:
+            parents = []
+        if parents:
+            if upstream is not None:
+                # See bug lp:309682
+                upstream.repository.fetch(branch.repository, parents[0])
+            db.extract_upstream_tree(parents[0], tempdir)
+        else:
+            db._create_empty_upstream_tree(tempdir)
+        tree = db.get_branch_tip_revtree()
+        tree.lock_read()
+        dbs = DistributionBranchSet()
+        dbs.add_branch(db)
+        if revision is None:
+            upstream_revid = None
+        elif len(revision) == 1:
+            upstream_revid = revision[0].in_history(upstream).rev_id
+        else:
+            raise BzrCommandError('bzr import-upstream --revision takes exactly'
+                                  ' one revision specifier.')
+        tag_name, _ = db.import_upstream_tarball(location, version, parents,
+            upstream_branch=upstream, upstream_revision=upstream_revid)
+        self.outf.write('Imported %s as tag:%s.\n' % (location, tag_name))
+
+
 class cmd_bd_do(Command):
     """Run a command in an exported package, copying the result back.
 
@@ -760,9 +964,8 @@
 
     def run(self, command_list=None):
         t = WorkingTree.open_containing('.')[0]
-        config = debuild_config(t, t, False)
-
-        if not config.merge:
+        config = debuild_config(t, t)
+        if config.build_type != BUILD_TYPE_MERGE:
             raise BzrCommandError("This command only works for merge mode "
                                   "packages. See /usr/share/doc/bzr-builddeb"
                                   "/user_manual/merge.html for more information.")
@@ -781,9 +984,13 @@
         orig_dir = config.orig_dir
         if orig_dir is None:
             orig_dir = default_orig_dir
+
         upstream_provider = UpstreamProvider(changelog.package, 
                 changelog.version.upstream_version, orig_dir, 
-                get_upstream_sources(t, t.branch, larstiq=larstiq))
+                [PristineTarSource(t, t.branch),
+                 AptSource(),
+                 GetOrigSourceSource(t, larstiq),
+                 UScanSource(t, larstiq) ])
 
         distiller = MergeModeDistiller(t, upstream_provider,
                 larstiq=larstiq)
@@ -797,16 +1004,16 @@
         builder.prepare()
         run_hook(t, 'pre-export', config)
         builder.export()
-        info('Running "%s" in the exported directory.' % (command))
+        note('Running "%s" in the exported directory.' % (command))
         if give_instruction:
-            info('If you want to cancel your changes then exit with a non-zero '
+            note('If you want to cancel your changes then exit with a non-zero '
                  'exit code, e.g. run "exit 1".')
         try:
             builder.build()
         except BuildFailedError:
             raise BzrCommandError('Not updating the working tree as the '
                     'command failed.')
-        info("Copying debian/ back")
+        note("Copying debian/ back")
         if larstiq:
             destination = ''
         else:
@@ -821,13 +1028,13 @@
             if proc.returncode != 0:
                 raise BzrCommandError('Copying back debian/ failed')
         builder.clean()
-        info('If any files were added or removed you should run "bzr add" or '
+        note('If any files were added or removed you should run "bzr add" or '
              '"bzr rm" as appropriate.')
 
 
 class cmd_mark_uploaded(Command):
     """Mark that this branch has been uploaded, prior to pushing it.
-    
+
     When a package has been uploaded we want to mark the revision
     that it was uploaded in. This command automates doing that
     by marking the current tip revision with the version indicated
@@ -836,9 +1043,9 @@
     force = Option('force', help="Mark the upload even if it is already "
             "marked.")
 
-    takes_options = [merge_opt, no_user_conf_opt, force]
+    takes_options = [merge_opt, force]
 
-    def run(self, merge=False, no_user_config=False, force=None):
+    def run(self, merge=None, force=None):
         t = WorkingTree.open_containing('.')[0]
         t.lock_write()
         try:
@@ -846,16 +1053,15 @@
               raise BzrCommandError("There are uncommitted changes in the "
                       "working tree. You must commit before using this "
                       "command")
-            config = debuild_config(t, t, no_user_config)
-            if not merge:
-                merge = config.merge
+            config = debuild_config(t, t)
+            if merge is None:
+                merge = (config.build_type == BUILD_TYPE_MERGE)
             (changelog, larstiq) = find_changelog(t, merge)
-            distributions = changelog.distributions.strip()
-            target_dist = distributions.split()[0]
-            distribution_name = suite_to_distribution(target_dist)
-            if distribution_name is None:
-                raise BzrCommandError("Unknown target distribution: %s" \
-                        % target_dist)
+            if changelog.distributions == 'UNRELEASED':
+                if not force:
+                    raise BzrCommandError("The changelog still targets "
+                            "'UNRELEASED', so apparently hasn't been "
+                            "uploaded.")
             db = DistributionBranch(t.branch, None)
             dbs = DistributionBranchSet()
             dbs.add_branch(db)
@@ -870,14 +1076,97 @@
             t.unlock()
 
 
-class cmd_test_builddeb(Command):
-    """Run the builddeb test suite"""
-
-    hidden = True
-
-    def run(self):
-        from bzrlib.tests import selftest
-        passed = selftest(test_suite_factory=test_suite)
-        # invert for shell exit code rules
-        return not passed
-
+class cmd_merge_package(Command):
+    """Merges source packaging branch into target packaging branch.
+
+    This will first check whether the upstream branches have diverged.
+
+    If that's the case an attempt will be made to fix the upstream ancestry
+    so that the user only needs to deal wth packaging branch merge issues.
+
+    In the opposite case a normal merge will be performed.
+    """
+    takes_args = ['source']
+
+    def run(self, source):
+        source_branch = None
+        # Get the target branch.
+        try:
+            tree = WorkingTree.open_containing('.')[0]
+        except (NotBranchError, NoWorkingTree):
+            raise BzrCommandError(
+                "There is no tree to merge the source branch in to")
+        # Get the source branch.
+        try:
+            source_branch = Branch.open(source)
+        except NotBranchError:
+            raise BzrCommandError("Invalid source branch URL?")
+
+        tree.lock_write()
+        self.add_cleanup(tree.unlock)
+        source_branch.lock_read()
+        self.add_cleanup(source_branch.unlock)
+        this_config = debuild_config(tree, tree)
+        that_config = debuild_config(source_branch.basis_tree(),
+                source_branch.basis_tree())
+        if not (this_config.build_type == BUILD_TYPE_NATIVE or
+                that_config.build_type == BUILD_TYPE_NATIVE):
+            fix_ancestry_as_needed(tree, source_branch)
+
+        # Merge source packaging branch in to the target packaging branch.
+        _merge_tags_if_possible(source_branch, tree.branch)
+        conflicts = tree.merge_from_branch(source_branch)
+        if conflicts > 0:
+            note('The merge resulted in %s conflicts. Please resolve these '
+                 'and commit the changes with "bzr commit".' % conflicts)
+        else:
+            note('The merge resulted in no conflicts. You may commit the '
+            'changes by running "bzr commit".')
+
+
+class cmd_dh_make(Command):
+    """Helps you create a new package.
+
+    This code wraps dh_make to do the Bazaar setup for you, ensuring that
+    your branches have all the necessary information and are correctly
+    linked to the upstream branches where necessary.
+
+    The basic use case is satisfied by
+
+        bzr dh-make project 0.1 http://project.org/project-0.1.tar.gz
+
+    which will import the tarball with the correct tags etc. and then
+    run dh_make for you in order to start the packaging.
+
+    If there upstream is available in bzr then run the command from the
+    root of a branch of that corresponding to the 0.1 release.
+
+    If there is no upstream available in bzr then run the command from
+    outside a branch and it will create a branch for you in a directory
+    named the same as the package name you specify as the second argument.
+
+    If you do not wish to use dh_make, but just take advantage of the
+    Bazaar specific parts then use the --bzr-only option.
+    """
+
+    aliases = ['dh_make']
+
+    takes_args = ['package_name', 'version', 'tarball']
+
+    bzr_only_opt = Option('bzr-only', help="Don't run dh_make.")
+    v3_opt = Option('v3', help="Use dpkg-source format v3.")
+
+    takes_options = [bzr_only_opt, v3_opt]
+
+    def run(self, package_name, version, tarball, bzr_only=None, v3=None):
+        tree = dh_make.import_upstream(tarball, package_name,
+                version.encode("utf-8"), use_v3=v3)
+        if not bzr_only:
+            tree.lock_write()
+            try:
+                dh_make.run_dh_make(tree, package_name, version, use_v3=v3)
+            finally:
+                tree.unlock()
+        note('Package prepared in %s'
+                % urlutils.unescape_for_display(tree.basedir,
+                    self.outf.encoding))

=== modified file 'config.py'
--- config.py	2009-03-30 11:58:12 +0000
+++ config.py	2011-01-28 14:24:44 +0000
@@ -20,7 +20,16 @@
 
 from bzrlib.config import ConfigObj, TreeConfig
 from bzrlib.trace import mutter, warning
-from bzrlib.util.configobj.configobj import ParseError
+try:
+  from bzrlib.util.configobj.configobj import ParseError
+except ImportError:
+  from configobj import ParseError
+
+
+BUILD_TYPE_NORMAL = "normal"
+BUILD_TYPE_NATIVE = "native"
+BUILD_TYPE_MERGE = "merge"
+BUILD_TYPE_SPLIT = "split"
 
 
 class SvnBuildPackageMappedConfig(object):
@@ -254,6 +263,17 @@
 
   merge = _bool_property('merge', "Run in merge mode")
 
+  @property
+  def build_type(self):
+    if self.merge:
+      return BUILD_TYPE_MERGE
+    elif self.native:
+      return BUILD_TYPE_NATIVE
+    elif self.split:
+      return BUILD_TYPE_SPLIT
+    else:
+      return BUILD_TYPE_NORMAL
+
   quick_builder = _opt_property('quick-builder',
                           "A quick command to build with", True)
 
@@ -267,6 +287,9 @@
   export_upstream = _opt_property('export-upstream',
                          "Get the upstream source from another branch")
 
+  export_upstream_revision = _opt_property('export-upstream-revision',
+                         "The revision of the upstream source to use.")
+
 
 def _test():
   import doctest

=== modified file 'debian/changelog'
--- debian/changelog	2009-07-26 18:21:49 +0000
+++ debian/changelog	2011-01-28 14:24:44 +0000
@@ -1,9 +1,181 @@
-bzr-builddeb (2.2~ubuntu3) UNRELEASED; urgency=low
+bzr-builddeb (2.5.1) UNRELEASED; urgency=low
+
+  [ James Westby ]
+
+  * Don't fail if asked to use a .bz2 tarball that is already in the desired
+    location. LP: #616786
+  * Don't crash if we are asked to merge-upstream with an unrelated branch.
+    LP: #619614.
+  * Don't strip -n from the version we get in merge-upstream, as some
+    upstreams have this in there, and trying to support both means supporting
+    both badly. If you are used to doing "bzr merge-upstream --version
+    <package version>" then it will no longer work for you, use the
+    upstream version instead.
+  * Don't crash when doing merge-upstream with a branch that does a rename
+    and then ships another file with the old path in the tarball that isn't
+    in the branch.
+  * Accept None as a valid previous_version value in merge_upstream(). LP: #680945
+
+  [ Jelmer Vernooij ]
+
+  * Fix the auto-detection of merge mode.
+  * Don't crash on merge mode packages where there is no export-upstream
+    if we can't find the tarball.
+  * Determine Bazaar home directory using bzrlib to prevent test
+    isolation issues. LP: #614125
+  * Support 'bzr tags --sort=debversion'. Closes #701244.
+  * When adding a changelog entry, support git and svn snapshots.
+  * Automatically use debian/source/format if package is native. Closes:
+    #586617
+  * Fix "bzr builddeb" if last upload was not to a Ubuntu release pocket.
+    LP: #709263
+
+ -- Jelmer Vernooij <[e-mail]>  Fri, 28 Jan 2011 15:13:22 +0100
+
+bzr-builddeb (2.5) unstable; urgency=low
+
+  [ Colin Watson ]
+  * Consider a .dsc without a Format: to be Format: 1.0.
+
+  [ Jelmer Vernooij ]
+  * export now uses the timestamp of the last revision, making them more
+    deterministic, and so hopefully producing the same tarballs when it is
+    used for that.
+  * Fix use of getattr to have 3 arguments to avoid exception. (LP: #572093)
+  * Implement the automatic_tag_name hook so that "bzr tag" with no arguments
+    will tag based on the version in debian/changelog.
+  * Support upstream/VERSION tags, for compatibility with git-
+    buildpackage. LP: #551362
+  * Support upstream tarballs without a pristine tar delta.
+  * Support -r argument to import-upstream.
+
+  [ Robert Collins ]
+  * Add import-upstream command which imports an upstream - useful for
+    migrating existing packaging branches into pristine-tar using mode.
+  * Stop stripping .bzrignore from tarball imports. LP: #496907
+  * Make the upstream branch authoritative for file ids when importing a
+    tarball, stopping errors when files are renamed. LP: #588060
+
+  [ James Westby ]
+  * Add a --package-merge option to builddeb to build with the -v and -sa
+    appropriate when doing a merge from Debian or similar. LP: #576027
+  * Fixed a logic error that stops -r working in merge-upstream. LP: #594575
+
+  [ Jelmer Vernooij ]
+  * Determine Bazaar home directory using bzrlib to prevent test
+    isolation issues. Closes: #614125
+  * Bump standards version to 3.9.1 (no changes).
+
+ -- Jelmer Vernooij <[e-mail]>  Wed, 11 Aug 2010 18:23:54 +0200
+
+bzr-builddeb (2.4.2) unstable; urgency=low
+
+  [ Jelmer Vernooij ]
+  * Avoid AttributeError in the python-apt compatibility code.
+
+  [ James Westby ]
+  * Add 'maverick' as an Ubuntu release.
+
+ -- Jelmer Vernooij <[e-mail]>  Tue, 13 Apr 2010 21:37:53 +0200
+
+bzr-builddeb (2.4.1) unstable; urgency=low
+
+  [ Colin Watson ]
+  * Consider a .dsc without a Format: to be Format: 1.0.
+
+  [ Jelmer Vernooij ]
+  * Fix use of getattr to have 3 arguments to avoid exception. (LP: #572093)
+
+  [ James Westby ]
+  * Fix for Launchpad's multi-version support.
+
+ -- James Westby <[e-mail]>  Thu, 18 Mar 2010 14:19:53 -0400
+
+bzr-builddeb (2.4) unstable; urgency=low
+
+  [ Jelmer Vernooij ]
+  * Switch section to vcs.
+  * Allow the directory service to work with older version of python-apt.
+  * Fix compatibility with versions of bzr that don't have
+  bzrlib.utils.configobj. (Closes: #572093)
+
+  [ James Westby ]
+  * Correct typo that causes packages with .orig.tar.bz2 to fail to build.
+  * Also merge tags in merge-package.
+  * Adapt to the python-apt 0.8 API. Thanks to Julian Andres Klode.
+    (Closes: #572093)
+  * Fix merge-upstream with just a branch. (LP: #528273)
+
+  [ John Arbash Meinel ]
+  * Improve the changelog merge hook to be smarter when both sides change.
+
+  [ Steve Langasek ]
+  * Make merge-upstream --v3 unpack .tar.bz2 with the correct arguments.
+    (LP: #529900)
+
+ -- Jelmer Vernooij <[e-mail]>  Sat, 13 Feb 2010 01:16:00 +0100
+
+bzr-builddeb (2.3) experimental; urgency=low
+
+  [ James Westby ]
+  * Some support for v3 source formats (Closes: #562991)
+    - Those that look quite a lot like v1 are supported well.
+    - .tar.bz2 tarballs are supported for import, building, merge-upstream,
+      etc., but only enabled for the latter with a --v3 switch for now.
+    - Multiple orig.tar.gz is not supported.
+    - .tar.lzma is not supported awaiting pristine-tar support.
+  * New "dh-make" command ("dh_make" alias) that allows you to start
+    packaging, either in an empty branch, or based on an upstream branch.
+  * Fix merge-package for native packages (LP: #476348)
+  * debian/changelog merge hook to reduce the manual conflict resolution
+    required there. Thanks to John Arbash Meinel and Andrew Bennetts
+    (LP: #501754).
+    - Requires newer bzr.
+  * Fix merge-package outside a shared repo (LP: #493462)
+  * Fix exporting of symlinks (LP: #364671)
+  * Add --force option to merge-upstream which may help certain people.
+  * Use system configobj if the bzr copy isn't available. Thanks Jelmer.
+  * Make merging multiple-root branches work. Thanks Robert Collins.
+  * Disentangle from bzrtools. Thanks Max Bowser.
+
+  [ Jelmer Vernooij ]
+  * Bump standards version to 3.8.4.
+  * Fix formatting in doc-base.
+
+ -- Jelmer Vernooij <[e-mail]>  Sat, 13 Feb 2010 00:44:03 +0100
+
+bzr-builddeb (2.2) unstable; urgency=low
+
+  * Upload to unstable.
+  * Bump standards version to 3.8.3.
+
+ -- Jelmer Vernooij <[e-mail]>  Mon, 18 Jan 2010 19:15:26 +1300
+
+bzr-builddeb (2.2~ubuntu3) karmic; urgency=low
 
   [ Jelmer Vernooij ]
   * Automatically use merge mode if there's only a debian/ directory in
     the packaging branch. Closes: #529816.
 
+  [ James Westby ]
+  * Merge merge-package command from Muharem Hrnjadovic to allow merging
+    another branch of the same package in a way that will avoid spurious
+    conflicts from divergent upstream histories. Thanks Muharem.
+  * Don't crash on merge-upstream due to API changes not being fully applied.
+  * Add plugin information as parsed by "bzr plugin-info".
+  * Improve the error when the upstream tag is missing during merge-upstream.
+  * Also query the config file for the revision to use in export-upstream
+    (LP: #415572)
+  * Don't populate the commit message editor with all lines added to
+    debian/changelog. Only use the stripped version of the "change" lines.
+  * Always use the date from debian/changelog during import-dsc. Thanks
+    Sveinung Kvilhaugsvik.
+  * pristine-tar errors are no longer fatal for building the package.
+    Thanks Muharem. (LP: #417153)
+  * Refuse to build a conflicted tree. Thanks Muharem. (LP: #381303)
+  * Don't crash if there are no deb-src lines when building. (LP: #375897)
+  * Make import-dsc work against redirected URIs. Thanks Muharem (LP: #337209)
+
  -- James Westby <[e-mail]>  Sun, 26 Jul 2009 18:38:47 +0200
 
 bzr-builddeb (2.2~ubuntu2) karmic; urgency=low
@@ -286,6 +458,7 @@
 
 bzr-builddeb (0.92) unstable; urgency=low
 
+  [ James Westby ]
   * Support incremental imports of normal mode packages from source packages
     for uploads done outside the VCS.
   * Also look for upstream tarballs in the archives. Do this in preference
@@ -299,8 +472,22 @@
   * Allow the last upstream not to be on the mainline during merge-upstream.
   * Don't complain when repacking the tarball if the target exists, but is the
     same as the source. Only .tar.gz can be considered identical.
-
- -- James Westby <[e-mail]>  Wed, 31 Oct 2007 21:06:58 +0000
+  * Bug fix: "bzr-builddeb: merge-upstream --version is a conflicting
+    optoin", thanks to Jamie Wilkinson (Closes: #449369).
+  * Close old bug, only parse first changelog entry (Closes: #429299)
+  * Bug fix: "bzr-builddeb: parse debian/watch if no URL specified for
+    merge-upstream", thanks to Jamie Wilkinson (Closes: #449362).
+  * Bug fix: "bzr-builddeb: can't do merge packages with
+    dh-make-pear", thanks to [e-mail] (Mark A. Hershberger)
+    (Closes: #440069).
+
+  [ Reinhard Tartler ]
+  * (Build-)Depend on python-apt
+  * bump dependency on bzrtools
+  * when running the testsuite, set home directory to effectively disable
+    any user installed plugins
+
+ -- Reinhard Tartler <[e-mail]>  Mon, 12 Nov 2007 16:39:43 +0100
 
 bzr-builddeb (0.91) unstable; urgency=low
 

=== modified file 'debian/control'
--- debian/control	2009-07-26 18:35:25 +0000
+++ debian/control	2011-01-28 14:24:44 +0000
@@ -1,19 +1,18 @@
 Source: bzr-builddeb
-Section: devel
+Section: vcs
 Priority: optional
-Maintainer: Ubuntu MOTU Developers <[e-mail]>
-XSBC-Original-Maintainer: Debian Bazaar Maintainers <[e-mail]>
-Uploaders: Reinhard Tartler <[e-mail]>, James Westby <[e-mail]>
+Maintainer: Debian Bazaar Maintainers <[e-mail]>
+Uploaders: Reinhard Tartler <[e-mail]>, James Westby <[e-mail]>, Jelmer Vernooij <[e-mail]>
 Build-Depends: debhelper (>= 5.0.37.2), python-all (>= 2.3.5-11)
-Build-Depends-Indep: bzr (>= 1.10~), python-central (>= 0.5.8), python-docutils, python-debian (>= 0.1.11), python-apt, bzrtools (>= 1.2~), patchutils
-Vcs-Bzr: http://bazaar.launchpad.net/~james-w/bzr-builddeb/2.1/
-Vcs-Browser: http://bazaar.launchpad.net/~james-w/bzr-builddeb/2.1/
+Build-Depends-Indep: bzr (>= 2.1~), python-central (>= 0.5.8), python-docutils, python-debian (>= 0.1.11), python-apt, patchutils
+Vcs-Bzr: http://bzr.debian.org/pkg-bazaar/bzr-builddeb/unstable
+Vcs-Browser: http://bzr.debian.org/loggerhead/pkg-bazaar/bzr-builddeb/unstable
 XS-Python-Version: >= 2.4
-Standards-Version: 3.7.2
+Standards-Version: 3.9.1
 
 Package: bzr-builddeb
 Architecture: all
-Depends: bzr (>= 1.10~), python-debian (>= 0.1.11), python-apt, ${python:Depends}, dpkg-dev, fakeroot, bzrtools (>= 1.2), devscripts, patchutils, pristine-tar
+Depends: bzr (>= 2.1~), python-debian (>= 0.1.11), python-apt, ${python:Depends}, dpkg-dev, fakeroot, devscripts, patchutils, pristine-tar, ${misc:Depends}
 Recommends: python-launchpadlib
 Suggests: bzr-svn (>= 0.4.10)
 Provides: bzr-buildpackage

=== modified file 'debian/doc-base'
--- debian/doc-base	2007-07-10 20:52:45 +0000
+++ debian/doc-base	2011-01-28 14:24:44 +0000
@@ -3,9 +3,8 @@
 Author: James Westby
 Abstract: This user guide describes how to use bzr-builddeb to build Debian
  packages from Bazaar branches.
-Section: Apps/Programming
+Section: Programming
 
 Format: HTML
 Index: /usr/share/doc/bzr-builddeb/user_manual/index.html
 Files: /usr/share/doc/bzr-builddeb/user_manual/*.html
- 

=== added file 'dh_make.py'
--- dh_make.py	1970-01-01 00:00:00 +0000
+++ dh_make.py	2011-01-28 14:24:44 +0000
@@ -0,0 +1,128 @@
+import os
+import sys
+import subprocess
+
+from bzrlib import (
+    bzrdir,
+    revision as mod_revision,
+    trace,
+    transport,
+    workingtree,
+    )
+from bzrlib import errors as bzr_errors
+
+from bzrlib.plugins.builddeb import (
+    default_orig_dir,
+    import_dsc,
+    upstream,
+    util,
+    )
+
+
+def _get_tree(package_name):
+    try:
+        tree = workingtree.WorkingTree.open(".")
+    except bzr_errors.NotBranchError:
+        if os.path.exists(package_name):
+            raise bzr_errors.BzrCommandError("Either run the command from an "
+                    "existing branch of upstream, or move %s aside "
+                    "and a new branch will be created there."
+                    % package_name)
+        to_transport = transport.get_transport(package_name)
+        tree = to_transport.ensure_base()
+        try:
+            a_bzrdir = bzrdir.BzrDir.open_from_transport(to_transport)
+        except bzr_errors.NotBranchError:
+            # really a NotBzrDir error...
+            create_branch = bzrdir.BzrDir.create_branch_convenience
+            branch = create_branch(to_transport.base,
+                                   possible_transports=[to_transport])
+            a_bzrdir = branch.bzrdir
+        else:
+            if a_bzrdir.has_branch():
+                raise bzr_errors.AlreadyBranchError(package_name)
+            branch = a_bzrdir.create_branch()
+            a_bzrdir.create_workingtree()
+        try:
+            tree = a_bzrdir.open_workingtree()
+        except bzr_errors.NoWorkingTree:
+            tree = a_bzrdir.create_workingtree()
+    return tree
+
+
+def _get_tarball(tree, tarball, package_name, version, use_v3=False):
+    from bzrlib.plugins.builddeb.repack_tarball import repack_tarball
+    config = util.debuild_config(tree, tree)
+    orig_dir = config.orig_dir or default_orig_dir
+    orig_dir = os.path.join(tree.basedir, orig_dir)
+    if not os.path.exists(orig_dir):
+        os.makedirs(orig_dir)
+    format = None
+    if use_v3:
+        if tarball.endswith(".tar.bz2") or tarball.endswith(".tbz2"):
+            format = "bz2"
+    dest_name = util.tarball_name(package_name, version, format=format)
+    tarball_filename = os.path.join(orig_dir, dest_name)
+    trace.note("Fetching tarball")
+    repack_tarball(tarball, dest_name, target_dir=orig_dir,
+            force_gz=not use_v3)
+    provider = upstream.UpstreamProvider(package_name, "%s-1" % version,
+            orig_dir, [])
+    provider.provide(os.path.join(tree.basedir, ".."))
+    return tarball_filename, util.md5sum_filename(tarball_filename)
+
+
+def import_upstream(tarball, package_name, version, use_v3=False):
+    tree = _get_tree(package_name)
+    if tree.branch.last_revision() != mod_revision.NULL_REVISION:
+        parents = [tree.branch.last_revision()]
+    else:
+        parents = []
+    tarball_filename, md5sum = _get_tarball(tree, tarball,
+            package_name, version, use_v3=use_v3)
+    db = import_dsc.DistributionBranch(tree.branch, tree.branch, tree=tree,
+            upstream_tree=tree)
+    dbs = import_dsc.DistributionBranchSet()
+    dbs.add_branch(db)
+    db.import_upstream_tarball(tarball_filename, version, parents, md5sum=md5sum)
+    return tree
+
+
+def run_dh_make(tree, package_name, version, use_v3=False):
+    if not tree.has_filename("debian"):
+        tree.mkdir("debian")
+    # FIXME: give a nice error on 'debian is not a directory'
+    if tree.path2id("debian") is None:
+        tree.add("debian")
+    if use_v3:
+        if not tree.has_filename("debian/source"):
+            tree.mkdir("debian/source")
+        if tree.path2id("debian/source") is None:
+            tree.add("debian/source")
+        f = open("debian/source/format")
+        try:
+            f.write("3.0 (quilt)\n")
+        finally:
+            f.close()
+        if tree.path2id("debian/source/format") is None:
+            tree.add("debian/source/format")
+    command = ["dh_make", "--addmissing", "--packagename",
+                "%s_%s" % (package_name, version)]
+    if getattr(sys.stdin, 'fileno', None) is None:
+        # running in a test or something
+        stdin = subprocess.PIPE
+        input = "s\n\n"
+    else:
+        stdin = sys.stdin
+        input = None
+    proc = subprocess.Popen(command, cwd=tree.basedir,
+            preexec_fn=util.subprocess_setup, stdin=stdin)
+    if input is not None:
+        proc.stdin.write(input)
+        proc.stdin.close()
+    retcode = proc.wait()
+    if retcode != 0:
+        raise bzr_errors.BzrCommandError("dh_make failed.")
+    for fn in os.listdir(tree.abspath("debian")):
+        if not fn.endswith(".ex") and not fn.endswith(".EX"):
+            tree.add(os.path.join("debian", fn))

=== modified file 'directory.py'
--- directory.py	2009-04-16 10:42:12 +0000
+++ directory.py	2011-01-28 14:24:44 +0000
@@ -19,7 +19,7 @@
 #
 
 from bzrlib import errors
-from bzrlib.trace import info
+from bzrlib.trace import note
 
 import apt_pkg
 
@@ -35,11 +35,19 @@
 
         apt_pkg.init()
 
-        sources = apt_pkg.GetPkgSrcRecords()
+        # Older versions of apt_pkg don't have SourceRecords,
+        # newer versions give a deprecation warning when using
+        # GetPkgSrcRecords.
+        try:
+            sources = apt_pkg.SourceRecords()
+        except AttributeError:
+            sources = apt_pkg.GetPkgSrcRecords()
 
         urls = {}
-        while sources.Lookup(name):
-            for l in sources.Record.splitlines():
+        lookup = getattr(sources, 'lookup', getattr(sources, 'Lookup'))
+        while lookup(name):
+            record = getattr(sources, 'record', getattr(sources, 'Record'))
+            for l in record.splitlines():
                 if not ": " in l:
                     continue
                 (field, value) = l.strip("\n").split(": ", 1)
@@ -55,13 +63,15 @@
 
         if version is None:
             # Try the latest version
-            version = sorted(urls,cmp=apt_pkg.VersionCompare)[0]
+            cmp = getattr(apt_pkg, 'version_compare',
+                    getattr(apt_pkg, 'VersionCompare'))
+            version = sorted(urls,cmp=cmp)[0]
 
         if not version in urls:
             raise errors.InvalidURL(path=url,
                     extra='version %s not found' % version)
         
-        info("Retrieving Vcs locating from %s Debian version %s", name, version)
+        note("Retrieving Vcs locating from %s Debian version %s", name, version)
 
         if "Bzr" in urls[version]:
             return urls[version]["Bzr"]
@@ -70,7 +80,7 @@
             try:
                 import bzrlib.plugins.svn
             except ImportError:
-                info("This package uses subversion. If you would like to "
+                note("This package uses subversion. If you would like to "
                         "access it with bzr then please install bzr-svn "
                         "and re-run the command.")
             else:
@@ -80,7 +90,7 @@
             try:
                 import bzrlib.plugins.git
             except ImportError:
-                info("This package uses git. If you would like to "
+                note("This package uses git. If you would like to "
                         "access it with bzr then please install bzr-git "
                         "and re-run the command.")
             else:
@@ -90,7 +100,7 @@
             try:
                 import bzrlib.plugins.hg
             except ImportError:
-                info("This package uses hg. If you would like to "
+                note("This package uses hg. If you would like to "
                         "access it with bzr then please install bzr-hg"
                         "and re-run the command.")
             else:

=== modified file 'doc/user_manual/normal.rst'
--- doc/user_manual/normal.rst	2009-02-18 22:50:44 +0000
+++ doc/user_manual/normal.rst	2011-01-28 14:24:44 +0000
@@ -247,6 +247,42 @@
 
   $ bzr merge-upstream --version 0.2 http://scruff.org/bzr/scruff.dev
 
+Merging a package
+#################
+
+When merging a package you should use the ``merge-package`` command,
+which knows about packages in a way that ``merge`` does not. This
+knowledge allows it to reconcile deviations in the upstream
+ancestry so that they don't cause excess conflicts. (Note that the
+command works whether or not there are deviations in the upstream
+ancestry.)
+
+The command works in the same way as ``merge``. For example::
+
+    $ cd scruff-unstable/
+    $ bzr merge-package ../scruff-experimental
+
+will leave the branch in the same state as a normal merge allowing
+you to review the changes and commit.
+
+In a small number of cases, however, the source `upstream` and target
+`packaging` branches will have conflicts that cause the following error
+instead::
+
+    $ bzr merge-package ../scruff-highly-experimental
+    The upstream branches for the merge source and target have diverged.
+    Unfortunately, the attempt to fix this problem resulted in conflicts.
+    Please resolve these, commit and re-run the "merge-package" command to
+    finish.
+    Alternatively, until you commit you can use "bzr revert" to restore the
+    state of the unmerged branch.
+
+This will leave you in a conflicted tree, and you can deal with the conflicts
+and use ``resolve`` as normal. Once you have resolved all the conflicts you
+need to commit and then run the same ``merge-package`` command again to
+complete the operation. As with normal merges until you commit you can
+use ``revert`` to return you to the state before you started.
+
 Importing a source package from elsewhere
 #########################################
 
@@ -266,7 +302,7 @@
 local path this can be any URI that Bazaar supports, for instance a
 ``http://`` URL. For instance::
 
-  $ bzr import-dsc --distribution debian ../scruff_0.2-1.1.dsc
+  $ bzr import-dsc ../scruff_0.2-1.1.dsc
 
 The command will import the changes and then leave you with a tree that is
 the result of merging the changes in the source package in to the tip of

=== modified file 'doc/user_manual/upstream_tarballs.rst'
--- doc/user_manual/upstream_tarballs.rst	2009-02-18 22:50:44 +0000
+++ doc/user_manual/upstream_tarballs.rst	2011-01-28 14:24:44 +0000
@@ -13,7 +13,9 @@
 If it can it will reconstruct the tarball from ``pristine-tar`` information
 stored in the branch. ``bzr-builddeb`` will store this information whenever
 it can, so using its commands such as ``merge-upstream`` and ``import-dsc``
-will lead to the best experience.
+will lead to the best experience. If you have an existing branch missing
+this information, you can use the ``import-upstream`` command to import a
+single tarball, after which the ``merge-upstream`` command should be used.
 
 If there is no ``pristine-tar`` information then it will use apt to download
 the tarball from the archive if there is one of the correct version there.

=== modified file 'errors.py'
--- errors.py	2009-04-16 09:30:49 +0000
+++ errors.py	2011-01-28 14:24:44 +0000
@@ -66,7 +66,7 @@
 
 
 class MissingChangelogError(BzrError):
-    _fmt = 'Could not find changelog at %(locations)s.'
+    _fmt = 'Could not find changelog at %(location)s.'
 
     def __init__(self, locations):
         BzrError.__init__(self, location=locations)
@@ -175,3 +175,48 @@
 
     def __init__(self, error):
         BzrError.__init__(self, error=error)
+
+
+class SharedUpstreamConflictsWithTargetPackaging(BzrError):
+    _fmt = ('The upstream branches for the merge source and target have '
+            'diverged. Unfortunately, the attempt to fix this problem '
+            'resulted in conflicts. Please resolve these, commit and '
+            're-run the "merge-package" command to finish. '
+            'Alternatively, until you commit you can use "bzr revert" to '
+            'restore the state of the unmerged branch.')
+
+
+class PerFileTimestampsNotSupported(BzrError):
+
+    _fmt = ("Per file timestamps are not supported by the "
+            "currently loaded version of bzrlib.")
+
+
+class NoPreviousUpload(BzrError):
+
+    _fmt = ("There was no previous upload to %(distribution)s.")
+
+    def __init__(self, distribution):
+        BzrError.__init__(self, distribution=distribution)
+
+
+class UnableToFindPreviousUpload(BzrError):
+
+    _fmt = ("Unable to determine the previous upload for --package-merge.")
+
+
+class InconsistentSourceFormatError(BzrError):
+
+    _fmt = ("Inconsistency between source format and version: version is "
+            "%(version_bool)snative, format is %(format_bool)snative.")
+
+    def __init__(self, version_native, format_native):
+        if version_native:
+            version_bool = ""
+        else:
+            version_bool = "not "
+        if format_native:
+            format_bool = ""
+        else:
+            format_bool = "not "
+        BzrError.__init__(self, version_bool=version_bool, format_bool=format_bool)

=== modified file 'hooks.py'
--- hooks.py	2008-05-18 00:04:21 +0000
+++ hooks.py	2011-01-28 14:24:44 +0000
@@ -20,7 +20,7 @@
 
 import subprocess
 
-from bzrlib.trace import info
+from bzrlib.trace import note
 
 from bzrlib.plugins.builddeb.errors import HookFailedError
 
@@ -29,7 +29,7 @@
   hook = config.get_hook(hook_name)
   if hook is None:
     return
-  info("Running %s as %s hook" % (hook, hook_name))
+  note("Running %s as %s hook" % (hook, hook_name))
   proc = subprocess.Popen(hook, shell=True, 
                           cwd=tree.abspath(wd))
   proc.wait()

=== modified file 'import_dsc.py'
--- import_dsc.py	2009-07-26 16:44:17 +0000
+++ import_dsc.py	2011-01-28 14:24:44 +0000
@@ -29,290 +29,59 @@
         standard_b64decode,
         standard_b64encode,
         )
-try:
-    import hashlib as md5
-except ImportError:
-    import md5
+import errno
 import os
+import re
 import shutil
 import stat
-from subprocess import Popen, PIPE
-from StringIO import StringIO
+import subprocess
 import tempfile
 
-from debian_bundle import deb822
-from debian_bundle.changelog import Version, Changelog, VersionError
+try:
+    from debian import deb822
+    from debian.changelog import Version, Changelog, VersionError
+except ImportError:
+  # Prior to 0.1.15 the debian module was called debian_bundle
+    from debian_bundle import deb822
+    from debian_bundle.changelog import Version, Changelog, VersionError
 
 from bzrlib import (
                     bzrdir,
-                    generate_ids,
                     osutils,
-                    urlutils,
                     )
 from bzrlib.config import ConfigObj
 from bzrlib.errors import (
+        AlreadyBranchError,
         BzrCommandError,
         NotBranchError,
-        AlreadyBranchError,
+        NoSuchRevision,
+        NoWorkingTree,
+        UnrelatedBranches,
         )
-from bzrlib.export import export
-from bzrlib.osutils import file_iterator, isdir, basename, splitpath
 from bzrlib.revisionspec import RevisionSpec
 from bzrlib.revision import NULL_REVISION
-from bzrlib.trace import warning, info, mutter
-from bzrlib.transform import TreeTransform, cook_conflicts, resolve_conflicts
-from bzrlib.transport import get_transport
-
-from bzrlib.plugins.bzrtools.upstream_import import (
-                                                     names_of_files,
-                                                     add_implied_parents,
-                                                     )
-
+from bzrlib.trace import warning, mutter
+from bzrlib.transport import (
+    get_transport,
+    )
+
+from bzrlib.plugins.builddeb.bzrtools_import import import_dir
 from bzrlib.plugins.builddeb.errors import (
                 PristineTarError,
-                UnknownType,
+                TarFailed,
                 UpstreamAlreadyImported,
                 UpstreamBranchAlreadyMerged,
                 )
-from bzrlib.plugins.builddeb.util import get_commit_info_from_changelog, get_snapshot_revision
-
-
-files_to_ignore = set(['.cvsignore', '.arch-inventory', '.bzrignore',
-    '.gitignore', 'CVS', 'RCS', '.deps', '{arch}', '.arch-ids', '.svn',
-    '.hg', '_darcs', '.git', '.shelf', '.bzr', '.bzr.backup', '.bzrtags',
-    '.bzr-builddeb'])
-
-exclude_as_files = ['*/' + x for x in files_to_ignore]
-exclude_as_dirs = ['*/' + x + '/*' for x in files_to_ignore]
-exclude = exclude_as_files + exclude_as_dirs
-underscore_x = ['-x'] * len(exclude)
-ignore_arguments = []
-map(ignore_arguments.extend, zip(underscore_x, exclude))
-ignore_arguments = ignore_arguments + ['-x', '*,v']
-
-
-class DirWrapper(object):
-    def __init__(self, fileobj, mode='r'):
-        assert mode == 'r', mode
-        self.root = os.path.realpath(fileobj.read())
-
-    def __repr__(self):
-        return 'DirWrapper(%r)' % self.root
-
-    def getmembers(self, subdir=None):
-        if subdir is not None:
-            mydir = os.path.join(self.root, subdir)
-        else:
-            mydir = self.root
-        for child in os.listdir(mydir):
-            if subdir is not None:
-                child = os.path.join(subdir, child)
-            fi = FileInfo(self.root, child)
-            yield fi
-            if fi.isdir():
-                for v in self.getmembers(child):
-                    yield v
-
-    def extractfile(self, member):
-        return open(member.fullpath)
-
-
-class FileInfo(object):
-
-    def __init__(self, root, filepath):
-        self.fullpath = os.path.join(root, filepath)
-        self.root = root
-        if filepath != '':
-            self.name = os.path.join(basename(root), filepath)
-        else:
-            self.name = basename(root)
-        self.type = None
-        stat = os.lstat(self.fullpath)
-        self.mode = stat.st_mode
-        if self.isdir():
-            self.name += '/'
-
-    def __repr__(self):
-        return 'FileInfo(%r)' % self.name
-
-    def isreg(self):
-        return stat.S_ISREG(self.mode)
-
-    def isdir(self):
-        return stat.S_ISDIR(self.mode)
-
-    def issym(self):
-        if stat.S_ISLNK(self.mode):
-            self.linkname = os.readlink(self.fullpath)
-            return True
-        else:
-            return False
-
-    def islnk(self):
-        # This could be accurate, but the use below seems like
-        # it wouldn't really care
-        return False
-
-
-def import_dir(tree, dir, file_ids_from=None):
-    dir_input = StringIO(dir)
-    dir_file = DirWrapper(dir_input)
-    import_archive(tree, dir_file, file_ids_from=file_ids_from)
-
-
-def do_directory(tt, trans_id, tree, relative_path, path):
-    if isdir(path) and tree.path2id(relative_path) is not None:
-        tt.cancel_deletion(trans_id)
-    else:
-        tt.create_directory(trans_id)
-
-
-def should_ignore(relative_path):
-    parts = splitpath(relative_path)
-    if not parts:
-        return False
-    for part in parts:
-        if part in files_to_ignore:
-            return True
-        if part.endswith(',v'):
-            return True
-
-
-def top_directory(path):
-    """Return the top directory given in a path."""
-    parts = osutils.splitpath(osutils.normpath(path))
-    if len(parts) > 0:
-        return parts[0]
-    return ''
-
-
-def common_directory(names):
-    """Determine a single directory prefix from a list of names"""
-    prefixes = set()
-    prefixes.update(map(top_directory, names))
-    if '' in prefixes:
-        prefixes.remove('')
-    if len(prefixes) != 1:
-        return None
-    prefix = prefixes.pop()
-    if prefix == '':
-        return None
-    return prefix
-
-
-def import_archive(tree, archive_file, file_ids_from=None):
-    prefix = common_directory(names_of_files(archive_file))
-    tt = TreeTransform(tree)
-
-    if file_ids_from is None:
-        file_ids_from = []
-
-    removed = set()
-    for path, entry in tree.inventory.iter_entries():
-        if entry.parent_id is None:
-            continue
-        trans_id = tt.trans_id_tree_path(path)
-        tt.delete_contents(trans_id)
-        removed.add(path)
-
-    added = set()
-    implied_parents = set()
-    seen = set()
-    for member in archive_file.getmembers():
-        if member.type == 'g':
-            # type 'g' is a header
-            continue
-        relative_path = member.name
-        relative_path = osutils.normpath(relative_path)
-        relative_path = relative_path.lstrip('/')
-        if prefix is not None:
-            relative_path = relative_path[len(prefix)+1:]
-        if relative_path == '' or relative_path == '.':
-            continue
-        if should_ignore(relative_path):
-            continue
-        add_implied_parents(implied_parents, relative_path)
-        trans_id = tt.trans_id_tree_path(relative_path)
-        added.add(relative_path.rstrip('/'))
-        path = tree.abspath(relative_path)
-        if member.name in seen:
-            if tt.final_kind(trans_id) == 'file':
-                tt.set_executability(None, trans_id)
-            tt.cancel_creation(trans_id)
-        seen.add(member.name)
-        if member.isreg() or member.islnk():
-            tt.create_file(file_iterator(archive_file.extractfile(member)),
-                           trans_id)
-            executable = (member.mode & 0111) != 0
-            tt.set_executability(executable, trans_id)
-        elif member.isdir():
-            do_directory(tt, trans_id, tree, relative_path, path)
-        elif member.issym():
-            tt.create_symlink(member.linkname, trans_id)
-        else:
-            raise UnknownType(relative_path)
-        if tt.tree_file_id(trans_id) is None:
-            found = False
-            for other_tree in file_ids_from:
-                other_tree.lock_read()
-                try:
-                    if other_tree.has_filename(relative_path):
-                        file_id = other_tree.path2id(relative_path)
-                        if file_id is not None:
-                            tt.version_file(file_id, trans_id)
-                            found = True
-                            break
-                finally:
-                    other_tree.unlock()
-            if not found:
-                name = basename(member.name.rstrip('/'))
-                file_id = generate_ids.gen_file_id(name)
-                tt.version_file(file_id, trans_id)
-
-    for relative_path in implied_parents.difference(added):
-        if relative_path == "":
-            continue
-        trans_id = tt.trans_id_tree_path(relative_path)
-        path = tree.abspath(relative_path)
-        do_directory(tt, trans_id, tree, relative_path, path)
-        if tt.tree_file_id(trans_id) is None:
-            found = False
-            for other_tree in file_ids_from:
-                other_tree.lock_read()
-                try:
-                    if other_tree.has_filename(relative_path):
-                        file_id = other_tree.path2id(relative_path)
-                        if file_id is not None:
-                            tt.version_file(file_id, trans_id)
-                            found = True
-                            break
-                finally:
-                    other_tree.unlock()
-            if not found:
-                tt.version_file(trans_id, trans_id)
-        added.add(relative_path)
-
-    for path in removed.difference(added):
-        tt.unversion_file(tt.trans_id_tree_path(path))
-
-    for conflict in cook_conflicts(resolve_conflicts(tt), tt):
-        warning(conflict)
-    tt.apply()
-
-
-def open_file(path, transport, base_dir=None):
-  """Open a file, possibly over a transport.
-
-  Open the named path, using the transport if not None. If the transport and
-  base_dir are not None, then path will be interpreted relative to base_dir.
-  """
-  if transport is None:
-    base_dir, path = urlutils.split(path)
-    transport = get_transport(base_dir)
-  else:
-    if base_dir is not None:
-      path = urlutils.join(base_dir, path)
-  return (transport.get(path), transport)
+from bzrlib.plugins.builddeb.util import (
+    export,
+    get_commit_info_from_changelog,
+    get_snapshot_revision,
+    md5sum_filename,
+    open_file_via_transport,
+    open_transport,
+    safe_decode,
+    subprocess_setup,
+    )
 
 
 class DscCache(object):
@@ -323,16 +92,20 @@
     self.transport = transport
 
   def get_dsc(self, name):
+
     if name in self.cache:
       dsc1 = self.cache[name]
     else:
-      (f1, transport) = open_file(name, self.transport)
+      # Obtain the dsc file, following any redirects as needed.
+      filename, transport = open_transport(name)
+      f1 = open_file_via_transport(filename, transport)
       try:
         dsc1 = deb822.Dsc(f1)
       finally:
         f1.close()
       self.cache[name] = dsc1
       self.transport_cache[name] = transport
+
     return dsc1
 
   def get_transport(self, name):
@@ -355,6 +128,57 @@
     return -1
 
 
+
+def reconstruct_pristine_tar(dest, delta, dest_filename):
+    """Reconstruct a pristine tarball from a directory and a delta.
+
+    :param dest: Directory to pack
+    :param delta: pristine-tar delta
+    :param dest_filename: Destination filename
+    """
+    command = ["pristine-tar", "gentar", "-",
+               os.path.abspath(dest_filename)]
+    try:
+        proc = subprocess.Popen(command, stdin=subprocess.PIPE,
+                cwd=dest, preexec_fn=subprocess_setup,
+                stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
+    except OSError, e:
+        if e.errno == errno.ENOENT:
+            raise PristineTarError("pristine-tar is not installed")
+        else:
+            raise
+    (stdout, stderr) = proc.communicate(delta)
+    if proc.returncode != 0:
+        raise PristineTarError("Generating tar from delta failed: %s" % stdout)
+
+
+def make_pristine_tar_delta(dest, tarball_path):
+    """Create a pristine-tar delta for a tarball.
+
+    :param dest: Directory to generate pristine tar delta for
+    :param tarball_path: Path to the tarball
+    :return: pristine-tarball
+    """
+    # If tarball_path is relative, the cwd=dest parameter to Popen will make
+    # pristine-tar faaaail. pristine-tar doesn't use the VFS either, so we
+    # assume local paths.
+    tarball_path = osutils.abspath(tarball_path)
+    command = ["pristine-tar", "gendelta", tarball_path, "-"]
+    try:
+        proc = subprocess.Popen(command, stdout=subprocess.PIPE,
+                cwd=dest, preexec_fn=subprocess_setup,
+                stderr=subprocess.PIPE)
+    except OSError, e:
+        if e.errno == errno.ENOENT:
+            raise PristineTarError("pristine-tar is not installed")
+        else:
+            raise
+    (stdout, stderr) = proc.communicate()
+    if proc.returncode != 0:
+        raise PristineTarError("Generating delta from tar failed: %s" % stderr)
+    return stdout
+
+
 class DistributionBranchSet(object):
     """A collection of DistributionBranches with an ordering.
 
@@ -573,28 +397,16 @@
         :return: True if the upstream branch contains the specified upstream
             version of the package. False otherwise.
         """
-        tag_name = self.upstream_tag_name(version)
-        if self._has_version(self.upstream_branch, tag_name, md5=md5):
-            return True
-        tag_name = self.upstream_tag_name(version, distro="debian")
-        if self._has_version(self.upstream_branch, tag_name, md5=md5):
-            return True
-        tag_name = self.upstream_tag_name(version, distro="ubuntu")
-        if self._has_version(self.upstream_branch, tag_name, md5=md5):
-            return True
+        for tag_name in self.possible_upstream_tag_names(version):
+            if self._has_version(self.upstream_branch, tag_name, md5=md5):
+                return True
         return False
 
     def has_upstream_version_in_packaging_branch(self, version, md5=None):
-        assert isinstance(version, str)
-        tag_name = self.upstream_tag_name(version)
-        if self._has_version(self.branch, tag_name, md5=md5):
-            return True
-        tag_name = self.upstream_tag_name(version, distro="debian")
-        if self._has_version(self.branch, tag_name, md5=md5):
-            return True
-        tag_name = self.upstream_tag_name(version, distro="ubuntu")
-        if self._has_version(self.branch, tag_name, md5=md5):
-            return True
+        assert isinstance(version, str), str(type(version))
+        for tag_name in self.possible_upstream_tag_names(version):
+            if self._has_version(self.branch, tag_name, md5=md5):
+                return True
         return False
 
     def contained_versions(self, versions):
@@ -693,47 +505,62 @@
         :return: the revision id corresponding to the upstream portion
             of the version
         """
-        tag_name = self.upstream_tag_name(version)
-        if self._has_version(self.upstream_branch, tag_name):
-            return self.upstream_branch.tags.lookup_tag(tag_name)
-        tag_name = self.upstream_tag_name(version, distro="debian")
-        if self._has_version(self.upstream_branch, tag_name):
-            return self.upstream_branch.tags.lookup_tag(tag_name)
-        tag_name = self.upstream_tag_name(version, distro="ubuntu")
-        if self._has_version(self.upstream_branch, tag_name):
-            return self.upstream_branch.tags.lookup_tag(tag_name)
+        for tag_name in self.possible_upstream_tag_names(version):
+            if self._has_version(self.upstream_branch, tag_name):
+                return self.upstream_branch.tags.lookup_tag(tag_name)
         tag_name = self.upstream_tag_name(version)
         return self.upstream_branch.tags.lookup_tag(tag_name)
 
-    def tag_version(self, version):
+    def possible_upstream_tag_names(self, version):
+        tags = [self.upstream_tag_name(version),
+                self.upstream_tag_name(version, distro="debian"),
+                self.upstream_tag_name(version, distro="ubuntu"),
+                "upstream/%s" % self.tag_name(version)]
+        return tags
+
+    def tag_version(self, version, revid=None):
         """Tags the branch's last revision with the given version.
 
         Sets a tag on the last revision of the branch with a tag that refers
         to the version provided.
 
         :param version: the Version object to derive the tag name from.
+        :param revid: the revid to associate the tag with, or None for the
+            tip of self.branch.
         :return: Name of the tag set
         """
         tag_name = self.tag_name(version)
-        self.branch.tags.set_tag(tag_name,
-                self.branch.last_revision())
+        if revid is None:
+            revid = self.branch.last_revision()
+        self.branch.tags.set_tag(tag_name, revid)
         return tag_name
 
-    def tag_upstream_version(self, version):
+    def tag_upstream_version(self, version, revid=None):
         """Tags the upstream branch's last revision with an upstream version.
 
-        Sets a tag on the last revision of the upstream branch with a tag
-        that refers to the upstream part of the version provided.
+        Sets a tag on the last revision of the upstream branch and on the main
+        branch with a tag that refers to the upstream part of the version
+        provided.
 
         :param version: the upstream part of the version number to derive the 
             tag name from.
+        :param revid: the revid to associate the tag with, or None for the
+            tip of self.upstream_branch.
+        :return The tag name, revid of the added tag.
         """
         assert isinstance(version, str)
         tag_name = self.upstream_tag_name(version)
-        self.upstream_branch.tags.set_tag(tag_name,
-                self.upstream_branch.last_revision())
-        self.branch.tags.set_tag(tag_name,
-                self.upstream_branch.last_revision())
+        if revid is None:
+            revid = self.upstream_branch.last_revision()
+        self.upstream_branch.tags.set_tag(tag_name, revid)
+        try:
+            self.branch.repository.fetch(self.upstream_branch.repository,
+                revision_id=revid)
+        except NoSuchRevision:
+            # See bug lp:574223
+            pass
+        self.branch.tags.set_tag(tag_name, revid)
+        return tag_name, revid
 
     def _default_config_for_tree(self, tree):
         # FIXME: shouldn't go to configobj directly
@@ -752,7 +579,6 @@
                 tree.unlock()
         return config
 
-
     def _is_tree_native(self, tree):
         config = self._default_config_for_tree(tree)
         if config is not None:
@@ -899,7 +725,7 @@
         """Return the list of parents for a specific version.
 
         This method returns the list of revision ids that should be parents
-        for importing a specifc package version. The specific package version
+        for importing a specific package version. The specific package version
         is the first element of the list of versions passed.
 
         The parents are determined by looking at the other versions in the
@@ -984,7 +810,7 @@
             "Can't pull upstream with no tree"
         self.upstream_tree.pull(up_pull_branch,
                 stop_revision=pull_revision)
-        self.tag_upstream_version(version)
+        self.tag_upstream_version(version, revid=pull_revision)
         self.branch.fetch(self.upstream_branch, last_revision=pull_revision)
         self.upstream_branch.tags.merge_to(self.branch.tags)
 
@@ -1014,7 +840,7 @@
                 % (str(version), pull_revision))
         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)
+        self.tag_version(version, revid=pull_revision)
         if not native and not self.has_upstream_version(version.upstream_version):
             if pull_branch.has_upstream_version(version.upstream_version):
                 self.pull_upstream_from_branch(pull_branch, 
@@ -1079,33 +905,18 @@
         return real_parents
 
     def _fetch_upstream_to_branch(self, revid):
-        """Fetch the revision from the upstream branch in to the pacakging one.
-
-        This will unlock self.tree, then re-lock it and fetch. This is
-        necessary as if the two branches share a repository the branch
-        won't see any revisions added by the upstream branch since self.tree
-        was locked.
-
-        It will check that the last revision is the same before and after,
-        and that there are no working tree changes, to prevent unexpected
-        things happening if say a commit was done in this time.
+        """Fetch the revision from the upstream branch in to the packaging one.
         """
-        if self.tree.is_locked():
-            last_revision = self.branch.last_revision()
-            # Unlock the tree and lock it again
-            self.tree.unlock()
-            self.tree.lock_write()
-            assert self.branch.last_revision() == last_revision, \
-                    "Branch committed to while refreshing it. Not proceeding."
-            assert not self.tree.changes_from(
-                    self.tree.basis_tree()).has_changed(), \
-                    "Treee altered while refreshing it. Not proceeding."
+        # Make sure we see any revisions added by the upstream branch
+        # since self.tree was locked.
+        self.branch.repository.refresh_data()
         self.branch.fetch(self.upstream_branch, last_revision=revid)
         self.upstream_branch.tags.merge_to(self.branch.tags)
 
     def import_upstream(self, upstream_part, version, md5, upstream_parents,
             upstream_tarball=None, upstream_branch=None,
-            upstream_revision=None, timestamp=None, author=None):
+            upstream_revision=None, timestamp=None, author=None,
+            file_ids_from=None):
         """Import an upstream part on to the upstream branch.
 
         This imports the upstream part of the code and places it on to
@@ -1118,6 +929,7 @@
         :param upstream_parents: the parents to give the upstream revision
         :param timestamp: a tuple of (timestamp, timezone) to use for
             the commit, or None to use the current time.
+        :return: (tag_name, revision_id) of the imported tarball.
         """
         # Should we just dump the upstream part on whatever is currently
         # there, or try and pull all of the other upstream versions
@@ -1140,6 +952,7 @@
             return br.repository.revision_tree(br.last_revision())
         upstream_trees = [get_last_revision_tree(o.upstream_branch)
             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()
@@ -1147,18 +960,32 @@
                     last_revision=upstream_revision)
             upstream_branch.tags.merge_to(self.upstream_branch.tags)
             upstream_parents.append(upstream_revision)
-            upstream_trees.insert(0,
-                    self.upstream_branch.repository.revision_tree(
-                        upstream_revision))
-        import_dir(self.upstream_tree, upstream_part,
-                file_ids_from=upstream_trees + [self.tree])
+            target_tree = self.upstream_branch.repository.revision_tree(
+                        upstream_revision)
+        if file_ids_from is not None:
+            upstream_trees = file_ids_from + upstream_trees
+        if self.tree:
+            self_tree = self.tree
+            self_tree.lock_write() # might also be upstream tree for dh_make
+        else:
+            self_tree = self.get_branch_tip_revtree()
+            self_tree.lock_read()
+        try:
+            import_dir(self.upstream_tree, upstream_part,
+                    file_ids_from=[self_tree] + upstream_trees,
+                    target_tree=target_tree)
+        finally:
+            self_tree.unlock()
         self.upstream_tree.set_parent_ids(upstream_parents)
         revprops = {"deb-md5": md5}
         if upstream_tarball is not None:
             delta = self.make_pristine_tar_delta(self.upstream_tree,
                     upstream_tarball)
             uuencoded = standard_b64encode(delta)
-            revprops["deb-pristine-delta"] = uuencoded
+            if upstream_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
@@ -1168,12 +995,41 @@
         revid = self.upstream_tree.commit("Import upstream version %s" \
                 % (version,),
                 revprops=revprops, timestamp=timestamp, timezone=timezone)
-        self.tag_upstream_version(version)
-        return revid
+        tag_name, _ = self.tag_upstream_version(version, revid=revid)
+        return tag_name, revid
+
+    def import_upstream_tarball(self, tarball_filename, version, parents,
+        md5sum=None, upstream_branch=None, upstream_revision=None):
+        """Import an upstream part to the upstream branch.
+
+        :param tarball_filename: The tarball to import.
+        :param version: The upstream version to import.
+        :param parents: The tarball-branch parents to use for the import.
+            If an upstream branch is supplied, its automatically added to
+            parents.
+        :param upstream_branch: An upstream branch to associate with the
+            tarball.
+        :param upstream_revision: Upstream revision id
+        :param md5sum: hex digest of the md5sum of the tarball, if known.
+        :return: (tag_name, revision_id) of the imported tarball.
+        """
+        if not md5sum:
+            md5sum = md5sum_filename(tarball_filename)
+        tarball_dir = self._extract_tarball_to_tempdir(tarball_filename)
+        try:
+            return self.import_upstream(tarball_dir, version, md5sum, parents,
+                upstream_tarball=tarball_filename,
+                upstream_branch=upstream_branch,
+                upstream_revision=upstream_revision)
+        finally:
+            shutil.rmtree(tarball_dir)
+
+    def get_branch_tip_revtree(self):
+        return self.branch.repository.revision_tree(
+                self.branch.last_revision())
 
     def _mark_native_config(self, native):
-        poss_native_tree = self.branch.repository.revision_tree(
-                self.branch.last_revision())
+        poss_native_tree = self.get_branch_tip_revtree()
         current_native = self._is_tree_native(poss_native_tree)
         current_config = self._default_config_for_tree(poss_native_tree)
         dirname = os.path.join(self.tree.basedir,
@@ -1219,7 +1075,7 @@
                                 '.bzr-builddeb/default.conf'])
 
     def import_debian(self, debian_part, version, parents, md5,
-            native=False, timestamp=None):
+            native=False, timestamp=None, file_ids_from=None):
         """Import the debian part of a source package.
 
         :param debian_part: the path of a directory containing the unpacked
@@ -1259,6 +1115,8 @@
         debian_trees = [get_last_revision_tree(o.branch)
             for o in other_branches]
         parent_trees = []
+        if file_ids_from is not None:
+            parent_trees = file_ids_from[:]
         for parent in parents:
             parent_trees.append(self.branch.repository.revision_tree(
                         parent))
@@ -1298,54 +1156,9 @@
             timezone = timestamp[1]
             timestamp = timestamp[0]
         self._mark_native_config(native)
-        self.tree.commit(message, revprops=revprops, timestamp=timestamp,
+        revid = self.tree.commit(message, revprops=revprops, timestamp=timestamp,
                 timezone=timezone)
-        self.tag_version(version)
-
-    def _get_dsc_part(self, dsc, end):
-        """Get the path and md5 of a file ending with end in dsc."""
-        files = dsc['files']
-        for file_info in files:
-            name = file_info['name']
-            if name.endswith(end):
-                filename = name
-                md5 = file_info['md5sum']
-                return (filename, md5)
-        return (None, None)
-
-    def get_upstream_part(self, dsc):
-        """Gets the information about the upstream part from the dsc.
-
-        :param dsc: a deb822.Dsc object to take the information from.
-        :return: a tuple (path, md5), both strings, the former being
-            the path to the .orig.tar.gz, the latter being the md5
-            reported for it. If there is no upstream part both will
-            be None.
-        """
-        return self._get_dsc_part(dsc, ".orig.tar.gz")
-
-    def get_diff_part(self, dsc):
-        """Gets the information about the diff part from the dsc.
-
-        :param dsc: a deb822.Dsc object to take the information from.
-        :return: a tuple (path, md5), both strings, the former being
-            the path to the .diff.gz, the latter being the md5
-            reported for it. If there is no diff part both will be
-            None.
-        """
-        return self._get_dsc_part(dsc, ".diff.gz")
-
-    def get_native_part(self, dsc):
-        """Gets the information about the native part from the dsc.
-
-        :param dsc: a deb822.Dsc object to take the information from.
-        :return: a tuple (path, md5), both strings, the former being
-            the path to the .tar.gz, the latter being the md5 reported
-            for it. If there is not native part both will be None.
-        """
-        (path, md5) = self._get_dsc_part(dsc, ".tar.gz")
-        assert not path.endswith(".orig.tar.gz")
-        return (path, md5)
+        self.tag_version(version, revid=revid)
 
     def upstream_parents(self, versions, version):
         """Get the parents for importing a new upstream.
@@ -1399,21 +1212,13 @@
         cl.parse_changelog(open(cl_filename).read(), strict=False)
         return cl
 
-    def extract_dsc(self, dsc_filename):
-        """Extract a dsc file in to a temporary directory."""
-        tempdir = tempfile.mkdtemp()
-        dsc_filename = os.path.abspath(dsc_filename)
-        proc = Popen("dpkg-source -su -x %s" % (dsc_filename,), shell=True,
-                cwd=tempdir, stdout=PIPE, stderr=PIPE)
-        (stdout, stderr) = proc.communicate()
-        assert proc.returncode == 0, "dpkg-source -x failed, output:\n%s\n%s" % \
-                    (stdout, stderr)
-        return tempdir
-
     def _do_import_package(self, version, versions, debian_part, md5,
             upstream_part, upstream_md5, upstream_tarball=None,
-            timestamp=None, author=None):
-        pull_branch = self.branch_to_pull_version_from(version, md5)
+            timestamp=None, author=None, file_ids_from=None,
+            pull_debian=True):
+        pull_branch = None
+        if pull_debian:
+            pull_branch = self.branch_to_pull_version_from(version, md5)
         if pull_branch is not None:
             if (self.branch_to_pull_upstream_from(version.upstream_version,
                         upstream_md5)
@@ -1438,11 +1243,12 @@
                     # from another branch:
                     upstream_parents = self.upstream_parents(versions,
                             version.upstream_version)
-                    new_revid = self.import_upstream(upstream_part,
+                    _, new_revid = self.import_upstream(upstream_part,
                             version.upstream_version,
                             upstream_md5, upstream_parents,
                             upstream_tarball=upstream_tarball,
-                            timestamp=timestamp, author=author)
+                            timestamp=timestamp, author=author,
+                            file_ids_from=file_ids_from)
                     self._fetch_upstream_to_branch(new_revid)
             else:
                 mutter("We already have the needed upstream part")
@@ -1450,7 +1256,7 @@
                     force_upstream_parent=imported_upstream)
             # Now we have the list of parents we need to import the .diff.gz
             self.import_debian(debian_part, version, parents, md5,
-                    timestamp=timestamp)
+                    timestamp=timestamp, file_ids_from=file_ids_from)
 
     def get_native_parents(self, version, versions):
         last_contained_version = self.last_contained_version(versions)
@@ -1492,14 +1298,17 @@
 
 
     def _import_native_package(self, version, versions, debian_part, md5,
-            timestamp=None):
-        pull_branch = self.branch_to_pull_version_from(version, md5)
+            timestamp=None, file_ids_from=None, pull_debian=True):
+        pull_branch = None
+        if pull_debian:
+            pull_branch = self.branch_to_pull_version_from(version, md5)
         if pull_branch is not None:
             self.pull_version_from_branch(pull_branch, version, native=True)
         else:
             parents = self.get_native_parents(version, versions)
             self.import_debian(debian_part, version, parents, md5,
-                    native=True, timestamp=timestamp)
+                    native=True, timestamp=timestamp,
+                    file_ids_from=file_ids_from)
 
     def _get_safe_versions_from_changelog(self, cl):
         versions = []
@@ -1510,7 +1319,8 @@
                 break
         return versions
 
-    def import_package(self, dsc_filename, use_time_from_changelog=False):
+    def import_package(self, dsc_filename, use_time_from_changelog=True,
+            file_ids_from=None, pull_debian=True):
         """Import a source package.
 
         :param dsc_filename: a path to a .dsc file for the version
@@ -1521,29 +1331,15 @@
         base_path = osutils.dirname(dsc_filename)
         dsc = deb822.Dsc(open(dsc_filename).read())
         version = Version(dsc['Version'])
-        name = dsc['Source']
-        upstream_tarball = None
-        for part in dsc['files']:
-            if part['name'].endswith(".orig.tar.gz"):
-                assert upstream_tarball is None, "Two .orig.tar.gz?"
-                upstream_tarball = os.path.abspath(
-                        os.path.join(base_path, part['name']))
-        tempdir = self.extract_dsc(dsc_filename)
+        format = dsc.get('Format', '1.0').strip()
+        extractor_cls = SOURCE_EXTRACTORS.get(format)
+        if extractor_cls is None:
+            raise AssertionError("Don't know how to import source format %s yet"
+                    % format)
+        extractor = extractor_cls(dsc_filename, dsc)
         try:
-            # TODO: make more robust against strange .dsc files.
-            upstream_part = os.path.join(tempdir,
-                    "%s-%s.orig" % (name, str(version.upstream_version)))
-            debian_part = os.path.join(tempdir,
-                    "%s-%s" % (name, str(version.upstream_version)))
-            native = False
-            if not os.path.exists(upstream_part):
-                mutter("It's a native package")
-                native = True
-                (_, md5) = self.get_native_part(dsc)
-            else:
-                (_, upstream_md5) = self.get_upstream_part(dsc)
-                (_, md5) = self.get_diff_part(dsc)
-            cl = self.get_changelog_from_source(debian_part)
+            extractor.extract()
+            cl = self.get_changelog_from_source(extractor.extracted_debianised)
             timestamp = None
             author = None
             if use_time_from_changelog and len(cl._blocks) > 0:
@@ -1552,36 +1348,52 @@
                  time_tuple = rfc822.parsedate_tz(raw_timestamp)
                  if time_tuple is not None:
                      timestamp = (time.mktime(time_tuple[:9]), time_tuple[9])
-                 author = cl.author
+                 author = safe_decode(cl.author)
             versions = self._get_safe_versions_from_changelog(cl)
             assert not self.has_version(version), \
                 "Trying to import version %s again" % str(version)
             #TODO: check that the versions list is correctly ordered,
             # as some methods assume that, and it's not clear what
             # should happen if it isn't.
-            if not native:
-                self._do_import_package(version, versions, debian_part, md5,
-                        upstream_part, upstream_md5,
-                        upstream_tarball=upstream_tarball,
-                        timestamp=timestamp, author=author)
+            if extractor.extracted_upstream is not None:
+                self._do_import_package(version, versions,
+                        extractor.extracted_debianised,
+                        extractor.unextracted_debian_md5,
+                        extractor.extracted_upstream,
+                        extractor.unextracted_upstream_md5,
+                        upstream_tarball=extractor.unextracted_upstream,
+                        timestamp=timestamp, author=author,
+                        file_ids_from=file_ids_from,
+                        pull_debian=pull_debian)
             else:
-                self._import_native_package(version, versions, debian_part,
-                        md5, timestamp=timestamp)
+                self._import_native_package(version, versions,
+                        extractor.extracted_debianised,
+                        extractor.unextracted_debian_md5,
+                        timestamp=timestamp, file_ids_from=file_ids_from,
+                        pull_debian=pull_debian)
         finally:
-            shutil.rmtree(tempdir)
+            extractor.cleanup()
 
-    def _extract_upstream_tree(self, upstream_tip, basedir):
-        # Extract that to a tempdir so we can get a working
-        # tree for it.
+    def extract_upstream_tree(self, upstream_tip, 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")
-        dir_to = self.branch.bzrdir.sprout(to_location,
+        # Use upstream_branch if it has been set, otherwise self.branch.
+        source_branch = self.upstream_branch or self.branch
+        dir_to = source_branch.bzrdir.sprout(to_location,
                 revision_id=upstream_tip,
                 accelerator_tree=self.tree)
-        self.upstream_tree = dir_to.open_workingtree()
+        try:
+            self.upstream_tree = dir_to.open_workingtree()
+        except NoWorkingTree:
+            # Handle shared treeless repo's.
+            self.upstream_tree = dir_to.create_workingtree()
         self.upstream_branch = self.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)
@@ -1604,82 +1416,111 @@
                 existing_bzrdir.create_workingtree()
         self.upstream_branch = branch
         self.upstream_tree = branch.bzrdir.open_workingtree()
+        if self.tree:
+            root_id = self.tree.path2id('')
+        else:
+            tip = self.get_branch_tip_revtree()
+            tip.lock_read()
+            try:
+                root_id = tip.path2id('')
+            finally:
+                tip.unlock()
+        if root_id:
+            self.upstream_tree.set_root_id(root_id)
 
     def _extract_tarball_to_tempdir(self, tarball_filename):
         tempdir = tempfile.mkdtemp()
+        if tarball_filename.endswith(".tar.bz2"):
+            tar_args = 'xjf'
+        else:
+            tar_args = 'xzf'
         try:
-            assert os.system("tar xzf %s -C %s --strip-components 1"
-                    % (tarball_filename, tempdir)) == 0
+            proc = subprocess.Popen(["tar", tar_args, tarball_filename, "-C",
+                    tempdir, "--strip-components", "1"],
+                    preexec_fn=subprocess_setup)
+            proc.communicate()
+            if proc.returncode != 0:
+                raise TarFailed("extract", tarball_filename)
             return tempdir
         except:
             shutil.rmtree(tempdir)
             raise
 
     def _revid_of_upstream_version_from_branch(self, version):
+        """The private method below will go away eventually."""
+        return self.revid_of_upstream_version_from_branch(version)
+
+    def revid_of_upstream_version_from_branch(self, version):
+        # TODO: remove the _revid_of_upstream_version_from_branch alias below.
         assert isinstance(version, str)
-        tag_name = self.upstream_tag_name(version)
-        if self._has_version(self.branch, tag_name):
-            return self.branch.tags.lookup_tag(tag_name)
-        tag_name = self.upstream_tag_name(version, distro="debian")
-        if self._has_version(self.branch, tag_name):
-            return self.branch.tags.lookup_tag(tag_name)
-        tag_name = self.upstream_tag_name(version, distro="ubuntu")
-        if self._has_version(self.branch, tag_name):
-            return self.branch.tags.lookup_tag(tag_name)
+        for tag_name in self.possible_upstream_tag_names(version):
+            if self._has_version(self.branch, tag_name):
+                return self.branch.tags.lookup_tag(tag_name)
         tag_name = self.upstream_tag_name(version)
         return self.branch.tags.lookup_tag(tag_name)
 
+    _revid_of_upstream_version_from_branch = revid_of_upstream_version_from_branch
+
+    def _export_previous_upstream_tree(self, previous_version, tempdir, upstream_branch=None):
+        assert isinstance(previous_version, str), \
+            "Should pass upstream version as str, not Version."
+        previous_upstream_revision = get_snapshot_revision(previous_version)
+        if self.has_upstream_version_in_packaging_branch(previous_version):
+            upstream_tip = self.revid_of_upstream_version_from_branch(
+                    previous_version)
+            self.extract_upstream_tree(upstream_tip, tempdir)
+        elif (upstream_branch is not None and
+              previous_upstream_revision is not None):
+            upstream_tip = RevisionSpec.from_string(previous_upstream_revision).as_revision_id(upstream_branch)
+            assert isinstance(upstream_tip, str)
+            self.extract_upstream_tree(upstream_tip, tempdir)
+        else:
+            raise BzrCommandError("Unable to find the tag for the "
+                    "previous upstream version, %s, in the branch: "
+                    "%s" % (
+                previous_version,
+                self.upstream_tag_name(previous_version)))
+
     def merge_upstream(self, tarball_filename, version, previous_version,
-            upstream_branch=None, upstream_revision=None, merge_type=None):
+            upstream_branch=None, upstream_revision=None, merge_type=None,
+            force=False):
         assert self.upstream_branch is None, \
                 "Should use self.upstream_branch if set"
+        assert isinstance(version, str), \
+            "Should pass version as str not %s" % str(type(version))
+        assert isinstance(previous_version, str) or previous_version is None, \
+            "Should pass previous_version as str not %s" % str(
+                    type(previous_version))
         tempdir = tempfile.mkdtemp(dir=os.path.join(self.tree.basedir, '..'))
         try:
-            previous_upstream_revision = get_snapshot_revision(previous_version.upstream_version)
             if previous_version is not None:
-                if self.has_upstream_version_in_packaging_branch(
-                        previous_version.upstream_version):
-                    upstream_tip = self._revid_of_upstream_version_from_branch(
-                            previous_version.upstream_version)
-                    self._extract_upstream_tree(upstream_tip, tempdir)
-                elif (upstream_branch is not None and 
-                      previous_upstream_revision is not None):
-                    upstream_tip = RevisionSpec.from_string(previous_upstream_revision).as_revision_id(upstream_branch)
-                    assert isinstance(upstream_tip, str)
-                    self._extract_upstream_tree(upstream_tip, tempdir)
-                else:
-                    raise BzrCommandError("Unable to find the tag for the "
-                            "previous upstream version, %s, in the branch: "
-                            "%s" % (
-                        previous_version.upstream_version,
-                        self.upstream_tag_name(
-                            previous_version.upstream_version)))
+                self._export_previous_upstream_tree(previous_version, tempdir,
+                    upstream_branch)
             else:
                 self._create_empty_upstream_tree(tempdir)
-            if self.has_upstream_version_in_packaging_branch(version.upstream_version):
+            if self.has_upstream_version_in_packaging_branch(version):
                 raise UpstreamAlreadyImported(version)
+            if upstream_branch is not None:
+                upstream_branch.lock_read()
             try:
                 if upstream_branch is not None:
-                    upstream_branch.lock_read()
-                    if upstream_revision 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 graph.is_ancestor(upstream_revision,
+                    if not force and graph.is_ancestor(upstream_revision,
                             self.branch.last_revision()):
                         raise UpstreamBranchAlreadyMerged
                 tarball_filename = os.path.abspath(tarball_filename)
-                m = md5.md5()
-                m.update(open(tarball_filename).read())
-                md5sum = m.hexdigest()
+                md5sum = md5sum_filename(tarball_filename)
                 tarball_dir = self._extract_tarball_to_tempdir(tarball_filename)
                 try:
                     # FIXME: should use upstream_parents()?
                     parents = []
                     if self.upstream_branch.last_revision() != NULL_REVISION:
                         parents = [self.upstream_branch.last_revision()]
-                    new_revid = self.import_upstream(tarball_dir,
-                            version.upstream_version,
+                    _, new_revid = self.import_upstream(tarball_dir,
+                            version,
                             md5sum, parents, upstream_tarball=tarball_filename,
                             upstream_branch=upstream_branch,
                             upstream_revision=upstream_revision)
@@ -1687,8 +1528,20 @@
                 finally:
                     shutil.rmtree(tarball_dir)
                 if self.branch.last_revision() != NULL_REVISION:
-                    conflicts = self.tree.merge_from_branch(
-                            self.upstream_branch, merge_type=merge_type)
+                    try:
+                        conflicts = self.tree.merge_from_branch(
+                                self.upstream_branch, merge_type=merge_type)
+                    except UnrelatedBranches:
+                        # Bug lp:515367 where the first upstream tarball is
+                        # missing a proper history link and a criss-cross merge
+                        # then recurses and finds no deeper ancestor.
+                        if len(parents) != 2:
+                            # Very first import... shouldn't be possible.
+                            raise
+                        # Use the previous upstream import as the from revision
+                        conflicts = self.tree.merge_from_branch(
+                                self.upstream_branch, merge_type=merge_type,
+                                from_revision=parents[0])
                 else:
                     # Pull so that merge-upstream allows you to start a branch
                     # from upstream tarball.
@@ -1702,39 +1555,49 @@
         finally:
             shutil.rmtree(tempdir)
 
-    def has_pristine_tar_delta(self, revid):
-        rev = self.branch.repository.get_revision(revid)
-        return 'deb-pristine-delta' in rev.properties
-
-    def pristine_tar_delta(self, revid):
-        rev = self.branch.repository.get_revision(revid)
-        uuencoded = rev.properties['deb-pristine-delta']
+    def has_pristine_tar_delta(self, rev):
+        return ('deb-pristine-delta' in rev.properties
+                or 'deb-pristine-delta-bz2' in rev.properties)
+
+    def pristine_tar_format(self, rev):
+        if 'deb-pristine-delta' in rev.properties:
+            return 'gz'
+        elif 'deb-pristine-delta-bz2' in rev.properties:
+            return 'bz2'
+        assert self.has_pristine_tar_delta(rev)
+        raise AssertionError("Not handled new delta type in "
+                "pristine_tar_format")
+
+    def pristine_tar_delta(self, rev):
+        if 'deb-pristine-delta' in rev.properties:
+            uuencoded = rev.properties['deb-pristine-delta']
+        elif 'deb-pristine-delta-bz2' in rev.properties:
+            uuencoded = rev.properties['deb-pristine-delta-bz2']
+        else:
+            assert self.has_pristine_tar_delta(rev)
+            raise AssertionError("Not handled new delta type in "
+                    "pristine_tar_delta")
         delta = standard_b64decode(uuencoded)
         return delta
 
     def reconstruct_pristine_tar(self, revid, package, version,
             dest_filename):
         """Reconstruct a pristine-tar tarball from a bzr revision."""
-        if not os.path.exists("/usr/bin/pristine-tar"):
-            raise PristineTarError("/usr/bin/pristine-tar is not available")
         tree = self.branch.repository.revision_tree(revid)
         tmpdir = tempfile.mkdtemp(prefix="builddeb-pristine-")
         try:
             dest = os.path.join(tmpdir, "orig")
-            export(tree, dest, format='dir')
-            delta = self.pristine_tar_delta(revid)
-            command = ["/usr/bin/pristine-tar", "gentar", "-",
-                       os.path.abspath(dest_filename)]
-            proc = Popen(command, stdin=PIPE, cwd=dest)
-            (stdout, stderr) = proc.communicate(delta)
-            if proc.returncode != 0:
-                raise PristineTarError("Generating tar from delta failed: %s" % stderr)
+            rev = self.branch.repository.get_revision(revid)
+            if self.has_pristine_tar_delta(rev):
+                export(tree, dest, format='dir')
+                delta = self.pristine_tar_delta(rev)
+                reconstruct_pristine_tar(dest, delta, dest_filename)
+            else:
+                export(tree, dest_filename, require_per_file_timestamps=True)
         finally:
             shutil.rmtree(tmpdir)
 
     def make_pristine_tar_delta(self, tree, tarball_path):
-        if not os.path.exists("/usr/bin/pristine-tar"):
-            raise PristineTarError("/usr/bin/pristine-tar is not available")
         tmpdir = tempfile.mkdtemp(prefix="builddeb-pristine-")
         try:
             dest = os.path.join(tmpdir, "orig")
@@ -1745,12 +1608,133 @@
                 export(tree, dest, format='dir')
             finally:
                 tree.unlock()
-            command = ["/usr/bin/pristine-tar", "gendelta", tarball_path, "-"]
-            info(" ".join(command))
-            proc = Popen(command, stdout=PIPE, cwd=dest)
-            (stdout, stderr) = proc.communicate()
-            if proc.returncode != 0:
-                raise PristineTarError("Generating delta from tar failed: %s" % stderr)
-            return stdout
+            return make_pristine_tar_delta(dest, tarball_path)
         finally:
             shutil.rmtree(tmpdir)
+
+
+class SourceExtractor(object):
+    """A class to extract a source package to its constituent parts"""
+
+    def __init__(self, dsc_path, dsc):
+        self.dsc_path = dsc_path
+        self.dsc = dsc
+        self.extracted_upstream = None
+        self.extracted_debianised = None
+        self.unextracted_upstream = None
+        self.unextracted_debian_md5 = None
+        self.unextracted_upstream_md5 = None
+
+    def extract(self):
+        """Extract the package to a new temporary directory."""
+        self.tempdir = tempfile.mkdtemp()
+        dsc_filename = os.path.abspath(self.dsc_path)
+        proc = subprocess.Popen("dpkg-source -su -x %s" % (dsc_filename,), shell=True,
+                cwd=self.tempdir, stdout=subprocess.PIPE,
+                stderr=subprocess.STDOUT, preexec_fn=subprocess_setup)
+        (stdout, _) = proc.communicate()
+        assert proc.returncode == 0, "dpkg-source -x failed, output:\n%s" % \
+                    (stdout,)
+        name = self.dsc['Source']
+        version = Version(self.dsc['Version'])
+        self.extracted_upstream = os.path.join(self.tempdir,
+                "%s-%s.orig" % (name, str(version.upstream_version)))
+        self.extracted_debianised = os.path.join(self.tempdir,
+                "%s-%s" % (name, str(version.upstream_version)))
+        if not os.path.exists(self.extracted_upstream):
+            mutter("It's a native package")
+            self.extracted_upstream = None
+        for part in self.dsc['files']:
+            if self.extracted_upstream is None:
+                if part['name'].endswith(".tar.gz"):
+                    self.unextracted_debian_md5 = part['md5sum']
+            else:
+                if part['name'].endswith(".orig.tar.gz"):
+                    assert self.unextracted_upstream is None, "Two .orig.tar.gz?"
+                    self.unextracted_upstream = os.path.abspath(
+                            os.path.join(osutils.dirname(self.dsc_path),
+                                part['name']))
+                    self.unextracted_upstream_md5 = part['md5sum']
+                elif part['name'].endswith(".diff.gz"):
+                    self.unextracted_debian_md5 = part['md5sum']
+
+    def cleanup(self):
+        if os.path.exists(self.tempdir):
+            shutil.rmtree(self.tempdir)
+
+
+class ThreeDotZeroNativeSourceExtractor(SourceExtractor):
+
+    def extract(self):
+        self.tempdir = tempfile.mkdtemp()
+        dsc_filename = os.path.abspath(self.dsc_path)
+        proc = subprocess.Popen("dpkg-source -x %s" % (dsc_filename,), shell=True,
+                cwd=self.tempdir, stdout=subprocess.PIPE,
+                stderr=subprocess.STDOUT, preexec_fn=subprocess_setup)
+        (stdout, _) = proc.communicate()
+        assert proc.returncode == 0, "dpkg-source -x failed, output:\n%s" % \
+                    (stdout,)
+        name = self.dsc['Source']
+        version = Version(self.dsc['Version'])
+        self.extracted_debianised = os.path.join(self.tempdir,
+                "%s-%s" % (name, str(version.upstream_version)))
+        self.extracted_upstream = None
+        for part in self.dsc['files']:
+            if (part['name'].endswith(".tar.gz")
+                    or part['name'].endswith(".tar.bz2")):
+                self.unextracted_debian_md5 = part['md5sum']
+
+
+class ThreeDotZeroQuiltSourceExtractor(SourceExtractor):
+
+    def extract(self):
+        self.tempdir = tempfile.mkdtemp()
+        dsc_filename = os.path.abspath(self.dsc_path)
+        proc = subprocess.Popen("dpkg-source --skip-debianization -x %s"
+                % (dsc_filename,), shell=True,
+                cwd=self.tempdir, stdout=subprocess.PIPE,
+                stderr=subprocess.STDOUT, preexec_fn=subprocess_setup)
+        (stdout, _) = proc.communicate()
+        assert proc.returncode == 0, "dpkg-source -x failed, output:\n%s" % \
+                    (stdout,)
+        name = self.dsc['Source']
+        version = Version(self.dsc['Version'])
+        self.extracted_debianised = os.path.join(self.tempdir,
+                "%s-%s" % (name, str(version.upstream_version)))
+        self.extracted_upstream = self.extracted_debianised + ".orig"
+        os.rename(self.extracted_debianised, self.extracted_upstream)
+        proc = subprocess.Popen("dpkg-source -x %s" % (dsc_filename,), shell=True,
+                cwd=self.tempdir, stdout=subprocess.PIPE,
+                stderr=subprocess.STDOUT, preexec_fn=subprocess_setup)
+        (stdout, _) = proc.communicate()
+        assert proc.returncode == 0, "dpkg-source -x failed, output:\n%s" % \
+                    (stdout,)
+        # Check that there are no unreadable files extracted.
+        subprocess.call(["find", self.extracted_upstream, "-perm",
+                "0000", "-exec", "chmod", "644", "{}", ";"])
+        subprocess.call(["find", self.extracted_debianised, "-perm",
+                "0000", "-exec", "chmod", "644", "{}", ";"])
+        for part in self.dsc['files']:
+            if (re.search("\.orig-[^.]+\.tar\.(gz|bz2|lzma)$", part['name'])):
+                raise AssertionError("Can't import packages with multiple "
+                    "upstream tarballs yet")
+            if (part['name'].endswith(".orig.tar.gz")
+                    or part['name'].endswith(".orig.tar.bz2")):
+                assert self.unextracted_upstream is None, "Two .orig.tar.(gz|bz2)?"
+                self.unextracted_upstream = os.path.abspath(
+                        os.path.join(osutils.dirname(self.dsc_path),
+                            part['name']))
+                self.unextracted_upstream_md5 = part['md5sum']
+            elif (part['name'].endswith(".debian.tar.gz")
+                    or part['name'].endswith(".debian.tar.bz2")):
+                self.unextracted_debian_md5 = part['md5sum']
+        assert self.unextracted_upstream is not None, \
+            "Can't handle non gz|bz2 tarballs yet"
+        assert self.unextracted_debian_md5 is not None, \
+            "Can't handle non gz|bz2 tarballs yet"
+
+
+SOURCE_EXTRACTORS = {}
+SOURCE_EXTRACTORS["1.0"] = SourceExtractor
+SOURCE_EXTRACTORS["3.0 (native)"] = ThreeDotZeroNativeSourceExtractor
+SOURCE_EXTRACTORS["3.0 (quilt)"] = ThreeDotZeroQuiltSourceExtractor

=== modified file 'info.py'
--- info.py	2009-07-26 15:51:02 +0000
+++ info.py	2011-01-28 14:24:44 +0000
@@ -18,7 +18,7 @@
 
 bzr_plugin_name = 'builddeb'
 
-bzr_plugin_version = (2, 1, 1, 'dev', 0)
+bzr_plugin_version = (2, 2, 0, 'final', 0)
 
 bzr_commands = [
     "test_builddeb",

=== modified file 'launchpad.py'
--- launchpad.py	2009-03-11 07:23:20 +0000
+++ launchpad.py	2011-01-28 14:24:44 +0000
@@ -20,18 +20,20 @@
 
 import os
 
+from bzrlib.config import config_dir
 from bzrlib.trace import mutter
 
 try:
-    from launchpadlib.launchpad import Launchpad, EDGE_SERVICE_ROOT
+    from launchpadlib.launchpad import Launchpad
     from launchpadlib.credentials import Credentials
+    from launchpadlib.uris import LPNET_SERVICE_ROOT
     HAVE_LPLIB = True
 except ImportError:
     HAVE_LPLIB = False
 
 
 def _get_launchpad():
-    creds_path = os.path.expanduser("~/.bazaar/builddeb.lp_creds.txt")
+    creds_path = os.path.join(config_dir(), "builddeb.lp_creds.txt")
     if not os.path.exists(creds_path):
         return None
     creds = Credentials("bzr-builddeb")
@@ -40,7 +42,7 @@
         creds.load(f)
     finally:
         f.close()
-    lp = Launchpad(creds, EDGE_SERVICE_ROOT)
+    lp = Launchpad(creds, service_root=LPNET_SERVICE_ROOT)
     return lp
 
 
@@ -51,8 +53,7 @@
     if lp is None:
         return []
     try:
-        bug = lp.load("https://api.edge.launchpad.net/beta/bugs/"
-                "bugtrackers/debbugs/%s")
+        bug = lp.load(str(lp._root_uri) + "bugs/bugtrackers/debbugs/%s")
         tasks = bug.bug_tasks
         for task in tasks:
             if task.bug_target_name.endswith("(Ubuntu)"):

=== added file 'merge_changelog.py'
--- merge_changelog.py	1970-01-01 00:00:00 +0000
+++ merge_changelog.py	2011-01-28 14:24:44 +0000
@@ -0,0 +1,152 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+# Copyright ? 2008 Canonical Ltd.
+# Author: Scott James Remnant <[e-mail]>.
+# Hacked up by: Bryce Harrington <[e-mail]>
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of version 3 of the GNU General Public License as
+# published by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+import re
+
+from bzrlib import (
+    merge,
+    )
+
+
+class ChangeLogFileMerge(merge.ConfigurableFileMerger):
+
+    name_prefix = 'deb_changelog'
+    default_files = ['debian/changelog']
+
+    def merge_text(self, params):
+        return merge_changelog(params.this_lines, params.other_lines,
+                               params.base_lines)
+
+
+# Regular expression for top of debian/changelog
+CL_RE = re.compile(r'^(\w[-+0-9a-z.]*) \(([^\(\) \t]+)\)((\s+[-0-9a-z]+)+)\;',
+                   re.IGNORECASE)
+
+def merge_changelog(this_lines, other_lines, base_lines=[]):
+    """Merge a changelog file."""
+    try:
+       from debian import changelog
+    except ImportError:
+        # Prior to 0.1.15 the debian module was called debian_bundle
+        from debian_bundle import changelog
+
+    try:
+        left_cl = read_changelog(this_lines)
+        right_cl = read_changelog(other_lines)
+        # BASE lines don't end up in the output, so we allow strict=False
+        base_cl = read_changelog(base_lines, strict=False)
+    except changelog.ChangelogParseError:
+        return ('not_applicable', None)
+
+    content = []
+    def step(iterator):
+        try:
+            return iterator.next()
+        except StopIteration:
+            return None
+    left_blocks = dict((b.version, b) for b in left_cl._blocks)
+    right_blocks = dict((b.version, b) for b in right_cl._blocks)
+    # Unfortunately, while version objects implement __eq__ they *don't*
+    # implement __hash__, which means we can't do dict lookups properly, so
+    # instead, we fall back on the version string instead of the object.
+    # Make sure never to try to use right_version in left_blocks because of
+    # this.
+    # We lazily parse the base data, in case we never need it
+    base_blocks = dict((b.version.full_version, b) for b in base_cl._blocks)
+    left_order = iter(sorted(left_blocks.keys(), reverse=True))
+    right_order = iter(sorted(right_blocks.keys(), reverse=True))
+    left_version = step(left_order)
+    right_version = step(right_order)
+
+    # TODO: Do we want to support the ability to delete a section? We could do
+    #       a first-pass algorithm that checks the versions in base versus the
+    #       versions in this and other, to determine what versions should be in
+    #       the output. For now, we just assume that if a version is present in
+    #       any of this or other, then we want it in the output.
+    conflict_status = 'success'
+
+    while left_version is not None or right_version is not None:
+        if (left_version is None or
+            (right_version is not None and right_version > left_version)):
+            next_content = str(right_blocks[right_version])
+            right_version = step(right_order)
+        elif (right_version is None or
+            (left_version is not None and left_version > right_version)):
+            next_content = str(left_blocks[left_version])
+            left_version = step(left_order)
+        else:
+            assert left_version == right_version
+            # Same version, step both
+            # TODO: Conflict if left_version != right
+            # Note: See above comment why we can't use
+            #       right_blocks[left_version] even though they *should* be
+            #       equivalent
+            left_content = str(left_blocks[left_version])
+            right_content = str(right_blocks[right_version])
+            if left_content == right_content:
+                # Identical content
+                next_content = left_content
+            else:
+                # Sides disagree, compare with base
+                base_content = str(base_blocks.get(left_version.full_version,
+                                                   ''))
+                if left_content == base_content:
+                    next_content = right_content
+                elif right_content == base_content:
+                    next_content = left_content
+                else:
+                    # TODO: We could use merge3.Merge3 to try a line-based
+                    #       textual merge on the content. However, for now I'm
+                    #       just going to conflict on the whole region
+                    # Conflict names taken from merge.py
+                    next_content = ('<<<<<<< TREE\n'
+                                    + left_content
+                                    + '=======\n'
+                                    + right_content
+                                    + '>>>>>>> MERGE-SOURCE\n'
+                                   )
+                    conflict_status = 'conflicted'
+            next_block = left_blocks[left_version]
+            left_version = step(left_order)
+            right_version = step(right_order)
+        content.append(next_content)
+
+    return conflict_status, content
+
+
+def read_changelog(lines, strict=True):
+    """Return a parsed changelog file."""
+    try:
+        from debian import changelog
+    except ImportError:
+        # Prior to 0.1.15 the debian module was called debian_bundle
+        from debian_bundle import changelog
+    # Note: There appears to be a bug in Changelog if you pass it an iterable
+    #       of lines (like a file obj, or a list of lines). Specifically, it
+    #       does not strip trailing newlines, and it adds ones back in, so you
+    #       get doubled blank lines... :(
+    #       So we just ''.join() the lines and don't worry about it
+    # Note: There is also a bug that the Changelog constructor suppresses parse
+    #       errors, so we want to always call parse_changelog separately
+    content = ''.join(lines)
+    cl = changelog.Changelog()
+    if content:
+        # We get a warning if we try to parse an empty changelog file, which in
+        # strict mode is an error, so only parse when we have content
+        cl.parse_changelog(content, strict=strict)
+    return cl

=== added file 'merge_package.py'
--- merge_package.py	1970-01-01 00:00:00 +0000
+++ merge_package.py	2011-01-28 14:24:44 +0000
@@ -0,0 +1,183 @@
+#    merge_package.py -- The plugin for bzr
+#    Copyright (C) 2009 Canonical Ltd.
+#
+#    :Author: Muharem Hrnjadovic <[e-mail]>
+#
+#    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
+#
+
+import os
+import shutil
+import tempfile
+
+try:
+    from debian.changelog import Version
+except ImportError:
+    # Prior to 0.1.15 the debian module was called debian_bundle
+    from debian_bundle.changelog import Version
+
+from bzrlib.plugins.builddeb.errors import (
+    SharedUpstreamConflictsWithTargetPackaging)
+from bzrlib.plugins.builddeb.import_dsc import DistributionBranch
+from bzrlib.plugins.builddeb.util import find_changelog
+
+
+def _latest_version(branch):
+    """Version of the most recent source package upload in the given `branch`.
+    
+    :param branch: A Branch object containing the source upload of interest.
+    """
+    changelog, _ignore = find_changelog(branch.basis_tree(), False)
+
+    return changelog.version
+
+
+def _upstream_version_data(source, target):
+    """Most recent upstream versions/revision IDs of the merge source/target.
+
+    Please note: both packaging branches must have been read-locked
+    beforehand.
+
+    :param source: The merge source branch.
+    :param target: The merge target branch.
+    """
+    results = list()
+    for branch in (source, target):
+        db = DistributionBranch(branch, branch)
+        uver = _latest_version(branch).upstream_version
+        results.append((Version(uver),
+                    db.revid_of_upstream_version_from_branch(uver)))
+
+    return results
+
+
+def fix_ancestry_as_needed(tree, source):
+    """Manipulate the merge target's ancestry to avoid upstream conflicts.
+
+    Merging J->I given the following ancestry tree is likely to result in
+    upstream merge conflicts:
+
+    debian-upstream                 ,------------------H
+                       A-----------B                    \
+    ubuntu-upstream     \           \`-------G           \
+                         \           \        \           \
+    debian-packaging      \ ,---------D--------\-----------J
+                           C           \        \
+    ubuntu-packaging        `----E------F--------I
+
+    Here there was a new upstream release (G) that Ubuntu packaged (I), and
+    then another one that Debian packaged, skipping G, at H and J.
+
+    Now, the way to solve this is to introduce the missing link.
+
+    debian-upstream                 ,------------------H------.
+                       A-----------B                    \      \
+    ubuntu-upstream     \           \`-------G-----------\------K
+                         \           \        \           \
+    debian-packaging      \ ,---------D--------\-----------J
+                           C           \        \
+    ubuntu-packaging        `----E------F--------I
+
+    at K, which isn't a real merge, as we just use the tree from H, but add
+    G as a parent and then we merge that in to Ubuntu.
+
+    debian-upstream                 ,------------------H------.
+                       A-----------B                    \      \
+    ubuntu-upstream     \           \`-------G-----------\------K
+                         \           \        \           \      \
+    debian-packaging      \ ,---------D--------\-----------J      \
+                           C           \        \                  \
+    ubuntu-packaging        `----E------F--------I------------------L
+
+    At this point we can merge J->L to merge the Debian and Ubuntu changes.
+
+    :param tree: The `WorkingTree` of the merge target branch.
+    :param source: The merge source (packaging) branch.
+    """
+    upstreams_diverged = False
+    t_upstream_reverted = False
+    target = tree.branch
+
+    source.lock_read()
+    try:
+        tree.lock_write()
+        try:
+            # "Unpack" the upstream versions and revision ids for the merge
+            # source and target branch respectively.
+            [(us_ver, us_revid), (ut_ver, ut_revid)] = _upstream_version_data(source, target)
+
+            # Did the upstream branches of the merge source/target diverge?
+            graph = source.repository.get_graph(target.repository)
+            upstreams_diverged = (len(graph.heads([us_revid, ut_revid])) > 1)
+
+            # No, we're done!
+            if not upstreams_diverged:
+                return (upstreams_diverged, t_upstream_reverted)
+
+            # Instantiate a `DistributionBranch` object for the merge target
+            # (packaging) branch.
+            db = DistributionBranch(tree.branch, tree.branch)
+            tempdir = tempfile.mkdtemp(dir=os.path.join(tree.basedir, '..'))
+
+            try:
+                # Extract the merge target's upstream tree into a temporary
+                # directory.
+                db.extract_upstream_tree(ut_revid, tempdir)
+                tmp_target_utree = db.upstream_tree
+
+                # Merge upstream branch tips to obtain a shared upstream parent.
+                # This will add revision K (see graph above) to a temporary merge
+                # target upstream tree.
+                tmp_target_utree.lock_write()
+                try:
+                    if us_ver > ut_ver:
+                        # The source upstream tree is more recent and the
+                        # temporary target tree needs to be reshaped to match it.
+                        tmp_target_utree.revert(
+                            None, source.repository.revision_tree(us_revid))
+                        t_upstream_reverted = True
+
+                    tmp_target_utree.set_parent_ids((ut_revid, us_revid))
+                    new_revid = tmp_target_utree.commit(
+                        'Prepared upstream tree for merging into target branch.')
+
+                    # Repository updates during a held lock are not visible,
+                    # hence the call to refresh the data in the /target/ repo.
+                    tree.branch.repository.refresh_data()
+
+                    tree.branch.fetch(source, last_revision=us_revid)
+                    tree.branch.fetch(tmp_target_utree.branch,
+                            last_revision=new_revid)
+
+                    # Merge shared upstream parent into the target merge branch. This
+                    # creates revison L in the digram above.
+                    conflicts = tree.merge_from_branch(tmp_target_utree.branch)
+                    if conflicts > 0:
+                        raise SharedUpstreamConflictsWithTargetPackaging()
+                    else:
+                        tree.commit('Merging shared upstream rev into target branch.')
+
+                finally:
+                    tmp_target_utree.unlock()
+            finally:
+                shutil.rmtree(tempdir)
+        finally:
+            tree.unlock()
+    finally:
+        source.unlock()
+
+    return (upstreams_diverged, t_upstream_reverted)

=== modified file 'merge_upstream.py'
--- merge_upstream.py	2009-03-10 01:57:05 +0000
+++ merge_upstream.py	2011-01-28 14:24:44 +0000
@@ -27,9 +27,15 @@
 #
 
 import itertools
-
-from debian_bundle.changelog import Version
-
+import subprocess
+
+try:
+    from debian.changelog import Version
+except ImportError:
+    # 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
@@ -38,6 +44,27 @@
 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.
 
@@ -46,7 +73,7 @@
     :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)
 
@@ -54,17 +81,18 @@
         return "%s~bzr%d" % (version_string[:version_string.rfind("~bzr")], revno)
 
     rev = upstream_branch.repository.get_revision(revid)
-    svn_revmeta = getattr(rev, "svn_meta", None)
-    if svn_revmeta is not None:
-        svn_revno = svn_revmeta.revnum
-
-        if "+svn" in version_string:
-            return "%s+svn%d" % (version_string[:version_string.rfind("+svn")], svn_revno)
-        if "~svn" in version_string:
-            return "%s~svn%d" % (version_string[:version_string.rfind("~svn")], svn_revno)
+    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)
-
-    return "%s+bzr%d" % (version_string, revno)
+    else:
+        return "%s+bzr%d" % (version_string, revno)
 
 
 def _upstream_branch_version(revhistory, reverse_tag_dict, package, 
@@ -107,6 +135,14 @@
 
 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
@@ -117,7 +153,7 @@
     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 
+        # Trim revision history - we don't care about any revisions
         # before the revision of the previous version
     else:
         previous_revno = 0
@@ -145,21 +181,61 @@
     return None
 
 
-def package_version(merged_version, distribution_name):
-    """Determine the package version from the merged version.
+def package_version(upstream_version, distribution_name):
+    """Determine the package version for a new upstream.
 
-    :param merged_version: Merged version string
+    :param upstream_version: Upstream version string
     :param distribution_name: Distribution the package is for
     """
-    ret = Version(merged_version)
-    if merged_version.debian_version is not None:
-        prev_packaging_revnum = int("".join(itertools.takewhile(
-                        lambda x: x.isdigit(),
-                        merged_version.debian_version)))
-    else:
-        prev_packaging_revnum = 0
+    assert isinstance(upstream_version, str), \
+        "upstream_version should be a str, not %s" % str(
+                type(upstream_version))
     if distribution_name == "ubuntu":
-        ret.debian_version = "%dubuntu1" % prev_packaging_revnum
+        ret = Version("%s-0ubuntu1" % upstream_version)
     else:
-        ret.debian_version = "%d" % (prev_packaging_revnum+1)
+        ret = Version("%s-1" % upstream_version)
     return ret
+
+
+def upstream_merge_changelog_line(upstream_version):
+    """Describe that a new upstream revision was merged.
+
+    This will either describe that a new upstream release or a new upstream snapshot
+    was merged.
+
+    :param upstream_version: Upstream version string
+    :return: Line string for use in changelog
+    """
+    vcs_suffixes = ["~bzr", "+bzr", "~svn", "+svn", "~git", "+git"]
+    for vcs_suffix in vcs_suffixes:
+        if vcs_suffix in str(upstream_version):
+            entry_description = "New upstream snapshot."
+            break
+    else:
+        entry_description = "New upstream release."
+    return entry_description
+
+
+def changelog_add_new_version(tree, upstream_version, distribution_name,
+        changelog, package):
+    """Add an entry to the changelog for a new version.
+
+    :param tree: WorkingTree in which the package lives
+    :param upstream_version: Upstream version to add
+    :param distribution_name: Distribution name (debian, ubuntu, ...)
+    :param changelog: Changelog object
+    :param package: Package name
+    :return: Whether an entry was successfully added
+    """
+    assert isinstance(upstream_version, str), \
+         "upstream_version should be a str, not %s" % str(
+                 type(upstream_version))
+    entry_description = upstream_merge_changelog_line(upstream_version)
+    proc = subprocess.Popen(["dch", "-v",
+            str(package_version(upstream_version, distribution_name)),
+            "-D", "UNRELEASED", "--release-heuristic", "changelog", entry_description],
+            cwd=tree.basedir)
+    proc.wait()
+    # FIXME: Raise insightful exception here rather than just checking
+    # return code.
+    return proc.returncode == 0

=== modified file 'repack_tarball.py'
--- repack_tarball.py	2009-03-08 23:28:22 +0000
+++ repack_tarball.py	2011-01-28 14:24:44 +0000
@@ -39,9 +39,9 @@
                            FileExists,
                            )
 from bzrlib.transport import get_transport
-from bzrlib import urlutils
 
 from bzrlib.plugins.builddeb.errors import UnsupportedRepackFormat
+from bzrlib.plugins.builddeb.util import open_file, open_file_via_transport
 
 
 class TgzRepacker(object):
@@ -123,36 +123,39 @@
             zip.close()
 
 
-def get_repacker_class(source_filename):
+def get_filetype(filename):
+    types = [".tar.gz", ".tgz", ".tar.bz2", ".tbz2", ".tar", ".zip"]
+    for filetype in types:
+        if filename.endswith(filetype):
+            return filetype
+
+
+def get_repacker_class(source_filename, force_gz=True):
     """Return the appropriate repacker based on the file extension."""
-    if (source_filename.endswith(".tar.gz")
-            or source_filename.endswith(".tgz")):
-        return TgzTgzRepacker
-    if (source_filename.endswith(".tar.bz2")
-            or source_filename.endswith(".tbz2")):
-        return Tbz2TgzRepacker
-    if source_filename.endswith(".tar"):
+    filetype = get_filetype(source_filename)
+    if (filetype == ".tar.gz" or filetype == ".tgz"):
+        return TgzTgzRepacker
+    if (filetype == ".tar.bz2" or filetype == ".tbz2"):
+        if force_gz:
+            return Tbz2TgzRepacker
+        return TgzTgzRepacker
+    if filetype == ".tar":
         return TarTgzRepacker
-    if source_filename.endswith(".zip"):
+    if filetype == ".zip":
         return ZipTgzRepacker
     return None
 
 
-def _get_file_from_location(location):
-    base_dir, path = urlutils.split(location)
-    transport = get_transport(base_dir)
-    return transport.get(path)
-
-
-def _error_if_exists(target_transport, new_name, source_name):
-    if not source_name.endswith('.tar.gz'):
+def _error_if_exists(target_transport, new_name, source_name, force_gz=True):
+    source_filetype = get_filetype(source_name)
+    if force_gz and source_filetype != ".tar.gz":
         raise FileExists(new_name)
-    source_f = _get_file_from_location(source_name)
+    source_f = open_file(source_name)
     try:
         source_sha = new_sha(source_f.read()).hexdigest()
     finally:
         source_f.close()
-    target_f = target_transport.get(new_name)
+    target_f = open_file_via_transport(new_name, target_transport)
     try:
         target_sha = new_sha(target_f.read()).hexdigest()
     finally:
@@ -174,14 +177,14 @@
         target_f.close()
 
 
-def _repack_other(target_transport, new_name, source_name):
-    repacker_cls = get_repacker_class(source_name)
+def _repack_other(target_transport, new_name, source_name, force_gz=True):
+    repacker_cls = get_repacker_class(source_name, force_gz=force_gz)
     if repacker_cls is None:
         raise UnsupportedRepackFormat(source_name)
     target_transport.ensure_base()
     target_f = target_transport.open_write_stream(new_name)
     try:
-        source_f = _get_file_from_location(source_name)
+        source_f = open_file(source_name)
         try:
             repacker = repacker_cls(source_f)
             repacker.repack(target_f)
@@ -191,7 +194,7 @@
         target_f.close()
 
 
-def repack_tarball(source_name, new_name, target_dir=None):
+def repack_tarball(source_name, new_name, target_dir=None, force_gz=True):
     """Repack the file/dir named to a .tar.gz with the chosen name.
 
     This function takes a named file of either .tar.gz, .tar .tgz .tar.bz2 
@@ -212,6 +215,7 @@
     :keyword target_dir: the directory to consider new_name relative to, and
                          will be created if non-existant.
     :type target_dir: string
+    :param force_gz: whether to repack other .tar files to .tar.gz.
     :return: None
     :throws NoSuchFile: if source_name doesn't exist.
     :throws FileExists: if the target filename (after considering target_dir)
@@ -229,9 +233,11 @@
     extra, new_name = os.path.split(new_name)
     target_transport = get_transport(os.path.join(target_dir, extra))
     if target_transport.has(new_name):
-        _error_if_exists(target_transport, new_name, source_name)
+        _error_if_exists(target_transport, new_name, source_name,
+                force_gz=force_gz)
         return
     if os.path.isdir(source_name):
         _repack_directory(target_transport, new_name, source_name)
     else:
-        _repack_other(target_transport, new_name, source_name)
+        _repack_other(target_transport, new_name, source_name,
+                force_gz=force_gz)

=== modified file 'source_distiller.py'
--- source_distiller.py	2009-07-15 12:02:25 +0000
+++ source_distiller.py	2011-01-28 14:24:44 +0000
@@ -20,29 +20,22 @@
 import glob
 import os
 import shutil
-import signal
 import subprocess
 import tempfile
 
 from bzrlib import errors as bzr_errors
-from bzrlib.export import export
 
 from bzrlib.plugins.builddeb.errors import (
         TarFailed,
         )
 from bzrlib.plugins.builddeb.util import (
+        export,
         get_parent_dir,
         recursive_copy,
+        subprocess_setup,
         )
 
 
-def subprocess_setup():
-    # Python installs a SIGPIPE handler by default. This is usually not what
-    # non-Python subprocesses expect.
-    # Many, many thanks to Colin Watson
-    signal.signal(signal.SIGPIPE, signal.SIG_DFL)
-
-
 class SourceDistiller(object):
     """A source distiller extracts the source to build from a location.
 
@@ -115,7 +108,7 @@
         self.upstream_provider.provide(parent_dir)
         if self.is_working_tree:
             self._prepare_working_tree()
-        export(self.tree, target, None, None)
+        export(self.tree, target)
 
 
 class MergeModeDistiller(SourceDistiller):
@@ -159,7 +152,7 @@
                 export_dir = tempdir
             if self.is_working_tree:
                 self._prepare_working_tree()
-            export(self.tree,export_dir,None,None)
+            export(self.tree, export_dir)
             # Remove any upstream debian dir, or from previous export with
             # use_existing
             if os.path.exists(os.path.join(target, 'debian')):

=== added file 'tagging.py'
--- tagging.py	1970-01-01 00:00:00 +0000
+++ tagging.py	2011-01-28 14:24:44 +0000
@@ -0,0 +1,75 @@
+# Copyright (C) 2010 Canonical Limited
+# vim: ts=4 sts=4 sw=4
+#
+# 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
+
+"""Tagging related functions for bzr-builddeb."""
+
+__all__ = ['is_upstream_tag', 'upstream_tag_version']
+
+
+try:
+    from debian.changelog import Version
+except ImportError:
+    # Prior to 0.1.15 the debian module was called debian_bundle
+    from debian_bundle.changelog import Version
+
+
+def is_upstream_tag(tag):
+    """Return true if tag is an upstream tag.
+    
+    :param tag: The string name of the tag.
+    :return: True if the tag name is one generated by upstream tag operations.
+
+    >>> is_upstream_tag('2.1')
+    False
+    >>> is_upstream_tag('upstream-2.1')
+    True
+    """
+    return tag.startswith('upstream-') or tag.startswith('upstream/')
+
+
+def upstream_tag_version(tag):
+    """Return the upstream version portion of an upstream tag name.
+
+    :param tag: The string name of the tag.
+    :return: The version portion of the tag.
+
+    >>> upstream_tag_version('upstream-2.1')
+    '2.1'
+    """
+    assert is_upstream_tag(tag), "Not an upstream tag: %s" % tag
+    if tag.startswith('upstream/'):
+        tag = tag[len('upstream/'):]
+    elif tag.startswith('upstream-'):
+        tag = tag[len('upstream-'):]
+        if tag.startswith('debian-'):
+            tag = tag[len('debian-'):]
+        elif tag.startswith('ubuntu-'):
+            tag = tag[len('ubuntu-'):]
+    return tag
+
+
+def sort_debversion(branch, tags):
+    """Sort tags using Debian version in-place.
+
+    :param branch: Branch to use
+    :param tags: List of tuples with name and version.
+    """
+    def debversion_key((version, revid)):
+        return Version(version)
+    tags.sort(key=debversion_key)

=== modified file 'tests/__init__.py'
--- tests/__init__.py	2009-07-04 20:45:01 +0000
+++ tests/__init__.py	2011-01-28 14:24:44 +0000
@@ -28,12 +28,14 @@
 import os
 from unittest import TestSuite
 
-from debian_bundle.changelog import Version, Changelog
+try:
+    from debian.changelog import Version, Changelog
+except ImportError:
+    # Prior to 0.1.15 the debian module was called debian_bundle
+    from debian_bundle.changelog import Version, Changelog
 
 from bzrlib.tests import TestUtil, multiply_tests, TestCaseWithTransport
 
-from bzrlib.plugins.builddeb.tests import blackbox
-
 
 def make_new_upstream_dir(source, dest):
     os.rename(source, dest)
@@ -109,21 +111,26 @@
         return result
 
 
-def test_suite():
-    loader = TestUtil.TestLoader()
-    suite = TestSuite()
+def load_tests(standard_tests, module, loader):
+    suite = loader.suiteClass()
     testmod_names = [
+            'blackbox',
             'test_builder',
+            'test_bzrtools_import',
             'test_commit_message',
             'test_config',
+            'test_dh_make',
             'test_hooks',
             'test_import_dsc',
+            'test_merge_changelog',
+            'test_merge_package',
             'test_merge_upstream',
             'test_repack_tarball_extra',
             'test_revspec',
             'test_source_distiller',
             'test_upstream',
             'test_util',
+            'test_tagging',
             ]
     suite.addTest(loader.loadTestsFromModuleNames(["%s.%s" % (__name__, i)
                                             for i in testmod_names]))
@@ -148,15 +155,9 @@
                               old_tarball='../package-0.2.tar')),
                  ]
     suite = multiply_tests(repack_tarball_tests, scenarios, suite)
-    packages_to_test = [
-             blackbox,
-             ]
-
-    for package in packages_to_test:
-        suite.addTest(package.test_suite())
-
     return suite
 
+
 class BuilddebTestCase(TestCaseWithTransport):
 
     package_name = 'test'
@@ -238,12 +239,13 @@
     >>> builder.dsc_name()
     """
 
-    def __init__(self, name, version, native=False):
+    def __init__(self, name, version, native=False, version3=False):
         self.upstream_files = {}
         self.upstream_symlinks = {}
         self.debian_files = {}
         self.name = name
         self.native = native
+        self.version3 = version3
         self._cl = Changelog()
         self.new_version(version)
 
@@ -327,6 +329,10 @@
     def basedir(self):
         return self.name + "-" + str(self._cl.version.upstream_version)
 
+    def write_debian_files(self, basedir):
+        self._make_files(self.debian_files, basedir)
+        self._make_files({"debian/changelog": str(self._cl)}, basedir)
+
     def _make_base(self):
         basedir = self.basedir()
         os.mkdir(basedir)
@@ -334,28 +340,46 @@
         self._make_symlinks(self.upstream_symlinks, basedir)
         return basedir
 
-    def build(self):
+    def build(self, tar_format=None):
+        if tar_format is None:
+            tar_format = 'gz'
         basedir = self._make_base()
-        if not self.native:
-            orig_basedir = basedir + ".orig"
-            shutil.copytree(basedir, orig_basedir, symlinks=True)
-            cmd = "dpkg-source -sa -b %s" % (basedir)
-            if os.path.exists("%s_%s.orig.tar.gz"
-                    % (self.name, self._cl.version.upstream_version)):
-                cmd = "dpkg-source -ss -b %s" % (basedir)
+        if not self.version3:
+            if not self.native:
+                orig_basedir = basedir + ".orig"
+                shutil.copytree(basedir, orig_basedir, symlinks=True)
+                cmd = ["dpkg-source", "-sa", "-b", basedir]
+                if os.path.exists("%s_%s.orig.tar.gz"
+                        % (self.name, self._cl.version.upstream_version)):
+                    cmd = ["dpkg-source", "-ss", "-b", basedir]
+            else:
+                cmd = ["dpkg-source", "-sn", "-b", basedir]
         else:
-            cmd = "dpkg-source -sn -b %s" % (basedir)
-        self._make_files(self.debian_files, basedir)
-        self._make_files({"debian/changelog": str(self._cl)}, basedir)
-        proc = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE,
-                stderr=subprocess.PIPE)
+            if not self.native:
+                tar_path = "%s_%s.orig.tar.%s" % (self.name,
+                        self._cl.version.upstream_version, tar_format)
+                if os.path.exists(tar_path):
+                    os.unlink(tar_path)
+                tar = tarfile.open(tar_path, 'w:%s' % tar_format)
+                try:
+                    tar.add(basedir)
+                finally:
+                    tar.close()
+                cmd = ["dpkg-source", "--format=3.0 (quilt)", "-b",
+                        basedir]
+            else:
+                cmd = ["dpkg-source", "--format=3.0 (native)", "-b",
+                        basedir]
+        self.write_debian_files(basedir)
+        proc = subprocess.Popen(cmd, stdout=subprocess.PIPE,
+                stderr=subprocess.STDOUT)
         ret = proc.wait()
-        assert ret == 0, "dpkg-source failed, output:\n%s\n%s" % \
-                (proc.stdout.read(), proc.stderr.read())
+        assert ret == 0, "dpkg-source failed, output:\n%s" % \
+                (proc.stdout.read(),)
         cmd = "dpkg-genchanges -S > ../%s" % self.changes_name()
         proc = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE,
-                stderr=subprocess.PIPE, cwd=basedir)
+                stderr=subprocess.STDOUT, cwd=basedir)
         ret = proc.wait()
-        assert ret == 0, "dpkg-genchanges failed, output:\n%s\n%s" % \
-                (proc.stdout.read(), proc.stderr.read())
+        assert ret == 0, "dpkg-genchanges failed, output:\n%s" % \
+                (proc.stdout.read(),)
         shutil.rmtree(basedir)

=== modified file 'tests/blackbox/__init__.py'
--- tests/blackbox/__init__.py	2008-08-27 11:57:30 +0000
+++ tests/blackbox/__init__.py	2011-01-28 14:24:44 +0000
@@ -21,15 +21,16 @@
 from bzrlib.tests import TestUtil
 
 
-def test_suite():
+def load_tests(standard_tests, module, loader):
   testmod_names = [
           'test_builddeb',
           'test_do',
           'test_import_dsc',
+          'test_import_upstream',
           'test_mark_uploaded',
+          'test_merge_package',
           'test_merge_upstream',
           ]
-  loader = TestUtil.TestLoader()
   suite = loader.loadTestsFromModuleNames(["%s.%s" % (__name__, i)
                                        for i in testmod_names])
   return suite

=== modified file 'tests/blackbox/test_builddeb.py'