GitPython 3.1.47__py3-none-any.whl → 3.1.49__py3-none-any.whl

git/__init__.py

@@ -86,7 +86,7 @@ __all__ = [
     "to_hex_sha",
 ]
 
-__version__ = '3.1.47'
+__version__ = '3.1.49'
 
 from typing import Any, List, Optional, Sequence, TYPE_CHECKING, Tuple, Union
 

git/config.py

@@ -882,6 +882,24 @@ class GitConfigParser(cp.RawConfigParser, metaclass=MetaParserBuilder):
             return str(value)
         return force_text(value)
 
+    def _value_to_string_safe(self, value: Union[str, bytes, int, float, bool]) -> str:
+        value_str = self._value_to_string(value)
+        if re.search(r"[\r\n\x00]", value_str):
+            raise ValueError("Git config values must not contain CR, LF, or NUL")
+        return value_str
+
+    @needs_values
+    @set_dirty_and_flush_changes
+    def set(
+        self,
+        section: str,
+        option: str,
+        value: Union[str, bytes, int, float, bool, None] = None,
+    ) -> None:
+        if value is not None:
+            value = self._value_to_string_safe(value)
+        return super().set(section, option, value)
+
     @needs_values
     @set_dirty_and_flush_changes
     def set_value(self, section: str, option: str, value: Union[str, bytes, int, float, bool]) -> "GitConfigParser":
@@ -902,9 +920,10 @@ class GitConfigParser(cp.RawConfigParser, metaclass=MetaParserBuilder):
         :return:
             This instance
         """
+        value_str = self._value_to_string_safe(value)
         if not self.has_section(section):
             self.add_section(section)
-        self.set(section, option, self._value_to_string(value))
+        super().set(section, option, value_str)
         return self
 
     @needs_values
@@ -929,9 +948,10 @@ class GitConfigParser(cp.RawConfigParser, metaclass=MetaParserBuilder):
         :return:
             This instance
         """
+        value_str = self._value_to_string_safe(value)
         if not self.has_section(section):
             self.add_section(section)
-        self._sections[section].add(option, self._value_to_string(value))
+        self._sections[section].add(option, value_str)
         return self
 
     def rename_section(self, section: str, new_name: str) -> "GitConfigParser":

git/refs/log.py

@@ -4,7 +4,6 @@
 __all__ = ["RefLog", "RefLogEntry"]
 
 from mmap import mmap
-import os.path as osp
 import re
 import time as _time
 
@@ -212,8 +211,11 @@ class RefLog(List[RefLogEntry], Serializable):
 
         :param ref:
             :class:`~git.refs.symbolic.SymbolicReference` instance
+
+        :raise ValueError:
+            If `ref.path` is invalid or escapes the repository's reflog directory.
         """
-        return osp.join(ref.repo.git_dir, "logs", to_native_path(ref.path))
+        return to_native_path(ref._get_validated_reflog_path(ref.repo, ref.path))
 
     @classmethod
     def iter_entries(cls, stream: Union[str, "BytesIO", mmap]) -> Iterator[RefLogEntry]:

git/refs/remote.py

@@ -58,17 +58,20 @@ class RemoteReference(Head):
             `kwargs` are given for comparability with the base class method as we
             should not narrow the signature.
         """
+        for ref in refs:
+            cls._check_ref_name_valid(ref.path)
+
         repo.git.branch("-d", "-r", *refs)
         # The official deletion method will ignore remote symbolic refs - these are
         # generally ignored in the refs/ folder. We don't though and delete remainders
         # manually.
         for ref in refs:
             try:
-                os.remove(os.path.join(repo.common_dir, ref.path))
+                os.remove(cls._get_validated_path(repo.common_dir, ref.path))
             except OSError:
                 pass
             try:
-                os.remove(os.path.join(repo.git_dir, ref.path))
+                os.remove(cls._get_validated_path(repo.git_dir, ref.path))
             except OSError:
                 pass
         # END for each ref

git/refs/symbolic.py

@@ -110,6 +110,32 @@ class SymbolicReference:
     def abspath(self) -> PathLike:
         return join_path_native(_git_dir(self.repo, self.path), self.path)
 
