Support linked working directories

Support for linked working directories:
- Add `commondir()` (equivalent to `GIT_COMMON_DIR`)
- Read the `commondir` file, to set it.

See `git-worktree(1)` and `gitrepository-layout(5)`.

dulwich/refs.py

@@ -403,9 +403,9 @@ class InfoRefsContainer(RefsContainer):
 class DiskRefsContainer(RefsContainer):
     """Refs container that reads refs from disk."""
 
-    def __init__(self, path, **kwargs):
+    def __init__(self, path, worktree_path=None):
         self.path = path
-        self.worktree_path = kwargs.get('worktree', path)
+        self.worktree_path = worktree_path or path;
         self._packed_refs = None
         self._peeled_refs = None
 
@@ -453,7 +453,7 @@ class DiskRefsContainer(RefsContainer):
             name = name.replace("/", os.path.sep)
         #TODO: as the 'HEAD' reference is working tree specific, it
         # should actually not be a part of RefsContainer
-        if(name == b'HEAD'):
+        if name == 'HEAD':
             return os.path.join(self.worktree_path, name)
         else:
             return os.path.join(self.path, name)

dulwich/repo.py

@@ -90,6 +90,8 @@ REFSDIR_TAGS = 'tags'
 REFSDIR_HEADS = 'heads'
 INDEX_FILENAME = "index"
 COMMONDIR = 'commondir'
