feat(git): Improve remotes support (#314)

Fixes #311 for use in vcs-python/vcspull#362

Author: tony

CHANGES

@@ -11,6 +11,35 @@ $ pip install --user --upgrade --pre libvcs
 
 ## current - unrelased
 
+### What's new
+
+- {class}`libvcs.git.GitRepo` now accepts remotes in `__init__`
+
+  ```python
+  repo = GitRepo(
+      url="https://github.com/vcs-python/libvcs",
+      repo_dir=checkout,
+      remotes={
+          'gitlab': 'https://gitlab.com/vcs-python/libvcs',
+      }
+  )
+  ```
+
+  ```python
+  repo = GitRepo(
+      url="https://github.com/vcs-python/libvcs",
+      repo_dir=checkout,
+      remotes={
+          'gitlab': {
+              'fetch': 'https://gitlab.com/vcs-python/libvcs',
+              'push': 'https://gitlab.com/vcs-python/libvcs',
+          },
+      }
+  )
+  ```
+
+- {meth}`libvcs.git.GitRepo.update_repo` now accepts `set_remotes=True`
+
 ### Compatibility
 
 - Python 3.7 and 3.8 dropped (#308)

docs/conf.py

@@ -87,6 +87,10 @@ def setup(app):
     ]
 }
 
+# sphinx.ext.autodoc
+autoclass_content = "both"
+autodoc_member_order = "bysource"
+
 # sphinxext.opengraph
 ogp_site_url = about["__docs__"]
 ogp_image = "_static/img/icons/icon-192x192.png"

libvcs/git.py

@@ -17,7 +17,7 @@
 import logging
 import os
 import re
-from typing import Dict, NamedTuple, Optional
+from typing import Dict, NamedTuple, Optional, TypedDict, Union
 from urllib import parse as urlparse
 
 from . import exc
@@ -125,11 +125,20 @@ def convert_pip_url(pip_url: str) -> VCSLocation:
     return VCSLocation(url=url, rev=rev)
 
 
+class RemoteDict(TypedDict):
+    fetch: str
+    push: str
+
+
+FullRemoteDict = Dict[str, RemoteDict]
+RemotesArgs = Union[None, FullRemoteDict, Dict[str, str]]
+
+
 class GitRepo(BaseRepo):
     bin_name = "git"
     schemes = ("git", "git+http", "git+https", "git+ssh", "git+git", "git+file")
 
-    def __init__(self, url, repo_dir, **kwargs):
+    def __init__(self, url: str, repo_dir: str, remotes: RemotesArgs = None, **kwargs):
         """A git repository.
 
         Parameters
@@ -139,12 +148,61 @@ def __init__(self, url, repo_dir, **kwargs):
 
         tls_verify : bool
             Should certificate for https be checked (default False)
+
+        Examples
+        --------
+
+        .. code-block:: python
+
+            import os
+            from libvcs.git import GitRepo
+
+            checkout = os.path.dirname(os.path.abspath(__name__)) + '/' + 'my_libvcs'
+
+            repo = GitRepo(
+               url="https://github.com/vcs-python/libvcs",
+               repo_dir=checkout,
+               remotes={
+                   'gitlab': 'https://gitlab.com/vcs-python/libvcs'
+               }
+            )
+
+        .. code-block:: python
+
+            import os
+            from libvcs.git import GitRepo
+
+            checkout = os.path.dirname(os.path.abspath(__name__)) + '/' + 'my_libvcs'
+
+            repo = GitRepo(
+               url="https://github.com/vcs-python/libvcs",
+               repo_dir=checkout,
+               remotes={
+                   'gitlab': {
+                       'fetch': 'https://gitlab.com/vcs-python/libvcs',
+                       'push': 'https://gitlab.com/vcs-python/libvcs',
+                   },
+               }
+            )
         """
         if "git_shallow" not in kwargs:
             self.git_shallow = False
         if "tls_verify" not in kwargs:
             self.tls_verify = False
 
+        self._remotes: Union[FullRemoteDict, None]
+
+        if remotes is None:
+            self._remotes: FullRemoteDict = {"origin": url}
+        elif isinstance(remotes, dict):
+            self._remotes: FullRemoteDict = remotes
+            for remote_name, url in remotes.items():
+                if isinstance(str, dict):
+                    remotes[remote_name] = {
+                        "fetch": url,
+                        "push": url,
+                    }
+
         BaseRepo.__init__(self, url, repo_dir, **kwargs)
 
     @classmethod