+    @staticmethod
+    def _get_validated_path(base: PathLike, path: PathLike) -> str:
+        path = os.fspath(path)
+        base_path = os.path.realpath(os.fspath(base))
+        abs_path = os.path.realpath(os.path.join(base_path, path))
+        try:
+            common_path = os.path.commonpath([base_path, abs_path])
+        except ValueError as e:
+            raise ValueError("Reference path %r escapes the repository" % path) from e
+        if os.path.normcase(common_path) != os.path.normcase(base_path):
+            raise ValueError("Reference path %r escapes the repository" % path)
+        return abs_path
+
+    @classmethod
+    def _get_validated_ref_path(cls, repo: "Repo", path: PathLike) -> str:
+        """Return the absolute filesystem path for a ref after validating it."""
+        cls._check_ref_name_valid(path)
+        ref_path = os.fspath(path)
+        return cls._get_validated_path(_git_dir(repo, ref_path), ref_path)
+
+    @classmethod
+    def _get_validated_reflog_path(cls, repo: "Repo", path: PathLike) -> str:
+        """Return the absolute filesystem path for a reflog after validating it."""
+        cls._check_ref_name_valid(path)
+        return cls._get_validated_path(os.path.join(repo.git_dir, "logs"), path)
+
     @classmethod
     def _get_packed_refs_path(cls, repo: "Repo") -> str:
         return os.path.join(repo.common_dir, "packed-refs")
@@ -485,7 +511,7 @@ class SymbolicReference:
             # END handle non-existing
         # END retrieve old hexsha
 
-        fpath = self.abspath
+        fpath = self._get_validated_ref_path(self.repo, self.path)
         assure_directory_exists(fpath, is_file=True)
 
         lfd = LockedFD(fpath)
@@ -632,7 +658,7 @@ class SymbolicReference:
             Alternatively the symbolic reference to be deleted.
         """
         full_ref_path = cls.to_full_path(path)
-        abs_path = os.path.join(repo.common_dir, full_ref_path)
+        abs_path = cls._get_validated_ref_path(repo, full_ref_path)
         if os.path.exists(abs_path):
             os.remove(abs_path)
         else:
@@ -695,9 +721,8 @@ class SymbolicReference:
         symbolic reference. Otherwise it will be resolved to the corresponding object
         and a detached symbolic reference will be created instead.
         """
-        git_dir = _git_dir(repo, path)
         full_ref_path = cls.to_full_path(path)
-        abs_ref_path = os.path.join(git_dir, full_ref_path)
+        abs_ref_path = cls._get_validated_ref_path(repo, full_ref_path)
 
         # Figure out target data.
         target = reference
@@ -789,8 +814,8 @@ class SymbolicReference:
         if self.path == new_path:
             return self
 
-        new_abs_path = os.path.join(_git_dir(self.repo, new_path), new_path)
-        cur_abs_path = os.path.join(_git_dir(self.repo, self.path), self.path)
+        new_abs_path = self._get_validated_ref_path(self.repo, new_path)
+        cur_abs_path = self._get_validated_ref_path(self.repo, self.path)
         if os.path.isfile(new_abs_path):
             if not force:
                 # If they point to the same file, it's not an error.

git/repo/fun.py