+GITDIR = 'gitdir'
+WORKTREES = 'worktrees'
 
 BASE_DIRECTORIES = [
     ["branches"],
@@ -677,23 +679,26 @@ class Repo(BaseRepo):
             raise NotGitRepository(
                 "No git repository was found at %(path)s" % dict(path=root)
             )
-        commondir = self.get_named_file(COMMONDIR)
+        commondir = self.get_named_file(COMMONDIR, mode='r')
         if commondir:
-            self._commondir = os.path.join(self.controldir(), commondir.read().rstrip("\n"))
+            with commondir:
+                self._commondir = os.path.join(self.controldir(), commondir.read().rstrip("\n"))
         else:
             self._commondir = self._controldir
         self.path = root
         object_store = DiskObjectStore(os.path.join(self.commondir(),
                                                     OBJECTDIR))
-        refs = DiskRefsContainer(self.commondir(), worktree=self._controldir)
+        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"))
+        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")
+        graft_file = self.get_named_file("shallow",
+                                         basedir=self.commondir())
         if graft_file:
             with graft_file:
                 self._graftpoints.update(parse_graftpoints(graft_file))
@@ -746,7 +751,7 @@ class Repo(BaseRepo):
         with GitFile(os.path.join(self.controldir(), path), 'wb') as f:
             f.write(contents)
 
-    def get_named_file(self, path):
+    def get_named_file(self, path, **kwargs):
         """Get a file from the control dir with a specific name.
 
         Although the filename should be interpreted as a filename relative to
@@ -754,13 +759,16 @@ class Repo(BaseRepo):
         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.
+        basedir_ = kwargs.get('basedir', self.controldir())
+        mode = kwargs.get('mode', 'rb')
         path = path.lstrip(os.path.sep)
         try:
-            return open(os.path.join(self.controldir(), path), 'rb')
+            return open(os.path.join(basedir_, path), mode)
         except (IOError, OSError) as e:
             if e.errno == errno.ENOENT:
                 return None
@@ -949,6 +957,51 @@ class Repo(BaseRepo):
         cls._init_maybe_bare(controldir, False)
         return cls(path)
 
+    @classmethod
+    def init_new_working_directory(cls, path, main_path, mkdir=False):
+        """Create a new working directory linked to a repository.
+
+        :param path: Path in which to create the working tree.
+        :param main_path: Path to the main repository (that can be bare or not).
+        :param mkdir: Whether to create the directory
+        :return: `Repo` instance
+        """
+        if mkdir:
+            os.mkdir(path)
+        worktree_id = os.path.basename(path)
+        gitdirfile = os.path.join(path, CONTROLDIR)
+        main = Repo(main_path)
+        main_controldir = main.controldir()
+        main_worktreesdir = os.path.join(main_controldir, WORKTREES)
+        worktree_controldir = os.path.join(main_worktreesdir, worktree_id)
+        with open(gitdirfile, 'w') as f:
+            f.write('gitdir: {}\n'.format(worktree_controldir))
+        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), 'w') as f:
+            f.write(gitdirfile + '\n')
+        with open(os.path.join(worktree_controldir, COMMONDIR), 'w') as f:
+            f.write('../..\n')
+        with open(os.path.join(worktree_controldir, 'HEAD'), 'w') as f:
+            f.write('{}\n'.format(main.refs[b'HEAD'].decode('ascii')))
+        main.close()
+        r = cls(path)
+        from dulwich.index import (
+            build_index_from_tree,
+            )
+        indexfile = r.index_path()
+        tree = r[b'HEAD'].tree
+        build_index_from_tree(r.path, indexfile, r.object_store, tree)
+        return r
+
     @classmethod
     def init_bare(cls, path):
         """Create a new bare repository.

dulwich/tests/compat/test_client.py

@@ -62,13 +62,15 @@ from dulwich.tests import (
     SkipTest,
     expectedFailure,
     )
+from dulwich.tests.utils import (
+    rmtree_ro,
+)
 from dulwich.tests.compat.utils import (
     CompatTestCase,
     check_for_daemon,
     import_repo_to_dir,
     run_git_or_fail,
     _DEFAULT_GIT,
-    rmtree_ro,
     )
 
 

dulwich/tests/compat/test_repository.py

@@ -23,7 +23,7 @@
 
 from io import BytesIO
 from itertools import chain
-import os
+import os, tempfile
 
 from dulwich.objects import (
     hex_to_sha,
@@ -32,13 +32,13 @@ from dulwich.repo import (
     check_ref_format,
     Repo,
     )
-
-from dulwich.tests import skipIf
-
+from dulwich.tests.utils import (
+    rmtree_ro,
+    create_empty_commit,
+)
 from dulwich.tests.compat.utils import (
     run_git_or_fail,
     CompatTestCase,
-    rmtree_ro,
     git_version
 )
 
@@ -70,6 +70,13 @@ class ObjectStoreTestCase(CompatTestCase):
     def _parse_objects(self, output):
         return set(s.rstrip(b'\n').split(b' ')[0] for s in BytesIO(output))
 
+    def _parse_worktree_list(self, output):
+        worktrees = []
+        for line in BytesIO(output):
+            fields = line.rstrip(b'\n').split()
+            worktrees.append(tuple(f.decode() for f in fields))
+        return worktrees
+
     def test_bare(self):
         self.assertTrue(self._repo.bare)
         self.assertFalse(os.path.exists(os.path.join(self._repo.path, '.git')))
@@ -129,15 +136,17 @@ class ObjectStoreTestCase(CompatTestCase):
         self.assertShasMatch(expected_shas, iter(self._repo.object_store))
 
 
-@skipIf(git_version() < (2, 5), 'Git version must be >= 2.5')
 class WorkingTreeTestCase(ObjectStoreTestCase):
     """Test for compatibility with git-worktree."""
 
+    min_git_version = (2, 5, 0)
+
     def setUp(self):
         super(WorkingTreeTestCase, self).setUp()
-        self._worktree_path = self.create_new_worktree(self.repo_path())
+        self._worktree_path = self.create_new_worktree(self.repo_path(), 'branch')
         self._worktree_repo = Repo(self._worktree_path)
         self._mainworktree_repo = self._repo
+        self._number_of_working_tree = 2
         self._repo = self._worktree_repo
 
     def tearDown(self):
@@ -148,9 +157,50 @@ class WorkingTreeTestCase(ObjectStoreTestCase):
 
     def test_refs(self):
         super(WorkingTreeTestCase, self).test_refs()
-        self.assertTrue(self._mainworktree_repo.refs.allkeys()==\
-                        self._repo.refs.allkeys())
-        self.assertFalse(self._repo.refs[b'HEAD']==\
+        self.assertEqual(self._mainworktree_repo.refs.allkeys(),
+                         self._repo.refs.allkeys())
+
+    def test_head_equality(self):
+        self.assertNotEqual(self._repo.refs[b'HEAD'],
+                            self._mainworktree_repo.refs[b'HEAD'])
+
+    def test_bare(self):
+        self.assertFalse(self._repo.bare)
+        self.assertTrue(os.path.isfile(os.path.join(self._repo.path, '.git')))
+
+    def test_git_worktree_list(self):
+        output = run_git_or_fail(['worktree', 'list'], cwd=self._repo.path)
+        worktrees = self._parse_worktree_list(output)
+        self.assertEqual(len(worktrees), self._number_of_working_tree)
+        self.assertEqual(worktrees[0][1], '(bare)')
+        self.assertEqual(worktrees[0][0], self._mainworktree_repo.path)
+        
+        output = run_git_or_fail(['worktree', 'list'], cwd=self._mainworktree_repo.path)
+        worktrees = self._parse_worktree_list(output)
+        self.assertEqual(len(worktrees), self._number_of_working_tree)
+        self.assertEqual(worktrees[0][1], '(bare)')
+        self.assertEqual(worktrees[0][0], self._mainworktree_repo.path)
+
+class InitNewWorkingDirectoryTestCase(WorkingTreeTestCase):
+    """Test compatibility of Repo.init_new_working_directory."""
+
+    min_git_version = (2, 5, 0)
+
+    def setUp(self):
+        super(InitNewWorkingDirectoryTestCase, self).setUp()
+        self._other_worktree = self._repo
+        self._repo = Repo.init_new_working_directory(tempfile.mkdtemp(),
+                                                     self._mainworktree_repo.path)
+        self._number_of_working_tree = 3
+        
+    def tearDown(self):
+        self._repo.close()
+        rmtree_ro(self._repo.path)
+        self._repo = self._other_worktree
+        super(InitNewWorkingDirectoryTestCase, self).tearDown()
+
+    def test_head_equality(self):
+        self.assertEqual(self._repo.refs[b'HEAD'],
                          self._mainworktree_repo.refs[b'HEAD'])
 
     def test_bare(self):

dulwich/tests/compat/utils.py

@@ -21,19 +21,20 @@
 """Utilities for interacting with cgit."""
 
 import errno
-import functools
 import os
 import shutil
 import socket
 import stat
 import subprocess
-import sys
 import tempfile
 import time
 
 from dulwich.repo import Repo
 from dulwich.protocol import TCP_GIT_PORT
 
+from dulwich.tests.utils import (
+    rmtree_ro,
+)
 from dulwich.tests import (
     SkipTest,
     TestCase,
@@ -243,23 +244,23 @@ class CompatTestCase(TestCase):
         self.addCleanup(cleanup)
         return repo
 
-    def create_new_worktree(self, repo_dir):
+    def create_new_worktree(self, repo_dir, branch):
         """Create a new worktree using git-worktree.
 
         :param repo_dir: The directory of the main working tree.
+        :param branch: The branch or commit to checkout in the new worktree.
 
         :returns: The path to the new working tree.
         """
         temp_dir = tempfile.mkdtemp()
-        run_git_or_fail(['worktree', 'add', temp_dir, 'branch'],\
+        run_git_or_fail(['worktree', 'add', temp_dir, branch],
                         cwd=repo_dir)
         return temp_dir
 
-if sys.platform == 'win32':
-    def remove_ro(action, name, exc):
-        os.chmod(name, stat.S_IWRITE)
-        os.remove(name)
+    def debug_repo(self, s, repo):
+        print('{}: {}'.format(s, repo))
+        print('controldir: {}'.format(repo.controldir()))
+        print(' commondir: {}'.format(repo.commondir()))
+        for r in repo.get_refs().keys():
+            print('{}: {}'.format(r, repo.refs[r]))
 
-    rmtree_ro = functools.partial(shutil.rmtree, onerror=remove_ro)
-else:
-    rmtree_ro = shutil.rmtree

dulwich/tests/data/repos/a.git/worktrees/b/HEAD

@@ -0,0 +1 @@
+2a72d929692c41d8554c07f6301757ba18a65d91

dulwich/tests/data/repos/a.git/worktrees/b/commondir

@@ -0,0 +1 @@
+../..

dulwich/tests/data/repos/a.git/worktrees/b/gitdir

@@ -0,0 +1 @@
+../../../b

dulwich/tests/test_repository.py

@@ -47,8 +47,11 @@ from dulwich.tests import (
     )
 from dulwich.tests.utils import (
     open_repo,
+    rmtree_ro,
     tear_down_repo,
     setup_warning_catcher,
+    create_empty_commit,
+    create_repo_and_worktree,
     )
 
 missing_sha = b'b91fa4d900e17e99b433218e988c4eb4a3e9a097'
@@ -521,6 +524,15 @@ exit 1
             check(nonbare)
             check(bare)
 
+    def test_working_tree(self):
+        (r, w) = create_repo_and_worktree()
+        self.addCleanup(rmtree_ro, r.path)
+        self.addCleanup(rmtree_ro, w.path)
+        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())
+        self.assertEqual(w.get_parents(w.head()), [r.head()])
 
 class BuildRepoRootTests(TestCase):
     """Tests that build on-disk repos from scratch.

dulwich/tests/utils.py

@@ -22,8 +22,10 @@
 
 
 import datetime
+import functools
 import os
 import shutil
+import sys
 import tempfile
 import time
 import types
@@ -360,3 +362,32 @@ def setup_warning_catcher():
         warnings.showwarning = original_showwarning
 
     return caught_warnings, restore_showwarning
+
+def create_empty_commit(r):
+    return 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)
+
+def create_repo_and_worktree():
+    temp_dir = tempfile.mkdtemp()
+    worktree_temp_dir = tempfile.mkdtemp()
+    r = Repo.init(temp_dir)
+    root_sha = create_empty_commit(r)
+    second_sha = create_empty_commit(r)
+    r.refs[b'refs/heads/master'] = second_sha
+    w = Repo.init_new_working_directory(worktree_temp_dir, temp_dir)
+    new_sha = create_empty_commit(w)
+    w.refs[b'refs/heads/branch'] = new_sha
+    return (r, w)
+
+if sys.platform == 'win32':
+    def remove_ro(action, name, exc):
+        os.chmod(name, stat.S_IWRITE)
+        os.remove(name)
+
+    rmtree_ro = functools.partial(shutil.rmtree, onerror=remove_ro)
+else:
+    rmtree_ro = shutil.rmtree