@@ -161,6 +219,28 @@ def get_revision(self):
         except exc.CommandError:
             return "initial"
 
+    def set_remotes(self, overwrite: bool = False):
+        remotes = self._remotes
+        if isinstance(remotes, dict):
+            for remote_name, url in remotes.items():
+                existing_remote = self.remote(remote_name)
+                if isinstance(url, dict) and "fetch" in url:
+                    if not existing_remote or existing_remote.fetch_url != url:
+                        self.set_remote(
+                            name=remote_name, url=url["fetch"], overwrite=overwrite
+                        )
+                    if "push" in url:
+                        if not existing_remote or existing_remote.push_url != url:
+                            self.set_remote(
+                                name=remote_name,
+                                url=url["push"],
+                                push=True,
+                                overwrite=overwrite,
+                            )
+                else:
+                    if not existing_remote or existing_remote.fetch_url != url:
+                        self.set_remote(name=remote_name, url=url, overwrite=overwrite)
+
     def obtain(self):
         """Retrieve the repository, clone if doesn't exist."""
         self.ensure_dir()
@@ -182,14 +262,19 @@ def obtain(self):
         cmd = ["submodule", "update", "--recursive", "--init"]
         self.run(cmd, log_in_real_time=True)
 
-    def update_repo(self):
+        self.set_remotes()
+
+    def update_repo(self, set_remotes: bool = False):
         self.ensure_dir()
 
         if not os.path.isdir(os.path.join(self.path, ".git")):
             self.obtain()
             self.update_repo()
             return
 
+        if set_remotes:
+            self.set_remotes(overwrite=True)
+
         # Get requested revision or tag
         url, git_tag = self.url, getattr(self, "rev", None)
 
@@ -388,7 +473,7 @@ def remote(self, name, **kwargs) -> GitRemote:
         except exc.LibVCSException:
             return None
 
