Merge ~nacc/usd-importer:gu-lint into usd-importer:master

[Nish Aravamudan]

This will only make sense after the MP for gitubuntu-submit-fixes is fixed (it stacks on top).

With these changes:

$ git ubuntu clone squid3
$ git ubuntu remote add ahasenack
$ git ubuntu lint ahasenack/xenial-squid-passive-ftp-1560429 --target-branch pkg/ubuntu/xenial-devel --verbose
07/13/2017 17:13:12 - DEBUG:Executing: git config gitubuntu.lpuser
07/13/2017 17:13:12 - INFO:Using git repository at /home/nacc/work/imports/squid3
07/13/2017 17:13:12 - DEBUG:Executing: grep -q "* -ident" /home/nacc/work/imports/squid3/.git/info/attributes
07/13/2017 17:13:12 - DEBUG:Executing: grep -q "* -text" /home/nacc/work/imports/squid3/.git/info/attributes
07/13/2017 17:13:12 - DEBUG:Executing: grep -q "* -eol" /home/nacc/work/imports/squid3/.git/info/attributes
07/13/2017 17:13:12 - DEBUG:Executing: git config gitubuntu.lpuser
07/13/2017 17:13:12 - DEBUG:Executing: sh -c 'echo ahasenack/xenial-squid-passive-ftp-1560429:debian/changelog | git cat-file --batch --follow-symlinks | sed -n '1{/^[^ ]* blob/!{p;q1}};2,$p' | dpkg-parsechangelog -l- -SSource'
07/13/2017 17:13:12 - DEBUG:Executing: sh -c 'echo ahasenack/xenial-squid-passive-ftp-1560429:debian/changelog | git cat-file --batch --follow-symlinks | sed -n '1{/^[^ ]* blob/!{p;q1}};2,$p' | dpkg-parsechangelog -l- -SDistribution'
Verified that only new modifications to changelog are top-most additions
07/13/2017 17:13:17 - DEBUG:Executing: sh -c 'echo pkg/ubuntu/xenial-devel:debian/changelog | git cat-file --batch --follow-symlinks | sed -n '1{/^[^ ]* blob/!{p;q1}};2,$p' | dpkg-parsechangelog -l- -SDistribution'
07/13/2017 17:13:36 - DEBUG:Executing: sh -c 'echo ahasenack/xenial-squid-passive-ftp-1560429:debian/changelog | git cat-file --batch --follow-symlinks | sed -n '1{/^[^ ]* blob/!{p;q1}};2,$p' | dpkg-parsechangelog -l- -n1 -SVersion'
07/13/2017 17:13:37 - DEBUG:Executing: sh -c 'echo ahasenack/xenial-squid-passive-ftp-1560429:debian/changelog | git cat-file --batch --follow-symlinks | sed -n '1{/^[^ ]* blob/!{p;q1}};2,$p' | dpkg-parsechangelog -l- -n1 -o1 -SVersion'
Verified that debian/changelog version is as expected
07/13/2017 17:13:37 - DEBUG:Executing: git checkout pkg/ubuntu/xenial-devel
07/13/2017 17:13:38 - DEBUG:Executing: update-maintainer
07/13/2017 17:13:38 - DEBUG:Executing: git --work-tree . add -f -A
07/13/2017 17:13:38 - DEBUG:Executing: git --work-tree . write-tree
07/13/2017 17:13:38 - DEBUG:Executing: git clean -f -d
07/13/2017 17:13:38 - DEBUG:Executing: git reset --hard pkg/ubuntu/xenial-devel
07/13/2017 17:13:38 - DEBUG:Executing: git checkout d6f2273743dbaf14412092970d7740aadec37d53
Verified that update-maintainer has been run
All lint checks passed

Without --verbose, you just get the last line "All lint checks passed" :)

Example Ubuntu merge lint:

