Repository navigation
Expand file tree
/
Copy pathfun.py
More file actions
273 lines (218 loc) · 9.01 KB
/
Copy pathfun.py
File metadata and controls
273 lines (218 loc) · 9.01 KB
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
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
# This module is part of GitPython and is released under the
# 3-Clause BSD License: https://opensource.org/license/bsd-3-clause/
"""Functions that are supposed to be as fast as possible."""
__all__ = [
"tree_to_stream",
"tree_entries_from_data",
"traverse_trees_recursive",
"traverse_tree_recursive",
]
from stat import S_ISDIR
from git.compat import safe_decode, defenc
from git.util import _validate_repo_path
# typing ----------------------------------------------
from typing import (
Callable,
List,
MutableSequence,
Sequence,
Tuple,
TYPE_CHECKING,
Union,
overload,
)
if TYPE_CHECKING:
from _typeshed import ReadableBuffer
from gitdb.db.base import ObjectDBR
EntryTup = Tuple[bytes, int, str] # Same as TreeCacheTup in tree.py.
EntryTupOrNone = Union[EntryTup, None]
# ---------------------------------------------------
def _validate_tree_entry_name(name: str, mode: Union[int, None] = None) -> None:
if "/" in name:
raise ValueError("Tree entry names must not contain '/' characters")
# A tree name is a component, not a rooted path; a colon cannot select a drive.
_validate_repo_path("tree/" + name, mode)
def tree_to_stream(entries: Sequence[EntryTup], write: Callable[["ReadableBuffer"], Union[int, None]]) -> None:
"""Write the given list of entries into a stream using its ``write`` method.
:param entries:
**Sorted** list of tuples with (binsha, mode, name).
:param write:
A ``write`` method which takes a data string.
"""
ord_zero = ord("0")
bit_mask = 7 # 3 bits set.
for binsha, mode, name in entries:
if len(binsha) != 20:
raise ValueError("Tree entry object IDs must be exactly 20 bytes")
if mode >> 12 not in (4, 8, 10, 14):
raise ValueError("Invalid tree entry mode")
mode_str = b""
for i in range(6):
mode_str = bytes([((mode >> (i * 3)) & bit_mask) + ord_zero]) + mode_str
# END for each 8 octal value
# git slices away the first octal if it's zero.
if mode_str[0] == ord_zero:
mode_str = mode_str[1:]
# END save a byte
# Here it comes: If the name is actually unicode, the replacement below will not
# work as the binsha is not part of the ascii unicode encoding - hence we must
# convert to an UTF-8 string for it to work properly. According to my tests,
# this is exactly what git does, that is it just takes the input literally,
# which appears to be UTF-8 on linux.
if isinstance(name, str):
name_bytes = name.encode(defenc)
else:
name_bytes = name # type: ignore[unreachable] # check runtime types - is always str?
_validate_tree_entry_name(safe_decode(name_bytes), mode)
write(b"".join((mode_str, b" ", name_bytes, b"\0", binsha)))
# END for each item
def tree_entries_from_data(data: bytes) -> List[EntryTup]:
"""Read complete tree records, rejecting invalid names and truncated fields.
:param data:
Data block with tree data (as bytes).
:return:
list(tuple(binsha, mode, tree_relative_path), ...)
"""
out = []
offset = 0
while offset < len(data):
mode_end = data.find(b" ", offset)
if mode_end < 0:
raise ValueError("Unterminated tree entry mode")
mode_bytes = data[offset:mode_end]
if not mode_bytes or mode_bytes.strip(b"01234567"):
raise ValueError("Invalid tree entry mode")
mode = int(mode_bytes, 8)
if mode >> 12 not in (4, 8, 10, 14):
raise ValueError("Invalid tree entry mode")
name_end = data.find(b"\0", mode_end + 1)
if name_end < 0 or name_end + 21 > len(data):
raise ValueError("Truncated tree entry")
name = safe_decode(bytes(data[mode_end + 1 : name_end]))
_validate_tree_entry_name(name, mode)
offset = name_end + 21
out.append((bytes(data[name_end + 1 : offset]), mode, name))
return out
def _find_by_name(tree_data: MutableSequence[EntryTupOrNone], name: str, is_dir: bool, start_at: int) -> EntryTupOrNone:
"""Return data entry matching the given name and tree mode or ``None``.
Before the item is returned, the respective data item is set None in the `tree_data`
list to mark it done.
"""
try:
item = tree_data[start_at]
if item and item[2] == name and S_ISDIR(item[1]) == is_dir:
tree_data[start_at] = None
return item
except IndexError:
pass
# END exception handling
for index, item in enumerate(tree_data):
if item and item[2] == name and S_ISDIR(item[1]) == is_dir:
tree_data[index] = None
return item
# END if item matches
# END for each item
return None
@overload
def _to_full_path(item: None, path_prefix: str) -> None: ...
@overload
def _to_full_path(item: EntryTup, path_prefix: str) -> EntryTup: ...
def _to_full_path(item: EntryTupOrNone, path_prefix: str) -> EntryTupOrNone:
"""Rebuild entry with given path prefix."""
if not item:
return item
return (item[0], item[1], path_prefix + item[2])
def traverse_trees_recursive(
odb: "ObjectDBR", tree_shas: Sequence[Union[bytes, None]], path_prefix: str
) -> List[Tuple[EntryTupOrNone, ...]]:
"""
:return:
List of list with entries according to the given binary tree-shas.
The result is encoded in a list
of n tuple|None per blob/commit, (n == len(tree_shas)), where:
* [0] == 20 byte sha
* [1] == mode as int
* [2] == path relative to working tree root
The entry tuple is ``None`` if the respective blob/commit did not exist in the
given tree.
:param tree_shas:
Iterable of shas pointing to trees. All trees must be on the same level.
A tree-sha may be ``None``, in which case ``None``.
:param path_prefix:
A prefix to be added to the returned paths on this level.
Set it ``""`` for the first iteration.
:note:
The ordering of the returned items will be partially lost.
"""
trees_data: List[List[EntryTupOrNone]] = []
nt = len(tree_shas)
for tree_sha in tree_shas:
if tree_sha is None:
data: List[EntryTupOrNone] = []
else:
# Make new list for typing as list invariant.
data = list(tree_entries_from_data(odb.stream(tree_sha).read()))
# END handle muted trees
trees_data.append(data)
# END for each sha to get data for
out: List[Tuple[EntryTupOrNone, ...]] = []
# Find all matching entries and recursively process them together if the match is a
# tree. If the match is a non-tree item, put it into the result.
# Processed items will be set None.
for ti, tree_data in enumerate(trees_data):
for ii, item in enumerate(tree_data):
if not item:
continue
# END skip already done items
entries: List[EntryTupOrNone]
entries = [None for _ in range(nt)]
entries[ti] = item
_sha, mode, name = item
is_dir = S_ISDIR(mode) # Type mode bits
# Find this item in all other tree data items.
# Wrap around, but stop one before our current index, hence ti+nt, not
# ti+1+nt.
for tio in range(ti + 1, ti + nt):
tio = tio % nt
entries[tio] = _find_by_name(trees_data[tio], name, is_dir, ii)
# END for each other item data
# If we are a directory, enter recursion.
if is_dir:
out.extend(
traverse_trees_recursive(
odb,
[((ei and ei[0]) or None) for ei in entries],
path_prefix + name + "/",
)
)
else:
out.append(tuple(_to_full_path(e, path_prefix) for e in entries))
# END handle recursion
# Finally mark it done.
tree_data[ii] = None
# END for each item
# We are done with one tree, set all its data empty.
del tree_data[:]
# END for each tree_data chunk
return out
def traverse_tree_recursive(odb: "ObjectDBR", tree_sha: bytes, path_prefix: str) -> List[EntryTup]:
"""
:return:
List of entries of the tree pointed to by the binary `tree_sha`.
An entry has the following format:
* [0] 20 byte sha
* [1] mode as int
* [2] path relative to the repository
:param path_prefix:
Prefix to prepend to the front of all returned paths.
"""
entries = []
data = tree_entries_from_data(odb.stream(tree_sha).read())
# Unpacking/packing is faster than accessing individual items.
for sha, mode, name in data:
if S_ISDIR(mode):
entries.extend(traverse_tree_recursive(odb, sha, path_prefix + name + "/"))
else:
entries.append((sha, mode, path_prefix + name))
# END for each item
return entries