-    def set_remote(self, name, url, overwrite=False):
+    def set_remote(self, name, url, push: bool = False, overwrite=False):
         """Set remote with name and URL like git remote add.
 
         Parameters

tests/test_git.py

@@ -12,6 +12,7 @@
 
 from libvcs import exc
 from libvcs.git import (
+    FullRemoteDict,
     GitRemote,
     GitRepo,
     convert_pip_url as git_convert_pip_url,
@@ -26,6 +27,7 @@
 
 RepoTestFactory = Callable[..., GitRepo]
 RepoTestFactoryLazyKwargs = Callable[..., dict]
+RepoTestFactoryRemotesLazyExpected = Callable[..., FullRemoteDict]
 
 
 @pytest.fixture(autouse=True, scope="module")
@@ -215,21 +217,61 @@ def progress_callback_spy(output, timestamp):
 
 @pytest.mark.parametrize(
     # Postpone evaluation of options so fixture variables can interpolate
-    "constructor,lazy_constructor_options",
+    "constructor,lazy_constructor_options,lazy_remote_expected",
     [
         [
             GitRepo,
             lambda git_remote, repos_path, repo_name, **kwargs: {
                 "url": f"file://{git_remote}",
                 "repo_dir": repos_path / repo_name,
             },
+            lambda git_remote, **kwargs: {"origin": f"file://{git_remote}"},
+        ],
+        [
+            GitRepo,
+            lambda git_remote, repos_path, repo_name, **kwargs: {
+                "url": f"file://{git_remote}",
+                "repo_dir": repos_path / repo_name,
+                "remotes": {"origin": f"file://{git_remote}"},
+            },
+            lambda git_remote, **kwargs: {"origin": f"file://{git_remote}"},
+        ],
+        [
+            GitRepo,
+            lambda git_remote, repos_path, repo_name, **kwargs: {
+                "url": f"file://{git_remote}",
+                "repo_dir": repos_path / repo_name,
+                "remotes": {
+                    "origin": f"file://{git_remote}",
+                    "second_remote": f"file://{git_remote}",
+                },
+            },
+            lambda git_remote, **kwargs: {
+                "origin": f"file://{git_remote}",
+                "second_remote": f"file://{git_remote}",
+            },
+        ],
+        [
+            GitRepo,
+            lambda git_remote, repos_path, repo_name, **kwargs: {
+                "url": f"file://{git_remote}",
+                "repo_dir": repos_path / repo_name,
+                "remotes": {
+                    "second_remote": f"file://{git_remote}",
+                },
+            },
+            lambda git_remote, **kwargs: {
+                "origin": f"file://{git_remote}",
+                "second_remote": f"file://{git_remote}",
+            },
         ],
         [
             create_repo_from_pip_url,
             lambda git_remote, repos_path, repo_name, **kwargs: {
                 "pip_url": f"git+file://{git_remote}",
                 "repo_dir": repos_path / repo_name,
             },
+            lambda git_remote, **kwargs: {"origin": f"file://{git_remote}"},
         ],
     ],
 )
@@ -238,16 +280,90 @@ def test_remotes(
     git_remote: pathlib.Path,
     constructor: RepoTestFactory,
     lazy_constructor_options: RepoTestFactoryLazyKwargs,
+    lazy_remote_expected: RepoTestFactoryRemotesLazyExpected,
+):
+    repo_name = "myrepo"
+    remote_name = "myremote"
+    remote_url = "https://localhost/my/git/repo.git"
+
+    git_repo: GitRepo = constructor(**lazy_constructor_options(**locals()))
+    git_repo.obtain()
+
+    expected = lazy_remote_expected(**locals())
+    assert len(expected.keys()) > 0
+    for expected_remote_name, expected_remote_url in expected.items():
+        assert (
+            expected_remote_name,
+            expected_remote_url,
+            expected_remote_url,
+        ) == git_repo.remote(expected_remote_name)
+
+
+@pytest.mark.parametrize(
+    # Postpone evaluation of options so fixture variables can interpolate
+    "constructor,lazy_constructor_options,lazy_remote_dict,lazy_remote_expected",
+    [
+        [
+            GitRepo,
+            lambda git_remote, repos_path, repo_name, **kwargs: {
+                "url": f"file://{git_remote}",
+                "repo_dir": repos_path / repo_name,
+                "remotes": {
+                    "origin": f"file://{git_remote}",
+                },
+            },
+            lambda git_remote, **kwargs: {
+                "second_remote": f"file://{git_remote}",
+            },
+            lambda git_remote, **kwargs: {
+                "origin": f"file://{git_remote}",
+                "second_remote": f"file://{git_remote}",
+            },
+        ],
+        [
+            GitRepo,
+            lambda git_remote, repos_path, repo_name, **kwargs: {
+                "url": f"file://{git_remote}",
+                "repo_dir": repos_path / repo_name,
+                "remotes": {
+                    "origin": f"file://{git_remote}",
+                },
+            },
+            lambda git_remote, **kwargs: {
+                "origin": "https://github.com/vcs-python/libvcs",
+            },
+            lambda git_remote, **kwargs: {
+                "origin": "https://github.com/vcs-python/libvcs",
+            },
+        ],
+    ],
+)
+def test_remotes_update_repo(
+    repos_path: pathlib.Path,
+    git_remote: pathlib.Path,
+    constructor: RepoTestFactory,
+    lazy_constructor_options: RepoTestFactoryLazyKwargs,
+    lazy_remote_dict: RepoTestFactoryRemotesLazyExpected,
+    lazy_remote_expected: RepoTestFactoryRemotesLazyExpected,
 ):
     repo_name = "myrepo"
     remote_name = "myremote"
     remote_url = "https://localhost/my/git/repo.git"
 
     git_repo: GitRepo = constructor(**lazy_constructor_options(**locals()))
     git_repo.obtain()
-    git_repo.set_remote(name=remote_name, url=remote_url)
 
-    assert (remote_name, remote_url, remote_url) == git_repo.remote(remote_name)
+    git_repo._remotes = lazy_remote_dict(**locals())
+    git_repo.update_repo(set_remotes=True)
+
+    expected = lazy_remote_expected(**locals())
+    assert len(expected.keys()) > 0
+    for expected_remote_name, expected_remote_url in expected.items():
+        assert (
+            expected_remote_name,
+            expected_remote_url,
+            expected_remote_url,
+        ) == git_repo.remote(expected_remote_name)
 
 
 def test_git_get_url_and_rev_from_pip_url():