diff --git a/NEWS b/NEWS
index eda6774a..9835ad21 100644
--- a/NEWS
+++ b/NEWS
@@ -1,1420 +1,1425 @@
 0.16.2	UNRELEASED
 
  IMPROVEMENTS
 
   * Fixed failing test-cases on windows.
     (Koen Martens)
 
+ API CHANGES
+
+  * Repo is now a context manager, so that it can be easily
+    closed using a ``with`` statement.
+
  TEST FIXES
 
   * Only run worktree list compat tests against git 2.7.0,
     when 'git worktree list' was introduced. (Jelmer Vernooij)
 
  BUG FIXES
 
   * Ignore filemode when building index when core.filemode
     is false.
     (Koen Martens)
 
   * Initialize core.filemode configuration setting by
     probing the filesystem for trustable permissions.
     (Koen Martens)
 
   * Fix ``porcelain.reset`` to respect the comittish argument.
     (Koen Martens)
 
   * Fix dulwich.porcelain.ls_remote() on Python 3.
     (#471, Jelmer Vernooij)
 
   * Allow both unicode and byte strings for host paths
     in dulwich.client. (#435, Jelmer Vernooij)
 
   * Add remote from porcelain.clone. (#466, Jelmer Vernooij)
 
 0.16.1	2016-12-25
 
  BUG FIXES
 
   * Fix python3 compatibility for dulwich.contrib.release_robot.
     (Jelmer Vernooij)
 
 0.16.0	2016-12-24
 
  IMPROVEMENTS
 
   * Add support for worktrees. See `git-worktree(1)` and
     `gitrepository-layout(5)`. (Laurent Rineau)
 
   * Add support for `commondir` file in Git control
     directories. (Laurent Rineau)
 
   * Add support for passwords in HTTP URLs.
     (Jon Bain, Mika Mäenpää)
 
   * Add `release_robot` script to contrib,
     allowing easy finding of current version based on Git tags.
     (Mark Mikofski)
 
   * Add ``Blob.splitlines`` method.
     (Jelmer Vernooij)
 
  BUG FIXES
 
   * Fix handling of ``Commit.tree`` being set to an actual
     tree object rather than a tree id. (Jelmer Vernooij)
 
   * Return remote refs from LocalGitClient.fetch_pack(),
     consistent with the documentation for that method.
     (#461, Jelmer Vernooij)
 
   * Fix handling of unknown URL schemes in get_transport_and_path.
     (#465, Jelmer Vernooij)
 
 0.15.0	2016-10-09
 
  BUG FIXES
 
   * Allow missing trailing LF when reading service name from
     HTTP servers. (Jelmer Vernooij, Andrew Shadura, #442)
 
   * Fix dulwich.porcelain.pull() on Python3. (Jelmer Vernooij, #451)
 
   * Properly pull in tags during dulwich.porcelain.clone.
     (Jelmer Vernooij, #408)
 
  CHANGES
 
   * Changed license from "GNU General Public License, version 2.0 or later"
     to "Apache License, version 2.0 or later or GNU General Public License,
     version 2.0 or later". (#153)
 
  IMPROVEMENTS
 
   * Add ``dulwich.porcelain.ls_tree`` implementation. (Jelmer Vernooij)
 
 0.14.1	2016-07-05
 
  BUG FIXES
 
   * Fix regression removing untouched refs when pushing over SSH.
     (Jelmer Vernooij #441)
 
   * Skip Python3 tests for SWIFT contrib module, as it has not yet
     been ported.
 
 0.14.0	2016-07-03
 
  BUG FIXES
 
   * Fix ShaFile.id after modification of a copied ShaFile.
     (Félix Mattrat, Jelmer Vernooij)
 
   * Support removing refs from porcelain.push.
     (Jelmer Vernooij, #437)
 
   * Stop magic protocol ref `capabilities^{}` from leaking out
     to clients. (Jelmer Vernooij, #254)
 
  IMPROVEMENTS
 
   * Add `dulwich.config.parse_submodules` function.
 
   * Add `RefsContainer.follow` method. (#438)
 
 0.13.0	2016-04-24
 
  IMPROVEMENTS
 
   * Support `ssh://` URLs in get_transport_and_path_from_url().
     (Jelmer Vernooij, #402)
 
   * Support missing empty line after headers in Git commits and tags.
     (Nicolas Dandrimont, #413)
 
   * Fix `dulwich.porcelain.status` when used in empty trees.
     (Jelmer Vernooij, #415)
 
   * Return copies of objects in MemoryObjectStore rather than
     references, making the behaviour more consistent with that of
     DiskObjectStore. (Félix Mattrat, Jelmer Vernooij)
 
   * Fix ``dulwich.web`` on Python3. (#295, Jonas Haag)
 
  CHANGES
 
   * Drop support for Python 2.6.
 
   * Fix python3 client web support. (Jelmer Vernooij)
 
  BUG FIXES
 
   * Fix hang on Gzip decompression. (Jonas Haag)
 
   * Don't rely on working tell() and seek() methods
     on wsgi.input. (Jonas Haag)
 
   * Support fastexport/fastimport functionality on python3 with newer
     versions of fastimport (>= 0.9.5). (Jelmer Vernooij, Félix Mattrat)
 
 0.12.0	2015-12-13
 
  IMPROVEMENTS
 
   * Add a `dulwich.archive` module that can create tarballs.
     Based on code from Jonas Haag in klaus.
 
   * Add a `dulwich.reflog` module for reading and writing reflogs.
     (Jelmer Vernooij)
 
   * Fix handling of ambiguous refs in `parse_ref` to make
     it match the behaviour described in https://git-scm.com/docs/gitrevisions.
     (Chris Bunney)
 
   * Support Python3 in C modules. (Lele Gaifax)
 
  BUG FIXES
 
   * Simplify handling of SSH command invocation.
     Fixes quoting of paths. Thanks, Thomas Liebetraut. (#384)
 
   * Fix inconsistent handling of trailing slashes for DictRefsContainer. (#383)
 
   * Add hack to support thin packs duing fetch(), albeit while requiring the
     entire pack file to be loaded into memory. (jsbain)
 
  CHANGES
 
   * This will be the last release to support Python 2.6.
 
 0.11.2	2015-09-18
 
  IMPROVEMENTS
 
   * Add support for agent= capability. (Jelmer Vernooij, #298)
 
   * Add support for quiet capability. (Jelmer Vernooij)
 
  CHANGES
 
   * The ParamikoSSHVendor class has been moved to
   * dulwich.contrib.paramiko_vendor, as it's currently untested.
     (Jelmer Vernooij, #364)
 
 0.11.1	2015-09-13
 
  Fix-up release to exclude broken blame.py file.
 
 0.11.0	2015-09-13
 
  IMPROVEMENTS
 
   * Extended Python3 support to most of the codebase.
     (Gary van der Merwe, Jelmer Vernooij)
   * The `Repo` object has a new `close` method that can be called to close any
     open resources. (Gary van der Merwe)
   * Support 'git.bat' in SubprocessGitClient on Windows.
     (Stefan Zimmermann)
   * Advertise 'ofs-delta' capability in receive-pack server side
     capabilities. (Jelmer Vernooij)
   * Switched `default_local_git_client_cls` to `LocalGitClient`.
     (Gary van der Merwe)
   * Add `porcelain.ls_remote` and `GitClient.get_refs`.
     (Michael Edgar)
   * Add `Repo.discover` method. (B. M. Corser)
   * Add `dulwich.objectspec.parse_refspec`. (Jelmer Vernooij)
   * Add `porcelain.pack_objects` and `porcelain.repack`.
     (Jelmer Vernooij)
 
  BUG FIXES
 
   * Fix handling of 'done' in graph walker and implement the
     'no-done' capability. (Tommy Yu, #88)
 
   * Avoid recursion limit issues resolving deltas. (William Grant, #81)
 
   * Allow arguments in local client binary path overrides.
     (Jelmer Vernooij)
 
   * Fix handling of commands with arguments in paramiko SSH
     client. (Andreas Klöckner, Jelmer Vernooij, #363)
 
   * Fix parsing of quoted strings in configs. (Jelmer Vernooij, #305)
 
 0.10.1  2015-03-25
 
  BUG FIXES
 
   * Return `ApplyDeltaError` when encountering delta errors
     in both C extensions and native delta application code.
     (Jelmer Vernooij, #259)
 
 0.10.0	2015-03-22
 
  BUG FIXES
 
   * In dulwich.index.build_index_from_tree, by default
     refuse to create entries that start with .git/.
 
   * Fix running of testsuite when installed.
     (Jelmer Vernooij, #223)
 
   * Use a block cache in _find_content_rename_candidates(),
     improving performance. (Mike Williams)
 
   * Add support for ``core.protectNTFS`` setting.
     (Jelmer Vernooij)
 
   * Fix TypeError when fetching empty updates.
     (Hwee Miin Koh)
 
   * Resolve delta refs when pulling into a MemoryRepo.
     (Max Shawabkeh, #256)
 
   * Fix handling of tags of non-commits in missing object finder.
     (Augie Fackler, #211)
 
   * Explicitly disable mmap on plan9 where it doesn't work.
     (Jeff Sickel)
 
  IMPROVEMENTS
 
   * New public method `Repo.reset_index`. (Jelmer Vernooij)
 
   * Prevent duplicate parsing of loose files in objects
     directory when reading. Thanks to David Keijser for the
     report. (Jelmer Vernooij, #231)
 
 0.9.9	2015-03-20
 
  SECURITY BUG FIXES
 
   * Fix buffer overflow in C implementation of pack apply_delta().
     (CVE-2015-0838)
 
     Thanks to Ivan Fratric of the Google Security Team for
     reporting this issue.
     (Jelmer Vernooij)
 
 0.9.8	2014-11-30
 
  BUG FIXES
 
   * Various fixes to improve test suite running on Windows.
     (Gary van der Merwe)
 
   * Limit delta copy length to 64K in v2 pack files. (Robert Brown)
 
   * Strip newline from final ACKed SHA while fetching packs.
     (Michael Edgar)
 
   * Remove assignment to PyList_SIZE() that was causing segfaults on
     pypy. (Jelmer Vernooij, #196)
 
  IMPROVEMENTS
 
   * Add porcelain 'receive-pack' and 'upload-pack'. (Jelmer Vernooij)
 
   * Handle SIGINT signals in bin/dulwich. (Jelmer Vernooij)
 
   * Add 'status' support to bin/dulwich. (Jelmer Vernooij)
 
   * Add 'branch_create', 'branch_list', 'branch_delete' porcelain.
     (Jelmer Vernooij)
 
   * Add 'fetch' porcelain. (Jelmer Vernooij)
 
   * Add 'tag_delete' porcelain. (Jelmer Vernooij)
 
   * Add support for serializing/deserializing 'gpgsig' attributes in Commit.
     (Jelmer Vernooij)
 
  CHANGES
 
   * dul-web is now available as 'dulwich web-daemon'.
     (Jelmer Vernooij)
 
   * dulwich.porcelain.tag has been renamed to tag_create.
     dulwich.porcelain.list_tags has been renamed to tag_list.
     (Jelmer Vernooij)
 
  API CHANGES
 
   * Restore support for Python 2.6. (Jelmer Vernooij, Gary van der Merwe)
 
 
 0.9.7	2014-06-08
 
  BUG FIXES
 
   * Fix tests dependent on hash ordering. (Michael Edgar)
 
   * Support staging symbolic links in Repo.stage.
     (Robert Brown)
 
   * Ensure that all files object are closed when running the test suite.
     (Gary van der Merwe)
 
   * When writing OFS_DELTA pack entries, write correct offset.
     (Augie Fackler)
 
   * Fix handler of larger copy operations in packs. (Augie Fackler)
 
   * Various fixes to improve test suite running on Windows.
     (Gary van der Merwe)
 
   * Fix logic for extra adds of identical files in rename detector.
     (Robert Brown)
 
  IMPROVEMENTS
 
   * Add porcelain 'status'. (Ryan Faulkner)
 
   * Add porcelain 'daemon'. (Jelmer Vernooij)
 
   * Add `dulwich.greenthreads` module which provides support
     for concurrency of some object store operations.
     (Fabien Boucher)
 
   * Various changes to improve compatibility with Python 3.
     (Gary van der Merwe, Hannu Valtonen, michael-k)
 
   * Add OpenStack Swift backed repository implementation
     in dulwich.contrib. See README.swift for details. (Fabien Boucher)
 
 API CHANGES
 
   * An optional close function can be passed to the Protocol class. This will
     be called by its close method. (Gary van der Merwe)
 
   * All classes with close methods are now context managers, so that they can
     be easily closed using a `with` statement. (Gary van der Merwe)
 
   * Remove deprecated `num_objects` argument to `write_pack` methods.
     (Jelmer Vernooij)
 
  OTHER CHANGES
 
   * The 'dul-daemon' script has been removed. The same functionality
     is now available as 'dulwich daemon'. (Jelmer Vernooij)
 
 0.9.6	2014-04-23
 
  IMPROVEMENTS
 
  * Add support for recursive add in 'git add'.
    (Ryan Faulkner, Jelmer Vernooij)
 
  * Add porcelain 'list_tags'. (Ryan Faulkner)
 
  * Add porcelain 'push'. (Ryan Faulkner)
 
  * Add porcelain 'pull'. (Ryan Faulkner)
 
  * Support 'http.proxy' in HttpGitClient.
    (Jelmer Vernooij, #1096030)
 
  * Support 'http.useragent' in HttpGitClient.
    (Jelmer Vernooij)
 
  * In server, wait for clients to send empty list of
    wants when talking to empty repository.
    (Damien Tournoud)
 
  * Various changes to improve compatibility with
    Python 3. (Gary van der Merwe)
 
  BUG FIXES
 
  * Support unseekable 'wsgi.input' streams.
    (Jonas Haag)
 
  * Raise TypeError when passing unicode() object
    to Repo.__getitem__.
    (Jonas Haag)
 
  * Fix handling of `reset` command in dulwich.fastexport.
    (Jelmer Vernooij, #1249029)
 
  * In client, don't wait for server to close connection
    first. Fixes hang when used against GitHub
    server implementation. (Siddharth Agarwal)
 
  * DeltaChainIterator: fix a corner case where an object is inflated as an
    object already in the repository.
    (Damien Tournoud, #135)
 
  * Stop leaking file handles during pack reload. (Damien Tournoud)
 
  * Avoid reopening packs during pack cache reload. (Jelmer Vernooij)
 
  API CHANGES
 
   * Drop support for Python 2.6. (Jelmer Vernooij)
 
 0.9.5	2014-02-23
 
  IMPROVEMENTS
 
  * Add porcelain 'tag'. (Ryan Faulkner)
 
  * New module `dulwich.objectspec` for parsing strings referencing
    objects and commit ranges. (Jelmer Vernooij)
 
  * Add shallow branch support. (milki)
 
  * Allow passing urllib2 `opener` into HttpGitClient.
    (Dov Feldstern, #909037)
 
  CHANGES
 
  * Drop support for Python 2.4 and 2.5. (Jelmer Vernooij)
 
  API CHANGES
 
  * Remove long deprecated ``Repo.commit``, ``Repo.get_blob``,
    ``Repo.tree`` and ``Repo.tag``. (Jelmer Vernooij)
 
  * Remove long deprecated ``Repo.revision_history`` and ``Repo.ref``.
    (Jelmer Vernooij)
 
  * Remove long deprecated ``Tree.entries``. (Jelmer Vernooij)
 
  BUG FIXES
 
  * Raise KeyError rather than TypeError when passing in
    unicode object of length 20 or 40 to Repo.__getitem__.
    (Jelmer Vernooij)
 
  * Use 'rm' rather than 'unlink' in tests, since the latter
    does not exist on OpenBSD and other platforms.
    (Dmitrij D. Czarkoff)
 
 0.9.4	2013-11-30
 
  IMPROVEMENTS
 
  * Add ssh_kwargs attribute to ParamikoSSHVendor. (milki)
 
  * Add Repo.set_description(). (Víðir Valberg Guðmundsson)
 
  * Add a basic `dulwich.porcelain` module. (Jelmer Vernooij, Marcin Kuzminski)
 
  * Various performance improvements for object access.
    (Jelmer Vernooij)
 
  * New function `get_transport_and_path_from_url`,
    similar to `get_transport_and_path` but only
    supports URLs.
    (Jelmer Vernooij)
 
  * Add support for file:// URLs in `get_transport_and_path_from_url`.
    (Jelmer Vernooij)
 
  * Add LocalGitClient implementation.
    (Jelmer Vernooij)
 
  BUG FIXES
 
   * Support filesystems with 64bit inode and device numbers.
     (André Roth)
 
  CHANGES
 
   * Ref handling has been moved to dulwich.refs.
     (Jelmer Vernooij)
 
  API CHANGES
 
   * Remove long deprecated RefsContainer.set_ref().
     (Jelmer Vernooij)
 
   * Repo.ref() is now deprecated in favour of Repo.refs[].
     (Jelmer Vernooij)
 
 FEATURES
 
   * Add support for graftpoints. (milki)
 
 0.9.3	2013-09-27
 
  BUG FIXES
 
   * Fix path for stdint.h in MANIFEST.in. (Jelmer Vernooij)
 
 0.9.2	2013-09-26
 
  BUG FIXES
 
   * Include stdint.h in MANIFEST.in (Mark Mikofski)
 
 0.9.1	2013-09-22
 
  BUG FIXES
 
   * Support lookups of 40-character refs in BaseRepo.__getitem__. (Chow Loong Jin, Jelmer Vernooij)
 
   * Fix fetching packs with side-band-64k capability disabled. (David Keijser, Jelmer Vernooij)
 
   * Several fixes in send-pack protocol behaviour - handling of empty pack files and deletes.
     (milki, #1063087)
 
   * Fix capability negotiation when fetching packs over HTTP.
     (#1072461, William Grant)
 
   * Enforce determine_wants returning an empty list rather than None. (Fabien Boucher, Jelmer Vernooij)
 
   * In the server, support pushes just removing refs. (Fabien Boucher, Jelmer Vernooij)
 
  IMPROVEMENTS
 
   * Support passing a single revision to BaseRepo.get_walker() rather than a list of revisions. 
     (Alberto Ruiz)
 
   * Add `Repo.get_description` method. (Jelmer Vernooij)
 
   * Support thin packs in Pack.iterobjects() and Pack.get_raw().
     (William Grant)
 
   * Add `MemoryObjectStore.add_pack` and `MemoryObjectStore.add_thin_pack` methods.
     (David Bennett)
 
   * Add paramiko-based SSH vendor. (Aaron O'Mullan)
 
   * Support running 'dulwich.server' and 'dulwich.web' using 'python -m'.
     (Jelmer Vernooij)
 
   * Add ObjectStore.close(). (Jelmer Vernooij)
 
   * Raise appropriate NotImplementedError when encountering dumb HTTP servers.
     (Jelmer Vernooij)
 
  API CHANGES
 
   * SSHVendor.connect_ssh has been renamed to SSHVendor.run_command.
     (Jelmer Vernooij)
 
   * ObjectStore.add_pack() now returns a 3-tuple. The last element will be an
     abort() method that can be used to cancel the pack operation.
     (Jelmer Vernooij)
 
 0.9.0	2013-05-31
 
  BUG FIXES
 
   * Push efficiency - report missing objects only. (#562676, Artem Tikhomirov)
 
   * Use indentation consistent with C Git in config files.
     (#1031356, Curt Moore, Jelmer Vernooij)
 
   * Recognize and skip binary files in diff function.
     (Takeshi Kanemoto)
 
   * Fix handling of relative paths in dulwich.client.get_transport_and_path.
     (Brian Visel, #1169368)
 
   * Preserve ordering of entries in configuration.
     (Benjamin Pollack)
 
   * Support ~ expansion in SSH client paths. (milki, #1083439)
 
   * Support relative paths in alternate paths.
     (milki, Michel Lespinasse, #1175007)
 
   * Log all error messages from wsgiref server to the logging module. This
     makes the test suit quiet again. (Gary van der Merwe)
 
   * Support passing None for empty tree in changes_from_tree.
     (Kevin Watters)
 
   * Support fetching empty repository in client. (milki, #1060462)
 
  IMPROVEMENTS:
 
   * Add optional honor_filemode flag to build_index_from_tree.
     (Mark Mikofski)
 
   * Support core/filemode setting when building trees. (Jelmer Vernooij)
 
   * Add chapter on tags in tutorial. (Ryan Faulkner)
 
  FEATURES
 
   * Add support for mergetags. (milki, #963525)
 
   * Add support for posix shell hooks. (milki)
 
 0.8.7	2012-11-27
 
  BUG FIXES
 
   * Fix use of alternates in ``DiskObjectStore``.{__contains__,__iter__}.
     (Dmitriy)
 
   * Fix compatibility with Python 2.4. (David Carr)
 
 0.8.6	2012-11-09
 
  API CHANGES
 
   * dulwich.__init__ no longer imports client, protocol, repo and
     server modules. (Jelmer Vernooij)
 
  FEATURES
 
   * ConfigDict now behaves more like a dictionary.
     (Adam 'Cezar' Jenkins, issue #58)
 
   * HTTPGitApplication now takes an optional
     `fallback_app` argument. (Jonas Haag, issue #67)
 
   * Support for large pack index files. (Jameson Nash)
 
  TESTING
 
   * Make index entry tests a little bit less strict, to cope with
     slightly different behaviour on various platforms.
     (Jelmer Vernooij)
 
   * ``setup.py test`` (available when setuptools is installed) now
     runs all tests, not just the basic unit tests.
     (Jelmer Vernooij)
 
  BUG FIXES
 
   * Commit._deserialize now actually deserializes the current state rather than
     the previous one. (Yifan Zhang, issue #59)
 
   * Handle None elements in lists of TreeChange objects. (Alex Holmes)
 
   * Support cloning repositories without HEAD set.
     (D-Key, Jelmer Vernooij, issue #69)
 
   * Support ``MemoryRepo.get_config``. (Jelmer Vernooij)
 
   * In ``get_transport_and_path``, pass extra keyword arguments on to
     HttpGitClient. (Jelmer Vernooij)
 
 0.8.5	2012-03-29
 
  BUG FIXES
 
   * Avoid use of 'with' in dulwich.index. (Jelmer Vernooij)
 
   * Be a little bit strict about OS behaviour in index tests.
     Should fix the tests on Debian GNU/kFreeBSD. (Jelmer Vernooij)
 
 0.8.4	2012-03-28
 
  BUG FIXES
 
   * Options on the same line as sections in config files are now supported.
     (Jelmer Vernooij, #920553)
 
   * Only negotiate capabilities that are also supported by the server.
     (Rod Cloutier, Risto Kankkunen)
 
   * Fix parsing of invalid timezone offsets with two minus signs.
     (Jason R. Coombs, #697828)
 
   * Reset environment variables during tests, to avoid
     test isolation leaks reading ~/.gitconfig. (Risto Kankkunen)
 
  TESTS
 
   * $HOME is now explicitly specified for tests that use it to read
     ``~/.gitconfig``, to prevent test isolation issues.
     (Jelmer Vernooij, #920330)
 
  FEATURES
 
   * Additional arguments to get_transport_and_path are now passed
     on to the constructor of the transport. (Sam Vilain)
 
   * The WSGI server now transparently handles when a git client submits data
     using Content-Encoding: gzip.
     (David Blewett, Jelmer Vernooij)
 
   * Add dulwich.index.build_index_from_tree(). (milki)
 
 0.8.3	2012-01-21
 
  FEATURES
 
   * The config parser now supports the git-config file format as
     described in git-config(1) and can write git config files.
     (Jelmer Vernooij, #531092, #768687)
 
   * ``Repo.do_commit`` will now use the user identity from
     .git/config or ~/.gitconfig if none was explicitly specified.
     (Jelmer Vernooij)
 
  BUG FIXES
 
   * Allow ``determine_wants`` methods to include the zero sha in their
     return value. (Jelmer Vernooij)
 
 0.8.2	2011-12-18
 
  BUG FIXES
 
   * Cope with different zlib buffer sizes in sha1 file parser.
     (Jelmer Vernooij)
 
   * Fix get_transport_and_path for HTTP/HTTPS URLs.
     (Bruno Renié)
 
   * Avoid calling free_objects() on NULL in error cases. (Chris Eberle)
 
   * Fix use --bare argument to 'dulwich init'. (Chris Eberle)
 
   * Properly abort connections when the determine_wants function
     raises an exception. (Jelmer Vernooij, #856769)
 
   * Tweak xcodebuild hack to deal with more error output.
     (Jelmer Vernooij, #903840)
 
  FEATURES
 
   * Add support for retrieving tarballs from remote servers.
     (Jelmer Vernooij, #379087)
 
   * New method ``update_server_info`` which generates data
     for dumb server access. (Jelmer Vernooij, #731235)
 
 0.8.1	2011-10-31
 
  FEATURES
 
   * Repo.do_commit has a new argument 'ref'.
 
   * Repo.do_commit has a new argument 'merge_heads'. (Jelmer Vernooij)
 
   * New ``Repo.get_walker`` method. (Jelmer Vernooij)
 
   * New ``Repo.clone`` method. (Jelmer Vernooij, #725369)
 
   * ``GitClient.send_pack`` now supports the 'side-band-64k' capability.
     (Jelmer Vernooij)
 
   * ``HttpGitClient`` which supports the smart server protocol over
     HTTP. "dumb" access is not yet supported. (Jelmer Vernooij, #373688)
 
   * Add basic support for alternates. (Jelmer Vernooij, #810429)
 
  CHANGES
 
   * unittest2 or python >= 2.7 is now required for the testsuite.
     testtools is no longer supported. (Jelmer Vernooij, #830713)
 
  BUG FIXES
 
   * Fix compilation with older versions of MSVC.  (Martin gz)
 
   * Special case 'refs/stash' as a valid ref. (Jelmer Vernooij, #695577)
 
   * Smart protocol clients can now change refs even if they are
     not uploading new data. (Jelmer Vernooij, #855993)
 
  * Don't compile C extensions when running in pypy.
    (Ronny Pfannschmidt, #881546)
 
  * Use different name for strnlen replacement function to avoid clashing
    with system strnlen. (Jelmer Vernooij, #880362)
 
  API CHANGES
 
   * ``Repo.revision_history`` is now deprecated in favor of ``Repo.get_walker``.
     (Jelmer Vernooij)
 
 0.8.0	2011-08-07
 
  FEATURES
 
   * New DeltaChainIterator abstract class for quickly iterating all objects in
     a pack, with implementations for pack indexing and inflation.
     (Dave Borowitz)
 
   * New walk module with a Walker class for customizable commit walking.
     (Dave Borowitz)
 
   * New tree_changes_for_merge function in diff_tree. (Dave Borowitz)
 
   * Easy rename detection in RenameDetector even without find_copies_harder.
     (Dave Borowitz)
 
  BUG FIXES
 
   * Avoid storing all objects in memory when writing pack.
     (Jelmer Vernooij, #813268)
 
   * Support IPv6 for git:// connections. (Jelmer Vernooij, #801543)
 
   * Improve performance of Repo.revision_history(). (Timo Schmid, #535118)
 
   * Fix use of SubprocessWrapper on Windows. (Paulo Madeira, #670035)
 
   * Fix compilation on newer versions of Mac OS X (Lion and up). (Ryan McKern, #794543)
 
   * Prevent raising ValueError for correct refs in RefContainer.__delitem__.
 
   * Correctly return a tuple from MemoryObjectStore.get_raw. (Dave Borowitz)
 
   * Fix a bug in reading the pack checksum when there are fewer than 20 bytes
     left in the buffer. (Dave Borowitz)
 
   * Support ~ in git:// URL paths. (Jelmer Vernooij, #813555)
 
   * Make ShaFile.__eq__ work when other is not a ShaFile. (Dave Borowitz)
 
   * ObjectStore.get_graph_walker() now no longer yields the same
     revision more than once. This has a significant improvement for
     performance when wide revision graphs are involved.
     (Jelmer Vernooij, #818168)
 
   * Teach ReceivePackHandler how to read empty packs. (Dave Borowitz)
 
   * Don't send a pack with duplicates of the same object. (Dave Borowitz)
 
   * Teach the server how to serve a clone of an empty repo. (Dave Borowitz)
 
   * Correctly advertise capabilities during receive-pack. (Dave Borowitz)
 
   * Fix add/add and add/rename conflicts in tree_changes_for_merge.
     (Dave Borowitz)
 
   * Use correct MIME types in web server. (Dave Borowitz)
 
  API CHANGES
 
   * write_pack no longer takes the num_objects argument and requires an object
     to be passed in that is iterable (rather than an iterator) and that
     provides __len__.  (Jelmer Vernooij)
 
   * write_pack_data has been renamed to write_pack_objects and no longer takes a
     num_objects argument. (Jelmer Vernooij)
 
   * take_msb_bytes, read_zlib_chunks, unpack_objects, and
     PackStreamReader.read_objects now take an additional argument indicating a
     crc32 to compute. (Dave Borowitz)
 
   * PackObjectIterator was removed; its functionality is still exposed by
     PackData.iterobjects. (Dave Borowitz)
 
   * Add a sha arg to write_pack_object to incrementally compute a SHA.
     (Dave Borowitz)
 
   * Include offset in PackStreamReader results. (Dave Borowitz)
 
   * Move PackStreamReader from server to pack. (Dave Borowitz)
 
   * Extract a check_length_and_checksum, compute_file_sha, and
     pack_object_header pack helper functions. (Dave Borowitz)
 
   * Extract a compute_file_sha function. (Dave Borowitz)
 
   * Remove move_in_thin_pack as a separate method; add_thin_pack now completes
     the thin pack and moves it in in one step. Remove ThinPackData as well.
     (Dave Borowitz)
 
   * Custom buffer size in read_zlib_chunks. (Dave Borowitz)
 
   * New UnpackedObject data class that replaces ad-hoc tuples in the return
     value of unpack_object and various DeltaChainIterator methods.
     (Dave Borowitz)
 
   * Add a lookup_path convenience method to Tree. (Dave Borowitz)
 
   * Optionally create RenameDetectors without passing in tree SHAs.
     (Dave Borowitz)
 
   * Optionally include unchanged entries in RenameDetectors. (Dave Borowitz)
 
   * Optionally pass a RenameDetector to tree_changes. (Dave Borowitz)
 
   * Optionally pass a request object through to server handlers. (Dave Borowitz)
 
  TEST CHANGES
 
   * If setuptools is installed, "python setup.py test" will now run the testsuite.
     (Jelmer Vernooij)
 
   * Add a new build_pack test utility for building packs from a simple spec.
     (Dave Borowitz)
 
   * Add a new build_commit_graph test utility for building commits from a
     simple spec. (Dave Borowitz)
 
 0.7.1	2011-04-12
 
  BUG FIXES
 
   * Fix double decref in _diff_tree.c. (Ted Horst, #715528)
 
   * Fix the build on Windows. (Pascal Quantin)
 
   * Fix get_transport_and_path compatibility with pre-2.6.5 versions of Python.
     (Max Bowsher, #707438)
 
   * BaseObjectStore.determine_wants_all no longer breaks on zero SHAs.
     (Jelmer Vernooij)
 
   * write_tree_diff() now supports submodules.
     (Jelmer Vernooij)
 
   * Fix compilation for XCode 4 and older versions of distutils.sysconfig.
     (Daniele Sluijters)
 
  IMPROVEMENTS
 
   * Sphinxified documentation. (Lukasz Balcerzak)
 
   * Add Pack.keep.(Marc Brinkmann)
 
  API CHANGES
 
   * The order of the parameters to Tree.add(name, mode, sha) has changed, and
     is now consistent with the rest of Dulwich. Existing code will still
     work but print a DeprecationWarning. (Jelmer Vernooij, #663550)
 
   * Tree.entries() is now deprecated in favour of Tree.items() and
     Tree.iteritems(). (Jelmer Vernooij)
 
 0.7.0	2011-01-21
 
  FEATURES
 
   * New `dulwich.diff_tree` module for simple content-based rename detection.
     (Dave Borowitz)
 
   * Add Tree.items(). (Jelmer Vernooij)
 
   * Add eof() and unread_pkt_line() methods to Protocol. (Dave Borowitz)
 
   * Add write_tree_diff(). (Jelmer Vernooij)
 
   * Add `serve_command` function for git server commands as executables.
     (Jelmer Vernooij)
 
   * dulwich.client.get_transport_and_path now supports rsync-style repository URLs.
     (Dave Borowitz, #568493)
 
  BUG FIXES
 
   * Correct short-circuiting operation for no-op fetches in the server.
     (Dave Borowitz)
 
   * Support parsing git mbox patches without a version tail, as generated by
     Mercurial.  (Jelmer Vernooij)
 
   * Fix dul-receive-pack and dul-upload-pack. (Jelmer Vernooij)
 
   * Zero-padded file modes in Tree objects no longer trigger an exception but
     the check code warns about them. (Augie Fackler, #581064)
 
   * Repo.init() now honors the mkdir flag. (#671159)
 
   * The ref format is now checked when setting a ref rather than when reading it back.
     (Dave Borowitz, #653527)
 
   * Make sure pack files are closed correctly. (Tay Ray Chuan)
 
  DOCUMENTATION
 
   * Run the tutorial inside the test suite. (Jelmer Vernooij)
 
   * Reorganized and updated the tutorial. (Jelmer Vernooij, Dave Borowitz, #610550,
      #610540)
 
 
 0.6.2	2010-10-16
 
  BUG FIXES
 
   * HTTP server correctly handles empty CONTENT_LENGTH. (Dave Borowitz)
 
   * Don't error when creating GitFiles with the default mode. (Dave Borowitz)
 
   * ThinPackData.from_file now works with resolve_ext_ref callback.
     (Dave Borowitz)
 
   * Provide strnlen() on mingw32 which doesn't have it. (Hans Kolek)
 
   * Set bare=true in the configuratin for bare repositories. (Dirk Neumann)
 
  FEATURES
 
   * Use slots for core objects to save up on memory. (Jelmer Vernooij)
 
   * Web server supports streaming progress/pack output. (Dave Borowitz)
 
   * New public function dulwich.pack.write_pack_header. (Dave Borowitz)
 
   * Distinguish between missing files and read errors in HTTP server.
     (Dave Borowitz)
 
   * Initial work on support for fastimport using python-fastimport.
     (Jelmer Vernooij)
 
   * New dulwich.pack.MemoryPackIndex class. (Jelmer Vernooij)
 
   * Delegate SHA peeling to the object store.  (Dave Borowitz)
 
  TESTS
 
   * Use GitFile when modifying packed-refs in tests. (Dave Borowitz)
 
   * New tests in test_web with better coverage and fewer ad-hoc mocks.
     (Dave Borowitz)
 
   * Standardize quote delimiters in test_protocol. (Dave Borowitz)
 
   * Fix use when testtools is installed. (Jelmer Vernooij)
 
   * Add trivial test for write_pack_header. (Jelmer Vernooij)
 
   * Refactor some of dulwich.tests.compat.server_utils. (Dave Borowitz)
 
   * Allow overwriting id property of objects in test utils. (Dave Borowitz)
 
   * Use real in-memory objects rather than stubs for server tests.
     (Dave Borowitz)
 
   * Clean up MissingObjectFinder. (Dave Borowitz)
 
  API CHANGES
 
   * ObjectStore.iter_tree_contents now walks contents in depth-first, sorted
     order. (Dave Borowitz)
 
   * ObjectStore.iter_tree_contents can optionally yield tree objects as well.
     (Dave Borowitz).
 
   * Add side-band-64k support to ReceivePackHandler. (Dave Borowitz)
 
   * Change server capabilities methods to classmethods. (Dave Borowitz)
 
   * Tweak server handler injection. (Dave Borowitz)
 
   * PackIndex1 and PackIndex2 now subclass FilePackIndex, which is 
     itself a subclass of PackIndex. (Jelmer Vernooij)
 
  DOCUMENTATION
 
   * Add docstrings for various functions in dulwich.objects. (Jelmer Vernooij)
 
   * Clean up docstrings in dulwich.protocol. (Dave Borowitz)
 
   * Explicitly specify allowed protocol commands to
     ProtocolGraphWalker.read_proto_line.  (Dave Borowitz)
 
   * Add utility functions to DictRefsContainer. (Dave Borowitz)
 
 
 0.6.1	2010-07-22
 
  BUG FIXES
 
   * Fix memory leak in C implementation of sorted_tree_items. (Dave Borowitz)
 
   * Use correct path separators for named repo files. (Dave Borowitz)
 
   * python > 2.7 and testtools-based test runners will now also pick up skipped
     tests correctly. (Jelmer Vernooij)
 
  FEATURES
 
   * Move named file initilization to BaseRepo. (Dave Borowitz)
 
   * Add logging utilities and git/HTTP server logging. (Dave Borowitz)
 
   * The GitClient interface has been cleaned up and instances are now reusable.
     (Augie Fackler)
 
   * Allow overriding paths to executables in GitSSHClient. 
     (Ross Light, Jelmer Vernooij, #585204)
 
   * Add PackBasedObjectStore.pack_loose_objects(). (Jelmer Vernooij)
 
  TESTS
 
   * Add tests for sorted_tree_items and C implementation. (Dave Borowitz)
 
   * Add a MemoryRepo that stores everything in memory. (Dave Borowitz)
 
   * Quiet logging output from web tests. (Dave Borowitz)
 
   * More flexible version checking for compat tests. (Dave Borowitz)
 
   * Compat tests for servers with and without side-band-64k. (Dave Borowitz)
 
  CLEANUP
 
   * Clean up file headers. (Dave Borowitz)
 
  TESTS
 
   * Use GitFile when modifying packed-refs in tests. (Dave Borowitz)
 
  API CHANGES
 
   * dulwich.pack.write_pack_index_v{1,2} now take a file-like object
     rather than a filename. (Jelmer Vernooij)
 
   * Make dul-daemon/dul-web trivial wrappers around server functionality.
     (Dave Borowitz)
 
   * Move reference WSGI handler to web.py. (Dave Borowitz)
 
   * Factor out _report_status in ReceivePackHandler. (Dave Borowitz)
 
   * Factor out a function to convert a line to a pkt-line. (Dave Borowitz)
 
 
 0.6.0	2010-05-22
 
 note: This list is most likely incomplete for 0.6.0.
 
  BUG FIXES
  
   * Fix ReceivePackHandler to disallow removing refs without delete-refs.
     (Dave Borowitz)
 
   * Deal with capabilities required by the client, even if they 
     can not be disabled in the server. (Dave Borowitz)
 
   * Fix trailing newlines in generated patch files.
     (Jelmer Vernooij)
 
   * Implement RefsContainer.__contains__. (Jelmer Vernooij)
 
   * Cope with \r in ref files on Windows. (
     http://github.com/jelmer/dulwich/issues/#issue/13, Jelmer Vernooij)
 
   * Fix GitFile breakage on Windows. (Anatoly Techtonik, #557585)
 
   * Support packed ref deletion with no peeled refs. (Augie Fackler)
 
   * Fix send pack when there is nothing to fetch. (Augie Fackler)
 
   * Fix fetch if no progress function is specified. (Augie Fackler)
 
   * Allow double-staging of files that are deleted in the index. 
     (Dave Borowitz)
 
   * Fix RefsContainer.add_if_new to support dangling symrefs.
     (Dave Borowitz)
 
   * Non-existant index files in non-bare repositories are now treated as 
     empty. (Dave Borowitz)
 
   * Always update ShaFile.id when the contents of the object get changed. 
     (Jelmer Vernooij)
 
   * Various Python2.4-compatibility fixes. (Dave Borowitz)
 
   * Fix thin pack handling. (Dave Borowitz)
  
  FEATURES
 
   * Add include-tag capability to server. (Dave Borowitz)
 
   * New dulwich.fastexport module that can generate fastexport 
     streams. (Jelmer Vernooij)
 
   * Implemented BaseRepo.__contains__. (Jelmer Vernooij)
 
   * Add __setitem__ to DictRefsContainer. (Dave Borowitz)
 
   * Overall improvements checking Git objects. (Dave Borowitz)
 
   * Packs are now verified while they are received. (Dave Borowitz)
 
  TESTS
 
   * Add framework for testing compatibility with C Git. (Dave Borowitz)
 
   * Add various tests for the use of non-bare repositories. (Dave Borowitz)
 
   * Cope with diffstat not being available on all platforms. 
     (Tay Ray Chuan, Jelmer Vernooij)
 
   * Add make_object and make_commit convenience functions to test utils.
     (Dave Borowitz)
 
  API BREAKAGES
 
   * The 'committer' and 'message' arguments to Repo.do_commit() have 
     been swapped. 'committer' is now optional. (Jelmer Vernooij)
 
   * Repo.get_blob, Repo.commit, Repo.tag and Repo.tree are now deprecated.
     (Jelmer Vernooij)
 
   * RefsContainer.set_ref() was renamed to RefsContainer.set_symbolic_ref(),
     for clarity. (Jelmer Vernooij)
 
  API CHANGES
 
   * The primary serialization APIs in dulwich.objects now work 
     with chunks of strings rather than with full-text strings. 
     (Jelmer Vernooij)
 
 0.5.02010-03-03
 
  BUG FIXES
 
   * Support custom fields in commits (readonly). (Jelmer Vernooij)
 
   * Improved ref handling. (Dave Borowitz)
 
   * Rework server protocol to be smarter and interoperate with cgit client.
     (Dave Borowitz)
 
   * Add a GitFile class that uses the same locking protocol for writes as 
     cgit. (Dave Borowitz)
 
   * Cope with forward slashes correctly in the index on Windows.
     (Jelmer Vernooij, #526793)
 
  FEATURES
 
   * --pure option to setup.py to allow building/installing without the C 
     extensions. (Hal Wine, Anatoly Techtonik, Jelmer Vernooij, #434326)
 
   * Implement Repo.get_config(). (Jelmer Vernooij, Augie Fackler)
 
   * HTTP dumb and smart server. (Dave Borowitz)
 
   * Add abstract baseclass for Repo that does not require file system 
     operations. (Dave Borowitz)
 
 0.4.1	2010-01-03
 
  FEATURES
 
   * Add ObjectStore.iter_tree_contents(). (Jelmer Vernooij)
 
   * Add Index.changes_from_tree(). (Jelmer Vernooij)
 
   * Add ObjectStore.tree_changes(). (Jelmer Vernooij)
 
   * Add functionality for writing patches in dulwich.patch.
     (Jelmer Vernooij)
 
 0.4.0	2009-10-07
 
  DOCUMENTATION
 
   * Added tutorial.
 
  API CHANGES
 
   * dulwich.object_store.tree_lookup_path will now return the mode and 
     sha of the object found rather than the object itself.
 
  BUG FIXES
 
   * Use binascii.hexlify / binascii.unhexlify for better performance.
 
   * Cope with extra unknown data in index files by ignoring it (for now).
 
   * Add proper error message when server unexpectedly hangs up. (#415843)
 
   * Correctly write opcode for equal in create_delta.
 
 0.3.3	2009-07-23
 
  FEATURES
 
   * Implement ShaFile.__hash__().
 
   * Implement Tree.__len__()
 
  BUG FIXES
   
   * Check for 'objects' and 'refs' directories
     when looking for a Git repository. (#380818)
 
 0.3.2	2009-05-20
 
  BUG FIXES
 
   * Support the encoding field in Commits.
   
   * Some Windows compatibility fixes.
 
   * Fixed several issues in commit support.
 
  FEATURES
 
   * Basic support for handling submodules.
 
 0.3.1	2009-05-13
 
  FEATURES
 
   * Implemented Repo.__getitem__, Repo.__setitem__ and Repo.__delitem__ to 
     access content.
 
  API CHANGES
 
   * Removed Repo.set_ref, Repo.remove_ref, Repo.tags, Repo.get_refs and 
     Repo.heads in favor of Repo.refs, a dictionary-like object for accessing
     refs.
 
  BUG FIXES
 
   * Removed import of 'sha' module in objects.py, which was causing 
     deprecation warnings on Python 2.6.
 
 0.3.0	2009-05-10
 
  FEATURES
 
   * A new function 'commit_tree' has been added that can commit a tree 
     based on an index.
 
  BUG FIXES
 
   * The memory usage when generating indexes has been significantly reduced.
  
   * A memory leak in the C implementation of parse_tree has been fixed.
 
   * The send-pack smart server command now works. (Thanks Scott Chacon)
 
   * The handling of short timestamps (less than 10 digits) has been fixed.
 
   * The handling of timezones has been fixed.
 
 0.2.1	2009-04-30
 
  BUG FIXES
 
   * Fix compatibility with Python2.4.
 
 0.2.0	2009-04-30
 
  FEATURES
 
   * Support for activity reporting in smart protocol client.
 
   * Optional C extensions for better performance in a couple of 
     places that are performance-critical.
 
 0.1.1	2009-03-13
 
  BUG FIXES
 
   * Fixed regression in Repo.find_missing_objects()
 
   * Don't fetch ^{} objects from remote hosts, as requesting them 
     causes a hangup.
 
   * Always write pack to disk completely before calculating checksum.
 
  FEATURES
 
   * Allow disabling thin packs when talking to remote hosts.
 
 0.1.0	2009-01-24
 
  * Initial release.
diff --git a/dulwich/repo.py b/dulwich/repo.py
index 4b6180ab..f1b58f59 100644
--- a/dulwich/repo.py
+++ b/dulwich/repo.py
@@ -1,1141 +1,1147 @@
 # repo.py -- For dealing with git repositories.
 # Copyright (C) 2007 James Westby <jw+debian@jameswestby.net>
 # Copyright (C) 2008-2013 Jelmer Vernooij <jelmer@samba.org>
 #
 # Dulwich is dual-licensed under the Apache License, Version 2.0 and the GNU
 # General Public License as public by the Free Software Foundation; version 2.0
 # or (at your option) any later version. You can redistribute it and/or
 # modify it under the terms of either of these two licenses.
 #
 # Unless required by applicable law or agreed to in writing, software
 # distributed under the License is distributed on an "AS IS" BASIS,
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
 #
 # You should have received a copy of the licenses; if not, see
 # <http://www.gnu.org/licenses/> for a copy of the GNU General Public License
 # and <http://www.apache.org/licenses/LICENSE-2.0> for a copy of the Apache
 # License, Version 2.0.
 #
 
 
 """Repository access.
 
 This module contains the base class for git repositories
 (BaseRepo) and an implementation which uses a repository on
 local disk (Repo).
 
 """
 
 from io import BytesIO
 import errno
 import os
 import sys
 import stat
 
 from dulwich.errors import (
     NoIndexPresent,
     NotBlobError,
     NotCommitError,
     NotGitRepository,
     NotTreeError,
     NotTagError,
     CommitError,
     RefFormatError,
     HookError,
     )
 from dulwich.file import (
     GitFile,
     )
 from dulwich.object_store import (
     DiskObjectStore,
     MemoryObjectStore,
     ObjectStoreGraphWalker,
     )
 from dulwich.objects import (
     check_hexsha,
     Blob,
     Commit,
     ShaFile,
     Tag,
     Tree,
     )
 
 from dulwich.hooks import (
     PreCommitShellHook,
     PostCommitShellHook,
     CommitMsgShellHook,
     )
 
 from dulwich.refs import (
     check_ref_format,
     RefsContainer,
     DictRefsContainer,
     InfoRefsContainer,
     DiskRefsContainer,
     read_packed_refs,
     read_packed_refs_with_peeled,
     write_packed_refs,
     SYMREF,
     )
 
 
 import warnings
 
 
 CONTROLDIR = '.git'
 OBJECTDIR = 'objects'
 REFSDIR = 'refs'
 REFSDIR_TAGS = 'tags'
 REFSDIR_HEADS = 'heads'
 INDEX_FILENAME = "index"
 COMMONDIR = 'commondir'
 GITDIR = 'gitdir'
 WORKTREES = 'worktrees'
 
 BASE_DIRECTORIES = [
     ["branches"],
     [REFSDIR],
     [REFSDIR, REFSDIR_TAGS],
     [REFSDIR, REFSDIR_HEADS],
     ["hooks"],
     ["info"]
     ]
 
 DEFAULT_REF = b'refs/heads/master'
 
 
 def parse_graftpoints(graftpoints):
     """Convert a list of graftpoints into a dict
 
     :param graftpoints: Iterator of graftpoint lines
 
     Each line is formatted as:
         <commit sha1> <parent sha1> [<parent sha1>]*
 
     Resulting dictionary is:
         <commit sha1>: [<parent sha1>*]
 
     https://git.wiki.kernel.org/index.php/GraftPoint
     """
     grafts = {}
     for l in graftpoints:
         raw_graft = l.split(None, 1)
 
         commit = raw_graft[0]
         if len(raw_graft) == 2:
             parents = raw_graft[1].split()
         else:
             parents = []
 
         for sha in [commit] + parents:
             check_hexsha(sha, 'Invalid graftpoint')
 
         grafts[commit] = parents
     return grafts
 
 
 def serialize_graftpoints(graftpoints):
     """Convert a dictionary of grafts into string
 
     The graft dictionary is:
         <commit sha1>: [<parent sha1>*]
 
     Each line is formatted as:
         <commit sha1> <parent sha1> [<parent sha1>]*
 
     https://git.wiki.kernel.org/index.php/GraftPoint
 
     """
     graft_lines = []
     for commit, parents in graftpoints.items():
         if parents:
             graft_lines.append(commit + b' ' + b' '.join(parents))
         else:
             graft_lines.append(commit)
     return b'\n'.join(graft_lines)
 
 
 class BaseRepo(object):
     """Base class for a git repository.
 
     :ivar object_store: Dictionary-like object for accessing
         the objects
     :ivar refs: Dictionary-like object with the refs in this
         repository
     """
 
     def __init__(self, object_store, refs):
         """Open a repository.
 
         This shouldn't be called directly, but rather through one of the
         base classes, such as MemoryRepo or Repo.
 
         :param object_store: Object store to use
         :param refs: Refs container to use
         """
         self.object_store = object_store
         self.refs = refs
 
         self._graftpoints = {}
         self.hooks = {}
 
     def _determine_file_mode(self):
         """Probe the file-system to determine whether permissions can be trusted.
 
         :return: True if permissions can be trusted, False otherwise.
         """
         raise NotImplementedError(self._determine_file_mode)
 
     def _init_files(self, bare):
         """Initialize a default set of named files."""
         from dulwich.config import ConfigFile
         self._put_named_file('description', b"Unnamed repository")
         f = BytesIO()
         cf = ConfigFile()
         cf.set(b"core", b"repositoryformatversion", b"0")
         if self._determine_file_mode():
             cf.set(b"core", b"filemode", True)
         else:
             cf.set(b"core", b"filemode", False)
 
         cf.set(b"core", b"bare", bare)
         cf.set(b"core", b"logallrefupdates", True)
         cf.write_to_file(f)
         self._put_named_file('config', f.getvalue())
         self._put_named_file(os.path.join('info', 'exclude'), b'')
 
     def get_named_file(self, path):
         """Get a file from the control dir with a specific name.
 
         Although the filename should be interpreted as a filename relative to
         the control dir in a disk-based Repo, the object returned need not be
         pointing to a file in that location.
 
         :param path: The path to the file, relative to the control dir.
         :return: An open file object, or None if the file does not exist.
         """
         raise NotImplementedError(self.get_named_file)
 
     def _put_named_file(self, path, contents):
         """Write a file to the control dir with the given name and contents.
 
         :param path: The path to the file, relative to the control dir.
         :param contents: A string to write to the file.
         """
         raise NotImplementedError(self._put_named_file)
 
     def open_index(self):
         """Open the index for this repository.
 
         :raise NoIndexPresent: If no index is present
         :return: The matching `Index`
         """
         raise NotImplementedError(self.open_index)
 
     def fetch(self, target, determine_wants=None, progress=None):
         """Fetch objects into another repository.
 
         :param target: The target repository
         :param determine_wants: Optional function to determine what refs to
             fetch.
         :param progress: Optional progress function
         :return: The local refs
         """
         if determine_wants is None:
             determine_wants = target.object_store.determine_wants_all
         target.object_store.add_objects(
             self.fetch_objects(determine_wants, target.get_graph_walker(),
                                progress))
         return self.get_refs()
 
     def fetch_objects(self, determine_wants, graph_walker, progress,
                       get_tagged=None):
         """Fetch the missing objects required for a set of revisions.
 
         :param determine_wants: Function that takes a dictionary with heads
             and returns the list of heads to fetch.
         :param graph_walker: Object that can iterate over the list of revisions
             to fetch and has an "ack" method that will be called to acknowledge
             that a revision is present.
         :param progress: Simple progress function that will be called with
             updated progress strings.
         :param get_tagged: Function that returns a dict of pointed-to sha -> tag
             sha for including tags.
         :return: iterator over objects, with __len__ implemented
         """
         wants = determine_wants(self.get_refs())
         if not isinstance(wants, list):
             raise TypeError("determine_wants() did not return a list")
 
         shallows = getattr(graph_walker, 'shallow', frozenset())
         unshallows = getattr(graph_walker, 'unshallow', frozenset())
 
         if wants == []:
             # TODO(dborowitz): find a way to short-circuit that doesn't change
             # this interface.
 
             if shallows or unshallows:
                 # Do not send a pack in shallow short-circuit path
                 return None
 
             return []
 
         # If the graph walker is set up with an implementation that can
         # ACK/NAK to the wire, it will write data to the client through
         # this call as a side-effect.
         haves = self.object_store.find_common_revisions(graph_walker)
 
         # Deal with shallow requests separately because the haves do
         # not reflect what objects are missing
         if shallows or unshallows:
             haves = []  # TODO: filter the haves commits from iter_shas.
                         # the specific commits aren't missing.
 
         def get_parents(commit):
             if commit.id in shallows:
                 return []
             return self.get_parents(commit.id, commit)
 
         return self.object_store.iter_shas(
           self.object_store.find_missing_objects(
               haves, wants, progress,
               get_tagged,
               get_parents=get_parents))
 
     def get_graph_walker(self, heads=None):
         """Retrieve a graph walker.
 
         A graph walker is used by a remote repository (or proxy)
         to find out which objects are present in this repository.
 
         :param heads: Repository heads to use (optional)
         :return: A graph walker object
         """
         if heads is None:
             heads = self.refs.as_dict(b'refs/heads').values()
         return ObjectStoreGraphWalker(heads, self.get_parents)
 
     def get_refs(self):
         """Get dictionary with all refs.
 
         :return: A ``dict`` mapping ref names to SHA1s
         """
         return self.refs.as_dict()
 
     def head(self):
         """Return the SHA1 pointed at by HEAD."""
         return self.refs[b'HEAD']
 
     def _get_object(self, sha, cls):
         assert len(sha) in (20, 40)
         ret = self.get_object(sha)
         if not isinstance(ret, cls):
             if cls is Commit:
                 raise NotCommitError(ret)
             elif cls is Blob:
                 raise NotBlobError(ret)
             elif cls is Tree:
                 raise NotTreeError(ret)
             elif cls is Tag:
                 raise NotTagError(ret)
             else:
                 raise Exception("Type invalid: %r != %r" % (
                   ret.type_name, cls.type_name))
         return ret
 
     def get_object(self, sha):
         """Retrieve the object with the specified SHA.
 
         :param sha: SHA to retrieve
         :return: A ShaFile object
         :raise KeyError: when the object can not be found
         """
         return self.object_store[sha]
 
     def get_parents(self, sha, commit=None):
         """Retrieve the parents of a specific commit.
 
         If the specific commit is a graftpoint, the graft parents
         will be returned instead.
 
         :param sha: SHA of the commit for which to retrieve the parents
         :param commit: Optional commit matching the sha
         :return: List of parents
         """
 
         try:
             return self._graftpoints[sha]
         except KeyError:
             if commit is None:
                 commit = self[sha]
             return commit.parents
 
     def get_config(self):
         """Retrieve the config object.
 
         :return: `ConfigFile` object for the ``.git/config`` file.
         """
         raise NotImplementedError(self.get_config)
 
     def get_description(self):
         """Retrieve the description for this repository.
 
         :return: String with the description of the repository
             as set by the user.
         """
         raise NotImplementedError(self.get_description)
 
     def set_description(self, description):
         """Set the description for this repository.
 
         :param description: Text to set as description for this repository.
         """
         raise NotImplementedError(self.set_description)
 
     def get_config_stack(self):
         """Return a config stack for this repository.
 
         This stack accesses the configuration for both this repository
         itself (.git/config) and the global configuration, which usually
         lives in ~/.gitconfig.
 
         :return: `Config` instance for this repository
         """
         from dulwich.config import StackedConfig
         backends = [self.get_config()] + StackedConfig.default_backends()
         return StackedConfig(backends, writable=backends[0])
 
     def get_peeled(self, ref):
         """Get the peeled value of a ref.
 
         :param ref: The refname to peel.
         :return: The fully-peeled SHA1 of a tag object, after peeling all
             intermediate tags; if the original ref does not point to a tag, this
             will equal the original SHA1.
         """
         cached = self.refs.get_peeled(ref)
         if cached is not None:
             return cached
         return self.object_store.peel_sha(self.refs[ref]).id
 
     def get_walker(self, include=None, *args, **kwargs):
         """Obtain a walker for this repository.
 
         :param include: Iterable of SHAs of commits to include along with their
             ancestors. Defaults to [HEAD]
         :param exclude: Iterable of SHAs of commits to exclude along with their
             ancestors, overriding includes.
         :param order: ORDER_* constant specifying the order of results. Anything
             other than ORDER_DATE may result in O(n) memory usage.
         :param reverse: If True, reverse the order of output, requiring O(n)
             memory.
         :param max_entries: The maximum number of entries to yield, or None for
             no limit.
         :param paths: Iterable of file or subtree paths to show entries for.
         :param rename_detector: diff.RenameDetector object for detecting
             renames.
         :param follow: If True, follow path across renames/copies. Forces a
             default rename_detector.
         :param since: Timestamp to list commits after.
         :param until: Timestamp to list commits before.
         :param queue_cls: A class to use for a queue of commits, supporting the
             iterator protocol. The constructor takes a single argument, the
             Walker.
         :return: A `Walker` object
         """
         from dulwich.walk import Walker
         if include is None:
             include = [self.head()]
         if isinstance(include, str):
             include = [include]
 
         kwargs['get_parents'] = lambda commit: self.get_parents(commit.id, commit)
 
         return Walker(self.object_store, include, *args, **kwargs)
 
     def __getitem__(self, name):
         """Retrieve a Git object by SHA1 or ref.
 
         :param name: A Git object SHA1 or a ref name
         :return: A `ShaFile` object, such as a Commit or Blob
         :raise KeyError: when the specified ref or object does not exist
         """
         if not isinstance(name, bytes):
             raise TypeError("'name' must be bytestring, not %.80s" %
                     type(name).__name__)
         if len(name) in (20, 40):
             try:
                 return self.object_store[name]
             except (KeyError, ValueError):
                 pass
         try:
             return self.object_store[self.refs[name]]
         except RefFormatError:
             raise KeyError(name)
 
     def __contains__(self, name):
         """Check if a specific Git object or ref is present.
 
         :param name: Git object SHA1 or ref name
         """
         if len(name) in (20, 40):
             return name in self.object_store or name in self.refs
         else:
             return name in self.refs
 
     def __setitem__(self, name, value):
         """Set a ref.
 
         :param name: ref name
         :param value: Ref value - either a ShaFile object, or a hex sha
         """
         if name.startswith(b"refs/") or name == b'HEAD':
             if isinstance(value, ShaFile):
                 self.refs[name] = value.id
             elif isinstance(value, bytes):
                 self.refs[name] = value
             else:
                 raise TypeError(value)
         else:
             raise ValueError(name)
 
     def __delitem__(self, name):
         """Remove a ref.
 
         :param name: Name of the ref to remove
         """
         if name.startswith(b"refs/") or name == b"HEAD":
             del self.refs[name]
         else:
             raise ValueError(name)
 
     def _get_user_identity(self):
         """Determine the identity to use for new commits.
         """
         config = self.get_config_stack()
         return (config.get((b"user", ), b"name") + b" <" +
                 config.get((b"user", ), b"email") + b">")
 
     def _add_graftpoints(self, updated_graftpoints):
         """Add or modify graftpoints
 
         :param updated_graftpoints: Dict of commit shas to list of parent shas
         """
 
         # Simple validation
         for commit, parents in updated_graftpoints.items():
             for sha in [commit] + parents:
                 check_hexsha(sha, 'Invalid graftpoint')
 
         self._graftpoints.update(updated_graftpoints)
 
     def _remove_graftpoints(self, to_remove=[]):
         """Remove graftpoints
 
         :param to_remove: List of commit shas
         """
         for sha in to_remove:
             del self._graftpoints[sha]
 
     def do_commit(self, message=None, committer=None,
                   author=None, commit_timestamp=None,
                   commit_timezone=None, author_timestamp=None,
                   author_timezone=None, tree=None, encoding=None,
                   ref=b'HEAD', merge_heads=None):
         """Create a new commit.
 
         :param message: Commit message
         :param committer: Committer fullname
         :param author: Author fullname (defaults to committer)
         :param commit_timestamp: Commit timestamp (defaults to now)
         :param commit_timezone: Commit timestamp timezone (defaults to GMT)
         :param author_timestamp: Author timestamp (defaults to commit timestamp)
         :param author_timezone: Author timestamp timezone
             (defaults to commit timestamp timezone)
         :param tree: SHA1 of the tree root to use (if not specified the
             current index will be committed).
         :param encoding: Encoding
         :param ref: Optional ref to commit to (defaults to current branch)
         :param merge_heads: Merge heads (defaults to .git/MERGE_HEADS)
         :return: New commit SHA1
         """
         import time
         c = Commit()
         if tree is None:
             index = self.open_index()
             c.tree = index.commit(self.object_store)
         else:
             if len(tree) != 40:
                 raise ValueError("tree must be a 40-byte hex sha string")
             c.tree = tree
 
         try:
             self.hooks['pre-commit'].execute()
         except HookError as e:
             raise CommitError(e)
         except KeyError:  # no hook defined, silent fallthrough
             pass
 
         if merge_heads is None:
             # FIXME: Read merge heads from .git/MERGE_HEADS
             merge_heads = []
         if committer is None:
             # FIXME: Support GIT_COMMITTER_NAME/GIT_COMMITTER_EMAIL environment
             # variables
             committer = self._get_user_identity()
         c.committer = committer
         if commit_timestamp is None:
             # FIXME: Support GIT_COMMITTER_DATE environment variable
             commit_timestamp = time.time()
         c.commit_time = int(commit_timestamp)
         if commit_timezone is None:
             # FIXME: Use current user timezone rather than UTC
             commit_timezone = 0
         c.commit_timezone = commit_timezone
         if author is None:
             # FIXME: Support GIT_AUTHOR_NAME/GIT_AUTHOR_EMAIL environment
             # variables
             author = committer
         c.author = author
         if author_timestamp is None:
             # FIXME: Support GIT_AUTHOR_DATE environment variable
             author_timestamp = commit_timestamp
         c.author_time = int(author_timestamp)
         if author_timezone is None:
             author_timezone = commit_timezone
         c.author_timezone = author_timezone
         if encoding is not None:
             c.encoding = encoding
         if message is None:
             # FIXME: Try to read commit message from .git/MERGE_MSG
             raise ValueError("No commit message specified")
 
         try:
             c.message = self.hooks['commit-msg'].execute(message)
             if c.message is None:
                 c.message = message
         except HookError as e:
             raise CommitError(e)
         except KeyError:  # no hook defined, message not modified
             c.message = message
 
         if ref is None:
             # Create a dangling commit
             c.parents = merge_heads
             self.object_store.add_object(c)
         else:
             try:
                 old_head = self.refs[ref]
                 c.parents = [old_head] + merge_heads
                 self.object_store.add_object(c)
                 ok = self.refs.set_if_equals(ref, old_head, c.id)
             except KeyError:
                 c.parents = merge_heads
                 self.object_store.add_object(c)
                 ok = self.refs.add_if_new(ref, c.id)
             if not ok:
                 # Fail if the atomic compare-and-swap failed, leaving the commit and
                 # all its objects as garbage.
                 raise CommitError("%s changed during commit" % (ref,))
 
         try:
             self.hooks['post-commit'].execute()
         except HookError as e:  # silent failure
             warnings.warn("post-commit hook failed: %s" % e, UserWarning)
         except KeyError:  # no hook defined, silent fallthrough
             pass
 
         return c.id
 
 
 
 def read_gitfile(f):
     """Read a ``.git`` file.
 
     The first line of the file should start with "gitdir: "
 
     :param f: File-like object to read from
     :return: A path
     """
     cs = f.read()
     if not cs.startswith("gitdir: "):
         raise ValueError("Expected file to start with 'gitdir: '")
     return cs[len("gitdir: "):].rstrip("\n")
 
 
 class Repo(BaseRepo):
     """A git repository backed by local disk.
 
     To open an existing repository, call the contructor with
     the path of the repository.
 
     To create a new repository, use the Repo.init class method.
     """
 
     def __init__(self, root):
         hidden_path = os.path.join(root, CONTROLDIR)
         if os.path.isdir(os.path.join(hidden_path, OBJECTDIR)):
             self.bare = False
             self._controldir = hidden_path
         elif (os.path.isdir(os.path.join(root, OBJECTDIR)) and
               os.path.isdir(os.path.join(root, REFSDIR))):
             self.bare = True
             self._controldir = root
         elif os.path.isfile(hidden_path):
             self.bare = False
             with open(hidden_path, 'r') as f:
                 path = read_gitfile(f)
             self.bare = False
             self._controldir = os.path.join(root, path)
         else:
             raise NotGitRepository(
                 "No git repository was found at %(path)s" % dict(path=root)
             )
         commondir = self.get_named_file(COMMONDIR)
         if commondir is not None:
             with commondir:
                 self._commondir = os.path.join(
                     self.controldir(),
                     commondir.read().rstrip(b"\r\n").decode(sys.getfilesystemencoding()))
         else:
             self._commondir = self._controldir
         self.path = root
         object_store = DiskObjectStore(
             os.path.join(self.commondir(), OBJECTDIR))
         refs = DiskRefsContainer(self.commondir(), self._controldir)
         BaseRepo.__init__(self, object_store, refs)
 
         self._graftpoints = {}
         graft_file = self.get_named_file(os.path.join("info", "grafts"),
                                          basedir=self.commondir())
         if graft_file:
             with graft_file:
                 self._graftpoints.update(parse_graftpoints(graft_file))
         graft_file = self.get_named_file("shallow",
                                          basedir=self.commondir())
         if graft_file:
             with graft_file:
                 self._graftpoints.update(parse_graftpoints(graft_file))
 
         self.hooks['pre-commit'] = PreCommitShellHook(self.controldir())
         self.hooks['commit-msg'] = CommitMsgShellHook(self.controldir())
         self.hooks['post-commit'] = PostCommitShellHook(self.controldir())
 
     @classmethod
     def discover(cls, start='.'):
         """Iterate parent directories to discover a repository
 
         Return a Repo object for the first parent directory that looks like a
         Git repository.
 
         :param start: The directory to start discovery from (defaults to '.')
         """
         remaining = True
         path = os.path.abspath(start)
         while remaining:
             try:
                 return cls(path)
             except NotGitRepository:
                 path, remaining = os.path.split(path)
         raise NotGitRepository(
             "No git repository was found at %(path)s" % dict(path=start)
         )
 
     def controldir(self):
         """Return the path of the control directory."""
         return self._controldir
 
     def commondir(self):
         """Return the path of the common directory.
 
         For a main working tree, it is identical to `controldir()`.
 
         For a linked working tree, it is the control directory of the
         main working tree."""
 
         return self._commondir
 
     def _determine_file_mode(self):
         """Probe the file-system to determine whether permissions can be trusted.
 
         :return: True if permissions can be trusted, False otherwise.
         """
         fname = os.path.join(self.path, '.probe-permissions')
         with open(fname, 'w') as f:
             f.write('')
 
         st1 = os.lstat(fname)
         os.chmod(fname, st1.st_mode ^ stat.S_IXUSR)
         st2 = os.lstat(fname)
 
         os.unlink(fname)
 
         mode_differs = st1.st_mode != st2.st_mode
         st2_has_exec = (st2.st_mode & stat.S_IXUSR) != 0
 
         return mode_differs and st2_has_exec
 
     def _put_named_file(self, path, contents):
         """Write a file to the control dir with the given name and contents.
 
         :param path: The path to the file, relative to the control dir.
         :param contents: A string to write to the file.
         """
         path = path.lstrip(os.path.sep)
         with GitFile(os.path.join(self.controldir(), path), 'wb') as f:
             f.write(contents)
 
     def get_named_file(self, path, basedir=None):
         """Get a file from the control dir with a specific name.
 
         Although the filename should be interpreted as a filename relative to
         the control dir in a disk-based Repo, the object returned need not be
         pointing to a file in that location.
 
         :param path: The path to the file, relative to the control dir.
         :param basedir: Optional argument that specifies an alternative to the control dir.
         :return: An open file object, or None if the file does not exist.
         """
         # TODO(dborowitz): sanitize filenames, since this is used directly by
         # the dumb web serving code.
         if basedir is None:
             basedir = self.controldir()
         path = path.lstrip(os.path.sep)
         try:
             return open(os.path.join(basedir, path), 'rb')
         except (IOError, OSError) as e:
             if e.errno == errno.ENOENT:
                 return None
             raise
 
     def index_path(self):
         """Return path to the index file."""
         return os.path.join(self.controldir(), INDEX_FILENAME)
 
     def open_index(self):
         """Open the index for this repository.
 
         :raise NoIndexPresent: If no index is present
         :return: The matching `Index`
         """
         from dulwich.index import Index
         if not self.has_index():
             raise NoIndexPresent()
         return Index(self.index_path())
 
     def has_index(self):
         """Check if an index is present."""
         # Bare repos must never have index files; non-bare repos may have a
         # missing index file, which is treated as empty.
         return not self.bare
 
     def stage(self, fs_paths):
         """Stage a set of paths.
 
         :param fs_paths: List of paths, relative to the repository path
         """
 
         root_path_bytes = self.path.encode(sys.getfilesystemencoding())
 
         if not isinstance(fs_paths, list):
             fs_paths = [fs_paths]
         from dulwich.index import (
             blob_from_path_and_stat,
             index_entry_from_stat,
             _fs_to_tree_path,
             )
         index = self.open_index()
         for fs_path in fs_paths:
             if not isinstance(fs_path, bytes):
                 fs_path = fs_path.encode(sys.getfilesystemencoding())
             tree_path = _fs_to_tree_path(fs_path)
             full_path = os.path.join(root_path_bytes, fs_path)
             try:
                 st = os.lstat(full_path)
             except OSError:
                 # File no longer exists
                 try:
                     del index[tree_path]
                 except KeyError:
                     pass  # already removed
             else:
                 blob = blob_from_path_and_stat(full_path, st)
                 self.object_store.add_object(blob)
                 index[tree_path] = index_entry_from_stat(st, blob.id, 0)
         index.write()
 
     def clone(self, target_path, mkdir=True, bare=False,
             origin=b"origin"):
         """Clone this repository.
 
         :param target_path: Target path
         :param mkdir: Create the target directory
         :param bare: Whether to create a bare repository
         :param origin: Base name for refs in target repository
             cloned from this repository
         :return: Created repository as `Repo`
         """
         if not bare:
             target = self.init(target_path, mkdir=mkdir)
         else:
             target = self.init_bare(target_path)
         self.fetch(target)
         target.refs.import_refs(
             b'refs/remotes/' + origin, self.refs.as_dict(b'refs/heads'))
         target.refs.import_refs(
             b'refs/tags', self.refs.as_dict(b'refs/tags'))
         try:
             target.refs.add_if_new(DEFAULT_REF, self.refs[DEFAULT_REF])
         except KeyError:
             pass
         target_config = target.get_config()
         encoded_path = self.path
         if not isinstance(encoded_path, bytes):
             encoded_path = encoded_path.encode(sys.getfilesystemencoding())
         target_config.set((b'remote', b'origin'), b'url', encoded_path)
         target_config.set((b'remote', b'origin'), b'fetch',
             b'+refs/heads/*:refs/remotes/origin/*')
         target_config.write_to_path()
 
         # Update target head
         head_chain, head_sha = self.refs.follow(b'HEAD')
         if head_chain and head_sha is not None:
             target.refs.set_symbolic_ref(b'HEAD', head_chain[-1])
             target[b'HEAD'] = head_sha
 
             if not bare:
                 # Checkout HEAD to target dir
                 target.reset_index()
 
         return target
 
     def reset_index(self, tree=None):
         """Reset the index back to a specific tree.
 
         :param tree: Tree SHA to reset to, None for current HEAD tree.
         """
         from dulwich.index import (
             build_index_from_tree,
             validate_path_element_default,
             validate_path_element_ntfs,
             )
         if tree is None:
             tree = self[b'HEAD'].tree
         config = self.get_config()
         honor_filemode = config.get_boolean('core', 'filemode', os.name != "nt")
         if config.get_boolean('core', 'core.protectNTFS', os.name == "nt"):
             validate_path_element = validate_path_element_ntfs
         else:
             validate_path_element = validate_path_element_default
         return build_index_from_tree(self.path, self.index_path(),
                 self.object_store, tree, honor_filemode=honor_filemode,
                 validate_path_element=validate_path_element)
 
     def get_config(self):
         """Retrieve the config object.
 
         :return: `ConfigFile` object for the ``.git/config`` file.
         """
         from dulwich.config import ConfigFile
         path = os.path.join(self._controldir, 'config')
         try:
             return ConfigFile.from_path(path)
         except (IOError, OSError) as e:
             if e.errno != errno.ENOENT:
                 raise
             ret = ConfigFile()
             ret.path = path
             return ret
 
     def get_description(self):
         """Retrieve the description of this repository.
 
         :return: A string describing the repository or None.
         """
         path = os.path.join(self._controldir, 'description')
         try:
             with GitFile(path, 'rb') as f:
                 return f.read()
         except (IOError, OSError) as e:
             if e.errno != errno.ENOENT:
                 raise
             return None
 
     def __repr__(self):
         return "<Repo at %r>" % self.path
 
     def set_description(self, description):
         """Set the description for this repository.
 
         :param description: Text to set as description for this repository.
         """
 
         self._put_named_file('description', description)
 
     @classmethod
     def _init_maybe_bare(cls, path, bare):
         for d in BASE_DIRECTORIES:
             os.mkdir(os.path.join(path, *d))
         DiskObjectStore.init(os.path.join(path, OBJECTDIR))
         ret = cls(path)
         ret.refs.set_symbolic_ref(b'HEAD', DEFAULT_REF)
         ret._init_files(bare)
         return ret
 
     @classmethod
     def init(cls, path, mkdir=False):
         """Create a new repository.
 
         :param path: Path in which to create the repository
         :param mkdir: Whether to create the directory
         :return: `Repo` instance
         """
         if mkdir:
             os.mkdir(path)
         controldir = os.path.join(path, CONTROLDIR)
         os.mkdir(controldir)
         cls._init_maybe_bare(controldir, False)
         return cls(path)
 
     @classmethod
     def _init_new_working_directory(cls, path, main_repo, identifier=None, mkdir=False):
         """Create a new working directory linked to a repository.
 
         :param path: Path in which to create the working tree.
         :param main_repo: Main repository to reference
         :param identifier: Worktree identifier
         :param mkdir: Whether to create the directory
         :return: `Repo` instance
         """
         if mkdir:
             os.mkdir(path)
         if identifier is None:
             identifier = os.path.basename(path)
         main_worktreesdir = os.path.join(main_repo.controldir(), WORKTREES)
         worktree_controldir = os.path.join(main_worktreesdir, identifier)
         gitdirfile = os.path.join(path, CONTROLDIR)
         with open(gitdirfile, 'wb') as f:
             f.write(b'gitdir: ' +
                     worktree_controldir.encode(sys.getfilesystemencoding()) +
                     b'\n')
         try:
             os.mkdir(main_worktreesdir)
         except OSError as e:
             if e.errno != errno.EEXIST:
                 raise
         try:
             os.mkdir(worktree_controldir)
         except OSError as e:
             if e.errno != errno.EEXIST:
                 raise
         with open(os.path.join(worktree_controldir, GITDIR), 'wb') as f:
             f.write(gitdirfile.encode(sys.getfilesystemencoding()) + b'\n')
         with open(os.path.join(worktree_controldir, COMMONDIR), 'wb') as f:
             f.write(b'../..\n')
         with open(os.path.join(worktree_controldir, 'HEAD'), 'wb') as f:
             f.write(main_repo.head() + b'\n')
         r = cls(path)
         r.reset_index()
         return r
 
     @classmethod
     def init_bare(cls, path):
         """Create a new bare repository.
 
         ``path`` should already exist and be an emty directory.
 
         :param path: Path to create bare repository in
         :return: a `Repo` instance
         """
         return cls._init_maybe_bare(path, True)
 
     create = init_bare
 
     def close(self):
         """Close any files opened by this repository."""
         self.object_store.close()
 
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.close()
+
 
 class MemoryRepo(BaseRepo):
     """Repo that stores refs, objects, and named files in memory.
 
     MemoryRepos are always bare: they have no working tree and no index, since
     those have a stronger dependency on the filesystem.
     """
 
     def __init__(self):
         from dulwich.config import ConfigFile
         BaseRepo.__init__(self, MemoryObjectStore(), DictRefsContainer({}))
         self._named_files = {}
         self.bare = True
         self._config = ConfigFile()
 
     def _determine_file_mode(self):
         """Probe the file-system to determine whether permissions can be trusted.
 
         :return: True if permissions can be trusted, False otherwise.
         """
         return sys.platform != 'win32'
 
     def _put_named_file(self, path, contents):
         """Write a file to the control dir with the given name and contents.
 
         :param path: The path to the file, relative to the control dir.
         :param contents: A string to write to the file.
         """
         self._named_files[path] = contents
 
     def get_named_file(self, path):
         """Get a file from the control dir with a specific name.
 
         Although the filename should be interpreted as a filename relative to
         the control dir in a disk-baked Repo, the object returned need not be
         pointing to a file in that location.
 
         :param path: The path to the file, relative to the control dir.
         :return: An open file object, or None if the file does not exist.
         """
         contents = self._named_files.get(path, None)
         if contents is None:
             return None
         return BytesIO(contents)
 
     def open_index(self):
         """Fail to open index for this repo, since it is bare.
 
         :raise NoIndexPresent: Raised when no index is present
         """
         raise NoIndexPresent()
 
     def get_config(self):
         """Retrieve the config object.
 
         :return: `ConfigFile` object.
         """
         return self._config
 
     def get_description(self):
         """Retrieve the repository description.
 
         This defaults to None, for no description.
         """
         return None
 
     @classmethod
     def init_bare(cls, objects, refs):
         """Create a new bare repository in memory.
 
         :param objects: Objects for the new repository,
             as iterable
         :param refs: Refs as dictionary, mapping names
             to object SHA1s
         """
         ret = cls()
         for obj in objects:
             ret.object_store.add_object(obj)
         for refname, sha in refs.items():
             ret.refs[refname] = sha
         ret._init_files(bare=True)
         return ret
diff --git a/dulwich/tests/compat/test_client.py b/dulwich/tests/compat/test_client.py
index 85c22a23..368a4ba2 100644
--- a/dulwich/tests/compat/test_client.py
+++ b/dulwich/tests/compat/test_client.py
@@ -1,533 +1,532 @@
 # test_client.py -- Compatibilty tests for git client.
 # Copyright (C) 2010 Google, Inc.
 #
 # Dulwich is dual-licensed under the Apache License, Version 2.0 and the GNU
 # General Public License as public by the Free Software Foundation; version 2.0
 # or (at your option) any later version. You can redistribute it and/or
 # modify it under the terms of either of these two licenses.
 #
 # Unless required by applicable law or agreed to in writing, software
 # distributed under the License is distributed on an "AS IS" BASIS,
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
 #
 # You should have received a copy of the licenses; if not, see
 # <http://www.gnu.org/licenses/> for a copy of the GNU General Public License
 # and <http://www.apache.org/licenses/LICENSE-2.0> for a copy of the Apache
 # License, Version 2.0.
 #
 
 """Compatibilty tests between the Dulwich client and the cgit server."""
 
-from contextlib import closing
 import copy
 from io import BytesIO
 import os
 import select
 import signal
 import subprocess
 import sys
 import tarfile
 import tempfile
 import threading
 
 try:
     from urlparse import unquote
 except ImportError:
     from urllib.parse import unquote
 
 
 try:
     import BaseHTTPServer
     import SimpleHTTPServer
 except ImportError:
     import http.server
     BaseHTTPServer = http.server
     SimpleHTTPServer = http.server
 
 if sys.platform == 'win32':
     import ctypes
 
 from dulwich import (
     client,
     errors,
     file,
     index,
     protocol,
     objects,
     repo,
     )
 from dulwich.tests import (
     SkipTest,
     expectedFailure,
     )
 from dulwich.tests.compat.utils import (
     CompatTestCase,
     check_for_daemon,
     import_repo_to_dir,
     rmtree_ro,
     run_git_or_fail,
     _DEFAULT_GIT,
     )
 
 
 class DulwichClientTestBase(object):
     """Tests for client/server compatibility."""
 
     def setUp(self):
         self.gitroot = os.path.dirname(import_repo_to_dir('server_new.export').rstrip(os.sep))
         self.dest = os.path.join(self.gitroot, 'dest')
         file.ensure_dir_exists(self.dest)
         run_git_or_fail(['init', '--quiet', '--bare'], cwd=self.dest)
 
     def tearDown(self):
         rmtree_ro(self.gitroot)
 
     def assertDestEqualsSrc(self):
         repo_dir = os.path.join(self.gitroot, 'server_new.export')
         dest_repo_dir = os.path.join(self.gitroot, 'dest')
-        with closing(repo.Repo(repo_dir)) as src:
-            with closing(repo.Repo(dest_repo_dir)) as dest:
+        with repo.Repo(repo_dir) as src:
+            with repo.Repo(dest_repo_dir) as dest:
                 self.assertReposEqual(src, dest)
 
     def _client(self):
         raise NotImplementedError()
 
     def _build_path(self):
         raise NotImplementedError()
 
     def _do_send_pack(self):
         c = self._client()
         srcpath = os.path.join(self.gitroot, 'server_new.export')
-        with closing(repo.Repo(srcpath)) as src:
+        with repo.Repo(srcpath) as src:
             sendrefs = dict(src.get_refs())
             del sendrefs[b'HEAD']
             c.send_pack(self._build_path(b'/dest'), lambda _: sendrefs,
                         src.object_store.generate_pack_contents)
 
     def test_send_pack(self):
         self._do_send_pack()
         self.assertDestEqualsSrc()
 
     def test_send_pack_nothing_to_send(self):
         self._do_send_pack()
         self.assertDestEqualsSrc()
         # nothing to send, but shouldn't raise either.
         self._do_send_pack()
 
     def test_send_without_report_status(self):
         c = self._client()
         c._send_capabilities.remove(b'report-status')
         srcpath = os.path.join(self.gitroot, 'server_new.export')
-        with closing(repo.Repo(srcpath)) as src:
+        with repo.Repo(srcpath) as src:
             sendrefs = dict(src.get_refs())
             del sendrefs[b'HEAD']
             c.send_pack(self._build_path(b'/dest'), lambda _: sendrefs,
                         src.object_store.generate_pack_contents)
             self.assertDestEqualsSrc()
 
     def make_dummy_commit(self, dest):
         b = objects.Blob.from_string(b'hi')
         dest.object_store.add_object(b)
         t = index.commit_tree(dest.object_store, [(b'hi', b.id, 0o100644)])
         c = objects.Commit()
         c.author = c.committer = b'Foo Bar <foo@example.com>'
         c.author_time = c.commit_time = 0
         c.author_timezone = c.commit_timezone = 0
         c.message = b'hi'
         c.tree = t
         dest.object_store.add_object(c)
         return c.id
 
     def disable_ff_and_make_dummy_commit(self):
         # disable non-fast-forward pushes to the server
         dest = repo.Repo(os.path.join(self.gitroot, 'dest'))
         run_git_or_fail(['config', 'receive.denyNonFastForwards', 'true'],
                         cwd=dest.path)
         commit_id = self.make_dummy_commit(dest)
         return dest, commit_id
 
     def compute_send(self, src):
         sendrefs = dict(src.get_refs())
         del sendrefs[b'HEAD']
         return sendrefs, src.object_store.generate_pack_contents
 
     def test_send_pack_one_error(self):
         dest, dummy_commit = self.disable_ff_and_make_dummy_commit()
         dest.refs[b'refs/heads/master'] = dummy_commit
         repo_dir = os.path.join(self.gitroot, 'server_new.export')
-        with closing(repo.Repo(repo_dir)) as src:
+        with repo.Repo(repo_dir) as src:
             sendrefs, gen_pack = self.compute_send(src)
             c = self._client()
             try:
                 c.send_pack(self._build_path(b'/dest'), lambda _: sendrefs, gen_pack)
             except errors.UpdateRefsError as e:
                 self.assertEqual('refs/heads/master failed to update',
                                  e.args[0])
                 self.assertEqual({b'refs/heads/branch': b'ok',
                                   b'refs/heads/master': b'non-fast-forward'},
                                  e.ref_status)
 
     def test_send_pack_multiple_errors(self):
         dest, dummy = self.disable_ff_and_make_dummy_commit()
         # set up for two non-ff errors
         branch, master = b'refs/heads/branch', b'refs/heads/master'
         dest.refs[branch] = dest.refs[master] = dummy
         repo_dir = os.path.join(self.gitroot, 'server_new.export')
-        with closing(repo.Repo(repo_dir)) as src:
+        with repo.Repo(repo_dir) as src:
             sendrefs, gen_pack = self.compute_send(src)
             c = self._client()
             try:
                 c.send_pack(self._build_path(b'/dest'), lambda _: sendrefs, gen_pack)
             except errors.UpdateRefsError as e:
                 self.assertIn(str(e),
                               ['{0}, {1} failed to update'.format(
                                   branch.decode('ascii'), master.decode('ascii')),
                                '{1}, {0} failed to update'.format(
                                    branch.decode('ascii'), master.decode('ascii'))])
                 self.assertEqual({branch: b'non-fast-forward',
                                   master: b'non-fast-forward'},
                                  e.ref_status)
 
     def test_archive(self):
         c = self._client()
         f = BytesIO()
         c.archive(self._build_path(b'/server_new.export'), b'HEAD', f.write)
         f.seek(0)
         tf = tarfile.open(fileobj=f)
         self.assertEqual(['baz', 'foo'], tf.getnames())
 
     def test_fetch_pack(self):
         c = self._client()
-        with closing(repo.Repo(os.path.join(self.gitroot, 'dest'))) as dest:
+        with repo.Repo(os.path.join(self.gitroot, 'dest')) as dest:
             refs = c.fetch(self._build_path(b'/server_new.export'), dest)
             for r in refs.items():
                 dest.refs.set_if_equals(r[0], None, r[1])
             self.assertDestEqualsSrc()
 
     def test_incremental_fetch_pack(self):
         self.test_fetch_pack()
         dest, dummy = self.disable_ff_and_make_dummy_commit()
         dest.refs[b'refs/heads/master'] = dummy
         c = self._client()
         repo_dir = os.path.join(self.gitroot, 'server_new.export')
-        with closing(repo.Repo(repo_dir)) as dest:
+        with repo.Repo(repo_dir) as dest:
             refs = c.fetch(self._build_path(b'/dest'), dest)
             for r in refs.items():
                 dest.refs.set_if_equals(r[0], None, r[1])
             self.assertDestEqualsSrc()
 
     def test_fetch_pack_no_side_band_64k(self):
         c = self._client()
         c._fetch_capabilities.remove(b'side-band-64k')
-        with closing(repo.Repo(os.path.join(self.gitroot, 'dest'))) as dest:
+        with repo.Repo(os.path.join(self.gitroot, 'dest')) as dest:
             refs = c.fetch(self._build_path(b'/server_new.export'), dest)
             for r in refs.items():
                 dest.refs.set_if_equals(r[0], None, r[1])
             self.assertDestEqualsSrc()
 
     def test_fetch_pack_zero_sha(self):
         # zero sha1s are already present on the client, and should
         # be ignored
         c = self._client()
-        with closing(repo.Repo(os.path.join(self.gitroot, 'dest'))) as dest:
+        with repo.Repo(os.path.join(self.gitroot, 'dest')) as dest:
             refs = c.fetch(self._build_path(b'/server_new.export'), dest,
                 lambda refs: [protocol.ZERO_SHA])
             for r in refs.items():
                 dest.refs.set_if_equals(r[0], None, r[1])
 
     def test_send_remove_branch(self):
-        with closing(repo.Repo(os.path.join(self.gitroot, 'dest'))) as dest:
+        with repo.Repo(os.path.join(self.gitroot, 'dest')) as dest:
             dummy_commit = self.make_dummy_commit(dest)
             dest.refs[b'refs/heads/master'] = dummy_commit
             dest.refs[b'refs/heads/abranch'] = dummy_commit
             sendrefs = dict(dest.refs)
             sendrefs[b'refs/heads/abranch'] = b"00" * 20
             del sendrefs[b'HEAD']
             gen_pack = lambda have, want: []
             c = self._client()
             self.assertEqual(dest.refs[b"refs/heads/abranch"], dummy_commit)
             c.send_pack(self._build_path(b'/dest'), lambda _: sendrefs, gen_pack)
             self.assertFalse(b"refs/heads/abranch" in dest.refs)
 
     def test_get_refs(self):
         c = self._client()
         refs = c.get_refs(self._build_path(b'/server_new.export'))
 
         repo_dir = os.path.join(self.gitroot, 'server_new.export')
-        with closing(repo.Repo(repo_dir)) as dest:
+        with repo.Repo(repo_dir) as dest:
             self.assertDictEqual(dest.refs.as_dict(), refs)
 
 
 class DulwichTCPClientTest(CompatTestCase, DulwichClientTestBase):
 
     def setUp(self):
         CompatTestCase.setUp(self)
         DulwichClientTestBase.setUp(self)
         if check_for_daemon(limit=1):
             raise SkipTest('git-daemon was already running on port %s' %
                               protocol.TCP_GIT_PORT)
         fd, self.pidfile = tempfile.mkstemp(prefix='dulwich-test-git-client',
                                             suffix=".pid")
         os.fdopen(fd).close()
         args = [_DEFAULT_GIT, 'daemon', '--verbose', '--export-all',
                 '--pid-file=%s' % self.pidfile,
                 '--base-path=%s' % self.gitroot,
                 '--enable=receive-pack', '--enable=upload-archive',
                 '--listen=localhost', '--reuseaddr',
                 self.gitroot]
         self.process = subprocess.Popen(
             args, cwd=self.gitroot,
             stdout=subprocess.PIPE, stderr=subprocess.PIPE)
         if not check_for_daemon():
             raise SkipTest('git-daemon failed to start')
 
     def tearDown(self):
         with open(self.pidfile) as f:
             pid = int(f.read().strip())
         if sys.platform == 'win32':
             PROCESS_TERMINATE = 1
             handle = ctypes.windll.kernel32.OpenProcess(
                 PROCESS_TERMINATE, False, pid)
             ctypes.windll.kernel32.TerminateProcess(handle, -1)
             ctypes.windll.kernel32.CloseHandle(handle)
         else:
             try:
                 os.kill(pid, signal.SIGKILL)
                 os.unlink(self.pidfile)
             except (OSError, IOError):
                 pass
         self.process.wait()
         self.process.stdout.close()
         self.process.stderr.close()
         DulwichClientTestBase.tearDown(self)
         CompatTestCase.tearDown(self)
 
     def _client(self):
         return client.TCPGitClient('localhost')
 
     def _build_path(self, path):
         return path
 
     if sys.platform == 'win32':
         @expectedFailure
         def test_fetch_pack_no_side_band_64k(self):
             DulwichClientTestBase.test_fetch_pack_no_side_band_64k(self)
 
 
 class TestSSHVendor(object):
 
     @staticmethod
     def run_command(host, command, username=None, port=None):
         cmd, path = command.split(b' ')
         cmd = cmd.split(b'-', 1)
         path = path.replace(b"'", b"")
         p = subprocess.Popen(cmd + [path], bufsize=0, stdin=subprocess.PIPE,
                              stdout=subprocess.PIPE, stderr=subprocess.PIPE)
         return client.SubprocessWrapper(p)
 
 
 class DulwichMockSSHClientTest(CompatTestCase, DulwichClientTestBase):
 
     def setUp(self):
         CompatTestCase.setUp(self)
         DulwichClientTestBase.setUp(self)
         self.real_vendor = client.get_ssh_vendor
         client.get_ssh_vendor = TestSSHVendor
 
     def tearDown(self):
         DulwichClientTestBase.tearDown(self)
         CompatTestCase.tearDown(self)
         client.get_ssh_vendor = self.real_vendor
 
     def _client(self):
         return client.SSHGitClient('localhost')
 
     def _build_path(self, path):
         return self.gitroot.encode(sys.getfilesystemencoding()) + path
 
 
 class DulwichSubprocessClientTest(CompatTestCase, DulwichClientTestBase):
 
     def setUp(self):
         CompatTestCase.setUp(self)
         DulwichClientTestBase.setUp(self)
 
     def tearDown(self):
         DulwichClientTestBase.tearDown(self)
         CompatTestCase.tearDown(self)
 
     def _client(self):
         return client.SubprocessGitClient(stderr=subprocess.PIPE)
 
     def _build_path(self, path):
         return self.gitroot.encode(sys.getfilesystemencoding()) + path
 
 
 class GitHTTPRequestHandler(SimpleHTTPServer.SimpleHTTPRequestHandler):
     """HTTP Request handler that calls out to 'git http-backend'."""
 
     # Make rfile unbuffered -- we need to read one line and then pass
     # the rest to a subprocess, so we can't use buffered input.
     rbufsize = 0
 
     def do_POST(self):
         self.run_backend()
 
     def do_GET(self):
         self.run_backend()
 
     def send_head(self):
         return self.run_backend()
 
     def log_request(self, code='-', size='-'):
         # Let's be quiet, the test suite is noisy enough already
         pass
 
     def run_backend(self):
         """Call out to git http-backend."""
         # Based on CGIHTTPServer.CGIHTTPRequestHandler.run_cgi:
         # Copyright (c) 2001-2010 Python Software Foundation; All Rights Reserved
         # Licensed under the Python Software Foundation License.
         rest = self.path
         # find an explicit query string, if present.
         i = rest.rfind('?')
         if i >= 0:
             rest, query = rest[:i], rest[i+1:]
         else:
             query = ''
 
         env = copy.deepcopy(os.environ)
         env['SERVER_SOFTWARE'] = self.version_string()
         env['SERVER_NAME'] = self.server.server_name
         env['GATEWAY_INTERFACE'] = 'CGI/1.1'
         env['SERVER_PROTOCOL'] = self.protocol_version
         env['SERVER_PORT'] = str(self.server.server_port)
         env['GIT_PROJECT_ROOT'] = self.server.root_path
         env["GIT_HTTP_EXPORT_ALL"] = "1"
         env['REQUEST_METHOD'] = self.command
         uqrest = unquote(rest)
         env['PATH_INFO'] = uqrest
         env['SCRIPT_NAME'] = "/"
         if query:
             env['QUERY_STRING'] = query
         host = self.address_string()
         if host != self.client_address[0]:
             env['REMOTE_HOST'] = host
         env['REMOTE_ADDR'] = self.client_address[0]
         authorization = self.headers.get("authorization")
         if authorization:
             authorization = authorization.split()
             if len(authorization) == 2:
                 import base64, binascii
                 env['AUTH_TYPE'] = authorization[0]
                 if authorization[0].lower() == "basic":
                     try:
                         authorization = base64.decodestring(authorization[1])
                     except binascii.Error:
                         pass
                     else:
                         authorization = authorization.split(':')
                         if len(authorization) == 2:
                             env['REMOTE_USER'] = authorization[0]
         # XXX REMOTE_IDENT
         env['CONTENT_TYPE'] = self.headers.get('content-type')
         length = self.headers.get('content-length')
         if length:
             env['CONTENT_LENGTH'] = length
         referer = self.headers.get('referer')
         if referer:
             env['HTTP_REFERER'] = referer
         accept = []
         for line in self.headers.getallmatchingheaders('accept'):
             if line[:1] in "\t\n\r ":
                 accept.append(line.strip())
             else:
                 accept = accept + line[7:].split(',')
         env['HTTP_ACCEPT'] = ','.join(accept)
         ua = self.headers.get('user-agent')
         if ua:
             env['HTTP_USER_AGENT'] = ua
         co = self.headers.get('cookie')
         if co:
             env['HTTP_COOKIE'] = co
         # XXX Other HTTP_* headers
         # Since we're setting the env in the parent, provide empty
         # values to override previously set values
         for k in ('QUERY_STRING', 'REMOTE_HOST', 'CONTENT_LENGTH',
                   'HTTP_USER_AGENT', 'HTTP_COOKIE', 'HTTP_REFERER'):
             env.setdefault(k, "")
 
         self.wfile.write(b"HTTP/1.1 200 Script output follows\r\n")
         self.wfile.write(
             ("Server: %s\r\n" % self.server.server_name).encode('ascii'))
         self.wfile.write(
             ("Date: %s\r\n" % self.date_time_string()).encode('ascii'))
 
         decoded_query = query.replace('+', ' ')
 
         try:
             nbytes = int(length)
         except (TypeError, ValueError):
             nbytes = 0
         if self.command.lower() == "post" and nbytes > 0:
             data = self.rfile.read(nbytes)
         else:
             data = None
         # throw away additional data [see bug #427345]
         while select.select([self.rfile._sock], [], [], 0)[0]:
             if not self.rfile._sock.recv(1):
                 break
         args = ['http-backend']
         if '=' not in decoded_query:
             args.append(decoded_query)
         stdout = run_git_or_fail(args, input=data, env=env, stderr=subprocess.PIPE)
         self.wfile.write(stdout)
 
 
 class HTTPGitServer(BaseHTTPServer.HTTPServer):
 
     allow_reuse_address = True
 
     def __init__(self, server_address, root_path):
         BaseHTTPServer.HTTPServer.__init__(self, server_address, GitHTTPRequestHandler)
         self.root_path = root_path
         self.server_name = "localhost"
 
     def get_url(self):
         return 'http://%s:%s/' % (self.server_name, self.server_port)
 
 
 class DulwichHttpClientTest(CompatTestCase, DulwichClientTestBase):
 
     min_git_version = (1, 7, 0, 2)
 
     def setUp(self):
         CompatTestCase.setUp(self)
         DulwichClientTestBase.setUp(self)
         self._httpd = HTTPGitServer(("localhost", 0), self.gitroot)
         self.addCleanup(self._httpd.shutdown)
         threading.Thread(target=self._httpd.serve_forever).start()
         run_git_or_fail(['config', 'http.uploadpack', 'true'],
                         cwd=self.dest)
         run_git_or_fail(['config', 'http.receivepack', 'true'],
                         cwd=self.dest)
 
     def tearDown(self):
         DulwichClientTestBase.tearDown(self)
         CompatTestCase.tearDown(self)
         self._httpd.shutdown()
         self._httpd.socket.close()
 
     def _client(self):
         return client.HttpGitClient(self._httpd.get_url())
 
     def _build_path(self, path):
         if sys.version_info[0] == 3:
             return path.decode('ascii')
         else:
             return path
 
     def test_archive(self):
         raise SkipTest("exporting archives not supported over http")
diff --git a/dulwich/tests/test_client.py b/dulwich/tests/test_client.py
index 9ac5f95a..59ac959f 100644
--- a/dulwich/tests/test_client.py
+++ b/dulwich/tests/test_client.py
@@ -1,841 +1,840 @@
 # test_client.py -- Tests for the git protocol, client side
 # Copyright (C) 2009 Jelmer Vernooij <jelmer@samba.org>
 #
 # Dulwich is dual-licensed under the Apache License, Version 2.0 and the GNU
 # General Public License as public by the Free Software Foundation; version 2.0
 # or (at your option) any later version. You can redistribute it and/or
 # modify it under the terms of either of these two licenses.
 #
 # Unless required by applicable law or agreed to in writing, software
 # distributed under the License is distributed on an "AS IS" BASIS,
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
 #
 # You should have received a copy of the licenses; if not, see
 # <http://www.gnu.org/licenses/> for a copy of the GNU General Public License
 # and <http://www.apache.org/licenses/LICENSE-2.0> for a copy of the Apache
 # License, Version 2.0.
 #
 
-from contextlib import closing
 from io import BytesIO
 import sys
 import shutil
 import tempfile
 
 
 import dulwich
 from dulwich import (
     client,
     )
 from dulwich.client import (
     LocalGitClient,
     TraditionalGitClient,
     TCPGitClient,
     SSHGitClient,
     HttpGitClient,
     ReportStatusParser,
     SendPackError,
     UpdateRefsError,
     get_transport_and_path,
     get_transport_and_path_from_url,
     )
 from dulwich.tests import (
     TestCase,
     )
 from dulwich.protocol import (
     TCP_GIT_PORT,
     Protocol,
     )
 from dulwich.pack import (
     write_pack_objects,
     )
 from dulwich.objects import (
     Commit,
     Tree
     )
 from dulwich.repo import (
     MemoryRepo,
     Repo,
     )
 from dulwich.tests import skipIf
 from dulwich.tests.utils import (
     open_repo,
     tear_down_repo,
     )
 
 
 class DummyClient(TraditionalGitClient):
 
     def __init__(self, can_read, read, write):
         self.can_read = can_read
         self.read = read
         self.write = write
         TraditionalGitClient.__init__(self)
 
     def _connect(self, service, path):
         return Protocol(self.read, self.write), self.can_read
 
 
 # TODO(durin42): add unit-level tests of GitClient
 class GitClientTests(TestCase):
 
     def setUp(self):
         super(GitClientTests, self).setUp()
         self.rout = BytesIO()
         self.rin = BytesIO()
         self.client = DummyClient(lambda x: True, self.rin.read,
                                   self.rout.write)
 
     def test_caps(self):
         agent_cap = ('agent=dulwich/%d.%d.%d' % dulwich.__version__).encode('ascii')
         self.assertEqual(set([b'multi_ack', b'side-band-64k', b'ofs-delta',
                                b'thin-pack', b'multi_ack_detailed',
                                agent_cap]),
                           set(self.client._fetch_capabilities))
         self.assertEqual(set([b'ofs-delta', b'report-status', b'side-band-64k',
                               agent_cap]),
                           set(self.client._send_capabilities))
 
     def test_archive_ack(self):
         self.rin.write(
             b'0009NACK\n'
             b'0000')
         self.rin.seek(0)
         self.client.archive(b'bla', b'HEAD', None, None)
         self.assertEqual(self.rout.getvalue(), b'0011argument HEAD0000')
 
     def test_fetch_empty(self):
         self.rin.write(b'0000')
         self.rin.seek(0)
         def check_heads(heads):
             self.assertIs(heads, None)
             return []
         ret = self.client.fetch_pack(b'/', check_heads, None, None)
         self.assertIs(None, ret)
 
     def test_fetch_pack_ignores_magic_ref(self):
         self.rin.write(
             b'00000000000000000000000000000000000000000000 capabilities^{}\x00 multi_ack '
             b'thin-pack side-band side-band-64k ofs-delta shallow no-progress '
             b'include-tag\n'
             b'0000')
         self.rin.seek(0)
         def check_heads(heads):
             self.assertEquals({}, heads)
             return []
         ret = self.client.fetch_pack(b'bla', check_heads, None, None, None)
         self.assertIs(None, ret)
         self.assertEqual(self.rout.getvalue(), b'0000')
 
     def test_fetch_pack_none(self):
         self.rin.write(
             b'008855dcc6bf963f922e1ed5c4bbaaefcfacef57b1d7 HEAD.multi_ack '
             b'thin-pack side-band side-band-64k ofs-delta shallow no-progress '
             b'include-tag\n'
             b'0000')
         self.rin.seek(0)
         self.client.fetch_pack(b'bla', lambda heads: [], None, None, None)
         self.assertEqual(self.rout.getvalue(), b'0000')
 
     def test_send_pack_no_sideband64k_with_update_ref_error(self):
         # No side-bank-64k reported by server shouldn't try to parse
         # side band data
         pkts = [b'55dcc6bf963f922e1ed5c4bbaaefcfacef57b1d7 capabilities^{}'
                 b'\x00 report-status delete-refs ofs-delta\n',
                 b'',
                 b"unpack ok",
                 b"ng refs/foo/bar pre-receive hook declined",
                 b'']
         for pkt in pkts:
             if pkt ==  b'':
                 self.rin.write(b"0000")
             else:
                 self.rin.write(("%04x" % (len(pkt)+4)).encode('ascii') + pkt)
         self.rin.seek(0)
 
         tree = Tree()
         commit = Commit()
         commit.tree = tree
         commit.parents = []
         commit.author = commit.committer = b'test user'
         commit.commit_time = commit.author_time = 1174773719
         commit.commit_timezone = commit.author_timezone = 0
         commit.encoding = b'UTF-8'
         commit.message = b'test message'
 
         def determine_wants(refs):
             return {b'refs/foo/bar': commit.id, }
 
         def generate_pack_contents(have, want):
             return [(commit, None), (tree, ''), ]
 
         self.assertRaises(UpdateRefsError,
                           self.client.send_pack, "blah",
                           determine_wants, generate_pack_contents)
 
     def test_send_pack_none(self):
         self.rin.write(
             b'0078310ca9477129b8586fa2afc779c1f57cf64bba6c '
             b'refs/heads/master\x00 report-status delete-refs '
             b'side-band-64k quiet ofs-delta\n'
             b'0000')
         self.rin.seek(0)
 
         def determine_wants(refs):
             return {
                 b'refs/heads/master': b'310ca9477129b8586fa2afc779c1f57cf64bba6c'
             }
 
         def generate_pack_contents(have, want):
             return {}
 
         self.client.send_pack(b'/', determine_wants, generate_pack_contents)
         self.assertEqual(self.rout.getvalue(), b'0000')
 
     def test_send_pack_keep_and_delete(self):
         self.rin.write(
             b'0063310ca9477129b8586fa2afc779c1f57cf64bba6c '
             b'refs/heads/master\x00report-status delete-refs ofs-delta\n'
             b'003f310ca9477129b8586fa2afc779c1f57cf64bba6c refs/heads/keepme\n'
             b'0000000eunpack ok\n'
             b'0019ok refs/heads/master\n'
             b'0000')
         self.rin.seek(0)
 
         def determine_wants(refs):
             return {b'refs/heads/master': b'0' * 40}
 
         def generate_pack_contents(have, want):
             return {}
 
         self.client.send_pack(b'/', determine_wants, generate_pack_contents)
         self.assertIn(
             self.rout.getvalue(),
             [b'007f310ca9477129b8586fa2afc779c1f57cf64bba6c '
              b'0000000000000000000000000000000000000000 '
              b'refs/heads/master\x00report-status ofs-delta0000',
              b'007f310ca9477129b8586fa2afc779c1f57cf64bba6c '
              b'0000000000000000000000000000000000000000 '
              b'refs/heads/master\x00ofs-delta report-status0000'])
 
     def test_send_pack_delete_only(self):
         self.rin.write(
             b'0063310ca9477129b8586fa2afc779c1f57cf64bba6c '
             b'refs/heads/master\x00report-status delete-refs ofs-delta\n'
             b'0000000eunpack ok\n'
             b'0019ok refs/heads/master\n'
             b'0000')
         self.rin.seek(0)
 
         def determine_wants(refs):
             return {b'refs/heads/master': b'0' * 40}
 
         def generate_pack_contents(have, want):
             return {}
 
         self.client.send_pack(b'/', determine_wants, generate_pack_contents)
         self.assertIn(
             self.rout.getvalue(),
             [b'007f310ca9477129b8586fa2afc779c1f57cf64bba6c '
              b'0000000000000000000000000000000000000000 '
              b'refs/heads/master\x00report-status ofs-delta0000',
              b'007f310ca9477129b8586fa2afc779c1f57cf64bba6c '
              b'0000000000000000000000000000000000000000 '
              b'refs/heads/master\x00ofs-delta report-status0000'])
 
     def test_send_pack_new_ref_only(self):
         self.rin.write(
             b'0063310ca9477129b8586fa2afc779c1f57cf64bba6c '
             b'refs/heads/master\x00report-status delete-refs ofs-delta\n'
             b'0000000eunpack ok\n'
             b'0019ok refs/heads/blah12\n'
             b'0000')
         self.rin.seek(0)
 
         def determine_wants(refs):
             return {
                 b'refs/heads/blah12':
                 b'310ca9477129b8586fa2afc779c1f57cf64bba6c',
                 b'refs/heads/master': b'310ca9477129b8586fa2afc779c1f57cf64bba6c'
             }
 
         def generate_pack_contents(have, want):
             return {}
 
         f = BytesIO()
         write_pack_objects(f, {})
         self.client.send_pack('/', determine_wants, generate_pack_contents)
         self.assertIn(
             self.rout.getvalue(),
             [b'007f0000000000000000000000000000000000000000 '
              b'310ca9477129b8586fa2afc779c1f57cf64bba6c '
              b'refs/heads/blah12\x00report-status ofs-delta0000' +
              f.getvalue(),
              b'007f0000000000000000000000000000000000000000 '
              b'310ca9477129b8586fa2afc779c1f57cf64bba6c '
              b'refs/heads/blah12\x00ofs-delta report-status0000' +
              f.getvalue()])
 
     def test_send_pack_new_ref(self):
         self.rin.write(
             b'0064310ca9477129b8586fa2afc779c1f57cf64bba6c '
             b'refs/heads/master\x00 report-status delete-refs ofs-delta\n'
             b'0000000eunpack ok\n'
             b'0019ok refs/heads/blah12\n'
             b'0000')
         self.rin.seek(0)
 
         tree = Tree()
         commit = Commit()
         commit.tree = tree
         commit.parents = []
         commit.author = commit.committer = b'test user'
         commit.commit_time = commit.author_time = 1174773719
         commit.commit_timezone = commit.author_timezone = 0
         commit.encoding = b'UTF-8'
         commit.message = b'test message'
 
         def determine_wants(refs):
             return {
                 b'refs/heads/blah12': commit.id,
                 b'refs/heads/master': b'310ca9477129b8586fa2afc779c1f57cf64bba6c'
             }
 
         def generate_pack_contents(have, want):
             return [(commit, None), (tree, b''), ]
 
         f = BytesIO()
         write_pack_objects(f, generate_pack_contents(None, None))
         self.client.send_pack(b'/', determine_wants, generate_pack_contents)
         self.assertIn(
             self.rout.getvalue(),
             [b'007f0000000000000000000000000000000000000000 ' + commit.id +
              b' refs/heads/blah12\x00report-status ofs-delta0000' + f.getvalue(),
              b'007f0000000000000000000000000000000000000000 ' + commit.id +
              b' refs/heads/blah12\x00ofs-delta report-status0000' + f.getvalue()])
 
     def test_send_pack_no_deleteref_delete_only(self):
         pkts = [b'310ca9477129b8586fa2afc779c1f57cf64bba6c refs/heads/master'
                 b'\x00 report-status ofs-delta\n',
                 b'',
                 b'']
         for pkt in pkts:
             if pkt == b'':
                 self.rin.write(b"0000")
             else:
                 self.rin.write(("%04x" % (len(pkt)+4)).encode('ascii') + pkt)
         self.rin.seek(0)
 
         def determine_wants(refs):
             return {b'refs/heads/master': b'0' * 40}
 
         def generate_pack_contents(have, want):
             return {}
 
         self.assertRaises(UpdateRefsError,
                           self.client.send_pack, b"/",
                           determine_wants, generate_pack_contents)
         self.assertEqual(self.rout.getvalue(), b'0000')
 
 
 class TestGetTransportAndPath(TestCase):
 
     def test_tcp(self):
         c, path = get_transport_and_path('git://foo.com/bar/baz')
         self.assertTrue(isinstance(c, TCPGitClient))
         self.assertEqual('foo.com', c._host)
         self.assertEqual(TCP_GIT_PORT, c._port)
         self.assertEqual('/bar/baz', path)
 
     def test_tcp_port(self):
         c, path = get_transport_and_path('git://foo.com:1234/bar/baz')
         self.assertTrue(isinstance(c, TCPGitClient))
         self.assertEqual('foo.com', c._host)
         self.assertEqual(1234, c._port)
         self.assertEqual('/bar/baz', path)
 
     def test_git_ssh_explicit(self):
         c, path = get_transport_and_path('git+ssh://foo.com/bar/baz')
         self.assertTrue(isinstance(c, SSHGitClient))
         self.assertEqual('foo.com', c.host)
         self.assertEqual(None, c.port)
         self.assertEqual(None, c.username)
         self.assertEqual('bar/baz', path)
 
     def test_ssh_explicit(self):
         c, path = get_transport_and_path('ssh://foo.com/bar/baz')
         self.assertTrue(isinstance(c, SSHGitClient))
         self.assertEqual('foo.com', c.host)
         self.assertEqual(None, c.port)
         self.assertEqual(None, c.username)
         self.assertEqual('bar/baz', path)
 
     def test_ssh_port_explicit(self):
         c, path = get_transport_and_path(
             'git+ssh://foo.com:1234/bar/baz')
         self.assertTrue(isinstance(c, SSHGitClient))
         self.assertEqual('foo.com', c.host)
         self.assertEqual(1234, c.port)
         self.assertEqual('bar/baz', path)
 
     def test_username_and_port_explicit_unknown_scheme(self):
         c, path = get_transport_and_path(
             'unknown://git@server:7999/dply/stuff.git')
         self.assertTrue(isinstance(c, SSHGitClient))
         self.assertEqual('unknown', c.host)
         self.assertEqual('//git@server:7999/dply/stuff.git', path)
 
     def test_username_and_port_explicit(self):
         c, path = get_transport_and_path(
             'ssh://git@server:7999/dply/stuff.git')
         self.assertTrue(isinstance(c, SSHGitClient))
         self.assertEqual('git', c.username)
         self.assertEqual('server', c.host)
         self.assertEqual(7999, c.port)
         self.assertEqual('dply/stuff.git', path)
 
     def test_ssh_abspath_explicit(self):
         c, path = get_transport_and_path('git+ssh://foo.com//bar/baz')
         self.assertTrue(isinstance(c, SSHGitClient))
         self.assertEqual('foo.com', c.host)
         self.assertEqual(None, c.port)
         self.assertEqual(None, c.username)
         self.assertEqual('/bar/baz', path)
 
     def test_ssh_port_abspath_explicit(self):
         c, path = get_transport_and_path(
             'git+ssh://foo.com:1234//bar/baz')
         self.assertTrue(isinstance(c, SSHGitClient))
         self.assertEqual('foo.com', c.host)
         self.assertEqual(1234, c.port)
         self.assertEqual('/bar/baz', path)
 
     def test_ssh_implicit(self):
         c, path = get_transport_and_path('foo:/bar/baz')
         self.assertTrue(isinstance(c, SSHGitClient))
         self.assertEqual('foo', c.host)
         self.assertEqual(None, c.port)
         self.assertEqual(None, c.username)
         self.assertEqual('/bar/baz', path)
 
     def test_ssh_host(self):
         c, path = get_transport_and_path('foo.com:/bar/baz')
         self.assertTrue(isinstance(c, SSHGitClient))
         self.assertEqual('foo.com', c.host)
         self.assertEqual(None, c.port)
         self.assertEqual(None, c.username)
         self.assertEqual('/bar/baz', path)
 
     def test_ssh_user_host(self):
         c, path = get_transport_and_path('user@foo.com:/bar/baz')
         self.assertTrue(isinstance(c, SSHGitClient))
         self.assertEqual('foo.com', c.host)
         self.assertEqual(None, c.port)
         self.assertEqual('user', c.username)
         self.assertEqual('/bar/baz', path)
 
     def test_ssh_relpath(self):
         c, path = get_transport_and_path('foo:bar/baz')
         self.assertTrue(isinstance(c, SSHGitClient))
         self.assertEqual('foo', c.host)
         self.assertEqual(None, c.port)
         self.assertEqual(None, c.username)
         self.assertEqual('bar/baz', path)
 
     def test_ssh_host_relpath(self):
         c, path = get_transport_and_path('foo.com:bar/baz')
         self.assertTrue(isinstance(c, SSHGitClient))
         self.assertEqual('foo.com', c.host)
         self.assertEqual(None, c.port)
         self.assertEqual(None, c.username)
         self.assertEqual('bar/baz', path)
 
     def test_ssh_user_host_relpath(self):
         c, path = get_transport_and_path('user@foo.com:bar/baz')
         self.assertTrue(isinstance(c, SSHGitClient))
         self.assertEqual('foo.com', c.host)
         self.assertEqual(None, c.port)
         self.assertEqual('user', c.username)
         self.assertEqual('bar/baz', path)
 
     def test_local(self):
         c, path = get_transport_and_path('foo.bar/baz')
         self.assertTrue(isinstance(c, LocalGitClient))
         self.assertEqual('foo.bar/baz', path)
 
     @skipIf(sys.platform != 'win32', 'Behaviour only happens on windows.')
     def test_local_abs_windows_path(self):
         c, path = get_transport_and_path('C:\\foo.bar\\baz')
         self.assertTrue(isinstance(c, LocalGitClient))
         self.assertEqual('C:\\foo.bar\\baz', path)
 
     def test_error(self):
         # Need to use a known urlparse.uses_netloc URL scheme to get the
         # expected parsing of the URL on Python versions less than 2.6.5
         c, path = get_transport_and_path('prospero://bar/baz')
         self.assertTrue(isinstance(c, SSHGitClient))
 
     def test_http(self):
         url = 'https://github.com/jelmer/dulwich'
         c, path = get_transport_and_path(url)
         self.assertTrue(isinstance(c, HttpGitClient))
         self.assertEqual('/jelmer/dulwich', path)
 
     def test_http_auth(self):
         url = 'https://user:passwd@github.com/jelmer/dulwich'
 
         c, path = get_transport_and_path(url)
 
         self.assertTrue(isinstance(c, HttpGitClient))
         self.assertEqual('/jelmer/dulwich', path)
         self.assertEqual('user', c._username)
         self.assertEqual('passwd', c._password)
 
     def test_http_no_auth(self):
         url = 'https://github.com/jelmer/dulwich'
 
         c, path = get_transport_and_path(url)
 
         self.assertTrue(isinstance(c, HttpGitClient))
         self.assertEqual('/jelmer/dulwich', path)
         self.assertIs(None, c._username)
         self.assertIs(None, c._password)
 
 
 class TestGetTransportAndPathFromUrl(TestCase):
 
     def test_tcp(self):
         c, path = get_transport_and_path_from_url('git://foo.com/bar/baz')
         self.assertTrue(isinstance(c, TCPGitClient))
         self.assertEqual('foo.com', c._host)
         self.assertEqual(TCP_GIT_PORT, c._port)
         self.assertEqual('/bar/baz', path)
 
     def test_tcp_port(self):
         c, path = get_transport_and_path_from_url('git://foo.com:1234/bar/baz')
         self.assertTrue(isinstance(c, TCPGitClient))
         self.assertEqual('foo.com', c._host)
         self.assertEqual(1234, c._port)
         self.assertEqual('/bar/baz', path)
 
     def test_ssh_explicit(self):
         c, path = get_transport_and_path_from_url('git+ssh://foo.com/bar/baz')
         self.assertTrue(isinstance(c, SSHGitClient))
         self.assertEqual('foo.com', c.host)
         self.assertEqual(None, c.port)
         self.assertEqual(None, c.username)
         self.assertEqual('bar/baz', path)
 
     def test_ssh_port_explicit(self):
         c, path = get_transport_and_path_from_url(
             'git+ssh://foo.com:1234/bar/baz')
         self.assertTrue(isinstance(c, SSHGitClient))
         self.assertEqual('foo.com', c.host)
         self.assertEqual(1234, c.port)
         self.assertEqual('bar/baz', path)
 
     def test_ssh_abspath_explicit(self):
         c, path = get_transport_and_path_from_url('git+ssh://foo.com//bar/baz')
         self.assertTrue(isinstance(c, SSHGitClient))
         self.assertEqual('foo.com', c.host)
         self.assertEqual(None, c.port)
         self.assertEqual(None, c.username)
         self.assertEqual('/bar/baz', path)
 
     def test_ssh_port_abspath_explicit(self):
         c, path = get_transport_and_path_from_url(
             'git+ssh://foo.com:1234//bar/baz')
         self.assertTrue(isinstance(c, SSHGitClient))
         self.assertEqual('foo.com', c.host)
         self.assertEqual(1234, c.port)
         self.assertEqual('/bar/baz', path)
 
     def test_ssh_host_relpath(self):
         self.assertRaises(ValueError, get_transport_and_path_from_url,
             'foo.com:bar/baz')
 
     def test_ssh_user_host_relpath(self):
         self.assertRaises(ValueError, get_transport_and_path_from_url,
             'user@foo.com:bar/baz')
 
     def test_local_path(self):
         self.assertRaises(ValueError, get_transport_and_path_from_url,
             'foo.bar/baz')
 
     def test_error(self):
         # Need to use a known urlparse.uses_netloc URL scheme to get the
         # expected parsing of the URL on Python versions less than 2.6.5
         self.assertRaises(ValueError, get_transport_and_path_from_url,
             'prospero://bar/baz')
 
     def test_http(self):
         url = 'https://github.com/jelmer/dulwich'
         c, path = get_transport_and_path_from_url(url)
         self.assertTrue(isinstance(c, HttpGitClient))
         self.assertEqual('/jelmer/dulwich', path)
 
     def test_file(self):
         c, path = get_transport_and_path_from_url('file:///home/jelmer/foo')
         self.assertTrue(isinstance(c, LocalGitClient))
         self.assertEqual('/home/jelmer/foo', path)
 
 
 class TestSSHVendor(object):
 
     def __init__(self):
         self.host = None
         self.command = ""
         self.username = None
         self.port = None
 
     def run_command(self, host, command, username=None, port=None):
         if not isinstance(command, bytes):
             raise TypeError(command)
 
         self.host = host
         self.command = command
         self.username = username
         self.port = port
 
         class Subprocess: pass
         setattr(Subprocess, 'read', lambda: None)
         setattr(Subprocess, 'write', lambda: None)
         setattr(Subprocess, 'close', lambda: None)
         setattr(Subprocess, 'can_read', lambda: None)
         return Subprocess()
 
 
 class SSHGitClientTests(TestCase):
 
     def setUp(self):
         super(SSHGitClientTests, self).setUp()
 
         self.server = TestSSHVendor()
         self.real_vendor = client.get_ssh_vendor
         client.get_ssh_vendor = lambda: self.server
 
         self.client = SSHGitClient('git.samba.org')
 
     def tearDown(self):
         super(SSHGitClientTests, self).tearDown()
         client.get_ssh_vendor = self.real_vendor
 
     def test_get_url(self):
         path = '/tmp/repo.git'
         c = SSHGitClient('git.samba.org')
 
         url = c.get_url(path)
         self.assertEqual('ssh://git.samba.org/tmp/repo.git', url)
 
     def test_get_url_with_username_and_port(self):
         path = '/tmp/repo.git'
         c = SSHGitClient('git.samba.org', port=2222, username='user')
 
         url = c.get_url(path)
         self.assertEqual('ssh://user@git.samba.org:2222/tmp/repo.git', url)
 
     def test_default_command(self):
         self.assertEqual(b'git-upload-pack',
                 self.client._get_cmd_path(b'upload-pack'))
 
     def test_alternative_command_path(self):
         self.client.alternative_paths[b'upload-pack'] = (
             b'/usr/lib/git/git-upload-pack')
         self.assertEqual(b'/usr/lib/git/git-upload-pack',
             self.client._get_cmd_path(b'upload-pack'))
 
     def test_alternative_command_path_spaces(self):
         self.client.alternative_paths[b'upload-pack'] = (
             b'/usr/lib/git/git-upload-pack -ibla')
         self.assertEqual(b"/usr/lib/git/git-upload-pack -ibla",
             self.client._get_cmd_path(b'upload-pack'))
 
     def test_connect(self):
         server = self.server
         client = self.client
 
         client.username = b"username"
         client.port = 1337
 
         client._connect(b"command", b"/path/to/repo")
         self.assertEqual(b"username", server.username)
         self.assertEqual(1337, server.port)
         self.assertEqual(b"git-command '/path/to/repo'", server.command)
 
         client._connect(b"relative-command", b"/~/path/to/repo")
         self.assertEqual(b"git-relative-command '~/path/to/repo'",
                           server.command)
 
 
 class ReportStatusParserTests(TestCase):
 
     def test_invalid_pack(self):
         parser = ReportStatusParser()
         parser.handle_packet(b"unpack error - foo bar")
         parser.handle_packet(b"ok refs/foo/bar")
         parser.handle_packet(None)
         self.assertRaises(SendPackError, parser.check)
 
     def test_update_refs_error(self):
         parser = ReportStatusParser()
         parser.handle_packet(b"unpack ok")
         parser.handle_packet(b"ng refs/foo/bar need to pull")
         parser.handle_packet(None)
         self.assertRaises(UpdateRefsError, parser.check)
 
     def test_ok(self):
         parser = ReportStatusParser()
         parser.handle_packet(b"unpack ok")
         parser.handle_packet(b"ok refs/foo/bar")
         parser.handle_packet(None)
         parser.check()
 
 
 class LocalGitClientTests(TestCase):
 
     def test_get_url(self):
         path = "/tmp/repo.git"
         c = LocalGitClient()
 
         url = c.get_url(path)
         self.assertEqual('file:///tmp/repo.git', url)
 
     def test_fetch_into_empty(self):
         c = LocalGitClient()
         t = MemoryRepo()
         s = open_repo('a.git')
         self.addCleanup(tear_down_repo, s)
         self.assertEqual(s.get_refs(), c.fetch(s.path, t))
 
     def test_fetch_empty(self):
         c = LocalGitClient()
         s = open_repo('a.git')
         self.addCleanup(tear_down_repo, s)
         out = BytesIO()
         walker = {}
         ret = c.fetch_pack(s.path, lambda heads: [], graph_walker=walker,
             pack_data=out.write)
         self.assertEqual({
             b'HEAD': b'a90fa2d900a17e99b433217e988c4eb4a2e9a097',
             b'refs/heads/master': b'a90fa2d900a17e99b433217e988c4eb4a2e9a097',
             b'refs/tags/mytag': b'28237f4dc30d0d462658d6b937b08a0f0b6ef55a',
             b'refs/tags/mytag-packed': b'b0931cadc54336e78a1d980420e3268903b57a50'
             }, ret)
         self.assertEqual(b"PACK\x00\x00\x00\x02\x00\x00\x00\x00\x02\x9d\x08"
             b"\x82;\xd8\xa8\xea\xb5\x10\xadj\xc7\\\x82<\xfd>\xd3\x1e", out.getvalue())
 
     def test_fetch_pack_none(self):
         c = LocalGitClient()
         s = open_repo('a.git')
         self.addCleanup(tear_down_repo, s)
         out = BytesIO()
         walker = MemoryRepo().get_graph_walker()
         c.fetch_pack(s.path,
             lambda heads: [b"a90fa2d900a17e99b433217e988c4eb4a2e9a097"],
             graph_walker=walker, pack_data=out.write)
         # Hardcoding is not ideal, but we'll fix that some other day..
         self.assertTrue(out.getvalue().startswith(b'PACK\x00\x00\x00\x02\x00\x00\x00\x07'))
 
     def test_send_pack_without_changes(self):
         local = open_repo('a.git')
         self.addCleanup(tear_down_repo, local)
 
         target = open_repo('a.git')
         self.addCleanup(tear_down_repo, target)
 
         self.send_and_verify(b"master", local, target)
 
     def test_send_pack_with_changes(self):
         local = open_repo('a.git')
         self.addCleanup(tear_down_repo, local)
 
         target_path = tempfile.mkdtemp()
         self.addCleanup(shutil.rmtree, target_path)
-        with closing(Repo.init_bare(target_path)) as target:
+        with Repo.init_bare(target_path) as target:
             self.send_and_verify(b"master", local, target)
 
     def test_get_refs(self):
         local = open_repo('refs.git')
         self.addCleanup(tear_down_repo, local)
 
         client = LocalGitClient()
         refs = client.get_refs(local.path)
         self.assertDictEqual(local.refs.as_dict(), refs)
 
     def send_and_verify(self, branch, local, target):
         """Send a branch from local to remote repository and verify it worked."""
         client = LocalGitClient()
         ref_name = b"refs/heads/" + branch
         new_refs = client.send_pack(target.path,
                                     lambda _: { ref_name: local.refs[ref_name] },
                                     local.object_store.generate_pack_contents)
 
         self.assertEqual(local.refs[ref_name], new_refs[ref_name])
 
         obj_local = local.get_object(new_refs[ref_name])
         obj_target = target.get_object(new_refs[ref_name])
         self.assertEqual(obj_local, obj_target)
 
 
 class HttpGitClientTests(TestCase):
 
     def test_get_url(self):
         base_url = 'https://github.com/jelmer/dulwich'
         path = '/jelmer/dulwich'
         c = HttpGitClient(base_url)
 
         url = c.get_url(path)
         self.assertEqual('https://github.com/jelmer/dulwich', url)
 
     def test_get_url_with_username_and_passwd(self):
         base_url = 'https://github.com/jelmer/dulwich'
         path = '/jelmer/dulwich'
         c = HttpGitClient(base_url, username='USERNAME', password='PASSWD')
 
         url = c.get_url(path)
         self.assertEqual('https://github.com/jelmer/dulwich', url)
 
     def test_init_username_passwd_set(self):
         url = 'https://github.com/jelmer/dulwich'
 
         c = HttpGitClient(url, config=None, username='user', password='passwd')
         self.assertEqual('user', c._username)
         self.assertEqual('passwd', c._password)
         [pw_handler] = [
             h for h in c.opener.handlers if getattr(h, 'passwd', None) is not None]
         self.assertEqual(
             ('user', 'passwd'),
             pw_handler.passwd.find_user_password(
                 None, 'https://github.com/jelmer/dulwich'))
 
     def test_init_no_username_passwd(self):
         url = 'https://github.com/jelmer/dulwich'
 
         c = HttpGitClient(url, config=None)
         self.assertIs(None, c._username)
         self.assertIs(None, c._password)
         pw_handler = [
             h for h in c.opener.handlers if getattr(h, 'passwd', None) is not None]
         self.assertEqual(0, len(pw_handler))
 
 
 class TCPGitClientTests(TestCase):
 
     def test_get_url(self):
         host = 'github.com'
         path = '/jelmer/dulwich'
         c = TCPGitClient(host)
 
         url = c.get_url(path)
         self.assertEqual('git://github.com/jelmer/dulwich', url)
 
     def test_get_url_with_port(self):
         host = 'github.com'
         path = '/jelmer/dulwich'
         port = 9090
         c = TCPGitClient(host, port=9090)
 
         url = c.get_url(path)
         self.assertEqual('git://github.com:9090/jelmer/dulwich', url)
diff --git a/dulwich/tests/test_index.py b/dulwich/tests/test_index.py
index 45e31a32..2e55bdde 100644
--- a/dulwich/tests/test_index.py
+++ b/dulwich/tests/test_index.py
@@ -1,502 +1,501 @@
 # -*- coding: utf-8 -*-
 # test_index.py -- Tests for the git index
 # encoding: utf-8
 # Copyright (C) 2008-2009 Jelmer Vernooij <jelmer@samba.org>
 #
 # Dulwich is dual-licensed under the Apache License, Version 2.0 and the GNU
 # General Public License as public by the Free Software Foundation; version 2.0
 # or (at your option) any later version. You can redistribute it and/or
 # modify it under the terms of either of these two licenses.
 #
 # Unless required by applicable law or agreed to in writing, software
 # distributed under the License is distributed on an "AS IS" BASIS,
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
 #
 # You should have received a copy of the licenses; if not, see
 # <http://www.gnu.org/licenses/> for a copy of the GNU General Public License
 # and <http://www.apache.org/licenses/LICENSE-2.0> for a copy of the Apache
 # License, Version 2.0.
 #
 
 """Tests for the index."""
 
 
-from contextlib import closing
 from io import BytesIO
 import os
 import shutil
 import stat
 import struct
 import sys
 import tempfile
 
 from dulwich.index import (
     Index,
     build_index_from_tree,
     cleanup_mode,
     commit_tree,
     get_unstaged_changes,
     index_entry_from_stat,
     read_index,
     read_index_dict,
     validate_path_element_default,
     validate_path_element_ntfs,
     write_cache_time,
     write_index,
     write_index_dict,
     _tree_to_fs_path,
     _fs_to_tree_path,
     )
 from dulwich.object_store import (
     MemoryObjectStore,
     )
 from dulwich.objects import (
     Blob,
     Tree,
     )
 from dulwich.repo import Repo
 from dulwich.tests import (
     TestCase,
     skipIf,
     )
 
 class IndexTestCase(TestCase):
 
     datadir = os.path.join(os.path.dirname(__file__), 'data/indexes')
 
     def get_simple_index(self, name):
         return Index(os.path.join(self.datadir, name))
 
 
 class SimpleIndexTestCase(IndexTestCase):
 
     def test_len(self):
         self.assertEqual(1, len(self.get_simple_index("index")))
 
     def test_iter(self):
         self.assertEqual([b'bla'], list(self.get_simple_index("index")))
 
     def test_getitem(self):
         self.assertEqual(((1230680220, 0), (1230680220, 0), 2050, 3761020,
                            33188, 1000, 1000, 0,
                            b'e69de29bb2d1d6434b8b29ae775ad8c2e48c5391', 0),
                           self.get_simple_index("index")[b"bla"])
 
     def test_empty(self):
         i = self.get_simple_index("notanindex")
         self.assertEqual(0, len(i))
         self.assertFalse(os.path.exists(i._filename))
 
     def test_against_empty_tree(self):
         i = self.get_simple_index("index")
         changes = list(i.changes_from_tree(MemoryObjectStore(), None))
         self.assertEqual(1, len(changes))
         (oldname, newname), (oldmode, newmode), (oldsha, newsha) = changes[0]
         self.assertEqual(b'bla', newname)
         self.assertEqual(b'e69de29bb2d1d6434b8b29ae775ad8c2e48c5391', newsha)
 
 class SimpleIndexWriterTestCase(IndexTestCase):
 
     def setUp(self):
         IndexTestCase.setUp(self)
         self.tempdir = tempfile.mkdtemp()
 
     def tearDown(self):
         IndexTestCase.tearDown(self)
         shutil.rmtree(self.tempdir)
 
     def test_simple_write(self):
         entries = [(b'barbla', (1230680220, 0), (1230680220, 0), 2050, 3761020,
                     33188, 1000, 1000, 0,
                     b'e69de29bb2d1d6434b8b29ae775ad8c2e48c5391', 0)]
         filename = os.path.join(self.tempdir, 'test-simple-write-index')
         with open(filename, 'wb+') as x:
             write_index(x, entries)
 
         with open(filename, 'rb') as x:
             self.assertEqual(entries, list(read_index(x)))
 
 
 class ReadIndexDictTests(IndexTestCase):
 
     def setUp(self):
         IndexTestCase.setUp(self)
         self.tempdir = tempfile.mkdtemp()
 
     def tearDown(self):
         IndexTestCase.tearDown(self)
         shutil.rmtree(self.tempdir)
 
     def test_simple_write(self):
         entries = {b'barbla': ((1230680220, 0), (1230680220, 0), 2050, 3761020,
                     33188, 1000, 1000, 0,
                     b'e69de29bb2d1d6434b8b29ae775ad8c2e48c5391', 0)}
         filename = os.path.join(self.tempdir, 'test-simple-write-index')
         with open(filename, 'wb+') as x:
             write_index_dict(x, entries)
 
         with open(filename, 'rb') as x:
             self.assertEqual(entries, read_index_dict(x))
 
 
 class CommitTreeTests(TestCase):
 
     def setUp(self):
         super(CommitTreeTests, self).setUp()
         self.store = MemoryObjectStore()
 
     def test_single_blob(self):
         blob = Blob()
         blob.data = b"foo"
         self.store.add_object(blob)
         blobs = [(b"bla", blob.id, stat.S_IFREG)]
         rootid = commit_tree(self.store, blobs)
         self.assertEqual(rootid, b"1a1e80437220f9312e855c37ac4398b68e5c1d50")
         self.assertEqual((stat.S_IFREG, blob.id), self.store[rootid][b"bla"])
         self.assertEqual(set([rootid, blob.id]), set(self.store._data.keys()))
 
     def test_nested(self):
         blob = Blob()
         blob.data = b"foo"
         self.store.add_object(blob)
         blobs = [(b"bla/bar", blob.id, stat.S_IFREG)]
         rootid = commit_tree(self.store, blobs)
         self.assertEqual(rootid, b"d92b959b216ad0d044671981196781b3258fa537")
         dirid = self.store[rootid][b"bla"][1]
         self.assertEqual(dirid, b"c1a1deb9788150829579a8b4efa6311e7b638650")
         self.assertEqual((stat.S_IFDIR, dirid), self.store[rootid][b"bla"])
         self.assertEqual((stat.S_IFREG, blob.id), self.store[dirid][b"bar"])
         self.assertEqual(set([rootid, dirid, blob.id]),
                           set(self.store._data.keys()))
 
 
 class CleanupModeTests(TestCase):
 
     def test_file(self):
         self.assertEqual(0o100644, cleanup_mode(0o100000))
 
     def test_executable(self):
         self.assertEqual(0o100755, cleanup_mode(0o100711))
 
     def test_symlink(self):
         self.assertEqual(0o120000, cleanup_mode(0o120711))
 
     def test_dir(self):
         self.assertEqual(0o040000, cleanup_mode(0o40531))
 
     def test_submodule(self):
         self.assertEqual(0o160000, cleanup_mode(0o160744))
 
 
 class WriteCacheTimeTests(TestCase):
 
     def test_write_string(self):
         f = BytesIO()
         self.assertRaises(TypeError, write_cache_time, f, "foo")
 
     def test_write_int(self):
         f = BytesIO()
         write_cache_time(f, 434343)
         self.assertEqual(struct.pack(">LL", 434343, 0), f.getvalue())
 
     def test_write_tuple(self):
         f = BytesIO()
         write_cache_time(f, (434343, 21))
         self.assertEqual(struct.pack(">LL", 434343, 21), f.getvalue())
 
     def test_write_float(self):
         f = BytesIO()
         write_cache_time(f, 434343.000000021)
         self.assertEqual(struct.pack(">LL", 434343, 21), f.getvalue())
 
 
 class IndexEntryFromStatTests(TestCase):
 
     def test_simple(self):
         st = os.stat_result((16877, 131078, 64769,
                 154, 1000, 1000, 12288,
                 1323629595, 1324180496, 1324180496))
         entry = index_entry_from_stat(st, "22" * 20, 0)
         self.assertEqual(entry, (
             1324180496,
             1324180496,
             64769,
             131078,
             16384,
             1000,
             1000,
             12288,
             '2222222222222222222222222222222222222222',
             0))
 
     def test_override_mode(self):
         st = os.stat_result((stat.S_IFREG + 0o644, 131078, 64769,
                 154, 1000, 1000, 12288,
                 1323629595, 1324180496, 1324180496))
         entry = index_entry_from_stat(st, "22" * 20, 0,
                 mode=stat.S_IFREG + 0o755)
         self.assertEqual(entry, (
             1324180496,
             1324180496,
             64769,
             131078,
             33261,
             1000,
             1000,
             12288,
             '2222222222222222222222222222222222222222',
             0))
 
 
 class BuildIndexTests(TestCase):
 
     def assertReasonableIndexEntry(self, index_entry, mode, filesize, sha):
         self.assertEqual(index_entry[4], mode)  # mode
         self.assertEqual(index_entry[7], filesize)  # filesize
         self.assertEqual(index_entry[8], sha)  # sha
 
     def assertFileContents(self, path, contents, symlink=False):
         if symlink:
             self.assertEqual(os.readlink(path), contents)
         else:
             with open(path, 'rb') as f:
                 self.assertEqual(f.read(), contents)
 
     def test_empty(self):
         repo_dir = tempfile.mkdtemp()
         self.addCleanup(shutil.rmtree, repo_dir)
-        with closing(Repo.init(repo_dir)) as repo:
+        with Repo.init(repo_dir) as repo:
             tree = Tree()
             repo.object_store.add_object(tree)
 
             build_index_from_tree(repo.path, repo.index_path(),
                     repo.object_store, tree.id)
 
             # Verify index entries
             index = repo.open_index()
             self.assertEqual(len(index), 0)
 
             # Verify no files
             self.assertEqual(['.git'], os.listdir(repo.path))
 
     def test_git_dir(self):
         repo_dir = tempfile.mkdtemp()
         self.addCleanup(shutil.rmtree, repo_dir)
-        with closing(Repo.init(repo_dir)) as repo:
+        with Repo.init(repo_dir) as repo:
 
             # Populate repo
             filea = Blob.from_string(b'file a')
             filee = Blob.from_string(b'd')
 
             tree = Tree()
             tree[b'.git/a'] = (stat.S_IFREG | 0o644, filea.id)
             tree[b'c/e'] = (stat.S_IFREG | 0o644, filee.id)
 
             repo.object_store.add_objects([(o, None)
                 for o in [filea, filee, tree]])
 
             build_index_from_tree(repo.path, repo.index_path(),
                     repo.object_store, tree.id)
 
             # Verify index entries
             index = repo.open_index()
             self.assertEqual(len(index), 1)
 
             # filea
             apath = os.path.join(repo.path, '.git', 'a')
             self.assertFalse(os.path.exists(apath))
 
             # filee
             epath = os.path.join(repo.path, 'c', 'e')
             self.assertTrue(os.path.exists(epath))
             self.assertReasonableIndexEntry(index[b'c/e'],
                 stat.S_IFREG | 0o644, 1, filee.id)
             self.assertFileContents(epath, b'd')
 
     def test_nonempty(self):
         repo_dir = tempfile.mkdtemp()
         self.addCleanup(shutil.rmtree, repo_dir)
-        with closing(Repo.init(repo_dir)) as repo:
+        with Repo.init(repo_dir) as repo:
 
             # Populate repo
             filea = Blob.from_string(b'file a')
             fileb = Blob.from_string(b'file b')
             filed = Blob.from_string(b'file d')
 
             tree = Tree()
             tree[b'a'] = (stat.S_IFREG | 0o644, filea.id)
             tree[b'b'] = (stat.S_IFREG | 0o644, fileb.id)
             tree[b'c/d'] = (stat.S_IFREG | 0o644, filed.id)
 
             repo.object_store.add_objects([(o, None)
                 for o in [filea, fileb, filed, tree]])
 
             build_index_from_tree(repo.path, repo.index_path(),
                     repo.object_store, tree.id)
 
             # Verify index entries
             index = repo.open_index()
             self.assertEqual(len(index), 3)
 
             # filea
             apath = os.path.join(repo.path, 'a')
             self.assertTrue(os.path.exists(apath))
             self.assertReasonableIndexEntry(index[b'a'],
                 stat.S_IFREG | 0o644, 6, filea.id)
             self.assertFileContents(apath, b'file a')
 
             # fileb
             bpath = os.path.join(repo.path, 'b')
             self.assertTrue(os.path.exists(bpath))
             self.assertReasonableIndexEntry(index[b'b'],
                 stat.S_IFREG | 0o644, 6, fileb.id)
             self.assertFileContents(bpath, b'file b')
 
             # filed
             dpath = os.path.join(repo.path, 'c', 'd')
             self.assertTrue(os.path.exists(dpath))
             self.assertReasonableIndexEntry(index[b'c/d'],
                 stat.S_IFREG | 0o644, 6, filed.id)
             self.assertFileContents(dpath, b'file d')
 
             # Verify no extra files
             self.assertEqual(['.git', 'a', 'b', 'c'],
                 sorted(os.listdir(repo.path)))
             self.assertEqual(['d'],
                 sorted(os.listdir(os.path.join(repo.path, 'c'))))
 
     @skipIf(not getattr(os, 'symlink', None), 'Requires symlink support')
     def test_symlink(self):
         repo_dir = tempfile.mkdtemp()
         self.addCleanup(shutil.rmtree, repo_dir)
-        with closing(Repo.init(repo_dir)) as repo:
+        with Repo.init(repo_dir) as repo:
 
             # Populate repo
             filed = Blob.from_string(b'file d')
             filee = Blob.from_string(b'd')
 
             tree = Tree()
             tree[b'c/d'] = (stat.S_IFREG | 0o644, filed.id)
             tree[b'c/e'] = (stat.S_IFLNK, filee.id)  # symlink
 
             repo.object_store.add_objects([(o, None)
                 for o in [filed, filee, tree]])
 
             build_index_from_tree(repo.path, repo.index_path(),
                     repo.object_store, tree.id)
 
             # Verify index entries
             index = repo.open_index()
 
             # symlink to d
             epath = os.path.join(repo.path, 'c', 'e')
             self.assertTrue(os.path.exists(epath))
             self.assertReasonableIndexEntry(
                 index[b'c/e'], stat.S_IFLNK,
                 0 if sys.platform == 'win32' else 1,
                 filee.id)
             self.assertFileContents(epath, 'd', symlink=True)
 
     def test_no_decode_encode(self):
         repo_dir = tempfile.mkdtemp()
         repo_dir_bytes = repo_dir.encode(sys.getfilesystemencoding())
         self.addCleanup(shutil.rmtree, repo_dir)
-        with closing(Repo.init(repo_dir)) as repo:
+        with Repo.init(repo_dir) as repo:
 
             # Populate repo
             file = Blob.from_string(b'foo')
 
             tree = Tree()
             latin1_name = u'À'.encode('latin1')
             utf8_name = u'À'.encode('utf8')
             tree[latin1_name] = (stat.S_IFREG | 0o644, file.id)
             tree[utf8_name] = (stat.S_IFREG | 0o644, file.id)
 
             repo.object_store.add_objects(
                 [(o, None) for o in [file, tree]])
 
             build_index_from_tree(
                 repo.path, repo.index_path(),
                 repo.object_store, tree.id)
 
             # Verify index entries
             index = repo.open_index()
 
             latin1_path = os.path.join(repo_dir_bytes, latin1_name)
             self.assertTrue(os.path.exists(latin1_path))
 
             utf8_path = os.path.join(repo_dir_bytes, utf8_name)
             self.assertTrue(os.path.exists(utf8_path))
 
 
 class GetUnstagedChangesTests(TestCase):
 
     def test_get_unstaged_changes(self):
         """Unit test for get_unstaged_changes."""
 
         repo_dir = tempfile.mkdtemp()
         self.addCleanup(shutil.rmtree, repo_dir)
-        with closing(Repo.init(repo_dir)) as repo:
+        with Repo.init(repo_dir) as repo:
 
             # Commit a dummy file then modify it
             foo1_fullpath = os.path.join(repo_dir, 'foo1')
             with open(foo1_fullpath, 'wb') as f:
                 f.write(b'origstuff')
 
             foo2_fullpath = os.path.join(repo_dir, 'foo2')
             with open(foo2_fullpath, 'wb') as f:
                 f.write(b'origstuff')
 
             repo.stage(['foo1', 'foo2'])
             repo.do_commit(b'test status', author=b'', committer=b'')
 
             with open(foo1_fullpath, 'wb') as f:
                 f.write(b'newstuff')
 
             # modify access and modify time of path
             os.utime(foo1_fullpath, (0, 0))
 
             changes = get_unstaged_changes(repo.open_index(), repo_dir)
 
             self.assertEqual(list(changes), [b'foo1'])
 
 
 class TestValidatePathElement(TestCase):
 
     def test_default(self):
         self.assertTrue(validate_path_element_default(b"bla"))
         self.assertTrue(validate_path_element_default(b".bla"))
         self.assertFalse(validate_path_element_default(b".git"))
         self.assertFalse(validate_path_element_default(b".giT"))
         self.assertFalse(validate_path_element_default(b".."))
         self.assertTrue(validate_path_element_default(b"git~1"))
 
     def test_ntfs(self):
         self.assertTrue(validate_path_element_ntfs(b"bla"))
         self.assertTrue(validate_path_element_ntfs(b".bla"))
         self.assertFalse(validate_path_element_ntfs(b".git"))
         self.assertFalse(validate_path_element_ntfs(b".giT"))
         self.assertFalse(validate_path_element_ntfs(b".."))
         self.assertFalse(validate_path_element_ntfs(b"git~1"))
 
 
 class TestTreeFSPathConversion(TestCase):
 
     def test_tree_to_fs_path(self):
         tree_path = u'délwíçh/foo'.encode('utf8')
         fs_path = _tree_to_fs_path(b'/prefix/path', tree_path)
         self.assertEqual(
             fs_path,
             os.path.join(u'/prefix/path', u'délwíçh', u'foo').encode('utf8'))
 
     def test_fs_to_tree_path_str(self):
         fs_path = os.path.join(os.path.join(u'délwíçh', u'foo'))
         tree_path = _fs_to_tree_path(fs_path, "utf-8")
         self.assertEqual(tree_path, u'délwíçh/foo'.encode("utf-8"))
 
     def test_fs_to_tree_path_bytes(self):
         fs_path = os.path.join(os.path.join(u'délwíçh', u'foo').encode('utf8'))
         tree_path = _fs_to_tree_path(fs_path, "utf-8")
         self.assertEqual(tree_path, u'délwíçh/foo'.encode('utf8'))
diff --git a/dulwich/tests/test_porcelain.py b/dulwich/tests/test_porcelain.py
index 45b1c4a0..2198df13 100644
--- a/dulwich/tests/test_porcelain.py
+++ b/dulwich/tests/test_porcelain.py
@@ -1,897 +1,896 @@
 # test_porcelain.py -- porcelain tests
 # Copyright (C) 2013 Jelmer Vernooij <jelmer@samba.org>
 #
 # Dulwich is dual-licensed under the Apache License, Version 2.0 and the GNU
 # General Public License as public by the Free Software Foundation; version 2.0
 # or (at your option) any later version. You can redistribute it and/or
 # modify it under the terms of either of these two licenses.
 #
 # Unless required by applicable law or agreed to in writing, software
 # distributed under the License is distributed on an "AS IS" BASIS,
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
 #
 # You should have received a copy of the licenses; if not, see
 # <http://www.gnu.org/licenses/> for a copy of the GNU General Public License
 # and <http://www.apache.org/licenses/LICENSE-2.0> for a copy of the Apache
 # License, Version 2.0.
 #
 
 """Tests for dulwich.porcelain."""
 
-from contextlib import closing
 from io import BytesIO
 try:
     from StringIO import StringIO
 except ImportError:
     from io import StringIO
 import os
 import shutil
 import tarfile
 import tempfile
 import time
 
 from dulwich import porcelain
 from dulwich.diff_tree import tree_changes
 from dulwich.objects import (
     Blob,
     Tag,
     Tree,
     ZERO_SHA,
     )
 from dulwich.repo import Repo
 from dulwich.tests import (
     TestCase,
     )
 from dulwich.tests.utils import (
     build_commit_graph,
     make_object,
     )
 
 
 class PorcelainTestCase(TestCase):
 
     def setUp(self):
         super(PorcelainTestCase, self).setUp()
         repo_dir = tempfile.mkdtemp()
         self.addCleanup(shutil.rmtree, repo_dir)
         self.repo = Repo.init(repo_dir)
 
     def tearDown(self):
         super(PorcelainTestCase, self).tearDown()
         self.repo.close()
 
 
 class ArchiveTests(PorcelainTestCase):
     """Tests for the archive command."""
 
     def test_simple(self):
         c1, c2, c3 = build_commit_graph(self.repo.object_store, [[1], [2, 1], [3, 1, 2]])
         self.repo.refs[b"refs/heads/master"] = c3.id
         out = BytesIO()
         err = BytesIO()
         porcelain.archive(self.repo.path, b"refs/heads/master", outstream=out,
             errstream=err)
         self.assertEqual(b"", err.getvalue())
         tf = tarfile.TarFile(fileobj=out)
         self.addCleanup(tf.close)
         self.assertEqual([], tf.getnames())
 
 
 class UpdateServerInfoTests(PorcelainTestCase):
 
     def test_simple(self):
         c1, c2, c3 = build_commit_graph(self.repo.object_store, [[1], [2, 1],
             [3, 1, 2]])
         self.repo.refs[b"refs/heads/foo"] = c3.id
         porcelain.update_server_info(self.repo.path)
         self.assertTrue(os.path.exists(os.path.join(self.repo.controldir(),
             'info', 'refs')))
 
 
 class CommitTests(PorcelainTestCase):
 
     def test_custom_author(self):
         c1, c2, c3 = build_commit_graph(self.repo.object_store, [[1], [2, 1],
             [3, 1, 2]])
         self.repo.refs[b"refs/heads/foo"] = c3.id
         sha = porcelain.commit(self.repo.path, message=b"Some message",
                 author=b"Joe <joe@example.com>", committer=b"Bob <bob@example.com>")
         self.assertTrue(isinstance(sha, bytes))
         self.assertEqual(len(sha), 40)
 
 
 class CloneTests(PorcelainTestCase):
 
     def test_simple_local(self):
         f1_1 = make_object(Blob, data=b'f1')
         commit_spec = [[1], [2, 1], [3, 1, 2]]
         trees = {1: [(b'f1', f1_1), (b'f2', f1_1)],
                  2: [(b'f1', f1_1), (b'f2', f1_1)],
                  3: [(b'f1', f1_1), (b'f2', f1_1)], }
 
         c1, c2, c3 = build_commit_graph(self.repo.object_store,
                                         commit_spec, trees)
         self.repo.refs[b"refs/heads/master"] = c3.id
         self.repo.refs[b"refs/tags/foo"] = c3.id
         target_path = tempfile.mkdtemp()
         errstream = BytesIO()
         self.addCleanup(shutil.rmtree, target_path)
         r = porcelain.clone(self.repo.path, target_path,
                             checkout=False, errstream=errstream)
         self.assertEqual(r.path, target_path)
         target_repo = Repo(target_path)
         self.assertEqual(target_repo.head(), c3.id)
         self.assertEqual(c3.id, target_repo.refs[b'refs/tags/foo'])
         self.assertTrue(b'f1' not in os.listdir(target_path))
         self.assertTrue(b'f2' not in os.listdir(target_path))
         c = r.get_config()
         encoded_path = self.repo.path
         if not isinstance(encoded_path, bytes):
             encoded_path = encoded_path.encode('utf-8')
         self.assertEqual(encoded_path, c.get((b'remote', b'origin'), b'url'))
         self.assertEqual(
             b'+refs/heads/*:refs/remotes/origin/*',
             c.get((b'remote', b'origin'), b'fetch'))
 
     def test_simple_local_with_checkout(self):
         f1_1 = make_object(Blob, data=b'f1')
         commit_spec = [[1], [2, 1], [3, 1, 2]]
         trees = {1: [(b'f1', f1_1), (b'f2', f1_1)],
                  2: [(b'f1', f1_1), (b'f2', f1_1)],
                  3: [(b'f1', f1_1), (b'f2', f1_1)], }
 
         c1, c2, c3 = build_commit_graph(self.repo.object_store,
                                         commit_spec, trees)
         self.repo.refs[b"refs/heads/master"] = c3.id
         target_path = tempfile.mkdtemp()
         errstream = BytesIO()
         self.addCleanup(shutil.rmtree, target_path)
-        with closing(porcelain.clone(self.repo.path, target_path,
-                                     checkout=True,
-                                     errstream=errstream)) as r:
+        with porcelain.clone(self.repo.path, target_path,
+                             checkout=True,
+                             errstream=errstream) as r:
             self.assertEqual(r.path, target_path)
-        with closing(Repo(target_path)) as r:
+        with Repo(target_path) as r:
             self.assertEqual(r.head(), c3.id)
         self.assertTrue('f1' in os.listdir(target_path))
         self.assertTrue('f2' in os.listdir(target_path))
 
     def test_bare_local_with_checkout(self):
         f1_1 = make_object(Blob, data=b'f1')
         commit_spec = [[1], [2, 1], [3, 1, 2]]
         trees = {1: [(b'f1', f1_1), (b'f2', f1_1)],
                  2: [(b'f1', f1_1), (b'f2', f1_1)],
                  3: [(b'f1', f1_1), (b'f2', f1_1)], }
 
         c1, c2, c3 = build_commit_graph(self.repo.object_store,
                                         commit_spec, trees)
         self.repo.refs[b"refs/heads/master"] = c3.id
         target_path = tempfile.mkdtemp()
         errstream = BytesIO()
         self.addCleanup(shutil.rmtree, target_path)
         r = porcelain.clone(self.repo.path, target_path,
                             bare=True, errstream=errstream)
         self.assertEqual(r.path, target_path)
         self.assertEqual(Repo(target_path).head(), c3.id)
         self.assertFalse(b'f1' in os.listdir(target_path))
         self.assertFalse(b'f2' in os.listdir(target_path))
 
     def test_no_checkout_with_bare(self):
         f1_1 = make_object(Blob, data=b'f1')
         commit_spec = [[1]]
         trees = {1: [(b'f1', f1_1), (b'f2', f1_1)]}
 
         (c1, ) = build_commit_graph(self.repo.object_store, commit_spec, trees)
         self.repo.refs[b"refs/heads/master"] = c1.id
         target_path = tempfile.mkdtemp()
         errstream = BytesIO()
         self.addCleanup(shutil.rmtree, target_path)
         self.assertRaises(ValueError, porcelain.clone, self.repo.path,
             target_path, checkout=True, bare=True, errstream=errstream)
 
 
 class InitTests(TestCase):
 
     def test_non_bare(self):
         repo_dir = tempfile.mkdtemp()
         self.addCleanup(shutil.rmtree, repo_dir)
         porcelain.init(repo_dir)
 
     def test_bare(self):
         repo_dir = tempfile.mkdtemp()
         self.addCleanup(shutil.rmtree, repo_dir)
         porcelain.init(repo_dir, bare=True)
 
 
 class AddTests(PorcelainTestCase):
 
     def test_add_default_paths(self):
 
         # create a file for initial commit
         with open(os.path.join(self.repo.path, 'blah'), 'w') as f:
             f.write("\n")
         porcelain.add(repo=self.repo.path, paths=['blah'])
         porcelain.commit(repo=self.repo.path, message=b'test',
             author=b'test', committer=b'test')
 
         # Add a second test file and a file in a directory
         with open(os.path.join(self.repo.path, 'foo'), 'w') as f:
             f.write("\n")
         os.mkdir(os.path.join(self.repo.path, 'adir'))
         with open(os.path.join(self.repo.path, 'adir', 'afile'), 'w') as f:
             f.write("\n")
         porcelain.add(self.repo.path)
 
         # Check that foo was added and nothing in .git was modified
         index = self.repo.open_index()
         self.assertEqual(sorted(index), [b'adir/afile', b'blah', b'foo'])
 
     def test_add_file(self):
         with open(os.path.join(self.repo.path, 'foo'), 'w') as f:
             f.write("BAR")
         porcelain.add(self.repo.path, paths=["foo"])
 
 
 class RemoveTests(PorcelainTestCase):
 
     def test_remove_file(self):
         with open(os.path.join(self.repo.path, 'foo'), 'w') as f:
             f.write("BAR")
         porcelain.add(self.repo.path, paths=["foo"])
         porcelain.rm(self.repo.path, paths=["foo"])
 
 
 class LogTests(PorcelainTestCase):
 
     def test_simple(self):
         c1, c2, c3 = build_commit_graph(self.repo.object_store, [[1], [2, 1],
             [3, 1, 2]])
         self.repo.refs[b"HEAD"] = c3.id
         outstream = StringIO()
         porcelain.log(self.repo.path, outstream=outstream)
         self.assertEqual(3, outstream.getvalue().count("-" * 50))
 
     def test_max_entries(self):
         c1, c2, c3 = build_commit_graph(self.repo.object_store, [[1], [2, 1],
             [3, 1, 2]])
         self.repo.refs[b"HEAD"] = c3.id
         outstream = StringIO()
         porcelain.log(self.repo.path, outstream=outstream, max_entries=1)
         self.assertEqual(1, outstream.getvalue().count("-" * 50))
 
 
 class ShowTests(PorcelainTestCase):
 
     def test_nolist(self):
         c1, c2, c3 = build_commit_graph(self.repo.object_store, [[1], [2, 1],
             [3, 1, 2]])
         self.repo.refs[b"HEAD"] = c3.id
         outstream = StringIO()
         porcelain.show(self.repo.path, objects=c3.id, outstream=outstream)
         self.assertTrue(outstream.getvalue().startswith("-" * 50))
 
     def test_simple(self):
         c1, c2, c3 = build_commit_graph(self.repo.object_store, [[1], [2, 1],
             [3, 1, 2]])
         self.repo.refs[b"HEAD"] = c3.id
         outstream = StringIO()
         porcelain.show(self.repo.path, objects=[c3.id], outstream=outstream)
         self.assertTrue(outstream.getvalue().startswith("-" * 50))
 
     def test_blob(self):
         b = Blob.from_string(b"The Foo\n")
         self.repo.object_store.add_object(b)
         outstream = StringIO()
         porcelain.show(self.repo.path, objects=[b.id], outstream=outstream)
         self.assertEqual(outstream.getvalue(), "The Foo\n")
 
 
 class SymbolicRefTests(PorcelainTestCase):
 
     def test_set_wrong_symbolic_ref(self):
         c1, c2, c3 = build_commit_graph(self.repo.object_store, [[1], [2, 1],
             [3, 1, 2]])
         self.repo.refs[b"HEAD"] = c3.id
 
         self.assertRaises(ValueError, porcelain.symbolic_ref, self.repo.path, b'foobar')
 
     def test_set_force_wrong_symbolic_ref(self):
         c1, c2, c3 = build_commit_graph(self.repo.object_store, [[1], [2, 1],
             [3, 1, 2]])
         self.repo.refs[b"HEAD"] = c3.id
 
         porcelain.symbolic_ref(self.repo.path, b'force_foobar', force=True)
 
         #test if we actually changed the file
         with self.repo.get_named_file('HEAD') as f:
             new_ref = f.read()
         self.assertEqual(new_ref, b'ref: refs/heads/force_foobar\n')
 
     def test_set_symbolic_ref(self):
         c1, c2, c3 = build_commit_graph(self.repo.object_store, [[1], [2, 1],
             [3, 1, 2]])
         self.repo.refs[b"HEAD"] = c3.id
 
         porcelain.symbolic_ref(self.repo.path, b'master')
 
     def test_set_symbolic_ref_other_than_master(self):
         c1, c2, c3 = build_commit_graph(self.repo.object_store, [[1], [2, 1],
             [3, 1, 2]], attrs=dict(refs='develop'))
         self.repo.refs[b"HEAD"] = c3.id
         self.repo.refs[b"refs/heads/develop"] = c3.id
 
         porcelain.symbolic_ref(self.repo.path, b'develop')
 
         #test if we actually changed the file
         with self.repo.get_named_file('HEAD') as f:
             new_ref = f.read()
         self.assertEqual(new_ref, b'ref: refs/heads/develop\n')
 
 
 class DiffTreeTests(PorcelainTestCase):
 
     def test_empty(self):
         c1, c2, c3 = build_commit_graph(self.repo.object_store, [[1], [2, 1],
             [3, 1, 2]])
         self.repo.refs[b"HEAD"] = c3.id
         outstream = BytesIO()
         porcelain.diff_tree(self.repo.path, c2.tree, c3.tree, outstream=outstream)
         self.assertEqual(outstream.getvalue(), b"")
 
 
 class CommitTreeTests(PorcelainTestCase):
 
     def test_simple(self):
         c1, c2, c3 = build_commit_graph(self.repo.object_store, [[1], [2, 1],
             [3, 1, 2]])
         b = Blob()
         b.data = b"foo the bar"
         t = Tree()
         t.add(b"somename", 0o100644, b.id)
         self.repo.object_store.add_object(t)
         self.repo.object_store.add_object(b)
         sha = porcelain.commit_tree(
             self.repo.path, t.id, message=b"Withcommit.",
             author=b"Joe <joe@example.com>",
             committer=b"Jane <jane@example.com>")
         self.assertTrue(isinstance(sha, bytes))
         self.assertEqual(len(sha), 40)
 
 
 class RevListTests(PorcelainTestCase):
 
     def test_simple(self):
         c1, c2, c3 = build_commit_graph(self.repo.object_store, [[1], [2, 1],
             [3, 1, 2]])
         outstream = BytesIO()
         porcelain.rev_list(
             self.repo.path, [c3.id], outstream=outstream)
         self.assertEqual(
             c3.id + b"\n" +
             c2.id + b"\n" +
             c1.id + b"\n",
             outstream.getvalue())
 
 
 class TagCreateTests(PorcelainTestCase):
 
     def test_annotated(self):
         c1, c2, c3 = build_commit_graph(self.repo.object_store, [[1], [2, 1],
             [3, 1, 2]])
         self.repo.refs[b"HEAD"] = c3.id
 
         porcelain.tag_create(self.repo.path, b"tryme", b'foo <foo@bar.com>',
                 b'bar', annotated=True)
 
         tags = self.repo.refs.as_dict(b"refs/tags")
         self.assertEqual(list(tags.keys()), [b"tryme"])
         tag = self.repo[b'refs/tags/tryme']
         self.assertTrue(isinstance(tag, Tag))
         self.assertEqual(b"foo <foo@bar.com>", tag.tagger)
         self.assertEqual(b"bar", tag.message)
         self.assertLess(time.time() - tag.tag_time, 5)
 
     def test_unannotated(self):
         c1, c2, c3 = build_commit_graph(self.repo.object_store, [[1], [2, 1],
             [3, 1, 2]])
         self.repo.refs[b"HEAD"] = c3.id
 
         porcelain.tag_create(self.repo.path, b"tryme", annotated=False)
 
         tags = self.repo.refs.as_dict(b"refs/tags")
         self.assertEqual(list(tags.keys()), [b"tryme"])
         self.repo[b'refs/tags/tryme']
         self.assertEqual(list(tags.values()), [self.repo.head()])
 
 
 class TagListTests(PorcelainTestCase):
 
     def test_empty(self):
         tags = porcelain.tag_list(self.repo.path)
         self.assertEqual([], tags)
 
     def test_simple(self):
         self.repo.refs[b"refs/tags/foo"] = b"aa" * 20
         self.repo.refs[b"refs/tags/bar/bla"] = b"bb" * 20
         tags = porcelain.tag_list(self.repo.path)
 
         self.assertEqual([b"bar/bla", b"foo"], tags)
 
 
 class TagDeleteTests(PorcelainTestCase):
 
     def test_simple(self):
         [c1] = build_commit_graph(self.repo.object_store, [[1]])
         self.repo[b"HEAD"] = c1.id
         porcelain.tag_create(self.repo, b'foo')
         self.assertTrue(b"foo" in porcelain.tag_list(self.repo))
         porcelain.tag_delete(self.repo, b'foo')
         self.assertFalse(b"foo" in porcelain.tag_list(self.repo))
 
 
 class ResetTests(PorcelainTestCase):
 
     def test_hard_head(self):
         with open(os.path.join(self.repo.path, 'foo'), 'w') as f:
             f.write("BAR")
         porcelain.add(self.repo.path, paths=["foo"])
         porcelain.commit(self.repo.path, message=b"Some message",
                 committer=b"Jane <jane@example.com>",
                 author=b"John <john@example.com>")
 
         with open(os.path.join(self.repo.path, 'foo'), 'wb') as f:
             f.write(b"OOH")
 
         porcelain.reset(self.repo, "hard", b"HEAD")
 
         index = self.repo.open_index()
         changes = list(tree_changes(self.repo,
                        index.commit(self.repo.object_store),
                        self.repo[b'HEAD'].tree))
 
         self.assertEqual([], changes)
 
     def test_hard_commit(self):
         with open(os.path.join(self.repo.path, 'foo'), 'w') as f:
             f.write("BAR")
         porcelain.add(self.repo.path, paths=["foo"])
         sha = porcelain.commit(self.repo.path, message=b"Some message",
                 committer=b"Jane <jane@example.com>",
                 author=b"John <john@example.com>")
 
         with open(os.path.join(self.repo.path, 'foo'), 'wb') as f:
             f.write(b"BAZ")
         porcelain.add(self.repo.path, paths=["foo"])
         porcelain.commit(self.repo.path, message=b"Some other message",
                 committer=b"Jane <jane@example.com>",
                 author=b"John <john@example.com>")
 
         porcelain.reset(self.repo, "hard", sha)
 
         index = self.repo.open_index()
         changes = list(tree_changes(self.repo,
                        index.commit(self.repo.object_store),
                        self.repo[sha].tree))
 
         self.assertEqual([], changes)
 
 
 class PushTests(PorcelainTestCase):
 
     def test_simple(self):
         """
         Basic test of porcelain push where self.repo is the remote.  First
         clone the remote, commit a file to the clone, then push the changes
         back to the remote.
         """
         outstream = BytesIO()
         errstream = BytesIO()
 
         porcelain.commit(repo=self.repo.path, message=b'init',
             author=b'', committer=b'')
 
         # Setup target repo cloned from temp test repo
         clone_path = tempfile.mkdtemp()
         self.addCleanup(shutil.rmtree, clone_path)
         target_repo = porcelain.clone(self.repo.path, target=clone_path,
             errstream=errstream)
         try:
             self.assertEqual(target_repo[b'HEAD'], self.repo[b'HEAD'])
         finally:
             target_repo.close()
 
         # create a second file to be pushed back to origin
         handle, fullpath = tempfile.mkstemp(dir=clone_path)
         os.close(handle)
         porcelain.add(repo=clone_path, paths=[os.path.basename(fullpath)])
         porcelain.commit(repo=clone_path, message=b'push',
             author=b'', committer=b'')
 
         # Setup a non-checked out branch in the remote
         refs_path = b"refs/heads/foo"
         new_id = self.repo[b'HEAD'].id
         self.assertNotEqual(new_id, ZERO_SHA)
         self.repo.refs[refs_path] = new_id
 
         # Push to the remote
         porcelain.push(clone_path, self.repo.path, b"HEAD:" + refs_path, outstream=outstream,
             errstream=errstream)
 
         # Check that the target and source
-        with closing(Repo(clone_path)) as r_clone:
+        with Repo(clone_path) as r_clone:
             self.assertEqual({
                 b'HEAD': new_id,
                 b'refs/heads/foo': r_clone[b'HEAD'].id,
                 b'refs/heads/master': new_id,
                 }, self.repo.get_refs())
             self.assertEqual(r_clone[b'HEAD'].id, self.repo.refs[refs_path])
 
             # Get the change in the target repo corresponding to the add
             # this will be in the foo branch.
             change = list(tree_changes(self.repo, self.repo[b'HEAD'].tree,
                                        self.repo[b'refs/heads/foo'].tree))[0]
             self.assertEqual(os.path.basename(fullpath),
                 change.new.path.decode('ascii'))
 
     def test_delete(self):
         """Basic test of porcelain push, removing a branch.
         """
         outstream = BytesIO()
         errstream = BytesIO()
 
         porcelain.commit(repo=self.repo.path, message=b'init',
             author=b'', committer=b'')
 
         # Setup target repo cloned from temp test repo
         clone_path = tempfile.mkdtemp()
         self.addCleanup(shutil.rmtree, clone_path)
         target_repo = porcelain.clone(self.repo.path, target=clone_path,
             errstream=errstream)
         target_repo.close()
 
         # Setup a non-checked out branch in the remote
         refs_path = b"refs/heads/foo"
         new_id = self.repo[b'HEAD'].id
         self.assertNotEqual(new_id, ZERO_SHA)
         self.repo.refs[refs_path] = new_id
 
         # Push to the remote
         porcelain.push(clone_path, self.repo.path, b":" + refs_path, outstream=outstream,
             errstream=errstream)
 
         self.assertEqual({
             b'HEAD': new_id,
             b'refs/heads/master': new_id,
             }, self.repo.get_refs())
 
 
 
 class PullTests(PorcelainTestCase):
 
     def setUp(self):
         super(PullTests, self).setUp()
         # create a file for initial commit
         handle, fullpath = tempfile.mkstemp(dir=self.repo.path)
         os.close(handle)
         filename = os.path.basename(fullpath)
         porcelain.add(repo=self.repo.path, paths=filename)
         porcelain.commit(repo=self.repo.path, message=b'test',
                          author=b'test', committer=b'test')
 
         # Setup target repo
         self.target_path = tempfile.mkdtemp()
         self.addCleanup(shutil.rmtree, self.target_path)
         target_repo = porcelain.clone(self.repo.path, target=self.target_path,
                 errstream=BytesIO())
         target_repo.close()
 
         # create a second file to be pushed
         handle, fullpath = tempfile.mkstemp(dir=self.repo.path)
         os.close(handle)
         filename = os.path.basename(fullpath)
         porcelain.add(repo=self.repo.path, paths=filename)
         porcelain.commit(repo=self.repo.path, message=b'test2',
             author=b'test2', committer=b'test2')
 
         self.assertTrue(b'refs/heads/master' in self.repo.refs)
         self.assertTrue(b'refs/heads/master' in target_repo.refs)
 
     def test_simple(self):
         outstream = BytesIO()
         errstream = BytesIO()
 
         # Pull changes into the cloned repo
         porcelain.pull(self.target_path, self.repo.path, b'refs/heads/master',
             outstream=outstream, errstream=errstream)
 
         # Check the target repo for pushed changes
-        with closing(Repo(self.target_path)) as r:
+        with Repo(self.target_path) as r:
             self.assertEqual(r[b'HEAD'].id, self.repo[b'HEAD'].id)
 
     def test_no_refspec(self):
         outstream = BytesIO()
         errstream = BytesIO()
 
         # Pull changes into the cloned repo
         porcelain.pull(self.target_path, self.repo.path, outstream=outstream,
                        errstream=errstream)
 
         # Check the target repo for pushed changes
-        with closing(Repo(self.target_path)) as r:
+        with Repo(self.target_path) as r:
             self.assertEqual(r[b'HEAD'].id, self.repo[b'HEAD'].id)
 
 
 class StatusTests(PorcelainTestCase):
 
     def test_empty(self):
         results = porcelain.status(self.repo)
         self.assertEqual(
             {'add': [], 'delete': [], 'modify': []},
             results.staged)
         self.assertEqual([], results.unstaged)
 
     def test_status(self):
         """Integration test for `status` functionality."""
 
         # Commit a dummy file then modify it
         fullpath = os.path.join(self.repo.path, 'foo')
         with open(fullpath, 'w') as f:
             f.write('origstuff')
 
         porcelain.add(repo=self.repo.path, paths=['foo'])
         porcelain.commit(repo=self.repo.path, message=b'test status',
             author=b'', committer=b'')
 
         # modify access and modify time of path
         os.utime(fullpath, (0, 0))
 
         with open(fullpath, 'wb') as f:
             f.write(b'stuff')
 
         # Make a dummy file and stage it
         filename_add = 'bar'
         fullpath = os.path.join(self.repo.path, filename_add)
         with open(fullpath, 'w') as f:
             f.write('stuff')
         porcelain.add(repo=self.repo.path, paths=filename_add)
 
         results = porcelain.status(self.repo)
 
         self.assertEqual(results.staged['add'][0], filename_add.encode('ascii'))
         self.assertEqual(results.unstaged, [b'foo'])
 
     def test_get_tree_changes_add(self):
         """Unit test for get_tree_changes add."""
 
         # Make a dummy file, stage
         filename = 'bar'
         with open(os.path.join(self.repo.path, filename), 'w') as f:
             f.write('stuff')
         porcelain.add(repo=self.repo.path, paths=filename)
         porcelain.commit(repo=self.repo.path, message=b'test status',
             author=b'', committer=b'')
 
         filename = 'foo'
         with open(os.path.join(self.repo.path, filename), 'w') as f:
             f.write('stuff')
         porcelain.add(repo=self.repo.path, paths=filename)
         changes = porcelain.get_tree_changes(self.repo.path)
 
         self.assertEqual(changes['add'][0], filename.encode('ascii'))
         self.assertEqual(len(changes['add']), 1)
         self.assertEqual(len(changes['modify']), 0)
         self.assertEqual(len(changes['delete']), 0)
 
     def test_get_tree_changes_modify(self):
         """Unit test for get_tree_changes modify."""
 
         # Make a dummy file, stage, commit, modify
         filename = 'foo'
         fullpath = os.path.join(self.repo.path, filename)
         with open(fullpath, 'w') as f:
             f.write('stuff')
         porcelain.add(repo=self.repo.path, paths=filename)
         porcelain.commit(repo=self.repo.path, message=b'test status',
             author=b'', committer=b'')
         with open(fullpath, 'w') as f:
             f.write('otherstuff')
         porcelain.add(repo=self.repo.path, paths=filename)
         changes = porcelain.get_tree_changes(self.repo.path)
 
         self.assertEqual(changes['modify'][0], filename.encode('ascii'))
         self.assertEqual(len(changes['add']), 0)
         self.assertEqual(len(changes['modify']), 1)
         self.assertEqual(len(changes['delete']), 0)
 
     def test_get_tree_changes_delete(self):
         """Unit test for get_tree_changes delete."""
 
         # Make a dummy file, stage, commit, remove
         filename = 'foo'
         with open(os.path.join(self.repo.path, filename), 'w') as f:
             f.write('stuff')
         porcelain.add(repo=self.repo.path, paths=filename)
         porcelain.commit(repo=self.repo.path, message=b'test status',
             author=b'', committer=b'')
         porcelain.rm(repo=self.repo.path, paths=[filename])
         changes = porcelain.get_tree_changes(self.repo.path)
 
         self.assertEqual(changes['delete'][0], filename.encode('ascii'))
         self.assertEqual(len(changes['add']), 0)
         self.assertEqual(len(changes['modify']), 0)
         self.assertEqual(len(changes['delete']), 1)
 
 
 # TODO(jelmer): Add test for dulwich.porcelain.daemon
 
 
 class UploadPackTests(PorcelainTestCase):
     """Tests for upload_pack."""
 
     def test_upload_pack(self):
         outf = BytesIO()
         exitcode = porcelain.upload_pack(self.repo.path, BytesIO(b"0000"), outf)
         outlines = outf.getvalue().splitlines()
         self.assertEqual([b"0000"], outlines)
         self.assertEqual(0, exitcode)
 
 
 class ReceivePackTests(PorcelainTestCase):
     """Tests for receive_pack."""
 
     def test_receive_pack(self):
         filename = 'foo'
         with open(os.path.join(self.repo.path, filename), 'w') as f:
             f.write('stuff')
         porcelain.add(repo=self.repo.path, paths=filename)
         self.repo.do_commit(message=b'test status',
             author=b'', committer=b'', author_timestamp=1402354300,
             commit_timestamp=1402354300, author_timezone=0, commit_timezone=0)
         outf = BytesIO()
         exitcode = porcelain.receive_pack(self.repo.path, BytesIO(b"0000"), outf)
         outlines = outf.getvalue().splitlines()
         self.assertEqual([
             b'00739e65bdcf4a22cdd4f3700604a275cd2aaf146b23 HEAD\x00 report-status '
             b'delete-refs quiet ofs-delta side-band-64k no-done',
             b'003f9e65bdcf4a22cdd4f3700604a275cd2aaf146b23 refs/heads/master',
             b'0000'], outlines)
         self.assertEqual(0, exitcode)
 
 
 class BranchListTests(PorcelainTestCase):
 
     def test_standard(self):
         self.assertEqual(set([]), set(porcelain.branch_list(self.repo)))
 
     def test_new_branch(self):
         [c1] = build_commit_graph(self.repo.object_store, [[1]])
         self.repo[b"HEAD"] = c1.id
         porcelain.branch_create(self.repo, b"foo")
         self.assertEqual(
             set([b"master", b"foo"]),
             set(porcelain.branch_list(self.repo)))
 
 
 class BranchCreateTests(PorcelainTestCase):
 
     def test_branch_exists(self):
         [c1] = build_commit_graph(self.repo.object_store, [[1]])
         self.repo[b"HEAD"] = c1.id
         porcelain.branch_create(self.repo, b"foo")
         self.assertRaises(KeyError, porcelain.branch_create, self.repo, b"foo")
         porcelain.branch_create(self.repo, b"foo", force=True)
 
     def test_new_branch(self):
         [c1] = build_commit_graph(self.repo.object_store, [[1]])
         self.repo[b"HEAD"] = c1.id
         porcelain.branch_create(self.repo, b"foo")
         self.assertEqual(
             set([b"master", b"foo"]),
             set(porcelain.branch_list(self.repo)))
 
 
 class BranchDeleteTests(PorcelainTestCase):
 
     def test_simple(self):
         [c1] = build_commit_graph(self.repo.object_store, [[1]])
         self.repo[b"HEAD"] = c1.id
         porcelain.branch_create(self.repo, b'foo')
         self.assertTrue(b"foo" in porcelain.branch_list(self.repo))
         porcelain.branch_delete(self.repo, b'foo')
         self.assertFalse(b"foo" in porcelain.branch_list(self.repo))
 
 
 class FetchTests(PorcelainTestCase):
 
     def test_simple(self):
         outstream = BytesIO()
         errstream = BytesIO()
 
         # create a file for initial commit
         handle, fullpath = tempfile.mkstemp(dir=self.repo.path)
         os.close(handle)
         filename = os.path.basename(fullpath)
         porcelain.add(repo=self.repo.path, paths=filename)
         porcelain.commit(repo=self.repo.path, message=b'test',
                          author=b'test', committer=b'test')
 
         # Setup target repo
         target_path = tempfile.mkdtemp()
         self.addCleanup(shutil.rmtree, target_path)
         target_repo = porcelain.clone(self.repo.path, target=target_path,
             errstream=errstream)
 
         # create a second file to be pushed
         handle, fullpath = tempfile.mkstemp(dir=self.repo.path)
         os.close(handle)
         filename = os.path.basename(fullpath)
         porcelain.add(repo=self.repo.path, paths=filename)
         porcelain.commit(repo=self.repo.path, message=b'test2',
             author=b'test2', committer=b'test2')
 
         self.assertFalse(self.repo[b'HEAD'].id in target_repo)
         target_repo.close()
 
         # Fetch changes into the cloned repo
         porcelain.fetch(target_path, self.repo.path, outstream=outstream,
             errstream=errstream)
 
         # Check the target repo for pushed changes
-        with closing(Repo(target_path)) as r:
+        with Repo(target_path) as r:
             self.assertTrue(self.repo[b'HEAD'].id in r)
 
 
 class RepackTests(PorcelainTestCase):
 
     def test_empty(self):
         porcelain.repack(self.repo)
 
     def test_simple(self):
         handle, fullpath = tempfile.mkstemp(dir=self.repo.path)
         os.close(handle)
         filename = os.path.basename(fullpath)
         porcelain.add(repo=self.repo.path, paths=filename)
         porcelain.repack(self.repo)
 
 
 class LsTreeTests(PorcelainTestCase):
 
     def test_empty(self):
         porcelain.commit(repo=self.repo.path, message=b'test status',
             author=b'', committer=b'')
 
         f = StringIO()
         porcelain.ls_tree(self.repo, b"HEAD", outstream=f)
         self.assertEqual(f.getvalue(), "")
 
     def test_simple(self):
         # Commit a dummy file then modify it
         fullpath = os.path.join(self.repo.path, 'foo')
         with open(fullpath, 'w') as f:
             f.write('origstuff')
 
         porcelain.add(repo=self.repo.path, paths=['foo'])
         porcelain.commit(repo=self.repo.path, message=b'test status',
             author=b'', committer=b'')
 
         f = StringIO()
         porcelain.ls_tree(self.repo, b"HEAD", outstream=f)
         self.assertEqual(
                 f.getvalue(),
                 '100644 blob 8b82634d7eae019850bb883f06abf428c58bc9aa\tfoo\n')
 
 
 class LsRemoteTests(PorcelainTestCase):
 
     def test_empty(self):
         self.assertEqual({}, porcelain.ls_remote(self.repo.path))
 
     def test_some(self):
         cid = porcelain.commit(repo=self.repo.path, message=b'test status',
             author=b'', committer=b'')
 
         self.assertEqual({
             b'refs/heads/master': cid,
             b'HEAD': cid},
             porcelain.ls_remote(self.repo.path))
diff --git a/dulwich/tests/test_repository.py b/dulwich/tests/test_repository.py
index de37253c..2719f204 100644
--- a/dulwich/tests/test_repository.py
+++ b/dulwich/tests/test_repository.py
@@ -1,851 +1,850 @@
 # -*- coding: utf-8 -*-
 # test_repository.py -- tests for repository.py
 # Copyright (C) 2007 James Westby <jw+debian@jameswestby.net>
 #
 # Dulwich is dual-licensed under the Apache License, Version 2.0 and the GNU
 # General Public License as public by the Free Software Foundation; version 2.0
 # or (at your option) any later version. You can redistribute it and/or
 # modify it under the terms of either of these two licenses.
 #
 # Unless required by applicable law or agreed to in writing, software
 # distributed under the License is distributed on an "AS IS" BASIS,
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
 #
 # You should have received a copy of the licenses; if not, see
 # <http://www.gnu.org/licenses/> for a copy of the GNU General Public License
 # and <http://www.apache.org/licenses/LICENSE-2.0> for a copy of the Apache
 # License, Version 2.0.
 #
 
 """Tests for the repository."""
 
-from contextlib import closing
 import locale
 import os
 import stat
 import shutil
 import sys
 import tempfile
 import warnings
 
 from dulwich import errors
 from dulwich.object_store import (
     tree_lookup_path,
     )
 from dulwich import objects
 from dulwich.config import Config
 from dulwich.errors import NotGitRepository
 from dulwich.repo import (
     Repo,
     MemoryRepo,
     )
 from dulwich.tests import (
     TestCase,
     skipIf,
     )
 from dulwich.tests.utils import (
     open_repo,
     tear_down_repo,
     setup_warning_catcher,
     )
 
 missing_sha = b'b91fa4d900e17e99b433218e988c4eb4a3e9a097'
 
 
 class CreateRepositoryTests(TestCase):
 
     def assertFileContentsEqual(self, expected, repo, path):
         f = repo.get_named_file(path)
         if not f:
             self.assertEqual(expected, None)
         else:
             with f:
                 self.assertEqual(expected, f.read())
 
     def _check_repo_contents(self, repo, expect_bare):
         self.assertEqual(expect_bare, repo.bare)
         self.assertFileContentsEqual(b'Unnamed repository', repo, 'description')
         self.assertFileContentsEqual(b'', repo, os.path.join('info', 'exclude'))
         self.assertFileContentsEqual(None, repo, 'nonexistent file')
         barestr = b'bare = ' + str(expect_bare).lower().encode('ascii')
         with repo.get_named_file('config') as f:
             config_text = f.read()
             self.assertTrue(barestr in config_text, "%r" % config_text)
         expect_filemode = sys.platform != 'win32'
         barestr = b'filemode = ' + str(expect_filemode).lower().encode('ascii')
         with repo.get_named_file('config') as f:
             config_text = f.read()
             self.assertTrue(barestr in config_text, "%r" % config_text)
 
 
     def test_create_memory(self):
         repo = MemoryRepo.init_bare([], {})
         self._check_repo_contents(repo, True)
 
     def test_create_disk_bare(self):
         tmp_dir = tempfile.mkdtemp()
         self.addCleanup(shutil.rmtree, tmp_dir)
         repo = Repo.init_bare(tmp_dir)
         self.assertEqual(tmp_dir, repo._controldir)
         self._check_repo_contents(repo, True)
 
     def test_create_disk_non_bare(self):
         tmp_dir = tempfile.mkdtemp()
         self.addCleanup(shutil.rmtree, tmp_dir)
         repo = Repo.init(tmp_dir)
         self.assertEqual(os.path.join(tmp_dir, '.git'), repo._controldir)
         self._check_repo_contents(repo, False)
 
 
 class RepositoryRootTests(TestCase):
 
     def mkdtemp(self):
         return tempfile.mkdtemp()
 
     def open_repo(self, name):
         temp_dir = self.mkdtemp()
         repo = open_repo(name, temp_dir)
         self.addCleanup(tear_down_repo, repo)
         return repo
 
     def test_simple_props(self):
         r = self.open_repo('a.git')
         self.assertEqual(r.controldir(), r.path)
 
     def test_setitem(self):
         r = self.open_repo('a.git')
         r[b"refs/tags/foo"] = b'a90fa2d900a17e99b433217e988c4eb4a2e9a097'
         self.assertEqual(b'a90fa2d900a17e99b433217e988c4eb4a2e9a097',
                           r[b"refs/tags/foo"].id)
 
     def test_getitem_unicode(self):
         r = self.open_repo('a.git')
 
         test_keys = [
             (b'refs/heads/master', True),
             (b'a90fa2d900a17e99b433217e988c4eb4a2e9a097', True),
             (b'11' * 19 + b'--', False),
         ]
 
         for k, contained in test_keys:
             self.assertEqual(k in r, contained)
 
         # Avoid deprecation warning under Py3.2+
         if getattr(self, 'assertRaisesRegex', None):
             assertRaisesRegexp = self.assertRaisesRegex
         else:
             assertRaisesRegexp = self.assertRaisesRegexp
         for k, _ in test_keys:
             assertRaisesRegexp(
                 TypeError, "'name' must be bytestring, not int",
                 r.__getitem__, 12
             )
 
     def test_delitem(self):
         r = self.open_repo('a.git')
 
         del r[b'refs/heads/master']
         self.assertRaises(KeyError, lambda: r[b'refs/heads/master'])
 
         del r[b'HEAD']
         self.assertRaises(KeyError, lambda: r[b'HEAD'])
 
         self.assertRaises(ValueError, r.__delitem__, b'notrefs/foo')
 
     def test_get_refs(self):
         r = self.open_repo('a.git')
         self.assertEqual({
             b'HEAD': b'a90fa2d900a17e99b433217e988c4eb4a2e9a097',
             b'refs/heads/master': b'a90fa2d900a17e99b433217e988c4eb4a2e9a097',
             b'refs/tags/mytag': b'28237f4dc30d0d462658d6b937b08a0f0b6ef55a',
             b'refs/tags/mytag-packed': b'b0931cadc54336e78a1d980420e3268903b57a50',
             }, r.get_refs())
 
     def test_head(self):
         r = self.open_repo('a.git')
         self.assertEqual(r.head(), b'a90fa2d900a17e99b433217e988c4eb4a2e9a097')
 
     def test_get_object(self):
         r = self.open_repo('a.git')
         obj = r.get_object(r.head())
         self.assertEqual(obj.type_name, b'commit')
 
     def test_get_object_non_existant(self):
         r = self.open_repo('a.git')
         self.assertRaises(KeyError, r.get_object, missing_sha)
 
     def test_contains_object(self):
         r = self.open_repo('a.git')
         self.assertTrue(r.head() in r)
 
     def test_contains_ref(self):
         r = self.open_repo('a.git')
         self.assertTrue(b"HEAD" in r)
 
     def test_get_no_description(self):
         r = self.open_repo('a.git')
         self.assertIs(None, r.get_description())
 
     def test_get_description(self):
         r = self.open_repo('a.git')
         with open(os.path.join(r.path, 'description'), 'wb') as f:
             f.write(b"Some description")
         self.assertEqual(b"Some description", r.get_description())
 
     def test_set_description(self):
         r = self.open_repo('a.git')
         description = b"Some description"
         r.set_description(description)
         self.assertEqual(description, r.get_description())
 
     def test_contains_missing(self):
         r = self.open_repo('a.git')
         self.assertFalse(b"bar" in r)
 
     def test_get_peeled(self):
         # unpacked ref
         r = self.open_repo('a.git')
         tag_sha = b'28237f4dc30d0d462658d6b937b08a0f0b6ef55a'
         self.assertNotEqual(r[tag_sha].sha().hexdigest(), r.head())
         self.assertEqual(r.get_peeled(b'refs/tags/mytag'), r.head())
 
         # packed ref with cached peeled value
         packed_tag_sha = b'b0931cadc54336e78a1d980420e3268903b57a50'
         parent_sha = r[r.head()].parents[0]
         self.assertNotEqual(r[packed_tag_sha].sha().hexdigest(), parent_sha)
         self.assertEqual(r.get_peeled(b'refs/tags/mytag-packed'), parent_sha)
 
         # TODO: add more corner cases to test repo
 
     def test_get_peeled_not_tag(self):
         r = self.open_repo('a.git')
         self.assertEqual(r.get_peeled(b'HEAD'), r.head())
 
     def test_get_walker(self):
         r = self.open_repo('a.git')
         # include defaults to [r.head()]
         self.assertEqual([e.commit.id for e in r.get_walker()],
                          [r.head(), b'2a72d929692c41d8554c07f6301757ba18a65d91'])
         self.assertEqual(
             [e.commit.id for e in r.get_walker([b'2a72d929692c41d8554c07f6301757ba18a65d91'])],
             [b'2a72d929692c41d8554c07f6301757ba18a65d91'])
         self.assertEqual(
             [e.commit.id for e in r.get_walker(b'2a72d929692c41d8554c07f6301757ba18a65d91')],
             [b'2a72d929692c41d8554c07f6301757ba18a65d91'])
 
     def test_clone(self):
         r = self.open_repo('a.git')
         tmp_dir = self.mkdtemp()
         self.addCleanup(shutil.rmtree, tmp_dir)
-        with closing(r.clone(tmp_dir, mkdir=False)) as t:
+        with r.clone(tmp_dir, mkdir=False) as t:
             self.assertEqual({
                 b'HEAD': b'a90fa2d900a17e99b433217e988c4eb4a2e9a097',
                 b'refs/remotes/origin/master':
                     b'a90fa2d900a17e99b433217e988c4eb4a2e9a097',
                 b'refs/heads/master': b'a90fa2d900a17e99b433217e988c4eb4a2e9a097',
                 b'refs/tags/mytag': b'28237f4dc30d0d462658d6b937b08a0f0b6ef55a',
                 b'refs/tags/mytag-packed':
                     b'b0931cadc54336e78a1d980420e3268903b57a50',
                 }, t.refs.as_dict())
             shas = [e.commit.id for e in r.get_walker()]
             self.assertEqual(shas, [t.head(),
                              b'2a72d929692c41d8554c07f6301757ba18a65d91'])
             c = t.get_config()
             encoded_path = r.path
             if not isinstance(encoded_path, bytes):
                 encoded_path = encoded_path.encode(sys.getfilesystemencoding())
             self.assertEqual(encoded_path, c.get((b'remote', b'origin'), b'url'))
             self.assertEqual(
                 b'+refs/heads/*:refs/remotes/origin/*',
                 c.get((b'remote', b'origin'), b'fetch'))
 
     def test_clone_no_head(self):
         temp_dir = self.mkdtemp()
         self.addCleanup(shutil.rmtree, temp_dir)
         repo_dir = os.path.join(os.path.dirname(__file__), 'data', 'repos')
         dest_dir = os.path.join(temp_dir, 'a.git')
         shutil.copytree(os.path.join(repo_dir, 'a.git'),
                         dest_dir, symlinks=True)
         r = Repo(dest_dir)
         del r.refs[b"refs/heads/master"]
         del r.refs[b"HEAD"]
         t = r.clone(os.path.join(temp_dir, 'b.git'), mkdir=True)
         self.assertEqual({
             b'refs/tags/mytag': b'28237f4dc30d0d462658d6b937b08a0f0b6ef55a',
             b'refs/tags/mytag-packed':
                 b'b0931cadc54336e78a1d980420e3268903b57a50',
             }, t.refs.as_dict())
 
     def test_clone_empty(self):
         """Test clone() doesn't crash if HEAD points to a non-existing ref.
 
         This simulates cloning server-side bare repository either when it is
         still empty or if user renames master branch and pushes private repo
         to the server.
         Non-bare repo HEAD always points to an existing ref.
         """
         r = self.open_repo('empty.git')
         tmp_dir = self.mkdtemp()
         self.addCleanup(shutil.rmtree, tmp_dir)
         r.clone(tmp_dir, mkdir=False, bare=True)
 
     def test_merge_history(self):
         r = self.open_repo('simple_merge.git')
         shas = [e.commit.id for e in r.get_walker()]
         self.assertEqual(shas, [b'5dac377bdded4c9aeb8dff595f0faeebcc8498cc',
                                 b'ab64bbdcc51b170d21588e5c5d391ee5c0c96dfd',
                                 b'4cffe90e0a41ad3f5190079d7c8f036bde29cbe6',
                                 b'60dacdc733de308bb77bb76ce0fb0f9b44c9769e',
                                 b'0d89f20333fbb1d2f3a94da77f4981373d8f4310'])
 
     def test_out_of_order_merge(self):
         """Test that revision history is ordered by date, not parent order."""
         r = self.open_repo('ooo_merge.git')
         shas = [e.commit.id for e in r.get_walker()]
         self.assertEqual(shas, [b'7601d7f6231db6a57f7bbb79ee52e4d462fd44d1',
                                 b'f507291b64138b875c28e03469025b1ea20bc614',
                                 b'fb5b0425c7ce46959bec94d54b9a157645e114f5',
                                 b'f9e39b120c68182a4ba35349f832d0e4e61f485c'])
 
     def test_get_tags_empty(self):
         r = self.open_repo('ooo_merge.git')
         self.assertEqual({}, r.refs.as_dict(b'refs/tags'))
 
     def test_get_config(self):
         r = self.open_repo('ooo_merge.git')
         self.assertIsInstance(r.get_config(), Config)
 
     def test_get_config_stack(self):
         r = self.open_repo('ooo_merge.git')
         self.assertIsInstance(r.get_config_stack(), Config)
 
     @skipIf(not getattr(os, 'symlink', None), 'Requires symlink support')
     def test_submodule(self):
         temp_dir = self.mkdtemp()
         self.addCleanup(shutil.rmtree, temp_dir)
         repo_dir = os.path.join(os.path.dirname(__file__), 'data', 'repos')
         shutil.copytree(os.path.join(repo_dir, 'a.git'),
                         os.path.join(temp_dir, 'a.git'), symlinks=True)
         rel = os.path.relpath(os.path.join(repo_dir, 'submodule'), temp_dir)
         os.symlink(os.path.join(rel, 'dotgit'), os.path.join(temp_dir, '.git'))
-        with closing(Repo(temp_dir)) as r:
+        with Repo(temp_dir) as r:
             self.assertEqual(r.head(), b'a90fa2d900a17e99b433217e988c4eb4a2e9a097')
 
     def test_common_revisions(self):
         """
         This test demonstrates that ``find_common_revisions()`` actually returns
         common heads, not revisions; dulwich already uses
         ``find_common_revisions()`` in such a manner (see
         ``Repo.fetch_objects()``).
         """
 
         expected_shas = set([b'60dacdc733de308bb77bb76ce0fb0f9b44c9769e'])
 
         # Source for objects.
         r_base = self.open_repo('simple_merge.git')
 
         # Re-create each-side of the merge in simple_merge.git.
         #
         # Since the trees and blobs are missing, the repository created is
         # corrupted, but we're only checking for commits for the purpose of this
         # test, so it's immaterial.
         r1_dir = self.mkdtemp()
         self.addCleanup(shutil.rmtree, r1_dir)
         r1_commits = [b'ab64bbdcc51b170d21588e5c5d391ee5c0c96dfd', # HEAD
                       b'60dacdc733de308bb77bb76ce0fb0f9b44c9769e',
                       b'0d89f20333fbb1d2f3a94da77f4981373d8f4310']
 
         r2_dir = self.mkdtemp()
         self.addCleanup(shutil.rmtree, r2_dir)
         r2_commits = [b'4cffe90e0a41ad3f5190079d7c8f036bde29cbe6', # HEAD
                       b'60dacdc733de308bb77bb76ce0fb0f9b44c9769e',
                       b'0d89f20333fbb1d2f3a94da77f4981373d8f4310']
 
         r1 = Repo.init_bare(r1_dir)
         for c in r1_commits:
             r1.object_store.add_object(r_base.get_object(c))
         r1.refs[b'HEAD'] = r1_commits[0]
 
         r2 = Repo.init_bare(r2_dir)
         for c in r2_commits:
             r2.object_store.add_object(r_base.get_object(c))
         r2.refs[b'HEAD'] = r2_commits[0]
 
         # Finally, the 'real' testing!
         shas = r2.object_store.find_common_revisions(r1.get_graph_walker())
         self.assertEqual(set(shas), expected_shas)
 
         shas = r1.object_store.find_common_revisions(r2.get_graph_walker())
         self.assertEqual(set(shas), expected_shas)
 
     def test_shell_hook_pre_commit(self):
         if os.name != 'posix':
             self.skipTest('shell hook tests requires POSIX shell')
 
         pre_commit_fail = """#!/bin/sh
 exit 1
 """
 
         pre_commit_success = """#!/bin/sh
 exit 0
 """
 
         repo_dir = os.path.join(self.mkdtemp())
         r = Repo.init(repo_dir)
         self.addCleanup(shutil.rmtree, repo_dir)
 
         pre_commit = os.path.join(r.controldir(), 'hooks', 'pre-commit')
 
         with open(pre_commit, 'w') as f:
             f.write(pre_commit_fail)
         os.chmod(pre_commit, stat.S_IREAD | stat.S_IWRITE | stat.S_IEXEC)
 
         self.assertRaises(errors.CommitError, r.do_commit, 'failed commit',
                           committer='Test Committer <test@nodomain.com>',
                           author='Test Author <test@nodomain.com>',
                           commit_timestamp=12345, commit_timezone=0,
                           author_timestamp=12345, author_timezone=0)
 
         with open(pre_commit, 'w') as f:
             f.write(pre_commit_success)
         os.chmod(pre_commit, stat.S_IREAD | stat.S_IWRITE | stat.S_IEXEC)
 
         commit_sha = r.do_commit(
             b'empty commit',
             committer=b'Test Committer <test@nodomain.com>',
             author=b'Test Author <test@nodomain.com>',
             commit_timestamp=12395, commit_timezone=0,
             author_timestamp=12395, author_timezone=0)
         self.assertEqual([], r[commit_sha].parents)
 
     def test_shell_hook_commit_msg(self):
         if os.name != 'posix':
             self.skipTest('shell hook tests requires POSIX shell')
 
         commit_msg_fail = """#!/bin/sh
 exit 1
 """
 
         commit_msg_success = """#!/bin/sh
 exit 0
 """
 
         repo_dir = self.mkdtemp()
         r = Repo.init(repo_dir)
         self.addCleanup(shutil.rmtree, repo_dir)
 
         commit_msg = os.path.join(r.controldir(), 'hooks', 'commit-msg')
 
         with open(commit_msg, 'w') as f:
             f.write(commit_msg_fail)
         os.chmod(commit_msg, stat.S_IREAD | stat.S_IWRITE | stat.S_IEXEC)
 
         self.assertRaises(errors.CommitError, r.do_commit, b'failed commit',
                           committer=b'Test Committer <test@nodomain.com>',
                           author=b'Test Author <test@nodomain.com>',
                           commit_timestamp=12345, commit_timezone=0,
                           author_timestamp=12345, author_timezone=0)
 
         with open(commit_msg, 'w') as f:
             f.write(commit_msg_success)
         os.chmod(commit_msg, stat.S_IREAD | stat.S_IWRITE | stat.S_IEXEC)
 
         commit_sha = r.do_commit(
             b'empty commit',
             committer=b'Test Committer <test@nodomain.com>',
             author=b'Test Author <test@nodomain.com>',
             commit_timestamp=12395, commit_timezone=0,
             author_timestamp=12395, author_timezone=0)
         self.assertEqual([], r[commit_sha].parents)
 
     def test_shell_hook_post_commit(self):
         if os.name != 'posix':
             self.skipTest('shell hook tests requires POSIX shell')
 
         repo_dir = self.mkdtemp()
 
         r = Repo.init(repo_dir)
         self.addCleanup(shutil.rmtree, repo_dir)
 
         (fd, path) = tempfile.mkstemp(dir=repo_dir)
         os.close(fd)
         post_commit_msg = """#!/bin/sh
 rm """ + path + """
 """
 
         root_sha = r.do_commit(
             b'empty commit',
             committer=b'Test Committer <test@nodomain.com>',
             author=b'Test Author <test@nodomain.com>',
             commit_timestamp=12345, commit_timezone=0,
             author_timestamp=12345, author_timezone=0)
         self.assertEqual([], r[root_sha].parents)
 
         post_commit = os.path.join(r.controldir(), 'hooks', 'post-commit')
 
         with open(post_commit, 'wb') as f:
             f.write(post_commit_msg.encode(locale.getpreferredencoding()))
         os.chmod(post_commit, stat.S_IREAD | stat.S_IWRITE | stat.S_IEXEC)
 
         commit_sha = r.do_commit(
             b'empty commit',
             committer=b'Test Committer <test@nodomain.com>',
             author=b'Test Author <test@nodomain.com>',
             commit_timestamp=12345, commit_timezone=0,
             author_timestamp=12345, author_timezone=0)
         self.assertEqual([root_sha], r[commit_sha].parents)
 
         self.assertFalse(os.path.exists(path))
 
         post_commit_msg_fail = """#!/bin/sh
 exit 1
 """
         with open(post_commit, 'w') as f:
             f.write(post_commit_msg_fail)
         os.chmod(post_commit, stat.S_IREAD | stat.S_IWRITE | stat.S_IEXEC)
 
         warnings.simplefilter("always", UserWarning)
         self.addCleanup(warnings.resetwarnings)
         warnings_list, restore_warnings = setup_warning_catcher()
         self.addCleanup(restore_warnings)
 
         commit_sha2 = r.do_commit(
             b'empty commit',
             committer=b'Test Committer <test@nodomain.com>',
             author=b'Test Author <test@nodomain.com>',
             commit_timestamp=12345, commit_timezone=0,
             author_timestamp=12345, author_timezone=0)
         self.assertEqual(len(warnings_list), 1, warnings_list)
         self.assertIsInstance(warnings_list[-1], UserWarning)
         self.assertTrue("post-commit hook failed: " in str(warnings_list[-1]))
         self.assertEqual([commit_sha], r[commit_sha2].parents)
 
     def test_as_dict(self):
         def check(repo):
             self.assertEqual(repo.refs.subkeys(b'refs/tags'), repo.refs.subkeys(b'refs/tags/'))
             self.assertEqual(repo.refs.as_dict(b'refs/tags'), repo.refs.as_dict(b'refs/tags/'))
             self.assertEqual(repo.refs.as_dict(b'refs/heads'), repo.refs.as_dict(b'refs/heads/'))
 
         bare = self.open_repo('a.git')
         tmp_dir = self.mkdtemp()
         self.addCleanup(shutil.rmtree, tmp_dir)
-        with closing(bare.clone(tmp_dir, mkdir=False)) as nonbare:
+        with bare.clone(tmp_dir, mkdir=False) as nonbare:
             check(nonbare)
             check(bare)
 
     def test_working_tree(self):
         temp_dir = tempfile.mkdtemp()
         self.addCleanup(shutil.rmtree, temp_dir)
         worktree_temp_dir = tempfile.mkdtemp()
         self.addCleanup(shutil.rmtree, worktree_temp_dir)
         r = Repo.init(temp_dir)
         root_sha = r.do_commit(
                 b'empty commit',
                 committer=b'Test Committer <test@nodomain.com>',
                 author=b'Test Author <test@nodomain.com>',
                 commit_timestamp=12345, commit_timezone=0,
                 author_timestamp=12345, author_timezone=0)
         r.refs[b'refs/heads/master'] = root_sha
         w = Repo._init_new_working_directory(worktree_temp_dir, r)
         new_sha = w.do_commit(
                 b'new commit',
                 committer=b'Test Committer <test@nodomain.com>',
                 author=b'Test Author <test@nodomain.com>',
                 commit_timestamp=12345, commit_timezone=0,
                 author_timestamp=12345, author_timezone=0)
         w.refs[b'HEAD'] = new_sha
         self.assertEqual(os.path.abspath(r.controldir()),
                          os.path.abspath(w.commondir()))
         self.assertEqual(r.refs.keys(), w.refs.keys())
         self.assertNotEqual(r.head(), w.head())
 
 
 class BuildRepoRootTests(TestCase):
     """Tests that build on-disk repos from scratch.
 
     Repos live in a temp dir and are torn down after each test. They start with
     a single commit in master having single file named 'a'.
     """
 
     def get_repo_dir(self):
         return os.path.join(tempfile.mkdtemp(), 'test')
 
     def setUp(self):
         super(BuildRepoRootTests, self).setUp()
         self._repo_dir = self.get_repo_dir()
         os.makedirs(self._repo_dir)
         r = self._repo = Repo.init(self._repo_dir)
         self.addCleanup(tear_down_repo, r)
         self.assertFalse(r.bare)
         self.assertEqual(b'ref: refs/heads/master', r.refs.read_ref(b'HEAD'))
         self.assertRaises(KeyError, lambda: r.refs[b'refs/heads/master'])
 
         with open(os.path.join(r.path, 'a'), 'wb') as f:
             f.write(b'file contents')
         r.stage(['a'])
         commit_sha = r.do_commit(b'msg',
                                  committer=b'Test Committer <test@nodomain.com>',
                                  author=b'Test Author <test@nodomain.com>',
                                  commit_timestamp=12345, commit_timezone=0,
                                  author_timestamp=12345, author_timezone=0)
         self.assertEqual([], r[commit_sha].parents)
         self._root_commit = commit_sha
 
     def test_build_repo(self):
         r = self._repo
         self.assertEqual(b'ref: refs/heads/master', r.refs.read_ref(b'HEAD'))
         self.assertEqual(self._root_commit, r.refs[b'refs/heads/master'])
         expected_blob = objects.Blob.from_string(b'file contents')
         self.assertEqual(expected_blob.data, r[expected_blob.id].data)
         actual_commit = r[self._root_commit]
         self.assertEqual(b'msg', actual_commit.message)
 
     def test_commit_modified(self):
         r = self._repo
         with open(os.path.join(r.path, 'a'), 'wb') as f:
             f.write(b'new contents')
         r.stage(['a'])
         commit_sha = r.do_commit(b'modified a',
                                  committer=b'Test Committer <test@nodomain.com>',
                                  author=b'Test Author <test@nodomain.com>',
                                  commit_timestamp=12395, commit_timezone=0,
                                  author_timestamp=12395, author_timezone=0)
         self.assertEqual([self._root_commit], r[commit_sha].parents)
         a_mode, a_id = tree_lookup_path(r.get_object, r[commit_sha].tree, b'a')
         self.assertEqual(stat.S_IFREG | 0o644, a_mode)
         self.assertEqual(b'new contents', r[a_id].data)
 
     @skipIf(not getattr(os, 'symlink', None), 'Requires symlink support')
     def test_commit_symlink(self):
         r = self._repo
         os.symlink('a', os.path.join(r.path, 'b'))
         r.stage(['a', 'b'])
         commit_sha = r.do_commit(b'Symlink b',
                                  committer=b'Test Committer <test@nodomain.com>',
                                  author=b'Test Author <test@nodomain.com>',
                                  commit_timestamp=12395, commit_timezone=0,
                                  author_timestamp=12395, author_timezone=0)
         self.assertEqual([self._root_commit], r[commit_sha].parents)
         b_mode, b_id = tree_lookup_path(r.get_object, r[commit_sha].tree, b'b')
         self.assertTrue(stat.S_ISLNK(b_mode))
         self.assertEqual(b'a', r[b_id].data)
 
     def test_commit_deleted(self):
         r = self._repo
         os.remove(os.path.join(r.path, 'a'))
         r.stage(['a'])
         commit_sha = r.do_commit(b'deleted a',
                                  committer=b'Test Committer <test@nodomain.com>',
                                  author=b'Test Author <test@nodomain.com>',
                                  commit_timestamp=12395, commit_timezone=0,
                                  author_timestamp=12395, author_timezone=0)
         self.assertEqual([self._root_commit], r[commit_sha].parents)
         self.assertEqual([], list(r.open_index()))
         tree = r[r[commit_sha].tree]
         self.assertEqual([], list(tree.iteritems()))
 
     def test_commit_follows(self):
         r = self._repo
         r.refs.set_symbolic_ref(b'HEAD', b'refs/heads/bla')
         commit_sha = r.do_commit(b'commit with strange character',
              committer=b'Test Committer <test@nodomain.com>',
              author=b'Test Author <test@nodomain.com>',
              commit_timestamp=12395, commit_timezone=0,
              author_timestamp=12395, author_timezone=0,
              ref=b'HEAD')
         self.assertEqual(commit_sha, r[b'refs/heads/bla'].id)
 
     def test_commit_encoding(self):
         r = self._repo
         commit_sha = r.do_commit(b'commit with strange character \xee',
              committer=b'Test Committer <test@nodomain.com>',
              author=b'Test Author <test@nodomain.com>',
              commit_timestamp=12395, commit_timezone=0,
              author_timestamp=12395, author_timezone=0,
              encoding=b"iso8859-1")
         self.assertEqual(b"iso8859-1", r[commit_sha].encoding)
 
     def test_commit_config_identity(self):
         # commit falls back to the users' identity if it wasn't specified
         r = self._repo
         c = r.get_config()
         c.set((b"user", ), b"name", b"Jelmer")
         c.set((b"user", ), b"email", b"jelmer@apache.org")
         c.write_to_path()
         commit_sha = r.do_commit(b'message')
         self.assertEqual(
             b"Jelmer <jelmer@apache.org>",
             r[commit_sha].author)
         self.assertEqual(
             b"Jelmer <jelmer@apache.org>",
             r[commit_sha].committer)
 
     def test_commit_config_identity_in_memoryrepo(self):
         # commit falls back to the users' identity if it wasn't specified
         r = MemoryRepo.init_bare([], {})
         c = r.get_config()
         c.set((b"user", ), b"name", b"Jelmer")
         c.set((b"user", ), b"email", b"jelmer@apache.org")
 
         commit_sha = r.do_commit(b'message', tree=objects.Tree().id)
         self.assertEqual(
             b"Jelmer <jelmer@apache.org>",
             r[commit_sha].author)
         self.assertEqual(
             b"Jelmer <jelmer@apache.org>",
             r[commit_sha].committer)
 
     def test_commit_fail_ref(self):
         r = self._repo
 
         def set_if_equals(name, old_ref, new_ref):
             return False
         r.refs.set_if_equals = set_if_equals
 
         def add_if_new(name, new_ref):
             self.fail('Unexpected call to add_if_new')
         r.refs.add_if_new = add_if_new
 
         old_shas = set(r.object_store)
         self.assertRaises(errors.CommitError, r.do_commit, b'failed commit',
                           committer=b'Test Committer <test@nodomain.com>',
                           author=b'Test Author <test@nodomain.com>',
                           commit_timestamp=12345, commit_timezone=0,
                           author_timestamp=12345, author_timezone=0)
         new_shas = set(r.object_store) - old_shas
         self.assertEqual(1, len(new_shas))
         # Check that the new commit (now garbage) was added.
         new_commit = r[new_shas.pop()]
         self.assertEqual(r[self._root_commit].tree, new_commit.tree)
         self.assertEqual(b'failed commit', new_commit.message)
 
     def test_commit_branch(self):
         r = self._repo
 
         commit_sha = r.do_commit(b'commit to branch',
              committer=b'Test Committer <test@nodomain.com>',
              author=b'Test Author <test@nodomain.com>',
              commit_timestamp=12395, commit_timezone=0,
              author_timestamp=12395, author_timezone=0,
              ref=b"refs/heads/new_branch")
         self.assertEqual(self._root_commit, r[b"HEAD"].id)
         self.assertEqual(commit_sha, r[b"refs/heads/new_branch"].id)
         self.assertEqual([], r[commit_sha].parents)
         self.assertTrue(b"refs/heads/new_branch" in r)
 
         new_branch_head = commit_sha
 
         commit_sha = r.do_commit(b'commit to branch 2',
              committer=b'Test Committer <test@nodomain.com>',
              author=b'Test Author <test@nodomain.com>',
              commit_timestamp=12395, commit_timezone=0,
              author_timestamp=12395, author_timezone=0,
              ref=b"refs/heads/new_branch")
         self.assertEqual(self._root_commit, r[b"HEAD"].id)
         self.assertEqual(commit_sha, r[b"refs/heads/new_branch"].id)
         self.assertEqual([new_branch_head], r[commit_sha].parents)
 
     def test_commit_merge_heads(self):
         r = self._repo
         merge_1 = r.do_commit(b'commit to branch 2',
              committer=b'Test Committer <test@nodomain.com>',
              author=b'Test Author <test@nodomain.com>',
              commit_timestamp=12395, commit_timezone=0,
              author_timestamp=12395, author_timezone=0,
              ref=b"refs/heads/new_branch")
         commit_sha = r.do_commit(b'commit with merge',
              committer=b'Test Committer <test@nodomain.com>',
              author=b'Test Author <test@nodomain.com>',
              commit_timestamp=12395, commit_timezone=0,
              author_timestamp=12395, author_timezone=0,
              merge_heads=[merge_1])
         self.assertEqual(
             [self._root_commit, merge_1],
             r[commit_sha].parents)
 
     def test_commit_dangling_commit(self):
         r = self._repo
 
         old_shas = set(r.object_store)
         old_refs = r.get_refs()
         commit_sha = r.do_commit(b'commit with no ref',
              committer=b'Test Committer <test@nodomain.com>',
              author=b'Test Author <test@nodomain.com>',
              commit_timestamp=12395, commit_timezone=0,
              author_timestamp=12395, author_timezone=0,
              ref=None)
         new_shas = set(r.object_store) - old_shas
 
         # New sha is added, but no new refs
         self.assertEqual(1, len(new_shas))
         new_commit = r[new_shas.pop()]
         self.assertEqual(r[self._root_commit].tree, new_commit.tree)
         self.assertEqual([], r[commit_sha].parents)
         self.assertEqual(old_refs, r.get_refs())
 
     def test_commit_dangling_commit_with_parents(self):
         r = self._repo
 
         old_shas = set(r.object_store)
         old_refs = r.get_refs()
         commit_sha = r.do_commit(b'commit with no ref',
              committer=b'Test Committer <test@nodomain.com>',
              author=b'Test Author <test@nodomain.com>',
              commit_timestamp=12395, commit_timezone=0,
              author_timestamp=12395, author_timezone=0,
              ref=None, merge_heads=[self._root_commit])
         new_shas = set(r.object_store) - old_shas
 
         # New sha is added, but no new refs
         self.assertEqual(1, len(new_shas))
         new_commit = r[new_shas.pop()]
         self.assertEqual(r[self._root_commit].tree, new_commit.tree)
         self.assertEqual([self._root_commit], r[commit_sha].parents)
         self.assertEqual(old_refs, r.get_refs())
 
     def test_stage_deleted(self):
         r = self._repo
         os.remove(os.path.join(r.path, 'a'))
         r.stage(['a'])
         r.stage(['a'])  # double-stage a deleted path
 
     def test_commit_no_encode_decode(self):
         r = self._repo
         repo_path_bytes = r.path.encode(sys.getfilesystemencoding())
         encodings = ('utf8', 'latin1')
         names = [u'À'.encode(encoding) for encoding in encodings]
         for name, encoding in zip(names, encodings):
             full_path = os.path.join(repo_path_bytes, name)
             with open(full_path, 'wb') as f:
                 f.write(encoding.encode('ascii'))
             # These files are break tear_down_repo, so cleanup these files
             # ourselves.
             self.addCleanup(os.remove, full_path)
 
         r.stage(names)
         commit_sha = r.do_commit(b'Files with different encodings',
              committer=b'Test Committer <test@nodomain.com>',
              author=b'Test Author <test@nodomain.com>',
              commit_timestamp=12395, commit_timezone=0,
              author_timestamp=12395, author_timezone=0,
              ref=None, merge_heads=[self._root_commit])
 
         for name, encoding in zip(names, encodings):
             mode, id = tree_lookup_path(r.get_object, r[commit_sha].tree, name)
             self.assertEqual(stat.S_IFREG | 0o644, mode)
             self.assertEqual(encoding.encode('ascii'), r[id].data)
 
     def test_discover_intended(self):
         path = os.path.join(self._repo_dir, 'b/c')
         r = Repo.discover(path)
         self.assertEqual(r.head(), self._repo.head())
 
     def test_discover_isrepo(self):
         r = Repo.discover(self._repo_dir)
         self.assertEqual(r.head(), self._repo.head())
 
     def test_discover_notrepo(self):
         with self.assertRaises(NotGitRepository):
             Repo.discover('/')