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
|
import patchstate as ps
import patchtheory as pt
import os, sys
class PatchSeq:
__slots__ = ('upstreamed', 'diff', 'reverted', 'late')
def __init__(self, *, rebase=pt.Diff()):
self.upstreamed = -rebase
self.diff = pt.Diff()
self.reverted = []
def flush(self):
# We move all late patches back through the reverted
try:
late_kind,late = self.late
except AttributeError:
return
del self.late
print('Flushing', file=sys.stderr)
late = sum(late, pt.Diff())
for rev in reversed(self.reverted):
(late, rev[1]) = pt.Diff.commute(rev[1], late)
if late_kind == 'apply':
self.diff += late
return
(late, self.diff) = pt.Diff.commute(self.diff, late)
if late_kind == 'upstreamed':
self.upstreamed += late
return
raise AssertionError
def _push_late(self, kind, diff):
try:
lkind,late = self.late
except AttributeError:
self.late = (kind, (late := []))
else:
if lkind != kind:
self.flush()
self.late = (kind, (late := []))
late.append(diff)
def _push_reverted(self, by_pid, diff):
self.flush()
self.reverted.append([by_pid, diff])
def _push_revert(self, pid, diff):
self.flush()
for i,rev in enumerate(reverted := self.reverted):
if rev[0] == pid:
break
else:
raise KeyError(f'patch {pid} not marked as reverted')
if reverted.pop(i) is not rev:
raise AssertionError
rdiff = rev[1]
for rev in reverted[i:]:
rev[1],rdiff = pt.Diff.commute(rdiff, rev[1])
if rdiff + diff:
raise KeyError(f'revert of {pid} not exact')
def push(self, patch_info, patch):
diff = patch.diff
mode = patch_info.mode.split(' ', 1)
kind = mode[0]
if kind in {'apply', 'upstreamed'}:
self._push_late(kind, diff)
return
if kind == 'subst':
with open(mode[1], 'rb') as diff2:
diff2 = diff2.read()
diff2 = pt.Diff.parse(diff2)
self._push_late('apply', diff2)
self._push_reverted(None, (-diff2) + diff)
return
if kind == 'reverted':
self._push_reverted(patch_info.patch_id, diff)
return
if kind in {'skip', 'replaced'}:
self._push_reverted(None, diff)
return
if kind == 'reverts':
self._push_revert(mode[1], diff)
return
raise TypeError(f'bad patch kind: {kind!r}')
def finish(self, prb):
self.flush()
for pid,_ in self.reverted:
if pid is not None:
raise RuntimeError(f'missing revert for {pid!r}')
return prb + pt.Diff.commute(-prb + self.upstreamed, self.diff)[0]
def main(args):
args = iter(args)
arg0 = next(args)
@ps.argparse_all(args)
def path(arg):
raise RuntimeError(f'Invalid argument: {arg!r}')
repo_path = path.pop(0)
if path:
with open(path.pop(0), 'rb') as rebase_patch:
rebase_patch = rebase_patch.read()
rebase_patch = pt.Diff.parse(rebase_patch)
else:
rebase_patch = pt.Diff()
if path:
with open(path.pop(0), 'rb') as prb_patch:
prb_patch = prb_patch.read()
prb_patch = pt.Diff.parse(prb_patch)
else:
prb_patch = pt.Diff()
assert not path
repo = ps.Repository(repo_path)
with open(os.path.join(repo.path, 'series'), 'r') as f:
pcur = ps.Series.parse(f.read())
seq = PatchSeq(rebase=rebase_patch)
for pi in pcur.info:
p = pi.get_patch(repo)
print('Applying', p.title, file=sys.stderr)
seq.push(pi, p)
seq.finish(prb_patch).write(sys.stdout.buffer.write)
return 0
if __name__ == '__main__':
sys.exit(main(sys.argv))
|
