Spaces:
Running
Running
File size: 5,630 Bytes
1380717 |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 |
# This module is part of GitPython and is released under the
# 3-Clause BSD License: https://opensource.org/license/bsd-3-clause/
__all__ = ["Reference"]
from git.util import IterableObj, LazyMixin
from .symbolic import SymbolicReference, T_References
# typing ------------------------------------------------------------------
from typing import Any, Callable, Iterator, TYPE_CHECKING, Type, Union
from git.types import AnyGitObject, PathLike, _T
if TYPE_CHECKING:
from git.repo import Repo
# ------------------------------------------------------------------------------
# { Utilities
def require_remote_ref_path(func: Callable[..., _T]) -> Callable[..., _T]:
"""A decorator raising :exc:`ValueError` if we are not a valid remote, based on the
path."""
def wrapper(self: T_References, *args: Any) -> _T:
if not self.is_remote():
raise ValueError("ref path does not point to a remote reference: %s" % self.path)
return func(self, *args)
# END wrapper
wrapper.__name__ = func.__name__
return wrapper
# } END utilities
class Reference(SymbolicReference, LazyMixin, IterableObj):
"""A named reference to any object.
Subclasses may apply restrictions though, e.g., a :class:`~git.refs.head.Head` can
only point to commits.
"""
__slots__ = ()
_points_to_commits_only = False
_resolve_ref_on_create = True
_common_path_default = "refs"
def __init__(self, repo: "Repo", path: PathLike, check_path: bool = True) -> None:
"""Initialize this instance.
:param repo:
Our parent repository.
:param path:
Path relative to the ``.git/`` directory pointing to the ref in question,
e.g. ``refs/heads/master``.
:param check_path:
If ``False``, you can provide any path.
Otherwise the path must start with the default path prefix of this type.
"""
if check_path and not str(path).startswith(self._common_path_default + "/"):
raise ValueError(f"Cannot instantiate {self.__class__.__name__!r} from path {path}")
self.path: str # SymbolicReference converts to string at the moment.
super().__init__(repo, path)
def __str__(self) -> str:
return self.name
# { Interface
# @ReservedAssignment
def set_object(
self,
object: Union[AnyGitObject, "SymbolicReference", str],
logmsg: Union[str, None] = None,
) -> "Reference":
"""Special version which checks if the head-log needs an update as well.
:return:
self
"""
oldbinsha = None
if logmsg is not None:
head = self.repo.head
if not head.is_detached and head.ref == self:
oldbinsha = self.commit.binsha
# END handle commit retrieval
# END handle message is set
super().set_object(object, logmsg)
if oldbinsha is not None:
# From refs/files-backend.c in git-source:
# /*
# * Special hack: If a branch is updated directly and HEAD
# * points to it (may happen on the remote side of a push
# * for example) then logically the HEAD reflog should be
# * updated too.
# * A generic solution implies reverse symref information,
# * but finding all symrefs pointing to the given branch
# * would be rather costly for this rare event (the direct
# * update of a branch) to be worth it. So let's cheat and
# * check with HEAD only which should cover 99% of all usage
# * scenarios (even 100% of the default ones).
# */
self.repo.head.log_append(oldbinsha, logmsg)
# END check if the head
return self
# NOTE: No need to overwrite properties, as the will only work without a the log.
@property
def name(self) -> str:
"""
:return:
(shortest) Name of this reference - it may contain path components
"""
# The first two path tokens can be removed as they are
# refs/heads or refs/tags or refs/remotes.
tokens = self.path.split("/")
if len(tokens) < 3:
return self.path # could be refs/HEAD
return "/".join(tokens[2:])
@classmethod
def iter_items(
cls: Type[T_References],
repo: "Repo",
common_path: Union[PathLike, None] = None,
*args: Any,
**kwargs: Any,
) -> Iterator[T_References]:
"""Equivalent to
:meth:`SymbolicReference.iter_items <git.refs.symbolic.SymbolicReference.iter_items>`,
but will return non-detached references as well."""
return cls._iter_items(repo, common_path)
# } END interface
# { Remote Interface
@property
@require_remote_ref_path
def remote_name(self) -> str:
"""
:return:
Name of the remote we are a reference of, such as ``origin`` for a reference
named ``origin/master``.
"""
tokens = self.path.split("/")
# /refs/remotes/<remote name>/<branch_name>
return tokens[2]
@property
@require_remote_ref_path
def remote_head(self) -> str:
"""
:return:
Name of the remote head itself, e.g. ``master``.
:note:
The returned name is usually not qualified enough to uniquely identify a
branch.
"""
tokens = self.path.split("/")
return "/".join(tokens[3:])
# } END remote interface
|