summaryrefslogtreecommitdiff
path: root/git/index/fun.py
diff options
context:
space:
mode:
Diffstat (limited to 'git/index/fun.py')
-rw-r--r--git/index/fun.py62
1 files changed, 31 insertions, 31 deletions
diff --git a/git/index/fun.py b/git/index/fun.py
index ffd109b1..e5e566a0 100644
--- a/git/index/fun.py
+++ b/git/index/fun.py
@@ -57,6 +57,8 @@ from git.types import PathLike, TypeGuard
if TYPE_CHECKING:
from .base import IndexFile
+ from git.objects.tree import TreeCacheTup
+ # from git.objects.fun import EntryTupOrNone
# ------------------------------------------------------------------------------------
@@ -186,16 +188,15 @@ def entry_key(*entry: Union[BaseIndexEntry, PathLike, int]) -> Tuple[PathLike, i
""":return: Key suitable to be used for the index.entries dictionary
:param entry: One instance of type BaseIndexEntry or the path and the stage"""
- def is_entry_tuple(entry: Tuple) -> TypeGuard[Tuple[PathLike, int]]:
- return isinstance(entry, tuple) and len(entry) == 2
-
+ def is_entry_key_tup(entry_key: Tuple) -> TypeGuard[Tuple[PathLike, int]]:
+ return isinstance(entry_key, tuple) and len(entry_key) == 2
+
if len(entry) == 1:
entry_first = entry[0]
assert isinstance(entry_first, BaseIndexEntry)
return (entry_first.path, entry_first.stage)
else:
- # entry = tuple(entry)
- assert is_entry_tuple(entry)
+ assert is_entry_key_tup(entry)
return entry
# END handle entry
@@ -249,7 +250,7 @@ def read_cache(stream: IO[bytes]) -> Tuple[int, Dict[Tuple[PathLike, int], 'Inde
def write_tree_from_cache(entries: List[IndexEntry], odb, sl: slice, si: int = 0
- ) -> Tuple[bytes, List[Tuple[str, int, str]]]:
+ ) -> Tuple[bytes, List['TreeCacheTup']]:
"""Create a tree from the given sorted list of entries and put the respective
trees into the given object database
@@ -259,8 +260,8 @@ def write_tree_from_cache(entries: List[IndexEntry], odb, sl: slice, si: int = 0
:param sl: slice indicating the range we should process on the entries list
:return: tuple(binsha, list(tree_entry, ...)) a tuple of a sha and a list of
tree entries being a tuple of hexsha, mode, name"""
- tree_items = [] # type: List[Tuple[Union[bytes, str], int, str]]
- tree_items_append = tree_items.append
+ tree_items: List['TreeCacheTup'] = []
+
ci = sl.start
end = sl.stop
while ci < end:
@@ -272,7 +273,7 @@ def write_tree_from_cache(entries: List[IndexEntry], odb, sl: slice, si: int = 0
rbound = entry.path.find('/', si)
if rbound == -1:
# its not a tree
- tree_items_append((entry.binsha, entry.mode, entry.path[si:]))
+ tree_items.append((entry.binsha, entry.mode, entry.path[si:]))
else:
# find common base range
base = entry.path[si:rbound]
@@ -289,7 +290,7 @@ def write_tree_from_cache(entries: List[IndexEntry], odb, sl: slice, si: int = 0
# enter recursion
# ci - 1 as we want to count our current item as well
sha, _tree_entry_list = write_tree_from_cache(entries, odb, slice(ci - 1, xi), rbound + 1)
- tree_items_append((sha, S_IFDIR, base))
+ tree_items.append((sha, S_IFDIR, base))
# skip ahead
ci = xi
@@ -298,15 +299,14 @@ def write_tree_from_cache(entries: List[IndexEntry], odb, sl: slice, si: int = 0
# finally create the tree
sio = BytesIO()
- tree_to_stream(tree_items, sio.write) # converts bytes of each item[0] to str
- tree_items_stringified = cast(List[Tuple[str, int, str]], tree_items)
+ tree_to_stream(tree_items, sio.write) # writes to stream as bytes, but doesnt change tree_items
sio.seek(0)
istream = odb.store(IStream(str_tree_type, len(sio.getvalue()), sio))
- return (istream.binsha, tree_items_stringified)
+ return (istream.binsha, tree_items)
-def _tree_entry_to_baseindexentry(tree_entry: Tuple[str, int, str], stage: int) -> BaseIndexEntry:
+def _tree_entry_to_baseindexentry(tree_entry: 'TreeCacheTup', stage: int) -> BaseIndexEntry:
return BaseIndexEntry((tree_entry[1], tree_entry[0], stage << CE_STAGESHIFT, tree_entry[2]))
@@ -319,14 +319,13 @@ def aggressive_tree_merge(odb, tree_shas: Sequence[bytes]) -> List[BaseIndexEntr
:param tree_shas: 1, 2 or 3 trees as identified by their binary 20 byte shas
If 1 or two, the entries will effectively correspond to the last given tree
If 3 are given, a 3 way merge is performed"""
- out = [] # type: List[BaseIndexEntry]
- out_append = out.append
+ out: List[BaseIndexEntry] = []
# one and two way is the same for us, as we don't have to handle an existing
# index, instrea
if len(tree_shas) in (1, 2):
for entry in traverse_tree_recursive(odb, tree_shas[-1], ''):
- out_append(_tree_entry_to_baseindexentry(entry, 0))
+ out.append(_tree_entry_to_baseindexentry(entry, 0))
# END for each entry
return out
# END handle single tree
@@ -347,23 +346,23 @@ def aggressive_tree_merge(odb, tree_shas: Sequence[bytes]) -> List[BaseIndexEntr
if(base[0] != ours[0] and base[0] != theirs[0] and ours[0] != theirs[0]) or \
(base[1] != ours[1] and base[1] != theirs[1] and ours[1] != theirs[1]):
# changed by both
- out_append(_tree_entry_to_baseindexentry(base, 1))
- out_append(_tree_entry_to_baseindexentry(ours, 2))
- out_append(_tree_entry_to_baseindexentry(theirs, 3))
+ out.append(_tree_entry_to_baseindexentry(base, 1))
+ out.append(_tree_entry_to_baseindexentry(ours, 2))
+ out.append(_tree_entry_to_baseindexentry(theirs, 3))
elif base[0] != ours[0] or base[1] != ours[1]:
# only we changed it
- out_append(_tree_entry_to_baseindexentry(ours, 0))
+ out.append(_tree_entry_to_baseindexentry(ours, 0))
else:
# either nobody changed it, or they did. In either
# case, use theirs
- out_append(_tree_entry_to_baseindexentry(theirs, 0))
+ out.append(_tree_entry_to_baseindexentry(theirs, 0))
# END handle modification
else:
if ours[0] != base[0] or ours[1] != base[1]:
# they deleted it, we changed it, conflict
- out_append(_tree_entry_to_baseindexentry(base, 1))
- out_append(_tree_entry_to_baseindexentry(ours, 2))
+ out.append(_tree_entry_to_baseindexentry(base, 1))
+ out.append(_tree_entry_to_baseindexentry(ours, 2))
# else:
# we didn't change it, ignore
# pass
@@ -376,8 +375,8 @@ def aggressive_tree_merge(odb, tree_shas: Sequence[bytes]) -> List[BaseIndexEntr
else:
if theirs[0] != base[0] or theirs[1] != base[1]:
# deleted in ours, changed theirs, conflict
- out_append(_tree_entry_to_baseindexentry(base, 1))
- out_append(_tree_entry_to_baseindexentry(theirs, 3))
+ out.append(_tree_entry_to_baseindexentry(base, 1))
+ out.append(_tree_entry_to_baseindexentry(theirs, 3))
# END theirs changed
# else:
# theirs didn't change
@@ -388,18 +387,19 @@ def aggressive_tree_merge(odb, tree_shas: Sequence[bytes]) -> List[BaseIndexEntr
# all three can't be None
if ours is None:
# added in their branch
- out_append(_tree_entry_to_baseindexentry(theirs, 0))
+ assert theirs is not None
+ out.append(_tree_entry_to_baseindexentry(theirs, 0))
elif theirs is None:
# added in our branch
- out_append(_tree_entry_to_baseindexentry(ours, 0))
+ out.append(_tree_entry_to_baseindexentry(ours, 0))
else:
# both have it, except for the base, see whether it changed
if ours[0] != theirs[0] or ours[1] != theirs[1]:
- out_append(_tree_entry_to_baseindexentry(ours, 2))
- out_append(_tree_entry_to_baseindexentry(theirs, 3))
+ out.append(_tree_entry_to_baseindexentry(ours, 2))
+ out.append(_tree_entry_to_baseindexentry(theirs, 3))
else:
# it was added the same in both
- out_append(_tree_entry_to_baseindexentry(ours, 0))
+ out.append(_tree_entry_to_baseindexentry(ours, 0))
# END handle two items
# END handle heads
# END handle base exists
View Lorry Controller Status