# This is a combination of 8 commits.

# This is the 1st commit message:
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)`.

# The commit message #2 will be skipped:

#	Fix DiskRefsContainer.refpath()

# The commit message #3 will be skipped:

#	Add a testsuite

# The commit message #4 will be skipped:

#	Add @skipIf for WorkingTreeTestCase

# The commit message #5 will be skipped:

#	worktree is optional and default to path

# The commit message #6 will be skipped:

#	add a TODO

# The commit message #7 will be skipped:

#	Save one syscall
#
#	See https://github.com/jelmer/dulwich/pull/454/files/0927deb7cd2ad24294b89e319ea060ed488acbba#r82424872

# The commit message #8 will be skipped:

#	Read commondir with get_named_file()

dulwich/refs.py

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

dulwich/repo.py

@@ -89,6 +89,7 @@ REFSDIR = 'refs'
 REFSDIR_TAGS = 'tags'
 REFSDIR_HEADS = 'heads'
 INDEX_FILENAME = "index"
+COMMONDIR = 'commondir'
 
 BASE_DIRECTORIES = [
     ["branches"],
@@ -676,10 +677,15 @@ class Repo(BaseRepo):
             raise NotGitRepository(
                 "No git repository was found at %(path)s" % dict(path=root)
             )
+        commondir = self.get_named_file(COMMONDIR)
+        if 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.controldir(),
+        object_store = DiskObjectStore(os.path.join(self.commondir(),
                                                     OBJECTDIR))
-        refs = DiskRefsContainer(self.controldir())
+        refs = DiskRefsContainer(self.commondir(), worktree=self._controldir)
         BaseRepo.__init__(self, object_store, refs)
 
         self._graftpoints = {}
@@ -720,6 +726,16 @@ class Repo(BaseRepo):
         """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 _put_named_file(self, path, contents):
         """Write a file to the control dir with the given name and contents.
 

dulwich/tests/compat/test_repository.py

@@ -30,12 +30,17 @@ from dulwich.objects import (
     )
 from dulwich.repo import (
     check_ref_format,
+    Repo,
     )
 
+from dulwich.tests import skipIf
+
 from dulwich.tests.compat.utils import (
     run_git_or_fail,
     CompatTestCase,
-    )
+    rmtree_ro,
+    git_version
+)
 
 
 class ObjectStoreTestCase(CompatTestCase):
@@ -45,6 +50,9 @@ class ObjectStoreTestCase(CompatTestCase):
         super(ObjectStoreTestCase, self).setUp()
         self._repo = self.import_repo('server_new.export')
 
+    def repo_path(self):
+        return self._repo.path
+
     def _run_git(self, args):
         return run_git_or_fail(args, cwd=self._repo.path)
 
@@ -119,3 +127,32 @@ class ObjectStoreTestCase(CompatTestCase):
     def test_all_objects(self):
         expected_shas = self._get_all_shas()
         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."""
+
+    def setUp(self):
+        super(WorkingTreeTestCase, self).setUp()
+        self._worktree_path = self.create_new_worktree(self.repo_path())
+        self._worktree_repo = Repo(self._worktree_path)
+        self._mainworktree_repo = self._repo
+        self._repo = self._worktree_repo
+
+    def tearDown(self):
+        self._worktree_repo.close()
+        rmtree_ro(self._worktree_path)
+        self._repo = self._mainworktree_repo
+        super(WorkingTreeTestCase, self).tearDown()
+
+    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._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')))

dulwich/tests/compat/utils.py

@@ -243,6 +243,17 @@ class CompatTestCase(TestCase):
         self.addCleanup(cleanup)
         return repo
 
+    def create_new_worktree(self, repo_dir):
+        """Create a new worktree using git-worktree.
+
+        :param repo_dir: The directory of the main working tree.
+
+        :returns: The path to the new working tree.
+        """
+        temp_dir = tempfile.mkdtemp()
+        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):