GitPython 3.1.48__py3-none-any.whl → 3.1.50__py3-none-any.whl

git/__init__.py

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

git/config.py

@@ -72,6 +72,9 @@ CONDITIONAL_INCLUDE_REGEXP = re.compile(r"(?<=includeIf )\"(gitdir|gitdir/i|onbr
 See: https://git-scm.com/docs/git-config#_conditional_includes
 """
 
+UNSAFE_CONFIG_CHARS_RE = re.compile(r"[\r\n\x00]")
+"""Characters that cannot be safely written in config names or values."""
+
 
 class MetaParserBuilder(abc.ABCMeta):  # noqa: B024
     """Utility class wrapping base-class methods into decorators that assure read-only
@@ -778,6 +781,7 @@ class GitConfigParser(cp.RawConfigParser, metaclass=MetaParserBuilder):
 
     def add_section(self, section: "cp._SectionName") -> None:
         """Assures added options will stay in order."""
+        self._assure_config_name_safe(section, "section")
         return super().add_section(section)
 
     @property
@@ -882,6 +886,30 @@ 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 UNSAFE_CONFIG_CHARS_RE.search(value_str):
+            raise ValueError("Git config values must not contain CR, LF, or NUL")
+        return value_str
+
+    def _assure_config_name_safe(self, name: "cp._SectionName", label: str) -> None:
+        if isinstance(name, str) and UNSAFE_CONFIG_CHARS_RE.search(name):
+            raise ValueError("Git config %s names must not contain CR, LF, or NUL" % label)
+
+    @needs_values
+    @set_dirty_and_flush_changes
+    def set(
+        self,
+        section: str,
+        option: str,
+        value: Union[str, bytes, int, float, bool, None] = None,
+    ) -> None:
+        self._assure_config_name_safe(section, "section")
+        self._assure_config_name_safe(option, "option")
+        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 +930,12 @@ class GitConfigParser(cp.RawConfigParser, metaclass=MetaParserBuilder):
         :return:
             This instance
         """
+        self._assure_config_name_safe(section, "section")
+        self._assure_config_name_safe(option, "option")
+        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 +960,12 @@ class GitConfigParser(cp.RawConfigParser, metaclass=MetaParserBuilder):
         :return:
             This instance
         """
+        self._assure_config_name_safe(section, "section")
+        self._assure_config_name_safe(option, "option")
+        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":
@@ -948,6 +982,7 @@ class GitConfigParser(cp.RawConfigParser, metaclass=MetaParserBuilder):
         """
         if not self.has_section(section):
             raise ValueError("Source section '%s' doesn't exist" % section)
+        self._assure_config_name_safe(new_name, "section")
         if self.has_section(new_name):
             raise ValueError("Destination section '%s' already exists" % new_name)
 

git/repo/base.py

@@ -242,6 +242,28 @@ class Repo:
             # It's important to normalize the paths, as submodules will otherwise
             # initialize their repo instances with paths that depend on path-portions
             # that will not exist after being removed. It's just cleaner.
+            if (
+                osp.isfile(osp.join(curpath, "gitdir"))
+                and osp.isfile(osp.join(curpath, "commondir"))
+                and osp.isfile(osp.join(curpath, "HEAD"))
+            ):
+                git_dir = curpath
+
+                if "GIT_WORK_TREE" in os.environ:
+                    self._working_tree_dir = os.getenv("GIT_WORK_TREE")
+                else:
+                    # Linked worktree administrative directories store the path to the
+                    # worktree's .git file in their gitdir file (without "gitdir: " prefix).
+                    with open(osp.join(git_dir, "gitdir")) as fp:
+                        worktree_gitfile = fp.read().strip()
+
+                    if not osp.isabs(worktree_gitfile):
+                        worktree_gitfile = osp.normpath(osp.join(git_dir, worktree_gitfile))
+
+                    self._working_tree_dir = osp.dirname(worktree_gitfile)
+
+                break
+
             if is_git_dir(curpath):
                 git_dir = curpath
                 # from man git-config : core.worktree

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

{gitpython-3.1.48.dist-info → gitpython-3.1.50.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: GitPython
-Version: 3.1.48
+Version: 3.1.50
 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.48.dist-info → gitpython-3.1.50.dist-info}/RECORD

@@ -1,7 +1,7 @@
-git/__init__.py,sha256=n7ZUyB_I0GQubucxnwYUAvFnLL3hiIF-G36z4clqUL4,8899
+git/__init__.py,sha256=-XcbLWMd0hzWrSVPHoz9wDkN1bWkUznLYN6x5oCYGdQ,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=tPAXhoQozL0Mr7x4gtoUlFGUkkT8LtO3Ocqsqz-7ZrU,37412
 git/db.py,sha256=vIW9uWSbqu99zbuU2ZDmOhVOv1UPTmxrnqiCtRHCfjE,2368
 git/diff.py,sha256=xhOeMmFDmXOdpje2vA1mzJpmpBnyX-nrt-mp2RiVR1M,27172
 git/exc.py,sha256=Gc7g1pHpn8OmTse30NHmJVsBJ2CYH8LxaR8y8UA3lIM,7119
@@ -34,11 +34,11 @@ 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.48.dist-info/licenses/AUTHORS,sha256=uyjC8YZ5vcAlx2nSJ44J8gE7wjA8nc69_zWYo_HKtVc,2360
-gitpython-3.1.48.dist-info/licenses/LICENSE,sha256=hvyUwyGpr7wRUUcTURuv3tIl8lEA3MD3NQ6CvCMbi-s,1503
-gitpython-3.1.48.dist-info/METADATA,sha256=qvywsw3FCGzL89bcxLt68LzVTKZRbiWdgdqbIpsPttM,14187
-gitpython-3.1.48.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
-gitpython-3.1.48.dist-info/top_level.txt,sha256=0hzDuIp8obv624V3GmbqsagBWkk8ohtGU-Bc1PmTT0o,4
-gitpython-3.1.48.dist-info/RECORD,,
+git/repo/base.py,sha256=EohoIREtbdpmUqVs7kfUgBIosEzZ29nMgiO9YMuAYDU,61165
+git/repo/fun.py,sha256=PDFNkuTSGGoQc0EEEXjxHw2_KaKYvVjBZ9rrkwH5Q6Y,23462
+gitpython-3.1.50.dist-info/licenses/AUTHORS,sha256=uyjC8YZ5vcAlx2nSJ44J8gE7wjA8nc69_zWYo_HKtVc,2360
+gitpython-3.1.50.dist-info/licenses/LICENSE,sha256=hvyUwyGpr7wRUUcTURuv3tIl8lEA3MD3NQ6CvCMbi-s,1503
+gitpython-3.1.50.dist-info/METADATA,sha256=3LhbhjxZJPBAeX0855vAyV3Eod7P7L0GlQB4qw6mNzY,14187
+gitpython-3.1.50.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+gitpython-3.1.50.dist-info/top_level.txt,sha256=0hzDuIp8obv624V3GmbqsagBWkk8ohtGU-Bc1PmTT0o,4
+gitpython-3.1.50.dist-info/RECORD,,