$ git ubuntu clone samba
$ git ubuntu remote add ahsenack
$ git ubuntu lint ahasenack/merge-artful-1700644 --verbose
$ git ubuntu lint ahasenack/merge-artful-1700644 --verbose
07/13/2017 17:55:40 - DEBUG:Executing: git config gitubuntu.lpuser
07/13/2017 17:55:40 - INFO:Using git repository at /home/nacc/work/imports/samba
07/13/2017 17:55:40 - DEBUG:Executing: grep -q "* -ident" /home/nacc/work/imports/samba/.git/info/attributes
07/13/2017 17:55:40 - DEBUG:Executing: grep -q "* -text" /home/nacc/work/imports/samba/.git/info/attributes
07/13/2017 17:55:40 - DEBUG:Executing: grep -q "* -eol" /home/nacc/work/imports/samba/.git/info/attributes
07/13/2017 17:55:40 - DEBUG:Executing: git config gitubuntu.lpuser
07/13/2017 17:55:40 - DEBUG:Executing: sh -c 'echo ahasenack/merge-artful-1700644:debian/changelog | git cat-file --batch --follow-symlinks | sed -n '1{/^[^ ]* blob/!{p;q1}};2,$p' | dpkg-parsechangelog -l- -SSource'
Verified ahasenack/old/debian exists
Verified old/debian is the same commit as ahasenack/old/debian
Verified old/debian is the same tree as ahasenack/old/debian
Verified ahasenack/old/ubuntu exists
Verified old/ubuntu is the same commit as ahasenack/old/ubuntu
Verified old/ubuntu is the same tree as ahasenack/old/ubuntu
Verified ahasenack/new/debian exists
W: Expected new/debian (f8ed72878e00e081b6e2cc8b94cd384c73e1521c) is not the same commit as ahasenack/new/debian (f717b664750fc98203b4b5a3a0ed435a2f17781d)
E: Expected new/debian (e67a4e80a20cc9086418550d33bf8952ec11c4f1) is not the same tree as ahasenack/new/debian (fbe6b4da6ac1b652f1019583ceb4b171a08a770b)
07/13/2017 17:55:40 - DEBUG:Executing: sh -c 'echo pkg/ubuntu/devel:debian/changelog | git cat-file --batch --follow-symlinks | sed -n '1{/^[^ ]* blob/!{p;q1}};2,$p' | dpkg-parsechangelog -l- -n1 -SVersion'
07/13/2017 17:55:40 - DEBUG:Executing: sh -c 'echo pkg/ubuntu/devel:debian/changelog | git cat-file --batch --follow-symlinks | sed -n '1{/^[^ ]* blob/!{p;q1}};2,$p' | dpkg-parsechangelog -l- -n1 -o1 -SVersion'
Verified ahasenack/reconstruct/2%4.5.8+dfsg-2ubuntu3 exists
Verified pkg/import/2%4.5.8+dfsg-2ubuntu3 is the same tree as ahasenack/reconstruct/2%4.5.8+dfsg-2ubuntu3
Verified ahasenack/deconstruct/2%4.5.8+dfsg-2ubuntu3 exists
Verified pkg/import/2%4.5.8+dfsg-2ubuntu3 is the same tree as ahasenack/deconstruct/2%4.5.8+dfsg-2ubuntu3
Verified ahasenack/logical/2%4.5.8+dfsg-2ubuntu3 exists
Verified debian/changelog is in diff between deconstruct and logical
Verified only update-maintainer changes are in diff between deconstruct and logical to debian/control
07/13/2017 17:55:40 - DEBUG:Executing: git checkout pkg/debian/sid
07/13/2017 17:55:40 - DEBUG:Executing: git-ubuntu.merge-changelogs 1588ab9c12d3d00598c188822ea861f9e6c36e72 pkg/ubuntu/devel pkg/debian/sid
07/13/2017 17:55:40 - DEBUG:Executing: git-merge-changelogs 1588ab9c12d3d00598c188822ea861f9e6c36e72 pkg/ubuntu/devel pkg/debian/sid
07/13/2017 17:55:41 - DEBUG:Executing: git --work-tree . add -f -A
07/13/2017 17:55:41 - DEBUG:Executing: git --work-tree . write-tree
07/13/2017 17:55:41 - DEBUG:Executing: git clean -f -d
07/13/2017 17:55:41 - DEBUG:Executing: git reset --hard pkg/debian/sid
07/13/2017 17:55:41 - DEBUG:Executing: git checkout 8cdb5099524ec5e8320544f36173045f215603ac
E: More than one changelog diff hunk detected
+samba (2:4.6.5+dfsg-3ubuntu1) artful; urgency=medium
+
+ * Merge with Debian unstable (LP: #1700644). Remaining changes:
+ - debian/VERSION.patch: Update vendor string to "Ubuntu".
+ - debian/smb.conf;
+ + Add "(Samba, Ubuntu)" to server string.
+ + Comment out the default [homes] share, and add a comment about
+ "valid users = %s" to show users how to restrict access to
+ \\server\username to only username.
+ - debian/samba-common.config:
+ + Do not change priority to high if dhclient3 is installed.
+ - Add apport hook:
+ + Created debian/source_samba.py.
+ + debian/rules, debian/samba-common-bin.install: install hook.
+ - Add extra DEP8 tests to samba (LP #1696823):
+ + d/t/control: enable the new DEP8 tests
+ + d/t/smbclient-anonymous-share-list: list available shares anonymously
+ + d/t/smbclient-authenticated-share-list: list available shares using
+ an authenticated connection
+ + d/t/smbclient-share-access: create a share and download a file from it
+ + d/t/cifs-share-access: access a file in a share using cifs
+ - Ask the user if we can run testparm against the config file. If yes,
+ include its stderr and exit status in the bug report. Otherwise, only
+ include the exit status. (LP #1694334)
+ - If systemctl is available, use it to query the status of the smbd
+ service before trying to reload it. Otherwise, keep the same check
+ as before and reload the service based on the existence of the
+ initscript. (LP #1579597)
+ * Refresh patches to get rid of offsets:
+ - d/p/usershare.patch
+ - d/p/xsltproc_dont_build_smb.conf.5.patch
+ * d/p/non-wide-symlinks-to-directories-12860.patch: fix a CVE-2017-2619
+ regression which breaks symlinks to directories on certain systems
+ (LP: #1701073)
+
+ -- Andreas Hasenack <email address hidden> Fri, 07 Jul 2017 18:07:38 -0300
+
 samba (2:4.6.5+dfsg-3) unstable; urgency=medium

   * Remove upstart code
  9-January-1994 Bruce Perens <email address hidden>
  * Added Debian GNU/Linux package maintenance system files, and
    configured for Debian systems.
+
07/13/2017 17:55:41 - DEBUG:Executing: git checkout pkg/debian/sid
07/13/2017 17:55:42 - DEBUG:Executing: update-maintainer
07/13/2017 17:55:42 - DEBUG:Executing: git --work-tree . add -f -A
07/13/2017 17:55:42 - DEBUG:Executing: git --work-tree . write-tree
07/13/2017 17:55:42 - DEBUG:Executing: git clean -f -d
07/13/2017 17:55:42 - DEBUG:Executing: git reset --hard pkg/debian/sid
07/13/2017 17:55:42 - DEBUG:Executing: git checkout 8cdb5099524ec5e8320544f36173045f215603ac
Verified that update-maintainer has been run
07/13/2017 17:55:43 - DEBUG:Executing: sh -c 'echo pkg/debian/sid:debian/changelog | git cat-file --batch --follow-symlinks | sed -n '1{/^[^ ]* blob/!{p;q1}};2,$p' | dpkg-parsechangelog -l- -n1 -SVersion'
07/13/2017 17:55:43 - DEBUG:Executing: sh -c 'echo pkg/debian/sid:debian/changelog | git cat-file --batch --follow-symlinks | sed -n '1{/^[^ ]* blob/!{p;q1}};2,$p' | dpkg-parsechangelog -l- -n1 -o1 -SVersion'
07/13/2017 17:55:43 - DEBUG:Executing: sh -c 'echo ahasenack/merge-artful-1700644:debian/changelog | git cat-file --batch --follow-symlinks | sed -n '1{/^[^ ]* blob/!{p;q1}};2,$p' | dpkg-parsechangelog -l- -n1 -SVersion'
07/13/2017 17:55:43 - DEBUG:Executing: sh -c 'echo ahasenack/merge-artful-1700644:debian/changelog | git cat-file --batch --follow-symlinks | sed -n '1{/^[^ ]* blob/!{p;q1}};2,$p' | dpkg-parsechangelog -l- -n1 -o1 -SVersion'
Verified that debian/changelog version is as expected
Some lint checks failed. Please investigate.

2f18b89... by Nish Aravamudan on 2017-07-13

fix nearest_remote_branch formatting

will be squashed up

0e56f4d... by Nish Aravamudan on 2017-07-14

git ubuntu lint: fix access of raw_repo index

Will be squashed up.

f5041f5... by Nish Aravamudan on 2017-07-14

git ubuntu lint: check update-maintainer has been run for bugfixes

Will be squashed up

68151ee... by Nish Aravamudan on 2017-07-14

git ubuntu lint: if --verbose indicate checks passed as well

Will be squahsed up

9831aa1... by Nish Aravamudan on 2017-07-14

git ubuntu lint: properly handle branch parameter

Will be squashed up

e3e9113... by Nish Aravamudan on 2017-07-14

git ubuntu lint: cleanup success logging

Will be squashed up

[Robie Basak (racb)]

Looks good, thanks!

I don't want to bikeshed this too much, because it'd better it be in the repository than not landed yet, and we can improve it incrementally. I see this submodule as at a prototype stage where it's appropriate to have more slack, unlike the importer which is now mature and we need to be more careful about.

I would like to have a hard rule about catch-all exception handlers though. That's the only thing I'd definitely like fixed before landing, please. It would probably be useful to fix the tab indents too. The others are at your discretion - I'd like to see them addressed (or for us to conclude they shouldn't be done if you disagree) at some point though.

review: Approve

[Nish Aravamudan (nacc)]

On Fri, Jul 14, 2017 at 11:22 AM, Robie Basak <email address hidden> wrote:
> Review: Approve
>
> Looks good, thanks!
>
> I don't want to bikeshed this too much, because it'd better it be in the repository than not landed yet, and we can improve it incrementally. I see this submodule as at a prototype stage where it's appropriate to have more slack, unlike the importer which is now mature and we need to be more careful about.
>
> I would like to have a hard rule about catch-all exception handlers though. That's the only thing I'd definitely like fixed before landing, please. It would probably be useful to fix the tab indents too. The others are at your discretion - I'd like to see them addressed (or for us to conclude they shouldn't be done if you disagree) at some point though.

Fixed most and pushed.

> Diff comments:
>
>> diff --git a/gitubuntu/git_repository.py b/gitubuntu/git_repository.py
>> index abf1165..2423150 100644
>> --- a/gitubuntu/git_repository.py
>> +++ b/gitubuntu/git_repository.py
>> @@ -336,32 +339,16 @@ class GitUbuntuRepository:
>> @property
>> def git_dir(self):
>> """Same as cached object in the environment"""
>> - return self._local_repo.path
>> + return self.raw_repo.path
>>
>> @property
>> - def local_repo(self):
>> + def raw_repo(self):
>> """Reference to pygit2 Repository object"""
>> - return self._local_repo
>> -
>> - @property
>> - def head_is_detached(self):
>> - return self._local_repo.head_is_detached
>> -
>> - @property
>> - def head_is_unborn(self):
>> - return self._local_repo.head_is_unborn
>> -
>> - @property
>> - def head(self):
>> - return self._local_repo.head
>> -
>> - @property
>> - def remotes(self):
>> - return self._local_repo.remotes
>> + return self._raw_repo
>
> Why not just use self.raw_repo instead of having the indirection around a property accessor method?

+1

>> def _references(self, prefix=''):
>> - return [self._local_repo.lookup_reference(r) for r in
>> - self._local_repo.listall_references() if
>> + return [self.raw_repo.lookup_reference(r) for r in
>> + self.raw_repo.listall_references() if
>> r.startswith(prefix)]
>>
>> def references_with_prefix(self, prefix):
>> diff --git a/gitubuntu/lint.py b/gitubuntu/lint.py
>> new file mode 100644
>> index 0000000..f93cb52
>> --- /dev/null
>> +++ b/gitubuntu/lint.py
>> @@ -0,0 +1,558 @@
>> +import argparse
>> +import itertools
>> +import logging
>> +import os
>> +from subprocess import CalledProcessError
>> +import sys
>> +import tempfile
>> +from gitubuntu.git_repository import GitUbuntuRepository, git_dep14_tag
>> +from gitubuntu.logging import warning, error, fatal
>> +from gitubuntu.run import run, decode_binary
>> +from gitubuntu.source_information import GitUbuntuSourceInformation
>> +from gitubuntu.versioning import next_development_version, next_sru_version
>
> I think we differ on opinion on this, but I'd prefer to see next_sru_version being called explicitly as gitubuntu.versioning.next_sru_version. Then it's more obvious to a reader where...

[Robie Basak (racb)]

On Sat, Jul 15, 2017 at 06:27:32AM -0000, Nish Aravamudan wrote:
> >> + ret = True
> >
> > I'm not keen on this pattern. It feels error prone. How about yielding each False or True instead, and then using all() on the a call to that generator?
>
> It is, probably :) Not yet fixed, but I think I'd prefer to wrap the
> all() usage in the API? That is, I think this is equally confusing:
>
> ret = all(self._check_changelog_addition(...))
>
> I was thinking we could drop the _check naming and make it check...
> and move the actual function into _check in this case?

I'm not sure I follow exactly. We should chat more on how we want this
to work I think. I suggest we leave it for now and try to improve just
this in separate MPs just for this, as there's no obviously right
pattern to use but we need to pick one.

Robie

diff --git a/doc/README.md b/doc/README.md
index eb09402..8179a75 100644
--- a/doc/README.md
+++ b/doc/README.md
@@ -21,7 +21,7 @@ or
 3. Get necessary dependencies
 
         $ sudo apt update -qy
-        $ deps="dpkg-dev git-buildpackage python3-argcomplete python3-lazr.restfulclient python3-debian python3-launchpadlib python3-pygit2 python3-ubuntutools python3-pkg-resources quilt"
+        $ deps="dpkg-dev git-buildpackage python3-argcomplete python3-lazr.restfulclient python3-debian python3-launchpadlib python3-pygit2 python3-ubuntutools python3-pkg-resources python3-pytest quilt"
         $ sudo apt install -qy $deps
 
 ## Getting via snap ##
diff --git a/gitubuntu/__main__.py b/gitubuntu/__main__.py
index 71b1479..619413e 100644
--- a/gitubuntu/__main__.py
+++ b/gitubuntu/__main__.py
@@ -20,6 +20,7 @@ def main():
         from gitubuntu.importppa import GitUbuntuImportPPA
         from gitubuntu.remote import GitUbuntuRemote
         from gitubuntu.submit import GitUbuntuSubmit
+        from gitubuntu.lint import GitUbuntuLint
         from gitubuntu.run import run
 
         try:
@@ -44,6 +45,7 @@ def main():
                              'import-ppa':GitUbuntuImportPPA,
                              'remote':GitUbuntuRemote,
                              'submit':GitUbuntuSubmit,
+                             'lint':GitUbuntuLint,
                             }
 
         known_network_subcommands = {'import', 'import-local',
diff --git a/gitubuntu/clone.py b/gitubuntu/clone.py
index 92c7733..e686c8d 100644
--- a/gitubuntu/clone.py
+++ b/gitubuntu/clone.py
@@ -99,7 +99,8 @@ Example:
             local_repo.fetch_lpuser_remote(must_exist=False)
 
             logging.debug("added remote '%s' -> %s", local_repo.lp_user,
-                local_repo.remotes[local_repo.lp_user].url)
+                local_repo.raw_repo.remotes[local_repo.lp_user].url
+            )
         except:
             pass
 
diff --git a/gitubuntu/git_repository.py b/gitubuntu/git_repository.py
index abf1165..2423150 100644
--- a/gitubuntu/git_repository.py
+++ b/gitubuntu/git_repository.py
@@ -98,6 +98,9 @@ class GitUbuntuRepository:
     import/ tags when succesfully imported); and 'orphan/' for published
     versions for which no parents can be found (these are also created
     by the importer).
+
+    To access the underlying pygit2.Repository object, use the raw_repo
+    property.
     """
 
     def __init__(self, local_dir, lp_user=None, fetch_proto=None):
@@ -118,10 +121,10 @@ class GitUbuntuRepository:
 
         logging.info('Using git repository at %s' % self._local_dir)
 
-        self._local_repo = pygit2.init_repository(self._local_dir)
+        self._raw_repo = pygit2.init_repository(self._local_dir)
 
         self._env = os.environ.copy()
-        self._env['GIT_DIR'] = self._local_repo.path
+        self._env['GIT_DIR'] = self.raw_repo.path
         self._env['GIT_WORK_TREE'] = self._local_dir
 
         self.set_git_attributes()
@@ -157,7 +160,7 @@ class GitUbuntuRepository:
                                  )
 
     def set_git_attributes(self):
-        git_attr_path = os.path.join(self.local_repo.path,
+        git_attr_path = os.path.join(self.raw_repo.path,
                                      'info',
                                      'attributes'
                                     )
@@ -218,7 +221,7 @@ class GitUbuntuRepository:
 
     def remote_exists(self, remote_name):
         # https://github.com/libgit2/pygit2/issues/671
-        return any(remote.name == remote_name for remote in self.remotes)
+        return any(remote.name == remote_name for remote in self.raw_repo.remotes)
 
     def _add_remote(self, remote_name, remote_url):
         if not self._fetch_proto:
@@ -228,12 +231,12 @@ class GitUbuntuRepository:
         logging.debug('Adding %s as remote %s', fetch_url, remote_name)
 
         if not self.remote_exists(remote_name):
-            self.local_repo.remotes.create(remote_name, fetch_url,
+            self.raw_repo.remotes.create(remote_name, fetch_url,
                 'refs/heads/*:refs/remotes/%s/*' % remote_name)
             # grab unreachable tags (orphans)
-            self.local_repo.remotes.add_fetch(remote_name,
+            self.raw_repo.remotes.add_fetch(remote_name,
                 'refs/tags/*:refs/tags/%s/*' % remote_name)
-            self.local_repo.remotes.set_push_url(remote_name,
+            self.raw_repo.remotes.set_push_url(remote_name,
                 'ssh://%s@%s' % (self.lp_user, remote_url))
             self.git_run(['config',
                           'remote.%s.tagOpt' % remote_name,
@@ -265,7 +268,7 @@ class GitUbuntuRepository:
     def _fetch_remote(self, remote_name, must_exist):
         try:
             # Does not seem to be working with https
-            # self.local_repo.remotes[remote_name].fetch()
+            # self.raw_repo.remotes[remote_name].fetch()
             logging.debug('Fetching remote %s' % remote_name)
             self.git_run(['fetch', remote_name], quiet=not must_exist)
         except CalledProcessError:
@@ -285,7 +288,7 @@ class GitUbuntuRepository:
     def fetch_remote_refspecs(self, remote_name, refspecs, must_exist):
         try:
             # Does not seem to be working with https
-            # self.local_repo.remotes[remote_name].fetch()
+            # self.raw_repo.remotes[remote_name].fetch()
             for refspec in refspecs:
                 logging.debug('Fetching refspec %s from remote %s' %
                              (refspec, remote_name))
@@ -308,7 +311,7 @@ class GitUbuntuRepository:
             for (target_refs, source_refs) in [
                 ('refs/heads/%s/' % namespace, 'refs/remotes/pkg/'),]:
                 if ref.name.startswith(source_refs):
-                    self._local_repo.create_reference(
+                    self.raw_repo.create_reference(
                         '%s/%s' % (target_refs, ref.name[len(source_refs):]),
                         ref.peel().id)
 
@@ -336,32 +339,16 @@ class GitUbuntuRepository:
     @property
     def git_dir(self):
         """Same as cached object in the environment"""
-        return self._local_repo.path
+        return self.raw_repo.path
 
     @property
-    def local_repo(self):
+    def raw_repo(self):
         """Reference to pygit2 Repository object"""
-        return self._local_repo
-
-    @property
-    def head_is_detached(self):
-        return self._local_repo.head_is_detached
-
-    @property
-    def head_is_unborn(self):
-        return self._local_repo.head_is_unborn
-
-    @property
-    def head(self):
-        return self._local_repo.head
-
-    @property
-    def remotes(self):
-        return self._local_repo.remotes
+        return self._raw_repo
 
     def _references(self, prefix=''):
-        return [self._local_repo.lookup_reference(r) for r in
-                self._local_repo.listall_references() if
+        return [self.raw_repo.lookup_reference(r) for r in
+                self.raw_repo.listall_references() if
                 r.startswith(prefix)]
 
     def references_with_prefix(self, prefix):
@@ -377,8 +364,14 @@ class GitUbuntuRepository:
 
     def _branches(self,
                   branch_type=pygit2.GIT_BRANCH_LOCAL | pygit2.GIT_BRANCH_REMOTE):
-        return [self._local_repo.lookup_branch(b) for b in
-                self._local_repo.listall_branches(branch_type)]
+        branches = []
+        if branch_type & pygit2.GIT_BRANCH_LOCAL:
+            branches.extend([self.raw_repo.lookup_branch(b) for b in
+                self.raw_repo.listall_branches(pygit2.GIT_BRANCH_LOCAL)])
+        if branch_type & pygit2.GIT_BRANCH_REMOTE:
+            branches.extend([self.raw_repo.lookup_branch(b, pygit2.GIT_BRANCH_REMOTE) for b in
+                self.raw_repo.listall_branches(pygit2.GIT_BRANCH_REMOTE)])
+        return branches
 
     @property
     def branches(self):
@@ -408,17 +401,8 @@ class GitUbuntuRepository:
     def lp_user(self):
         return self._lp_user
 
-    def status(self):
-        return self._local_repo.status()
-
-    def merge_base(self, *args):
-        return self._local_repo.merge_base(*args)
-
-    def lookup_branch(self, *args):
-        return self._local_repo.lookup_branch(*args)
-
     def get_commitish(self, commitish):
-        return self._local_repo.revparse_single(commitish)
+        return self.raw_repo.revparse_single(commitish)
 
     def head_to_commit(self, head_name):
         return str(self.get_head_by_name(head_name).peel().id)
@@ -636,28 +620,20 @@ class GitUbuntuRepository:
     def treeishs_identical(self, treeish1, treeish2):
         if treeish1 is None or treeish2 is None:
             return False
-        _treeish1 = self._local_repo.get(treeish1).peel(pygit2.Tree).id
-        _treeish2 = self._local_repo.get(treeish2).peel(pygit2.Tree).id
+        _treeish1 = self.raw_repo.get(treeish1).peel(pygit2.Tree).id
+        _treeish2 = self.raw_repo.get(treeish2).peel(pygit2.Tree).id
         return _treeish1 == _treeish2
 
     def get_head_by_name(self, name):
         try:
-            return self._local_repo.lookup_branch(name)
+            return self.raw_repo.lookup_branch(name)
         except TypeError:
             return None
 
-    def lookup_reference(self, reference):
-        """Return a pygit2.Reference object
-
-        Raises KeyError if the reference cannot be found.
-        """
-        return self._local_repo.lookup_reference(reference)
-
     def get_tag_reference(self, tag):
         """Return the tag object if it exists in the repository"""
         try:
-            return self._local_repo.lookup_reference('refs/tags/%s' %
-                                                     tag)
+            return self.raw_repo.lookup_reference('refs/tags/%s' % tag)
         except (KeyError, ValueError):
             return None
 
@@ -673,11 +649,42 @@ class GitUbuntuRepository:
     def get_upstream_tag(self, version, namespace):
         return self.get_tag_reference(upstream_tag(version, namespace))
 
+    def nearest_remote_branch(self, commit_hash, namespace=None):
+        # 1) cache all commit hashes in namespace/
+        remote_heads = {}
+        for b in self.remote_branches:
+            if namespace is not None and not b.branch_name.startswith(namespace):
+                continue
+            remote_heads[b.branch_name] = b.peel().id
+        # 2) walk from commit_hash backwards until a cached commit is found
+        candidate_branch = None
+        max_commits = 100
+        commit_count = 0
+        for commit in self.raw_repo.walk(self.get_commitish(commit_hash).id,
+            pygit2.GIT_SORT_TOPOLOGICAL
+        ):
+            try:
+                candidate_branches = [x for x in remote_heads
+                    if remote_heads[x] == commit.id]
+                if len(candidate_branches) > 1:
+                    raise Exception("Multiple remote branches found: %s" %
+                        candidate_branches
+                    )
+                if len(candidate_branches) == 1:
+                    return candidate_branches[0]
+                commit_count += 1
+                if commit_count > max_commits:
+                    raise Exception("Unable to find a remote branch as ancestor "
+                        "in the first 100 commits"
+                    )
+            except IndexError:
+                pass
+
     def nearest_applied_tag(self, commit_hash, namespace):
         try:
             return self.get_tag_reference(
-                       self._local_repo.describe(
-                           committish=self._local_repo.get(commit_hash),
+                       self.raw_repo.describe(
+                           committish=self.raw_repo.get(commit_hash),
                            describe_strategy=pygit2.GIT_DESCRIBE_TAGS,
                            pattern='%s/applied/*' % namespace,
                            abbreviated_size=0
@@ -689,8 +696,8 @@ class GitUbuntuRepository:
     def nearest_import_tag(self, commit_hash, namespace):
         try:
             return self.get_tag_reference(
-                       self._local_repo.describe(
-                           committish=self._local_repo.get(commit_hash),
+                       self.raw_repo.describe(
+                           committish=self.raw_repo.get(commit_hash),
                            describe_strategy=pygit2.GIT_DESCRIBE_TAGS,
                            pattern='%s/import/*' % namespace,
                            abbreviated_size=0
@@ -777,9 +784,9 @@ class GitUbuntuRepository:
                 'GIT_COMMITTER_DATE':committer_date}
 
     def create_tracking_branch(self, branch_name, upstream_name, force=False):
-        return self._local_repo.create_branch(
+        return self.raw_repo.create_branch(
             branch_name,
-            self._local_repo.lookup_branch(
+            self.raw_repo.lookup_branch(
                 upstream_name,
                 pygit2.GIT_BRANCH_REMOTE
             ).peel(pygit2.Commit),
@@ -789,16 +796,22 @@ class GitUbuntuRepository:
     def checkout_commitish(self, commitish):
         # pygit2 checkout does not accept hashes
         # https://github.com/libgit2/pygit2/issues/412
-        # self._local_repo.checkout_tree(self.get_commitish(commitish))
+        # self.raw_repo.checkout_tree(self.get_commitish(commitish))
         self.git_run(['checkout', commitish])
 
+    def reset_commitish(self, commitish):
+        # pygit2 checkout does not accept hashes
+        # https://github.com/libgit2/pygit2/issues/412
+        # self.checkout_tree(self.get_commitish(commitish))
+        self.git_run(['reset', '--hard', commitish])
+
     # given a branch name and a commit hash will create a merge of the
     # branch's HEAD and the commit hash and then move the branch HEAD to
     # that merge commit (used for the -devel branches)
     def merge_commit_to_devel_head(self, namespace, head_name, commit_hash,
                                    environment_spi=None):
         try:
-            commit_obj = self._local_repo.get(commit_hash)
+            commit_obj = self.raw_repo.get(commit_hash)
         except:
             logging.error('%s is not a defined object in this '
                           'git repository. Cannot merge to %s' %
@@ -806,7 +819,7 @@ class GitUbuntuRepository:
             sys.exit(1)
         try:
             parents = []
-            old_head_hash = str(self._local_repo.lookup_branch(head_name).peel().id)
+            old_head_hash = str(self.raw_repo.lookup_branch(head_name).peel().id)
             parents.append(old_head_hash)
             parents.append(commit_hash)
 
@@ -828,19 +841,19 @@ class GitUbuntuRepository:
                                                     parents,
                                                     msg,
                                                     environment_spi)
-            self._local_repo.lookup_branch(head_name).set_target(new_commit_hash)
+            self.raw_repo.lookup_branch(head_name).set_target(new_commit_hash)
         except AttributeError:
-            self._local_repo.create_branch(head_name,
-                                           self._local_repo.get(commit_hash)
-                                          )
+            self.raw_repo.create_branch(head_name,
+                self.raw_repo.get(commit_hash)
+            )
 
     def update_head_to_commit(self, head_name, commit_hash):
         try:
-            self._local_repo.lookup_branch(head_name).set_target(commit_hash)
+            self.raw_repo.lookup_branch(head_name).set_target(commit_hash)
         except AttributeError:
-            self._local_repo.create_branch(head_name,
-                                           self._local_repo.get(commit_hash)
-                                          )
+            self.raw_repo.create_branch(head_name,
+                self.raw_repo.get(commit_hash)
+            )
 
     def clean_repository_state(self):
         """Cleanup working tree"""
@@ -1052,12 +1065,12 @@ class GitUbuntuRepository:
                 env=index_env,
             )
         tree_hash_str = decode_binary(cp.stdout).strip()
-        tree = self._local_repo.get(tree_hash_str)
+        tree = self.raw_repo.get(tree_hash_str)
 
         # Add any empty directories that git did not import. Workaround for LP:
         # #1687057.
         replacement_oid = self._add_missing_tree_dirs(
-            repo=self._local_repo,
+            repo=self.raw_repo,
             top_path=path,
             top_tree=tree,
         )
diff --git a/gitubuntu/importer.py b/gitubuntu/importer.py
index d2e2421..bfbabb0 100644
--- a/gitubuntu/importer.py
+++ b/gitubuntu/importer.py
@@ -702,7 +702,7 @@ class GitUbuntuImport:
             )
             devel_hash = None
             devel_name = None
-            for rel in self.ubuntu_sinfo.active_series_list:
+            for rel in self.ubuntu_sinfo.active_series_name_list:
                 series_devel_hash = None
                 series_devel_name = None
                 series_devel_version = None
diff --git a/gitubuntu/importlocal.py b/gitubuntu/importlocal.py
index c50b515..4bcda7d 100644
--- a/gitubuntu/importlocal.py
+++ b/gitubuntu/importlocal.py
@@ -72,7 +72,7 @@ class GitUbuntuImportLocal(GitUbuntuImport):
 
         self.local_repo = GitUbuntuRepository(directory)
         self.local_repo.ensure_importer_branches_exist(self.namespace)
-        if len(self.local_repo.status()) != 0:
+        if len(self.local_repo.raw_repo.status()) != 0:
             logging.error('Working tree must be clean to continue.')
             run(['git', 'status'], stdout=None)
             sys.exit(1)
@@ -127,8 +127,8 @@ class GitUbuntuImportLocal(GitUbuntuImport):
 
         head = None
         head_version = None
-        if not self.local_repo.head_is_unborn:
-            head = self.local_repo.head
+        if not self.local_repo.raw_repo.head_is_unborn:
+            head = self.local_repo.raw_repo.head
         # check if the version to import has already been imported to
         # this head
         if head is not None:
diff --git a/gitubuntu/lint.py b/gitubuntu/lint.py
new file mode 100644
index 0000000..f93cb52
--- /dev/null
+++ b/gitubuntu/lint.py
@@ -0,0 +1,558 @@
+import argparse
+import itertools
+import logging
+import os
+from subprocess import CalledProcessError
+import sys
+import tempfile
+from gitubuntu.git_repository import GitUbuntuRepository, git_dep14_tag
+from gitubuntu.logging import warning, error, fatal
+from gitubuntu.run import run, decode_binary
+from gitubuntu.source_information import GitUbuntuSourceInformation
+from gitubuntu.versioning import next_development_version, next_sru_version
+
+try:
+    pkg = 'python3-pygit2'
+    import pygit2
+    pkg = 'python3-debian'
+    import debian
+except ImportError:
+    logging.error('Is %s installed?', pkg)
+    sys.exit(1)
+
+class GitUbuntuLint:
+    def __init__(self):
+        pass
+
+    def success(self, msg, *args):
+        if self.verbose:
+            print(msg % args)
+
+    def parse_args(self, subparsers=None, base_subparsers=None):
+        kwargs = dict(description='Given a commitish, perform automated checks',
+                      formatter_class=argparse.RawTextHelpFormatter,
+                      epilog='An exit code of 0 indicates all checks passed'
+                     )
+        if base_subparsers:
+            kwargs['parents'] = base_subparsers
+        if subparsers:
+            parser = subparsers.add_parser('lint', **kwargs)
+            parser.set_defaults(func=self.main)
+        else:
+            parser = argparse.ArgumentParser(**kwargs)
+
+        parser.add_argument('commitish', type=str, default='HEAD', nargs='?',
+            help='Commitish to lint'
+        )
+        parser.add_argument('--lint-namespace', action='store_true',
+            help='Namespace the branches and tags to lint live in. '
+                 'This will be derived if possible.'
+        )
+        parser.add_argument('--target-branch', type=str,
+            help='Target branch (typically a remote-tracking branch in pkg/) '
+                 'the current branch is against. This will be derived if '
+                 'possible.'
+        )
+        parser.add_argument('-d', '--directory', type=str,
+            help='Use git repository at specified location.',
+            default=os.path.abspath(os.getcwd())
+        )
+        if not subparsers:
+            return parser.parse_args()
+        return 'lint - %s' % kwargs['description']
+
+    def _check_commitish_exists(self, commitish):
+        try:
+            actual_commitish_obj = self.local_repo.get_commitish(
+                commitish
+            )
+            self.success('Verified %s exists', commitish)
+            return True
+        except:
+            warning('%s not found', commitish)
+            return False
+
+    def _check_commitish_exists_and_same(self, expected_tag_name,
+        actual_commitish, expected_commitish, check_commit_id=False
+    ):
+        ret = True
+        if not self._check_commitish_exists(actual_commitish):
+            return False
+
+        expected_commitish_obj = self.local_repo.get_commitish(
+            expected_commitish
+        )
+        actual_commitish_obj = self.local_repo.get_commitish(
+            actual_commitish
+        )
+        if check_commit_id:
+            expected_commit_id = str(expected_commitish_obj.id)
+            actual_commit_id = str(actual_commitish_obj.id)
+            if expected_commit_id == actual_commit_id:
+                self.success('Verified %s is the same commit as %s',
+                    expected_tag_name, actual_commitish
+                )
+            else:
+                warning('Expected %s (%s) is not the same commit as %s (%s)',
+                    expected_tag_name, expected_commit_id,
+                    actual_commitish, actual_commit_id
+                )
+                ret = False
+        expected_commit_tree_id = str(
+            expected_commitish_obj.peel(pygit2.Tree).id
+        )
+        actual_commit_tree_id = str(
+            actual_commitish_obj.peel(pygit2.Tree).id
+        )
+        if expected_commit_tree_id == actual_commit_tree_id:
+            self.success('Verified %s is the same tree as %s',
+                expected_tag_name, actual_commitish
+            )
+        else:
+            error('Expected %s (%s) is not the same tree as %s (%s)',
+                expected_tag_name, expected_commit_tree_id,
+                actual_commitish, actual_commit_tree_id
+            )
+            ret = False
+
+        return ret
+
+    def print_hunk(self, hunk):
+        for line in hunk.lines:
+            print('%s%s' % (line.origin, line.content.rstrip()))
+
+    def print_patch(self, patch):
+        for hunk in patch.hunks:
+            self.print_hunk(hunk)
+
+    def _check_deconstruct_to_logical_patch(self, patch):
+        if 'debian/changelog' in patch.delta.new_file.path:
+            self.success('Verified debian/changelog is in diff between '
+                'deconstruct and logical'
+            )
+            return True
+        if 'debian/control' in patch.delta.new_file.path:
+            for hunk in patch.hunks:
+                ret = True
+                for line in hunk.lines:
+                    if line.origin == ' ':
+                        continue
+                    if line.origin == '-':
+                        if line.content.startswith('Maintainer:'):
+                            continue
+                    if line.origin == '+':
+                        if line.content.rstrip() == 'Maintainer: Ubuntu Developers <[e-mail]>':
+                            continue
+                        if line.content.startswith('XSBC-Original-Maintainer:'):
+                            continue
+                    ret = False
+                if not ret:
+                    error('unexpected differences between logical '
+                        'and deconstruct tags'
+                    )
+                    self.print_hunk(hunk)
+            self.success('Verified only update-maintainer changes are in diff '
+                'between deconstruct and logical to debian/control'
+            )
+            return True
+
+    def get_changelog_blob(self, commitish):
+        tree = self.local_repo.get_commitish(commitish).peel(pygit2.Tree)
+        debian_tree = self.local_repo.raw_repo[tree['debian'].id] # XXX: follow symlinks
+        return self.local_repo.raw_repo[debian_tree['changelog'].id]
+
+    def get_control_blob(self, commitish):
+        tree = self.local_repo.get_commitish(commitish).peel(pygit2.Tree)
+        debian_tree = self.local_repo.raw_repo[tree['debian'].id] # XXX: follow symlinks
+        return self.local_repo.raw_repo[debian_tree['control'].id]
+
+    def _check_changelog_addition(self, mc_treeish, commitish):
+        changelog_patch = self.local_repo.raw_repo.diff(
+            self.get_changelog_blob(mc_treeish),
+            self.get_changelog_blob(commitish)
+        )
+
+        if not len(changelog_patch.hunks):
+            error('No changelog entry added')
+            return False
+        elif len(changelog_patch.hunks) > 1:
+            error('More than one changelog diff hunk detected')
+            self.print_patch(changelog_patch)
+            return False
+
+        ret = True
+        # The single hunk should consist of one or more new lines ('+') followed
+        # by one or more context lines (' ') and nothing else
+        line_types = [dl.origin for dl in changelog_patch.hunks[0].lines]
+        if [k for k, g in itertools.groupby(line_types)] != ['+', ' ']:
+            error('Unexpected modifications to changelog detected')
+            ret = False
+
+        if changelog_patch.hunks[0].new_lines < 2:
+            error('changelog must have added at least two lines')
+            ret = False
+
+        added_lines = [l.content for l in changelog_patch.hunks[0].lines if l.origin == '+']
+        if added_lines[-1] != '\n':
+            error('last added line to changelog must be blank')
+            ret = False
+
+        changelog = debian.changelog.Changelog(''.join(added_lines[:-1]),
+            strict=True
+        )
+        if len(changelog.versions) != 1:
+            error('must add exactly one changelog entry')
+            ret = False
+
+        if any(['\t' in l for l in added_lines]):
+            warning('Tab characters found in new changelog entry')
+            ret = False
+
+        if any([l.endswith(' \n') for l in added_lines]):
+            warning('Trailing whitespace found in new changelog entry')
+            ret = False
+
+        if ret:
+            self.success('Verified that only new modifications to changelog '
+                'are top-most additions'
+            )
+
+        return ret
+
+    def hunks_identical(self, a, b):
+        if a.old_start != b.old_start:
+            return False
+        if a.old_lines != b.old_lines:
+            return False
+        if a.new_start != b.new_start:
+            return False
+        if a.new_lines != b.new_lines:
+            return False
+        for (h_a, h_b) in zip(a.lines, b.lines):
+            if h_a.origin != h_b.origin:
+                return False
+            if h_a.content != h_b.content:
+                return False
+            if h_a.old_lineno != h_b.old_lineno:
+                return False
+            if h_a.new_lineno != h_b.new_lineno:
+                return False
+            if h_a.num_lines != h_b.num_lines:
+                return False
+        return True
+
+    def hunk_in_patch(self, hunk, patch):
+        for patch_hunk in patch.hunks:
+            if (self.hunks_identical(patch_hunk, hunk)):
+                return True
+        return False
+
+    def treeish_after_merge_changelogs(self, old, new):
+        commitish_id = str(self.local_repo.raw_repo.head.resolve().peel().id)
+        merge_base_id = str(self.local_repo.raw_repo.merge_base(
+            self.local_repo.get_commitish(old).id,
+            self.local_repo.get_commitish(new).id)
+        )
+        self.local_repo.checkout_commitish(new)
+        try:
+            run(['git-ubuntu.merge-changelogs', merge_base_id, old, new])
+        except (CalledProcessError, FileNotFoundError):
+            try:
+                run(['git-merge-changelogs', merge_base_id, old, new])
+            except (CalledProcessError, FileNotFoundError):
+                logging.error('Unable to find/execute merge-changelogs')
+                return None
+        finally:
+            self.local_repo.git_run(
+                ['--work-tree', '.', 'add', '-f', '-A'],
+            )
+            cp = self.local_repo.git_run(
+                ['--work-tree', '.', 'write-tree'],
+            )
+            treeish = decode_binary(cp.stdout).strip()
+            self.local_repo.git_run(['clean', '-f', '-d'])
+            self.local_repo.reset_commitish(new)
+            self.local_repo.checkout_commitish(commitish_id)
+
+        return treeish
+
+    def treeish_after_update_maintainer(self, new):
+        commitish_id = str(self.local_repo.raw_repo.head.resolve().peel().id)
+        self.local_repo.checkout_commitish(new)
+        try:
+            run(['update-maintainer'])
+        except (CalledProcessError, FileNotFoundError):
+            logging.error('Unable to find/execute update-maintainer')
+            return None
+        finally:
+            self.local_repo.git_run(
+                ['--work-tree', '.', 'add', '-f', '-A'],
+            )
+            cp = self.local_repo.git_run(
+                ['--work-tree', '.', 'write-tree'],
+            )
+            treeish = decode_binary(cp.stdout).strip()
+            self.local_repo.git_run(['clean', '-f', '-d'])
+            self.local_repo.reset_commitish(new)
+            self.local_repo.checkout_commitish(commitish_id)
+
+        return treeish
+
+    def _check_update_maintainer(self, new, um_treeish, commitish):
+        # is every hunk of diff new -> um_treeish in new -> commitish?
+        expected_patch = self.local_repo.raw_repo.diff(
+            self.get_control_blob(new),
+            self.get_control_blob(um_treeish)
+        )
+
+        actual_patch = self.local_repo.raw_repo.diff(
+            self.get_control_blob(new),
+            self.get_control_blob(um_treeish)
+        )
+
+        ret = True
+        for missing_hunk in filter(
+            lambda x : not self.hunk_in_patch(x, actual_patch),
+            expected_patch.hunks
+        ):
+            error('Unable to find expected update-maintainer hunk:')
+            self.print_hunk(missing_hunk)
+            ret = False
+
+        if ret:
+            self.success('Verified that update-maintainer has been run')
+
+        return ret
+
+    def _check_versioning(self, commitish, expected_version):
+        version, _ = self.local_repo.get_changelog_versions_from_treeish(
+            commitish
+        )
+        if version != expected_version:
+            error('Version (%s) does not match expected version (%s)',
+                version, expected_version
+            )
+            return False
+        self.success('Verified that debian/changelog version is as expected')
+        return True
+
+    def _next_development_version(self, commitish):
+        # given a commitish, return the version object for the next development
+        # version
+        version, _ = self.local_repo.get_changelog_versions_from_treeish(
+            commitish
+        )
+        return next_development_version(debian.debian_support.Version(version))
+
+    def _next_sru_version(self, commitish):
+        # given a commitish, return the version object for the next development
+        # version
+        dist = self.local_repo.get_changelog_distribution_from_treeish(
+            commitish
+        )
+        if '-' in dist:
+            dist  = dist.split('-')[0]
+	# Don't need most arguments here as we're only grabbing some
+	# data from launchpad about the active series
+        ubuntu_source_information = GitUbuntuSourceInformation('ubuntu')
+
+        series = list(filter(lambda x : x.name == dist,
+            ubuntu_source_information.active_series
+        ))[0]
+
+        return next_sru_version(series, self.pkgname)
+
+    def do_merge_lint(self, old, new_base):
+        ret = True
+        namespace = self.user_remote_branch.split('/')[0]
+        # for now, assume pkg/ubuntu/devel and pkg/debian/sid are the merge
+        # points and that we can do this command. Ideally, we abstract the merge
+        # API into a better place
+        merge_base_id = str(self.local_repo.raw_repo.merge_base(
+            self.local_repo.get_commitish(old).id,
+            self.local_repo.get_commitish(new_base).id)
+        )
+        # 1) check if old/debian, old/ubuntu and new/debian point to what we
+        # expect - compare treeishs and commits
+        ret = self._check_commitish_exists_and_same('old/debian',
+            '%s/old/debian' % namespace, merge_base_id,
+            check_commit_id=True
+        )
+        ret = self._check_commitish_exists_and_same('old/ubuntu',
+            '%s/old/ubuntu' % namespace, old,
+            check_commit_id=True
+        )
+        ret = self._check_commitish_exists_and_same('new/debian',
+            '%s/new/debian' % namespace, new_base,
+            check_commit_id=True
+        )
+        old_ubuntu_version, _ = self.local_repo.get_changelog_versions_from_treeish(
+            old
+        )
+        old_ubuntu_tag_version = git_dep14_tag(old_ubuntu_version)
+        import_tag = 'pkg/import/%s' % old_ubuntu_tag_version
+
+        # 2) does reconstruct tag exist?
+        # 2a) does import tag treeish match reconstruct tag treeish?
+        reconstruct_tag = '%s/reconstruct/%s' % (
+            namespace, old_ubuntu_tag_version
+        )
+        if self._check_commitish_exists_and_same(import_tag, reconstruct_tag,
+           import_tag
+        ):
+           # 2b) does deconstruct tag exist?
+           # 2b1) does import tag treeish match deconstruct tag treeish?
+           deconstruct_tag = '%s/deconstruct/%s' % (
+               namespace, old_ubuntu_tag_version
+           )
+           ret = self._check_commitish_exists_and_same(
+               import_tag, deconstruct_tag, import_tag
+           )
+        else:
+           ret = False
+
+        # 3) does logical tag exist?
+        logical_tag = '%s/logical/%s' % (
+            namespace, old_ubuntu_tag_version
+        )
+        if self._check_commitish_exists(logical_tag):
+            # 3a) only lint further if 3.0
+            try:
+                with open('debian/source/format') as f:
+                    if '3.0 (quilt)' not in f.read():
+                        raise Exception('Not 3.0 (quilt)')
+                # 3b) is the only diff between logical tag and deconstruct tag
+                # in debian/changelog and update-maintainer in debian/control
+                diff = self.local_repo.raw_repo.diff(logical_tag, deconstruct_tag)
+                for patch in diff:
+                    if not self._check_deconstruct_to_logical_patch(patch):
+                        ret = False
+            except:
+                warning('cannot lint logical tag since source '
+                    'format is not 3.0 (quilt).'
+                )
+        else:
+            ret = False
+        # result of running merge-changelogs on the new_base
+        new_merge_changelogs_treeish = self.treeish_after_merge_changelogs(
+            old, new_base
+        )
+        # 4) has merge-changelogs been run?
+        # 5) does changelog in new branch only have add hunks, and only at the
+        # top relative to new/debian, relative to merge-changelogs result
+        ret = self._check_changelog_addition(
+            new_merge_changelogs_treeish, self.commitish
+        )
+        # 6) has update-maintainer been run?
+        new_update_maintainer_treeish = self.treeish_after_update_maintainer(
+            new_base
+        )
+        ret = self._check_update_maintainer(
+            new_base, new_update_maintainer_treeish, self.commitish
+        )
+        # 7) does versioning make sense?
+        ret = self._check_versioning(
+            self.commitish, self._next_development_version(new_base)
+        )
+        # 8) TODO: list old logical delta for convenience
+        # 9) TODO: list new logical delta for convenience
+        # 10) TODO: compare side-by-side for delta we can determine has been
+        # carried
+        # forward
+        # 11) TODO: compare side-by-side for delta we cannot find any longer
+        # 12) TODO: compare side-by-side for delta that is new
+
+    def do_change_lint(self):
+        ret = True
+        dist = self.local_repo.get_changelog_distribution_from_treeish(self.commitish)
+	# Don't need most arguments here as we're only grabbing some
+	# data from launchpad about the active series
+        ubuntu_source_information = GitUbuntuSourceInformation('ubuntu')
+        # 1) does changelog in new branch only have additions at the top
+        # relative to target
+        ret = self._check_changelog_addition(
+            self.pkg_remote_branch, self.commitish
+        )
+        # 2) does versioning make sense?
+        if dist in ['devel', ubuntu_source_information.active_series_name_list[0]]:
+            ret = self._check_versioning(self.commitish,
+                self._next_development_version('pkg/ubuntu/devel')
+            )
+        elif dist in ubuntu_source_information.stable_series_name_list:
+            ret = self._check_versioning(self.commitish,
+                self._next_sru_version(self.pkg_remote_branch)
+            )
+        else:
+            error('Targetted distribution (%s) is not active', dist)
+            ret = False
+        # 3) has update-maintainer been run?
+        new_update_maintainer_treeish = self.treeish_after_update_maintainer(
+            self.pkg_remote_branch
+        )
+        ret = self._check_update_maintainer(
+            self.pkg_remote_branch, new_update_maintainer_treeish, self.commitish
+        )
+        return ret
+
+    def main(self, args):
+        # git ubuntu clone <pkgname>
+        # cd <pkgname>
+        # git ubuntu remote add <coworker>
+        # git checkout <coworker>/<branch>
+        # git ubuntu lint
+        # assume repository already exists
+        logging.basicConfig(level=logging.DEBUG,
+                            format='%(asctime)s - %(levelname)s:%(message)s',
+                            datefmt='%m/%d/%Y %H:%M:%S',
+                           )
+        self.directory = args.directory
+        self.local_repo = GitUbuntuRepository(self.directory)
+        self.pullfile = args.pullfile
+        self.verbose = args.verbose
+
+        if args.commitish:
+            try:
+                commitish_obj = self.local_repo.get_commitish(args.commitish)
+                self.commitish = args.commitish
+            except Exception as e:
+                logging.error('%s is not a defined object in this git '
+                              'repository: %s', args.commitish, e
+                             )
+                sys.exit(1)
+        else:
+            commitish_obj = self.local_repo.raw_repo.head
+            self.commitish = 'HEAD'
+        self.commitish_id = str(commitish_obj.id)
+
+        try:
+            self.user_remote_branch = self.local_repo.nearest_remote_branch(self.commitish)
+        except Exception as e:
+            logging.error('Unable to automatically determine target branch: '
+                '%s. Please pass --lint-namespace.', e
+            )
+            sys.exit(1)
+
+        self.pkgname = self.local_repo.get_changelog_srcpkg_from_treeish(self.commitish)
+
+        if args.target_branch:
+            self.pkg_remote_branch = args.target_branch
+        else:
+            try:
+                self.pkg_remote_branch = self.local_repo.nearest_remote_branch(
+                    self.commitish, 'pkg'
+                )
+            except Exception as e:
+                logging.error('Unable to automatically determine importer '
+                    'branch: %s.', e
+                )
+                sys.exit(1)
+
+        if 'debian' in self.pkg_remote_branch:
+            lint_pass = self.do_merge_lint('pkg/ubuntu/devel', 'pkg/debian/sid')
+        else:
+            lint_pass = self.do_change_lint()
+
+        if lint_pass:
+            print("All lint checks passed")
+        else:
+            print("Some lint checks failed. Please investigate.")
diff --git a/gitubuntu/logging.py b/gitubuntu/logging.py
new file mode 100644
index 0000000..376567f
--- /dev/null
+++ b/gitubuntu/logging.py
@@ -0,0 +1,12 @@
+import sys
+
+
+def warning(m, *args):
+    print('W:', m % args)
+
+def error(m, *args):
+    print('E:', m % args)
+
+def fatal(m, *args):
+    print('F:', m % args)
+    sys.exit(2)
diff --git a/gitubuntu/merge.py b/gitubuntu/merge.py
index a6f7195..4b3110f 100644
--- a/gitubuntu/merge.py
+++ b/gitubuntu/merge.py
@@ -195,8 +195,8 @@ class GitUbuntuMerge:
 	    # Don't need most arguments here as we're only grabbing some
 	    # data from launchpad about the active series
             ubuntu_source_information = GitUbuntuSourceInformation('ubuntu',
-                None, os.path.abspath(self.pullfile), None, None)
-            distribution = ubuntu_source_information.active_series_list[0]
+                None)
+            distribution = ubuntu_source_information.active_series_name_list[0]
         run(['dch', '--force-distribution', '--distribution',
              distribution, 'PLACEHOLDER'])
         with tempfile.NamedTemporaryFile(mode='w+t', delete=False) as fp:
@@ -367,8 +367,10 @@ class GitUbuntuMerge:
             logging.error(decode_binary(cp.stdout))
             sys.exit(1)
  
-        merge_base_id = self.local_repo.merge_base(self.onto_obj.id,
-                                                   self.commitish_obj.id)
+        merge_base_id = self.local_repo.raw_repo.merge_base(
+            self.onto_obj.id,
+            self.commitish_obj.id
+        )
         if merge_base_id is None:
             logging.error('Unable to find a common ancestor for '
                           '%s and %s.', self.onto, self.commitish)
diff --git a/gitubuntu/remote.py b/gitubuntu/remote.py
index 64e872f..bcd3b6d 100644
--- a/gitubuntu/remote.py
+++ b/gitubuntu/remote.py
@@ -68,7 +68,7 @@ class GitUbuntuRemote:
             self.local_repo.fetch_remote(self.remote_name, must_exist=False)
 
         logging.debug("added remote '%s' -> %s", self.remote_name,
-                      self.local_repo.remotes[self.remote_name].url)
+                      self.local_repo.raw_repo.remotes[self.remote_name].url)
 
     def main(self, args):
         self.user = args.user
diff --git a/gitubuntu/source_information.py b/gitubuntu/source_information.py
index 3177674..60a9eab 100644
--- a/gitubuntu/source_information.py
+++ b/gitubuntu/source_information.py
@@ -239,12 +239,13 @@ class NoPublicationHistoryException(Exception):
 
 # An abstraction of an information source about source packages
 class GitUbuntuSourceInformation(object):
-    _series_list = None
+    _active_series_list = None
+    _stable_series_list = None
 
-    def __init__(self, dist_name, pkgname,
-                 pull_overrides_filename,
-                 retries,
-                 retry_backoffs
+    def __init__(self, dist_name, pkgname=None,
+                 pull_overrides_filename='/dev/null',
+                 retries=0,
+                 retry_backoffs=[]
                 ):
         self.launchpad = launchpad_login()
         self.dist_name = dist_name
@@ -278,27 +279,37 @@ class GitUbuntuSourceInformation(object):
             return False
 
     @property
-    def active_series_list(self):
+    def active_series(self):
         if self.dist_name.startswith('ppa:'):
             return []
         # return a list of series names sorted with newest first.
-        if self._series_list is None:
-            _series = sorted([r for r in self.dist.series if r.active],
-                             key=lambda s: float(s.version), reverse=True)
-            self._series_list = [r.name for r in _series]
-        return self._series_list
+        if self._active_series_list is None:
+            self._active_series_list = sorted(
+                [r for r in self.dist.series if r.active],
+                key=lambda s: float(s.version), reverse=True
+            )
+        return self._active_series_list
 
     @property
-    def stable_series_list(self):
+    def stable_series(self):
         if self.dist_name.startswith('ppa:'):
             return []
         # return a list of released series names sorted with newest first.
-        if self._series_list is None:
-            _series = sorted([r for r in self.dist.series if r.active and
-                              r.status in ('Current Stable Release', 'Supported')],
-                             key=lambda s: float(s.version), reverse=True)
-            self._series_list = [r.name for r in _series]
-        return self._series_list
+        if self._stable_series_list is None:
+            self._stable_series_list = sorted(
+                [r for r in self.dist.series if r.active and
+                 r.status in ('Current Stable Release', 'Supported')],
+                key=lambda s: float(s.version), reverse=True
+            )
+        return self._stable_series_list
+
+    @property
+    def active_series_name_list(self):
+        return [r.name for r in self.active_series]
+
+    @property
+    def stable_series_name_list(self):
+        return [r.name for r in self.stable_series]
 
     def get_corrected_spi(self, srcpkg, workdir=None):
        try:
@@ -313,7 +324,7 @@ class GitUbuntuSourceInformation(object):
            dsc=dsc, files=files)
 
     def launchpad_versions_published(self, workdir=None,
-        sorted_by_version=False
+        sorted_by_version=False, series=None
     ):
         args = {
                 'exact_match':True,
@@ -321,6 +332,8 @@ class GitUbuntuSourceInformation(object):
                }
         if not sorted_by_version:
             args['order_by_date'] = True
+        if series:
+            args['distro_series'] = series
 
         spph = self.archive.getPublishedSources(**args)
         if len(spph) == 0:
@@ -381,7 +394,7 @@ class GitUbuntuSourceInformation(object):
                  in seen_versions:
                 continue
             spi = self.get_corrected_spi(srcpkg, workdir)
-            if active_series_only and spi.series.name.lower() not in self.active_series_list:
+            if active_series_only and spi.series.name.lower() not in self.active_series_name_list:
                 continue
             seen_versions.append(
                 (
diff --git a/gitubuntu/submit.py b/gitubuntu/submit.py
index 8b71496..f68dea3 100644
--- a/gitubuntu/submit.py
+++ b/gitubuntu/submit.py
@@ -35,17 +35,10 @@ class GitUbuntuSubmit:
         else:
             parser = argparse.ArgumentParser(**kwargs)
 
-        parser.add_argument('--release', type=str,
-            help='Release to target with merge proposal. If not '
-                 'specified, the release from debian/changelog is used. '
-                 'To propose an Ubuntu merge to Debian experimental, for '
-                 'example, this would be "experimental". To propose an Ubuntu '
-                 'bugfix to Xenial, this would be "xenial".'
-        )
-        parser.add_argument('--for-merge', action='store_true',
-            help='Specify the merge proposal is for an Ubuntu merge. This '
-                 'will default to using debian/sid as the target. If another '
-                 'Debian release should be used, specify it with --release.'
+        parser.add_argument('--target-branch', type=str,
+            help='Branch to target with merge proposal. If not specified, '
+                 'the nearest remote branch to the current branch, '
+                 'if unique, is used.'
         )
         parser.add_argument('--reviewer', action='append',
             help='Specify reviewers for the proposed merge. This '
@@ -81,7 +74,6 @@ class GitUbuntuSubmit:
         self.directory = args.directory
         self.force = args.force
         self.pullfile = args.pullfile
-        self.release = args.release
         self.target_user = args.target_user
         try:
             self.user = args.lp_user
@@ -98,10 +90,10 @@ class GitUbuntuSubmit:
                     args.branch
                 )
         else:
-            if self.local_repo.head_is_detached:
+            if self.local_repo.raw_repo.head_is_detached:
                 logging.error("Please create a local branch before submitting.")
                 sys.exit(1)
-            self.source_branch = self.local_repo.head.name
+            self.source_branch = self.local_repo.raw_repo.head.name
 
         logging.debug("source branch: %s", self.source_branch)
 
@@ -109,6 +101,26 @@ class GitUbuntuSubmit:
 
         logging.debug("source package: %s", self.pkgname)
 
+        if args.target_branch and args.target_user:
+            target_head = args.target_branch
+        else:
+            if args.target_user == 'usd-import-team':
+                namespace = 'pkg'
+            else:
+                namespace = args.target_user
+            try:
+                target_head = self.local_repo.nearest_remote_branch(
+                    'HEAD', namespace=namespace
+                )
+                target_head = target_head[len('pkg')+1:]
+            except e:
+                logging.error('Unable to automatically determine target branch: '
+                    '%s. Please pass --target-branch.', e
+                )
+                sys.exit(1)
+
+        logging.debug("target branch: %s", target_head)
+
         if not args.no_push:
             try:
                 # the refspec is specific because we may not be on the source
@@ -123,15 +135,6 @@ class GitUbuntuSubmit:
                 )
                 sys.exit(1)
 
-        if self.for_merge:
-            release = self.release if self.release else 'sid'
-            target_head = 'debian/%s' % release
-        else:
-            release = self.release if self.release else self.local_repo.get_changelog_distribution_from_treeish('HEAD')
-            target_head = 'ubuntu/%s-devel' % release
-
-        logging.debug("target release: %s", target_head)
-
         lp = launchpad_login_auth()
 
         # get target git_ref object
diff --git a/gitubuntu/tag.py b/gitubuntu/tag.py
index fcb4a0b..001e3d6 100644
--- a/gitubuntu/tag.py
+++ b/gitubuntu/tag.py
@@ -105,7 +105,7 @@ class GitUbuntuTag:
                          )
             sys.exit(1)
 
-        if len(self.local_repo.status()) != 0:
+        if len(self.local_repo.raw_repo.status()) != 0:
             logging.error('Working tree must be clean to continue.')
             sys.exit(1)
  
diff --git a/gitubuntu/versioning.py b/gitubuntu/versioning.py
new file mode 100644
index 0000000..3cea548
--- /dev/null
+++ b/gitubuntu/versioning.py
@@ -0,0 +1,200 @@
+import copy
+import logging
+import re
+import sys
+from gitubuntu.source_information import GitUbuntuSourceInformation
+
+try:
+    pkg = 'python3-pytest'
+    import pytest
+    pkg = 'python3-debian'
+    import debian
+except ImportError:
+    logging.error('Is %s installed?', pkg)
+    sys.exit(1)
+
+def _decompose_version_string(version_string):
+    """Return the "Ubuntu"-relevant parts of a version string
+
+    Returns a 3-tuple of (prefix_parts, ubuntu_maj, ubuntu_min), throwing away
+    some information.
+
+    prefix_parts is a list of separated string parts forming the first
+    "non-Ubuntu" part of the string, to which Ubuntu-specific version parts
+    might be appended. This excludes any "build" and subsequent parts, as they
+    are not relevant to version bumping. This also excludes any "ubuntu" and
+    subseqent parts, as the necessary information there is encoded using
+    ubuntu_maj and ubuntu_min instead.
+
+    ubuntu_maj is the "major" Ubuntu version number as an integer, or None if
+    not present. For example, in the version strings "1.0-2ubuntu3" and
+    "1.0-2ubuntu3.4", 3 is the major Ubuntu version number in both cases. In
+    "1.0-2", the major Ubuntu version number is not present.
+
+    ubuntu_series is the "series" in the Ubuntu version number as a string, or
+    None if not present. For example, in the version string
+    "1.0.2ubuntu3.17.04.4", 17.04 is the Ubuntu series string. In both
+    "1.0-2ubuntu3.4" and "1.0-2", the Ubuntu series is not present.
+
+    ubuntu_min is the "minor" Ubuntu version number as an integer, or None if
+    not present. For example, in the version strings "1.0-2ubuntu3.4" and
+    "1.0-2ubuntu3.17.04.4", 4 is the Ubuntu minor version number. In both
+    "1.0-2" and "1.0-2ubuntu3", the minor Ubuntu version number is not present.
+
+    For version strings not following these standard forms, the result is
+    undefined except where specific test cases exist for them.
+    """
+
+    parts = [
+        part
+        for part in
+        debian.debian_support.NativeVersion.re_all_digits_or_not.findall(version_string)
+    ]
+
+    if 'build' in parts and 'ubuntu' in parts:
+        raise ValueError("Not sure how to decompose %s" % version_string)
+    elif 'build' in parts:
+        return parts[:parts.index('build')], None, None
+    elif 'ubuntu' in parts:
+        ubuntu_idx = parts.index('ubuntu')
+        static_parts = parts[:ubuntu_idx]
+        suffix_parts = parts[ubuntu_idx+1:]
+        try:
+            ubuntu_maj = int(suffix_parts[0])
+        except IndexError:
+            # nothing after "Xubuntu", treated as 1
+            ubuntu_maj = 1
+        ubuntu_series = None
+        if len(suffix_parts) < 2:
+            ubuntu_min = None
+        else:
+            try:
+                ubuntu_min = int(suffix_parts[-1])
+                if len(suffix_parts) > 2:
+                    ubuntu_series = ''.join(suffix_parts[2:-2])
+                    if not re.match(r'\d\d\.\d\d', ubuntu_series): 
+                        ubuntu_series = None
+            except ValueError:
+                ubuntu_min = None
+        return static_parts, ubuntu_maj, ubuntu_series, ubuntu_min
+    else:
+        return parts, None, None, None
+
+
+def _bump_version_object(old_version_object, bump_function):
+    """Return a new Version object with the correct attribute bumped
+
+    Native packages need to have their debian_version bumped; conversely
+    non-native packages need to have their upstream_version bumped with their
+    debian_version staying the same. The bumping mechanism is the same either
+    way. This function handles this by working out which is needed, calling
+    bump_function with the old version string to return a bumped attribute
+    string, and creating a new Version object with the required attributed
+    bumped accordingly.
+    """
+
+    if old_version_object.debian_version is None:
+        bump_attr = 'upstream_version'
+    else:
+        bump_attr = 'debian_version'
+
+    old_version_string = getattr(old_version_object, bump_attr)
+    new_version_string = bump_function(old_version_string)
+    new_version_object = copy.deepcopy(old_version_object)
+    setattr(new_version_object, bump_attr, new_version_string)
+    return new_version_object
+
+
+def _bump_development_version_string(version):
+    static_parts, old_ubuntu_maj, _, _ = _decompose_version_string(version)
+
+    new_ubuntu_maj = 1 if old_ubuntu_maj is None else old_ubuntu_maj + 1
+    new_parts = static_parts + ['ubuntu', str(new_ubuntu_maj)]
+
+    return ''.join(new_parts)
+
+
+def _bump_sru_version_string(version):
+    static_parts, old_maj, series, old_min = _decompose_version_string(version)
+
+    new_maj = 0 if old_maj is None else old_maj
+    new_min = 1 if old_min is None else old_min + 1
+
+    bumped_parts = ['ubuntu', str(new_maj), '.']
+    if series:
+        bumped_parts.extend([series, '.'])
+    bumped_parts.append(str(new_min))
+
+    return ''.join(static_parts + bumped_parts)
+
+
+def next_development_version(version):
+    return _bump_version_object(version, _bump_development_version_string)
+
+
+def _next_sru_version(before, series, current, after):
+    return _bump_version_object(current, _bump_sru_version_string)
+
+
+def max_version(lp_series, pkgname):
+    ubuntu_source_information = GitUbuntuSourceInformation('ubuntu', pkgname)
+    for spi in ubuntu_source_information.launchpad_versions_published(
+        sorted_by_version=True, series=lp_series
+    ):
+        return debian.debian_support.Version(spi.version)
+
+
+def next_sru_version(series, pkgname):
+    # for a series extract the required parameters
+    ubuntu_source_information = GitUbuntuSourceInformation('ubuntu')
+    active_series = ubuntu_source_information.active_series
+    before = [max_version(before_series, pkgname)
+        for before_series in active_series 
+        if float(before_series.version) < float(series.version)
+    ]
+    after = [max_version(after_series, pkgname)
+        for after_series in active_series 
+        if float(after_series.version) > float(series.version)
+    ]
+    current = max_version(series, pkgname)
+    return _next_sru_version(before, series, current, after)
+
[e-mail]('test_input, expected', [
+    ('2', (['2'], None, None)),
+    ('2ubuntu1', (['2'], 1, None)),
+    ('2ubuntu1.3', (['2'], 1, 3)),
+    ('2ubuntu0.16.04.3', (['2'], 0, 3)),
+    ('2build1', (['2'], None, None)),
+    ('2build1.3', (['2'], None, None)),
+])
+def test_decompose_version_string(test_input, expected):
+    assert _decompose_version_string(test_input) == expected
+
+
[e-mail]('test_input, expected', [
+    ('1.0-2', '1.0-2ubuntu1'),
+    ('1.0-2ubuntu1', '1.0-2ubuntu2'),
+    ('1.0-2ubuntu1.3', '1.0-2ubuntu2'),
+    ('1.0-2ubuntu2', '1.0-2ubuntu3'),
+    ('1.0-2build1', '1.0-2ubuntu1'),
+    ('1', '1ubuntu1'),
+    ('1ubuntu2', '1ubuntu3'),
+    ('1.0-3ubuntu', '1.0-3ubuntu2'),
+])
+def test_next_development_version(test_input, expected):
+    assert next_development_version(
+        debian.debian_support.NativeVersion(test_input)
+    ) == expected
+
+
[e-mail]('before, series, current, after, expected', [
+    ([], '16.04', '1.0-1', [], '1.0-1ubuntu0.1'),
+    (['1.0-1'], '16.04', '1.0-1', [], '1.0-1ubuntu0.16.04.1'),
+])
+def test_next_sru_version(before, series, current, after, expected):
+    assert _next_sru_version(
+        before=[debian.debian_supported.NativeVersion(vstr) for vstr in before],
+        series=series,
+        current=debian.debian_supported.NativeVersion(current),
+        after=[debian.debian_supported.NativeVersion(vstr) for vstr in after],
+    ) == expected
diff --git a/snap/snapcraft.yaml b/snap/snapcraft.yaml
index ff86937..ae7b16b 100644
--- a/snap/snapcraft.yaml
+++ b/snap/snapcraft.yaml
@@ -31,6 +31,7 @@ parts:
          - python3-ubuntutools
          - python3-pkg-resources
          - python3-lazr.restfulclient
+         - python3-pytest
          - dpkg-dev
          - libdpkg-perl
          - git
diff --git a/wip/review b/wip/review
deleted file mode 100644
index 4a7416d..0000000
--- a/wip/review
+++ /dev/null
@@ -1,156 +0,0 @@
-#!/bin/sh
-set -e
-
-proposer_lpid=louis-bouchard
-package=clamav
-proposer_branch=merge
-
-reviewer_lpid=racb
-
-# Borrowed from usd-merge
-changelog_version()
-{
-    commit=$1
-    echo $(git show ${commit}:debian/changelog | dpkg-parsechangelog -l- -n1 -SVersion)
-}
-
-dsc_commit_version()
-{
-    version=$1
-    echo "${version}" | sed -e 's/~/_/g' -e 's/:/%/g'
-}
-
-commit_tag_exists()
-{
-    local result=0
-    git rev-parse -q --verify "$1" > /dev/null || result=$?
-    return $result
-}
-
-revs_match()
-{
-    local result=0
-    [ "$(git rev-parse "$1")" = "$(git rev-parse "$2")" ] || result=$?
-    return $result
-}
-
-source_format_is_3_0_quilt()
-{
-    local result
-    local fmt
-    result=0
-    fmt=$(git show "$1":debian/source/format 2>&1) || result=$?
-    if [ "$result" -eq 0 -a "$fmt" = "3.0 (quilt)" ]; then
-        return 0
-    else
-        return 1
-    fi
-}
-
-# Clone part
-
-mkdir "$package"
-mkdir "$package/git"
-cd "$package/git"
-
-git init
-# -text is needed to prevent CRLF mangling; see src:bouncycastle 1.51-4
-# -ident is needed to disable projects that enable it in .gitattributes like php7.0
-echo '* -text -ident' > .git/info/attributes
-
-git remote add lpusdi ssh://${reviewer_lpid}@git.launchpad.net/~usd-import-team/ubuntu/+source/$package
-git fetch lpusdi
-
-git branch debian/sid lpusdi/debian/sid
-git branch ubuntu/devel lpusdi/ubuntu/devel
-
-git remote add $proposer_lpid git://git.launchpad.net/~$proposer_lpid/ubuntu/+source/$package
-git config --add "remote.${proposer_lpid}.fetch" "+refs/tags/*:refs/tags/${proposer_lpid}/*"
-git config remote.$proposer_lpid.tagOpt --no-tags
-git fetch $proposer_lpid
-
-# Only makes sense if cloning
-git checkout $proposer_lpid/$proposer_branch
-
-# Not sure where this should go. In the case of
-# https://code.launchpad.net/~nacc/ubuntu/+source/sg3-utils/+git/sg3-utils/+merge/297686,
-# for example, I need to override it because it's a re-merge after an incorrect
-# sync. So this tool will correctly warn about this, but it should be possible
-# to use all other parts of the tool including the lint after this after the
-# reviewer fixes this up manually.
-
-usd merge --tag-only ubuntu/devel
-
-# Lint part
-
-
-# in
-# https://code.launchpad.net/~louis-bouchard/ubuntu/+source/clamav/+git/clamav/+merge/298630
-# proposed branch tip b130815, this produced the warning "Warning: tag
-# louis-bouchard/old/ubuntu does not match tag old/ubuntu". This is because the
-# Louis' tag pointed to the import into the release pocket, and usd-merge
-# pointed it to the import into the proposed pocket. The trees were identical.
-# So perhaps this check should check trees and not the commit itself? Or do we
-# need a stricter definition of what these tags shoud point to?
-
-for t in old/debian old/ubuntu; do
-    if ! commit_tag_exists $proposer_lpid/$t; then
-        echo "Warning: tag $t not found"
-    elif ! revs_match $t $proposer_lpid/$t; then
-        echo "Warning: tag $proposer_lpid/$t does not match tag $t"
-    fi
-done
-
-old_ubuntu_version_tag=$(dsc_commit_version $(changelog_version old/ubuntu))
-
-if ! commit_tag_exists "$proposer_lpid/reconstruct/$old_ubuntu_version_tag"; then
-    echo "Warning: tag $proposer_lpid/reconstruct/$old_ubuntu_version_tag does not exist"
-elif ! revs_match "import/${old_ubuntu_version_tag}^{tree}" "$proposer_lpid/reconstruct/${old_ubuntu_version_tag}^{tree}"; then
-    echo "Warning: import/$old_ubuntu_version_tag tree does not match $proposer_lpid/reconstruct/$old_ubuntu_version_tag"
-
-    if ! commit_tag_exists "$proposer_lpid/deconstruct/$old_ubuntu_version_tag"; then
-        echo "Warning: tag $proposer_lpid/deconstruct/$old_ubuntu_version_tag does not exist"
-    elif ! revs_match "import/${old_ubuntu_version_tag}^{tree}" "$proposer_lpid/deconstruct/${old_ubuntu_version_tag}^{tree}"; then
-        echo "Warning: import/$old_ubuntu_version_tag tree does not match $proposer_lpid/deconstruct/$old_ubuntu_version_tag"
-    fi
-fi
-
-echo "Warning: logical not checked against deconstruct yet"
-# No changes against deconstruct/<version> except:
-#   debian/changelog
-#   update-maintainer in debian/control
-#   If 3.0 (quilt), then anything not in debian/
-
-if ! commit_tag_exists "$proposer_lpid/logical/$old_ubuntu_version_tag"; then
-    echo "Warning: logical tag $proposer_lpid/logical/$old_ubuntu_version_tag does not appear to exist"
-elif ! source_format_is_3_0_quilt $proposer_lpid/logical/$old_ubuntu_version_tag; then
-    echo "Warning: cannot lint logical tag since format is not 3.0 (quilt)"
-else
-    # Can this be made cleaner?
-    actual_result=$(git diff --name-only $proposer_lpid/deconstruct/$old_ubuntu_version_tag $proposer_lpid/logical/$old_ubuntu_version_tag -- debian/|sort)
-    # Use /bin/echo to get -ne, which Bourne shell doesn't define
-    expected_result=$(/bin/echo -ne "debian/changelog\ndebian/control")
-    if [ "$actual_result" != "$expected_result" ]; then
-	echo "Warning: deconstruct differs from logical beyond just debian/control and debian/changelog"
-    fi
-
-    # TODO: this diff should only be "update-maintainer"
-    git diff $proposer_lpid/deconstruct/$old_ubuntu_version_tag $proposer_lpid/logical/$old_ubuntu_version_tag -- debian/control
-fi
-
-# TODO: check that logical doesn't change changelog
-
-# TODO: check debian/changelog between old/ubuntu and proposed merge only adds
-# changelog entries to the top
-PAGER=cat git diff old/ubuntu $proposer_lpid/$proposer_branch -- debian/changelog
-
-# TODO: check that merge-changelogs has been run
-# TODO: check that update-maintaner has been run
-
-# Shortcuts to view common things
-
-echo "Old logical delta:"
-echo git log -p --reverse old/debian..$proposer_lpid/logical/$old_ubuntu_version_tag
-
-echo "New logical delta:"
-echo git log -p --reverse new/debian..$proposer_lpid/$proposer_branch