@@ -20,6 +20,7 @@ __all__ = [
 import os
 import os.path as osp
 from pathlib import Path
+import re
 import stat
 from string import digits
 
@@ -28,19 +29,21 @@ from gitdb.exc import BadName, BadObject
 from git.cmd import Git
 from git.exc import WorkTreeRepositoryUnsupported
 from git.objects import Object
+from git.objects.util import parse_date
 from git.refs import SymbolicReference
 from git.util import cygpath, bin_to_hex, hex_to_bin
 
 # Typing ----------------------------------------------------------------------
 
-from typing import Optional, TYPE_CHECKING, Union, cast, overload
+from typing import Iterator, Optional, TYPE_CHECKING, Tuple, Union, cast, overload
 
 from git.types import AnyGitObject, Literal, PathLike
 
 if TYPE_CHECKING:
     from git.db import GitCmdObjectDB
-    from git.objects import Commit, TagObject
+    from git.objects import Commit
     from git.refs.reference import Reference
+    from git.refs.log import RefLog, RefLogEntry
     from git.refs.tag import Tag
 
     from .base import Repo
@@ -139,6 +142,23 @@ def short_to_long(odb: "GitCmdObjectDB", hexsha: str) -> Optional[bytes]:
     # END exception handling
 
 
+def _describe_to_long(repo: "Repo", name: str) -> Optional[bytes]:
+    """Resolve git-describe style names to the abbreviated object they contain."""
+    match = re.match(r"^.+-\d+-g([0-9A-Fa-f]{4,40})(?:-dirty)?$", name)
+    if match is None:
+        match = re.match(r"^.+-g([0-9A-Fa-f]{4,40})(?:-dirty)?$", name)
+    if match is None:
+        match = re.match(r"^([0-9A-Fa-f]{4,40})-dirty$", name)
+    if match is None:
+        return None
+    # END handle match
+
+    hexsha = match.group(1)
+    if len(hexsha) == 40:
+        return hexsha.encode("ascii")
+    return short_to_long(repo.odb, hexsha)
+
+
 @overload
 def name_to_object(repo: "Repo", name: str, return_ref: Literal[False] = ...) -> AnyGitObject: ...
 
@@ -192,6 +212,10 @@ def name_to_object(repo: "Repo", name: str, return_ref: bool = False) -> Union[A
         # END for each base
     # END handle hexsha
 
+    if hexsha is None:
+        hexsha = _describe_to_long(repo, name)
+    # END handle describe output
+
     # Didn't find any ref, this is an error.
     if return_ref:
         raise BadObject("Couldn't find reference named %r" % name)
@@ -227,6 +251,361 @@ def to_commit(obj: Object) -> "Commit":
     return obj
 
 
+def _object_from_hexsha(repo: "Repo", hexsha: str) -> AnyGitObject:
+    return Object.new_from_sha(repo, hex_to_bin(hexsha))
+
+
+def _current_reflog_ref(repo: "Repo") -> SymbolicReference:
+    try:
+        return repo.head.ref
+    except TypeError:
+        return repo.head
+    # END handle detached head
+
+
+def _common_reflog_path(repo: "Repo", ref: SymbolicReference) -> Optional[str]:
+    if repo.common_dir == repo.git_dir:
+        return None
+    # END handle normal repository
+    return SymbolicReference._get_validated_path(osp.join(repo.common_dir, "logs"), ref.path)
+
+
+def _ref_log(repo: "Repo", ref: SymbolicReference) -> "RefLog":
+    try:
+        return ref.log()
+    except FileNotFoundError:
+        common_path = _common_reflog_path(repo, ref)
+        if common_path and osp.isfile(common_path):
+            from git.refs.log import RefLog
+
+            return RefLog.from_file(common_path)
+        # END handle linked-worktree branch logs
+        try:
+            if ref.path == repo.head.ref.path:
+                return repo.head.log()
+            # END handle linked-worktree current branch logs
+        except TypeError:
+            pass
+        # END handle detached head
+        raise
+    # END handle missing branch log
+
+
+def _ref_log_entry(repo: "Repo", ref: SymbolicReference, index: int) -> "RefLogEntry":
+    try:
+        return ref.log_entry(index)
+    except FileNotFoundError:
+        common_path = _common_reflog_path(repo, ref)
+        if common_path and osp.isfile(common_path):
+            from git.refs.log import RefLog
+
+            return RefLog.entry_at(common_path, index)
+        # END handle linked-worktree branch logs
+        try:
+            if ref.path == repo.head.ref.path:
+                return repo.head.log_entry(index)
+            # END handle linked-worktree current branch logs
+        except TypeError:
+            pass
+        # END handle detached head
+        raise
+    # END handle missing branch log
+
+
+def _find_reflog_entry_by_date(repo: "Repo", ref: SymbolicReference, spec: str) -> str:
+    try:
+        timestamp, _offset = parse_date(spec)
+    except ValueError as e:
+        raise NotImplementedError("Support for additional @{...} modes not implemented") from e
+    # END handle unsupported dates
+    log = _ref_log(repo, ref)
+    if not log:
+        raise IndexError("Invalid revlog date: %s" % spec)
+    # END handle empty log
+
+    for entry in reversed(log):
+        if entry.time[0] <= timestamp:
+            return entry.newhexsha
+        # END found candidate
+    # END for each entry
+    return log[0].newhexsha
+
+
+def _previous_checked_out_branch(repo: "Repo", nth: int) -> AnyGitObject:
+    if nth <= 0:
+        raise ValueError("Invalid previous checkout selector: -%i" % nth)
+    # END handle invalid input
+
+    seen = 0
+    for entry in reversed(_ref_log(repo, repo.head)):
+        message = entry.message or ""
+        prefix = "checkout: moving from "
+        if not message.startswith(prefix):
+            continue
+        # END skip non-checkouts
+
+        previous_branch = message[len(prefix) :].split(" to ", 1)[0]
+        seen += 1
+        if seen == nth:
+            return name_to_object(repo, previous_branch)
+        # END found selector
+    # END for each entry
+    raise IndexError("Invalid previous checkout selector: -%i" % nth)
+
+
+def _tracking_branch_object(repo: "Repo", ref: Optional[SymbolicReference]) -> AnyGitObject:
+    from git.refs.head import Head
+
+    if ref is None:
+        try:
+            head = repo.active_branch
+        except TypeError as e:
+            raise BadName("@{upstream}") from e
+    elif isinstance(ref, Head):
+        head = ref
+    elif os.fspath(ref.path).startswith("refs/heads/"):
+        head = Head(repo, ref.path)
+    else:
+        raise BadName("%s@{upstream}" % ref.name)
+    # END handle head
+
+    tracking_branch = head.tracking_branch()
+    if tracking_branch is None:
+        raise BadName("%s@{upstream}" % head.name)
+    # END handle missing upstream
+    return tracking_branch.commit
+
+
+def _apply_reflog(repo: "Repo", ref: Optional[SymbolicReference], content: str) -> AnyGitObject:
+    if content.startswith("+"):
+        content = content[1:]
+    # END handle explicit positive sign
+
+    if content.startswith("-"):
+        if ref is not None:
+            raise ValueError("Previous checkout selectors do not take an explicit ref")
+        if content == "-0":
+            raise ValueError("Negative zero is invalid in reflog selector")
+        # END handle invalid negative zero
+        try:
+            return _previous_checked_out_branch(repo, int(content[1:]))
+        except ValueError as e:
+            raise ValueError("Invalid previous checkout selector: %s" % content) from e
+    # END handle previous checkout branch
+
+    content_lower = content.lower()
+    if content_lower in ("u", "upstream", "push"):
+        return _tracking_branch_object(repo, ref)
+    # END handle sibling branches
+
+    ref = ref or _current_reflog_ref(repo)
+    try:
+        entry_no = int(content)
+    except ValueError:
+        hexsha = _find_reflog_entry_by_date(repo, ref, content)
+    else:
+        if entry_no >= 100000000:
+            hexsha = _find_reflog_entry_by_date(repo, ref, "%s +0000" % entry_no)
+        elif entry_no == 0:
+            return ref.commit
+        else:
+            try:
+                entry = _ref_log_entry(repo, ref, -(entry_no + 1))
+            except IndexError as e:
+                raise IndexError("Invalid revlog index: %i" % entry_no) from e
+            # END handle index out of bound
+            hexsha = entry.newhexsha
+        # END handle offset or date-like timestamp
+    # END handle content
+    return _object_from_hexsha(repo, hexsha)
+
+
+def _find_closing_brace(rev: str, start: int) -> int:
+    depth = 1
+    escaped = False
+    for idx in range(start + 1, len(rev)):
+        char = rev[idx]
+        if escaped:
+            escaped = False
+        elif char == "\\":
+            escaped = True
+        elif char == "{":
+            depth += 1
+        elif char == "}":
+            depth -= 1
+            if depth == 0:
+                return idx
+            # END found end
+        # END handle char
+    # END for each char
+    raise ValueError("Missing closing brace to define type in %s" % rev)
+
+
+def _parse_search(pattern: str) -> Tuple[str, bool]:
+    if not pattern:
+        raise ValueError("Revision search requires a pattern")
+    # END handle empty pattern
+
+    if pattern.startswith("!-"):
+        return pattern[2:], True
+    if pattern.startswith("!!"):
+        return pattern[1:], False
+    if pattern.startswith("!"):
+        raise ValueError("Need one character after /!, typically -")
+    return pattern, False
+
+
+def _unescape_braced_regex(pattern: str) -> str:
+    out = []
+    idx = 0
+    while idx < len(pattern):
+        char = pattern[idx]
+        if char == "\\" and idx + 1 < len(pattern):
+            next_char = pattern[idx + 1]
+            if next_char in "{}\\":
+                out.append(next_char)
+            else:
+                out.append(char)
+                out.append(next_char)
+            # END handle escaped char
+            idx += 2
+            continue
+        # END handle backslash
+        out.append(char)
+        idx += 1
+    # END for each char
+    return "".join(out)
+
+
+def _find_commit_by_message(
+    repo: "Repo", rev: Optional[AnyGitObject], pattern: str, braced: bool = False
+) -> AnyGitObject:
+    pattern, negated = _parse_search(_unescape_braced_regex(pattern) if braced else pattern)
+    try:
+        regex = re.compile(pattern)
+    except re.error as e:
+        raise ValueError("Invalid commit message regex %r" % pattern) from e
+    # END handle invalid regex
+    if rev is None:
+        commits = _all_ref_commits(repo)
+    else:
+        commits = _reachable_commits([to_commit(cast(Object, rev))])
+    # END handle starting point
+
+    for commit in commits:
+        message = commit.message
+        if isinstance(message, bytes):
+            message = message.decode(commit.encoding, "replace")
+        # END handle bytes message
+        matches = regex.search(message or "") is not None
+        if matches != negated:
+            return commit
+        # END found commit
+    # END for each commit
+    raise BadName("No commit found matching message pattern %r" % pattern)
+
+
+def _all_ref_commits(repo: "Repo") -> Iterator["Commit"]:
+    starts = []
+    for ref in repo.references:
+        try:
+            starts.append(to_commit(cast(Object, ref.object)))
+        except (BadName, ValueError):
+            pass
+        # END skip refs that do not point to commits
+    # END for each ref
+    try:
+        starts.append(repo.head.commit)
+    except ValueError:
+        pass
+    # END handle unborn head
+    return _reachable_commits(starts)
+
+
+def _reachable_commits(starts: list["Commit"]) -> Iterator["Commit"]:
+    seen = set()
+    pending = starts[:]
+    while pending:
+        pending.sort(key=lambda commit: commit.committed_date, reverse=True)
+        commit = pending.pop(0)
+        if commit.binsha in seen:
+            continue
+        # END skip seen commit
+        seen.add(commit.binsha)
+        yield commit
+        pending.extend(commit.parents)
+    # END while commits remain
+
+
+def _index_lookup(repo: "Repo", spec: str) -> AnyGitObject:
+    if not spec:
+        raise ValueError("':' must be followed by a path")
+    # END handle empty lookup
+
+    stage = 0
+    path = spec
+    if len(spec) >= 2 and spec[1] == ":" and spec[0] in "0123":
+        stage = int(spec[0])
+        path = spec[2:]
+    # END handle stage
+
+    try:
+        return repo.index.entries[(path, stage)].to_blob(repo)
+    except KeyError as e:
+        raise BadName("Path %r did not exist in the index at stage %i" % (path, stage)) from e
+
+
+def _tree_lookup(obj: AnyGitObject, path: str) -> AnyGitObject:
+    if obj.type != "tree":
+        obj = to_commit(cast(Object, obj)).tree
+    # END get tree
+    if not path:
+        return obj
+    return obj[path]
+
+
+def _peel(obj: AnyGitObject, output_type: str, repo: "Repo", rev: str) -> AnyGitObject:
+    if output_type.startswith("/"):
+        return _find_commit_by_message(repo, obj, output_type[1:], braced=True)
+    if output_type == "":
+        return deref_tag(obj) if obj.type == "tag" else obj
+    if output_type == "object":
+        return obj
+    if output_type == "commit":
+        return to_commit(cast(Object, obj))
+    if output_type == "tree":
+        return to_commit(cast(Object, obj)).tree if obj.type != "tree" else obj
+    if output_type == "blob":
+        obj = deref_tag(obj) if obj.type == "tag" else obj
+        if obj.type == output_type:
+            return obj
+        # END handle matching type
+        raise ValueError("Could not accommodate requested object type %r, got %s" % (output_type, obj.type))
+    if output_type == "tag":
+        if obj.type == output_type:
+            return obj
+        # END handle matching type
+        raise ValueError("Could not accommodate requested object type %r, got %s" % (output_type, obj.type))
+    # END handle known types
+    raise ValueError("Invalid output type: %s ( in %s )" % (output_type, rev))
+
+
+def _first_rev_token(rev: str) -> Optional[int]:
+    for idx, char in enumerate(rev):
+        if char in "^~:":
+            return idx
+        if char == "@":
+            next_char = rev[idx + 1] if idx + 1 < len(rev) else None
+            if idx == 0 and next_char in (None, "^", "~", ":", "{"):
+                return idx
+            if next_char == "{":
+                return idx
+            # END handle reflog selector
+        # END handle at symbol
+    # END for each char
+    return None
+
+
 def rev_parse(repo: "Repo", rev: str) -> AnyGitObject:
     """Parse a revision string. Like :manpage:`git-rev-parse(1)`.
 
@@ -253,137 +632,82 @@ def rev_parse(repo: "Repo", rev: str) -> AnyGitObject:
     :raise IndexError:
         If an invalid reflog index is specified.
     """
-    # Are we in colon search mode?
     if rev.startswith(":/"):
-        # Colon search mode
-        raise NotImplementedError("commit by message search (regex)")
-    # END handle search
+        return _find_commit_by_message(repo, None, rev[2:])
+    if rev.startswith(":"):
+        return _index_lookup(repo, rev[1:])
+    # END handle top-level colon modes
 
     obj: Optional[AnyGitObject] = None
     ref = None
-    output_type = "commit"
-    start = 0
-    parsed_to = 0
     lr = len(rev)
-    while start < lr:
-        if rev[start] not in "^~:@":
-            start += 1
-            continue
-        # END handle start
+    first_token = _first_rev_token(rev)
+    if first_token is None:
+        return name_to_object(repo, rev)
+    # END handle plain name
+
+    if first_token == 0:
+        if rev[0] != "@":
+            raise ValueError("Revision specifier must start with an object name: %s" % rev)
+        # END handle invalid leading token
+        ref = _current_reflog_ref(repo)
+        obj = ref.commit
+        start = 0 if rev.startswith("@{") else 1
+    else:
+        if rev[first_token] == "@":
+            ref = cast("Reference", name_to_object(repo, rev[:first_token], return_ref=True))
+            obj = ref.commit
+        else:
+            obj = name_to_object(repo, rev[:first_token])
+        # END handle anchor
+        start = first_token
+    # END initialize anchor
 
+    while start < lr:
         token = rev[start]
 
-        if obj is None:
-            # token is a rev name.
-            if start == 0:
-                ref = repo.head.ref
-            else:
-                if token == "@":
-                    ref = cast("Reference", name_to_object(repo, rev[:start], return_ref=True))
-                else:
-                    obj = name_to_object(repo, rev[:start])
-                # END handle token
-            # END handle refname
-        else:
-            if ref is not None:
-                obj = ref.commit
-            # END handle ref
-        # END initialize obj on first token
+        if token == "@":
+            if start + 1 >= lr or rev[start + 1] != "{":
+                raise ValueError("Invalid @ token in revision specifier: %s" % rev)
+            # END handle invalid @
+            end = _find_closing_brace(rev, start + 1)
+            obj = _apply_reflog(repo, ref if first_token != 0 and start == first_token else None, rev[start + 2 : end])
+            ref = None
+            start = end + 1
+            continue
+        # END handle reflog
 
-        start += 1
+        if token == ":":
+            return _tree_lookup(obj, rev[start + 1 :])
+        # END handle path
 
-        # Try to parse {type}.
-        if start < lr and rev[start] == "{":
-            end = rev.find("}", start)
-            if end == -1:
-                raise ValueError("Missing closing brace to define type in %s" % rev)
-            output_type = rev[start + 1 : end]  # Exclude brace.
-
-            # Handle type.
-            if output_type == "commit":
-                obj = cast("TagObject", obj)
-                if obj and obj.type == "tag":
-                    obj = deref_tag(obj)
-                else:
-                    # Cannot do anything for non-tags.
-                    pass
-                # END handle tag
-            elif output_type == "tree":
-                try:
-                    obj = cast(AnyGitObject, obj)
-                    obj = to_commit(obj).tree
-                except (AttributeError, ValueError):
-                    pass  # Error raised later.
-                # END exception handling
-            elif output_type in ("", "blob"):
-                obj = cast("TagObject", obj)
-                if obj and obj.type == "tag":
-                    obj = deref_tag(obj)
-                else:
-                    # Cannot do anything for non-tags.
-                    pass
-                # END handle tag
-            elif token == "@":
-                # try single int
-                assert ref is not None, "Require Reference to access reflog"
-                revlog_index = None
-                try:
-                    # Transform reversed index into the format of our revlog.
-                    revlog_index = -(int(output_type) + 1)
-                except ValueError as e:
-                    # TODO: Try to parse the other date options, using parse_date maybe.
-                    raise NotImplementedError("Support for additional @{...} modes not implemented") from e
-                # END handle revlog index
-
-                try:
-                    entry = ref.log_entry(revlog_index)
-                except IndexError as e:
-                    raise IndexError("Invalid revlog index: %i" % revlog_index) from e
-                # END handle index out of bound
-
-                obj = Object.new_from_sha(repo, hex_to_bin(entry.newhexsha))
-
-                # Make it pass the following checks.
-                output_type = ""
-            else:
-                raise ValueError("Invalid output type: %s ( in %s )" % (output_type, rev))
-            # END handle output type
-
-            # Empty output types don't require any specific type, its just about
-            # dereferencing tags.
-            if output_type and obj and obj.type != output_type:
-                raise ValueError("Could not accommodate requested object type %r, got %s" % (output_type, obj.type))
-            # END verify output type
+        start += 1
 
-            start = end + 1  # Skip brace.
-            parsed_to = start
+        if token == "^" and start < lr and rev[start] == "{":
+            end = _find_closing_brace(rev, start)
+            obj = _peel(obj, rev[start + 1 : end], repo, rev)
+            ref = None
+            start = end + 1
             continue
         # END parse type
 
-        # Try to parse a number.
         num = 0
-        if token != ":":
-            found_digit = False
-            while start < lr:
-                if rev[start] in digits:
-                    num = num * 10 + int(rev[start])
-                    start += 1
-                    found_digit = True
-                else:
-                    break
-                # END handle number
-            # END number parse loop
-
-            # No explicit number given, 1 is the default. It could be 0 though.
-            if not found_digit:
-                num = 1
-            # END set default num
-        # END number parsing only if non-blob mode
-
-        parsed_to = start
-        # Handle hierarchy walk.
+        found_digit = False
+        while start < lr:
+            if rev[start] in digits:
+                num = num * 10 + int(rev[start])
+                start += 1
+                found_digit = True
+            else:
+                break
+            # END handle number
+        # END number parse loop
+
+        if not found_digit:
+            num = 1
+        # END set default num
+
         try:
-            obj = cast(AnyGitObject, obj)
             if token == "~":
                 obj = to_commit(obj)
                 for _ in range(num):
@@ -391,15 +715,11 @@ def rev_parse(repo: "Repo", rev: str) -> AnyGitObject:
                 # END for each history item to walk
             elif token == "^":
                 obj = to_commit(obj)
-                # Must be n'th parent.
-                if num:
+                if num == 0:
+                    pass
+                else:
                     obj = obj.parents[num - 1]
-            elif token == ":":
-                if obj.type != "tree":
-                    obj = obj.tree
-                # END get tree type
-                obj = obj[rev[start:]]
-                parsed_to = lr
+                # END handle parent
             else:
                 raise ValueError("Invalid token: %r" % token)
             # END end handle tag
@@ -410,16 +730,7 @@ def rev_parse(repo: "Repo", rev: str) -> AnyGitObject:
         # END exception handling
     # END parse loop
 
-    # Still no obj? It's probably a simple name.
-    if obj is None:
-        obj = name_to_object(repo, rev)
-        parsed_to = lr
-    # END handle simple name
-
     if obj is None:
         raise ValueError("Revision specifier could not be parsed: %s" % rev)
 
-    if parsed_to != lr:
-        raise ValueError("Didn't consume complete rev spec %s, consumed part: %s" % (rev, rev[:parsed_to]))
-
     return obj

git/util.py

@@ -289,7 +289,7 @@ def join_path(a: PathLike, *p: PathLike) -> PathLike:
 
 if sys.platform == "win32":
 
-    def to_native_path_windows(path: PathLike) -> PathLike:
+    def to_native_path_windows(path: PathLike) -> str:
         path = os.fspath(path)
         return path.replace("/", "\\")
 

{gitpython-3.1.47.dist-info → gitpython-3.1.49.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: GitPython
-Version: 3.1.47
+Version: 3.1.49
 Summary: GitPython is a Python library used to interact with Git repositories
 Home-page: https://github.com/gitpython-developers/GitPython
 Author: Sebastian Thiel, Michael Trier

{gitpython-3.1.47.dist-info → gitpython-3.1.49.dist-info}/RECORD

@@ -1,14 +1,14 @@
-git/__init__.py,sha256=49UjU1OnoLWwxOzoGLfyGbV0zNwKjN47YU5i4u3ku48,8899
+git/__init__.py,sha256=RAj8jt-mAbm_gxzftocy0RK5-zDBelW3ZND77e85dHk,8899
 git/cmd.py,sha256=4Ly0NF9kt1JarTD0zpPv7a0Al5I2PaohRMIG0UGKLCw,68559
 git/compat.py,sha256=y1E6y6O2q5r8clSlr8ZNmuIWG9nmHuehQEsVsmBffs8,4526
-git/config.py,sha256=vH4cb4n4HR_691Tex-ac3z-nLJpQqWxUsff1vqWZ-D8,35867
+git/config.py,sha256=FPGd0Y3jTFoPzE1GgbJ9L_yBxA0OADZr44-xSfHA874,36570
 git/db.py,sha256=vIW9uWSbqu99zbuU2ZDmOhVOv1UPTmxrnqiCtRHCfjE,2368
 git/diff.py,sha256=xhOeMmFDmXOdpje2vA1mzJpmpBnyX-nrt-mp2RiVR1M,27172
 git/exc.py,sha256=Gc7g1pHpn8OmTse30NHmJVsBJ2CYH8LxaR8y8UA3lIM,7119
 git/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 git/remote.py,sha256=pYn9dAlz-QwvNMWXD1M57pMPQitthOM86qTRK_cpTqU,46786
 git/types.py,sha256=d3oDduUGjfoqffcUL_GOD-3qroF8m3r9ai6Xi9_FraM,10279
-git/util.py,sha256=T1M3Nv-AbKSeZ3if33bpJFX450EeoGK67tr3SrEkjlU,44057
+git/util.py,sha256=cCbGpBpnQq1MtW_REe8ApsAGTzp9JgVCMUN8KFgnx14,44052
 git/index/__init__.py,sha256=i-Nqb8Lufp9aFbmxpQBORmmQnjEVVM1Pn58fsQkyGgQ,406
 git/index/base.py,sha256=PdOmwjSjVXdYJF31y1853QdYTV8qUVAgAK0YZw3eyEI,61233
 git/index/fun.py,sha256=v0WnKQxaAffMZxXXC7pQOiMvRRJfODhUNKDMruxKrN4,17110
@@ -28,17 +28,17 @@ git/objects/submodule/root.py,sha256=5eTtYNHasqdPq6q0oDCPr7IaO6uAHL3b4DxMoiO2LhE
 git/objects/submodule/util.py,sha256=sQqAYaiSJdFkZa9NlAuK_wTsMNiS-kkQnQjvIoJtc_o,3509
 git/refs/__init__.py,sha256=DWlJNnsx-4jM_E-VycbP-FZUdn6iWhjnH_uZ_pZXBro,509
 git/refs/head.py,sha256=59MUMVu9phmE_ImkmNw0sDDSCc75s7TxkQj_cKzRhbo,10397
-git/refs/log.py,sha256=ooqlw_mn14FSQGvZXDC0Tt4MQG-4Hob8T92SDH9ZzfY,12517
+git/refs/log.py,sha256=X88JTqjwX1ShvHr-NHNAZj0qLiHbVoF-0v3VymZDwoM,12612
 git/refs/reference.py,sha256=uzrvNTZ5fg7A0Aq4VC3KLSMbksgYUf4KvmHau0tFYIM,5646
-git/refs/remote.py,sha256=WwqV9T7BbYf3F_WZNUQivu9xktIIKGklCjDpwQrhD-A,2806
-git/refs/symbolic.py,sha256=seRKwWw7eegQyGoObE-PuuVpSvNyQRUAXqFRq0wI6yA,34892
+git/refs/remote.py,sha256=WTlkJtpu895jJxbknDNOwL31tivQY_AHQrvroUoFBX4,2902
+git/refs/symbolic.py,sha256=7ScmZHwlqPDKX9bxVC5queSZXUgqEY7_J_Si6gDBSLw,36139
 git/refs/tag.py,sha256=AKrFrMhkNzX8e9x5WmDRtHovbN9zYQghuKoneVW-TJg,5002
 git/repo/__init__.py,sha256=CILSVH36fX_WxVFSjD9o1WF5LgsNedPiJvSngKZqfVU,210
 git/repo/base.py,sha256=XI6FNYbd2HwrayazVPprFEHTMS6CHkzRZPjkYhw_elM,60220
-git/repo/fun.py,sha256=sjzJH8jy18nacsJjKKIqRBKadhhhxiyjmZKWXDErNnw,13787
-gitpython-3.1.47.dist-info/licenses/AUTHORS,sha256=uyjC8YZ5vcAlx2nSJ44J8gE7wjA8nc69_zWYo_HKtVc,2360
-gitpython-3.1.47.dist-info/licenses/LICENSE,sha256=hvyUwyGpr7wRUUcTURuv3tIl8lEA3MD3NQ6CvCMbi-s,1503
-gitpython-3.1.47.dist-info/METADATA,sha256=nopkhZXhd8oDQNXp-Ebzxz86dwqi15j1suk3BH8IoRc,14187
-gitpython-3.1.47.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
-gitpython-3.1.47.dist-info/top_level.txt,sha256=0hzDuIp8obv624V3GmbqsagBWkk8ohtGU-Bc1PmTT0o,4
-gitpython-3.1.47.dist-info/RECORD,,
+git/repo/fun.py,sha256=PDFNkuTSGGoQc0EEEXjxHw2_KaKYvVjBZ9rrkwH5Q6Y,23462
+gitpython-3.1.49.dist-info/licenses/AUTHORS,sha256=uyjC8YZ5vcAlx2nSJ44J8gE7wjA8nc69_zWYo_HKtVc,2360
+gitpython-3.1.49.dist-info/licenses/LICENSE,sha256=hvyUwyGpr7wRUUcTURuv3tIl8lEA3MD3NQ6CvCMbi-s,1503
+gitpython-3.1.49.dist-info/METADATA,sha256=PX5GVf1iClsOdFPHGLrlxU5QPfZ--z5GjS_nNhwsP1Q,14187
+gitpython-3.1.49.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+gitpython-3.1.49.dist-info/top_level.txt,sha256=0hzDuIp8obv624V3GmbqsagBWkk8ohtGU-Bc1PmTT0o,4
+gitpython-3.1.49.dist-info/RECORD,,