##// END OF EJS Templates
patch: don't separate \r and \n when colorizing diff output...
Sune Foldager -
r38649:e1987261 default
parent child Browse files
Show More
@@ -1,2866 +1,2869 b''
1 # patch.py - patch file parsing routines
1 # patch.py - patch file parsing routines
2 #
2 #
3 # Copyright 2006 Brendan Cully <brendan@kublai.com>
3 # Copyright 2006 Brendan Cully <brendan@kublai.com>
4 # Copyright 2007 Chris Mason <chris.mason@oracle.com>
4 # Copyright 2007 Chris Mason <chris.mason@oracle.com>
5 #
5 #
6 # This software may be used and distributed according to the terms of the
6 # This software may be used and distributed according to the terms of the
7 # GNU General Public License version 2 or any later version.
7 # GNU General Public License version 2 or any later version.
8
8
9 from __future__ import absolute_import, print_function
9 from __future__ import absolute_import, print_function
10
10
11 import collections
11 import collections
12 import contextlib
12 import contextlib
13 import copy
13 import copy
14 import email
14 import email
15 import errno
15 import errno
16 import hashlib
16 import hashlib
17 import os
17 import os
18 import posixpath
18 import posixpath
19 import re
19 import re
20 import shutil
20 import shutil
21 import zlib
21 import zlib
22
22
23 from .i18n import _
23 from .i18n import _
24 from .node import (
24 from .node import (
25 hex,
25 hex,
26 short,
26 short,
27 )
27 )
28 from . import (
28 from . import (
29 copies,
29 copies,
30 diffhelper,
30 diffhelper,
31 diffutil,
31 diffutil,
32 encoding,
32 encoding,
33 error,
33 error,
34 mail,
34 mail,
35 mdiff,
35 mdiff,
36 pathutil,
36 pathutil,
37 pycompat,
37 pycompat,
38 scmutil,
38 scmutil,
39 similar,
39 similar,
40 util,
40 util,
41 vfs as vfsmod,
41 vfs as vfsmod,
42 )
42 )
43 from .utils import (
43 from .utils import (
44 dateutil,
44 dateutil,
45 procutil,
45 procutil,
46 stringutil,
46 stringutil,
47 )
47 )
48
48
49 stringio = util.stringio
49 stringio = util.stringio
50
50
51 gitre = re.compile(br'diff --git a/(.*) b/(.*)')
51 gitre = re.compile(br'diff --git a/(.*) b/(.*)')
52 tabsplitter = re.compile(br'(\t+|[^\t]+)')
52 tabsplitter = re.compile(br'(\t+|[^\t]+)')
53 wordsplitter = re.compile(br'(\t+| +|[a-zA-Z0-9_\x80-\xff]+|'
53 wordsplitter = re.compile(br'(\t+| +|[a-zA-Z0-9_\x80-\xff]+|'
54 b'[^ \ta-zA-Z0-9_\x80-\xff])')
54 b'[^ \ta-zA-Z0-9_\x80-\xff])')
55
55
56 PatchError = error.PatchError
56 PatchError = error.PatchError
57
57
58 # public functions
58 # public functions
59
59
60 def split(stream):
60 def split(stream):
61 '''return an iterator of individual patches from a stream'''
61 '''return an iterator of individual patches from a stream'''
62 def isheader(line, inheader):
62 def isheader(line, inheader):
63 if inheader and line.startswith((' ', '\t')):
63 if inheader and line.startswith((' ', '\t')):
64 # continuation
64 # continuation
65 return True
65 return True
66 if line.startswith((' ', '-', '+')):
66 if line.startswith((' ', '-', '+')):
67 # diff line - don't check for header pattern in there
67 # diff line - don't check for header pattern in there
68 return False
68 return False
69 l = line.split(': ', 1)
69 l = line.split(': ', 1)
70 return len(l) == 2 and ' ' not in l[0]
70 return len(l) == 2 and ' ' not in l[0]
71
71
72 def chunk(lines):
72 def chunk(lines):
73 return stringio(''.join(lines))
73 return stringio(''.join(lines))
74
74
75 def hgsplit(stream, cur):
75 def hgsplit(stream, cur):
76 inheader = True
76 inheader = True
77
77
78 for line in stream:
78 for line in stream:
79 if not line.strip():
79 if not line.strip():
80 inheader = False
80 inheader = False
81 if not inheader and line.startswith('# HG changeset patch'):
81 if not inheader and line.startswith('# HG changeset patch'):
82 yield chunk(cur)
82 yield chunk(cur)
83 cur = []
83 cur = []
84 inheader = True
84 inheader = True
85
85
86 cur.append(line)
86 cur.append(line)
87
87
88 if cur:
88 if cur:
89 yield chunk(cur)
89 yield chunk(cur)
90
90
91 def mboxsplit(stream, cur):
91 def mboxsplit(stream, cur):
92 for line in stream:
92 for line in stream:
93 if line.startswith('From '):
93 if line.startswith('From '):
94 for c in split(chunk(cur[1:])):
94 for c in split(chunk(cur[1:])):
95 yield c
95 yield c
96 cur = []
96 cur = []
97
97
98 cur.append(line)
98 cur.append(line)
99
99
100 if cur:
100 if cur:
101 for c in split(chunk(cur[1:])):
101 for c in split(chunk(cur[1:])):
102 yield c
102 yield c
103
103
104 def mimesplit(stream, cur):
104 def mimesplit(stream, cur):
105 def msgfp(m):
105 def msgfp(m):
106 fp = stringio()
106 fp = stringio()
107 g = email.Generator.Generator(fp, mangle_from_=False)
107 g = email.Generator.Generator(fp, mangle_from_=False)
108 g.flatten(m)
108 g.flatten(m)
109 fp.seek(0)
109 fp.seek(0)
110 return fp
110 return fp
111
111
112 for line in stream:
112 for line in stream:
113 cur.append(line)
113 cur.append(line)
114 c = chunk(cur)
114 c = chunk(cur)
115
115
116 m = mail.parse(c)
116 m = mail.parse(c)
117 if not m.is_multipart():
117 if not m.is_multipart():
118 yield msgfp(m)
118 yield msgfp(m)
119 else:
119 else:
120 ok_types = ('text/plain', 'text/x-diff', 'text/x-patch')
120 ok_types = ('text/plain', 'text/x-diff', 'text/x-patch')
121 for part in m.walk():
121 for part in m.walk():
122 ct = part.get_content_type()
122 ct = part.get_content_type()
123 if ct not in ok_types:
123 if ct not in ok_types:
124 continue
124 continue
125 yield msgfp(part)
125 yield msgfp(part)
126
126
127 def headersplit(stream, cur):
127 def headersplit(stream, cur):
128 inheader = False
128 inheader = False
129
129
130 for line in stream:
130 for line in stream:
131 if not inheader and isheader(line, inheader):
131 if not inheader and isheader(line, inheader):
132 yield chunk(cur)
132 yield chunk(cur)
133 cur = []
133 cur = []
134 inheader = True
134 inheader = True
135 if inheader and not isheader(line, inheader):
135 if inheader and not isheader(line, inheader):
136 inheader = False
136 inheader = False
137
137
138 cur.append(line)
138 cur.append(line)
139
139
140 if cur:
140 if cur:
141 yield chunk(cur)
141 yield chunk(cur)
142
142
143 def remainder(cur):
143 def remainder(cur):
144 yield chunk(cur)
144 yield chunk(cur)
145
145
146 class fiter(object):
146 class fiter(object):
147 def __init__(self, fp):
147 def __init__(self, fp):
148 self.fp = fp
148 self.fp = fp
149
149
150 def __iter__(self):
150 def __iter__(self):
151 return self
151 return self
152
152
153 def next(self):
153 def next(self):
154 l = self.fp.readline()
154 l = self.fp.readline()
155 if not l:
155 if not l:
156 raise StopIteration
156 raise StopIteration
157 return l
157 return l
158
158
159 __next__ = next
159 __next__ = next
160
160
161 inheader = False
161 inheader = False
162 cur = []
162 cur = []
163
163
164 mimeheaders = ['content-type']
164 mimeheaders = ['content-type']
165
165
166 if not util.safehasattr(stream, 'next'):
166 if not util.safehasattr(stream, 'next'):
167 # http responses, for example, have readline but not next
167 # http responses, for example, have readline but not next
168 stream = fiter(stream)
168 stream = fiter(stream)
169
169
170 for line in stream:
170 for line in stream:
171 cur.append(line)
171 cur.append(line)
172 if line.startswith('# HG changeset patch'):
172 if line.startswith('# HG changeset patch'):
173 return hgsplit(stream, cur)
173 return hgsplit(stream, cur)
174 elif line.startswith('From '):
174 elif line.startswith('From '):
175 return mboxsplit(stream, cur)
175 return mboxsplit(stream, cur)
176 elif isheader(line, inheader):
176 elif isheader(line, inheader):
177 inheader = True
177 inheader = True
178 if line.split(':', 1)[0].lower() in mimeheaders:
178 if line.split(':', 1)[0].lower() in mimeheaders:
179 # let email parser handle this
179 # let email parser handle this
180 return mimesplit(stream, cur)
180 return mimesplit(stream, cur)
181 elif line.startswith('--- ') and inheader:
181 elif line.startswith('--- ') and inheader:
182 # No evil headers seen by diff start, split by hand
182 # No evil headers seen by diff start, split by hand
183 return headersplit(stream, cur)
183 return headersplit(stream, cur)
184 # Not enough info, keep reading
184 # Not enough info, keep reading
185
185
186 # if we are here, we have a very plain patch
186 # if we are here, we have a very plain patch
187 return remainder(cur)
187 return remainder(cur)
188
188
189 ## Some facility for extensible patch parsing:
189 ## Some facility for extensible patch parsing:
190 # list of pairs ("header to match", "data key")
190 # list of pairs ("header to match", "data key")
191 patchheadermap = [('Date', 'date'),
191 patchheadermap = [('Date', 'date'),
192 ('Branch', 'branch'),
192 ('Branch', 'branch'),
193 ('Node ID', 'nodeid'),
193 ('Node ID', 'nodeid'),
194 ]
194 ]
195
195
196 @contextlib.contextmanager
196 @contextlib.contextmanager
197 def extract(ui, fileobj):
197 def extract(ui, fileobj):
198 '''extract patch from data read from fileobj.
198 '''extract patch from data read from fileobj.
199
199
200 patch can be a normal patch or contained in an email message.
200 patch can be a normal patch or contained in an email message.
201
201
202 return a dictionary. Standard keys are:
202 return a dictionary. Standard keys are:
203 - filename,
203 - filename,
204 - message,
204 - message,
205 - user,
205 - user,
206 - date,
206 - date,
207 - branch,
207 - branch,
208 - node,
208 - node,
209 - p1,
209 - p1,
210 - p2.
210 - p2.
211 Any item can be missing from the dictionary. If filename is missing,
211 Any item can be missing from the dictionary. If filename is missing,
212 fileobj did not contain a patch. Caller must unlink filename when done.'''
212 fileobj did not contain a patch. Caller must unlink filename when done.'''
213
213
214 fd, tmpname = pycompat.mkstemp(prefix='hg-patch-')
214 fd, tmpname = pycompat.mkstemp(prefix='hg-patch-')
215 tmpfp = os.fdopen(fd, r'wb')
215 tmpfp = os.fdopen(fd, r'wb')
216 try:
216 try:
217 yield _extract(ui, fileobj, tmpname, tmpfp)
217 yield _extract(ui, fileobj, tmpname, tmpfp)
218 finally:
218 finally:
219 tmpfp.close()
219 tmpfp.close()
220 os.unlink(tmpname)
220 os.unlink(tmpname)
221
221
222 def _extract(ui, fileobj, tmpname, tmpfp):
222 def _extract(ui, fileobj, tmpname, tmpfp):
223
223
224 # attempt to detect the start of a patch
224 # attempt to detect the start of a patch
225 # (this heuristic is borrowed from quilt)
225 # (this heuristic is borrowed from quilt)
226 diffre = re.compile(br'^(?:Index:[ \t]|diff[ \t]-|RCS file: |'
226 diffre = re.compile(br'^(?:Index:[ \t]|diff[ \t]-|RCS file: |'
227 br'retrieving revision [0-9]+(\.[0-9]+)*$|'
227 br'retrieving revision [0-9]+(\.[0-9]+)*$|'
228 br'---[ \t].*?^\+\+\+[ \t]|'
228 br'---[ \t].*?^\+\+\+[ \t]|'
229 br'\*\*\*[ \t].*?^---[ \t])',
229 br'\*\*\*[ \t].*?^---[ \t])',
230 re.MULTILINE | re.DOTALL)
230 re.MULTILINE | re.DOTALL)
231
231
232 data = {}
232 data = {}
233
233
234 msg = mail.parse(fileobj)
234 msg = mail.parse(fileobj)
235
235
236 subject = msg[r'Subject'] and mail.headdecode(msg[r'Subject'])
236 subject = msg[r'Subject'] and mail.headdecode(msg[r'Subject'])
237 data['user'] = msg[r'From'] and mail.headdecode(msg[r'From'])
237 data['user'] = msg[r'From'] and mail.headdecode(msg[r'From'])
238 if not subject and not data['user']:
238 if not subject and not data['user']:
239 # Not an email, restore parsed headers if any
239 # Not an email, restore parsed headers if any
240 subject = '\n'.join(': '.join(map(encoding.strtolocal, h))
240 subject = '\n'.join(': '.join(map(encoding.strtolocal, h))
241 for h in msg.items()) + '\n'
241 for h in msg.items()) + '\n'
242
242
243 # should try to parse msg['Date']
243 # should try to parse msg['Date']
244 parents = []
244 parents = []
245
245
246 if subject:
246 if subject:
247 if subject.startswith('[PATCH'):
247 if subject.startswith('[PATCH'):
248 pend = subject.find(']')
248 pend = subject.find(']')
249 if pend >= 0:
249 if pend >= 0:
250 subject = subject[pend + 1:].lstrip()
250 subject = subject[pend + 1:].lstrip()
251 subject = re.sub(br'\n[ \t]+', ' ', subject)
251 subject = re.sub(br'\n[ \t]+', ' ', subject)
252 ui.debug('Subject: %s\n' % subject)
252 ui.debug('Subject: %s\n' % subject)
253 if data['user']:
253 if data['user']:
254 ui.debug('From: %s\n' % data['user'])
254 ui.debug('From: %s\n' % data['user'])
255 diffs_seen = 0
255 diffs_seen = 0
256 ok_types = ('text/plain', 'text/x-diff', 'text/x-patch')
256 ok_types = ('text/plain', 'text/x-diff', 'text/x-patch')
257 message = ''
257 message = ''
258 for part in msg.walk():
258 for part in msg.walk():
259 content_type = pycompat.bytestr(part.get_content_type())
259 content_type = pycompat.bytestr(part.get_content_type())
260 ui.debug('Content-Type: %s\n' % content_type)
260 ui.debug('Content-Type: %s\n' % content_type)
261 if content_type not in ok_types:
261 if content_type not in ok_types:
262 continue
262 continue
263 payload = part.get_payload(decode=True)
263 payload = part.get_payload(decode=True)
264 m = diffre.search(payload)
264 m = diffre.search(payload)
265 if m:
265 if m:
266 hgpatch = False
266 hgpatch = False
267 hgpatchheader = False
267 hgpatchheader = False
268 ignoretext = False
268 ignoretext = False
269
269
270 ui.debug('found patch at byte %d\n' % m.start(0))
270 ui.debug('found patch at byte %d\n' % m.start(0))
271 diffs_seen += 1
271 diffs_seen += 1
272 cfp = stringio()
272 cfp = stringio()
273 for line in payload[:m.start(0)].splitlines():
273 for line in payload[:m.start(0)].splitlines():
274 if line.startswith('# HG changeset patch') and not hgpatch:
274 if line.startswith('# HG changeset patch') and not hgpatch:
275 ui.debug('patch generated by hg export\n')
275 ui.debug('patch generated by hg export\n')
276 hgpatch = True
276 hgpatch = True
277 hgpatchheader = True
277 hgpatchheader = True
278 # drop earlier commit message content
278 # drop earlier commit message content
279 cfp.seek(0)
279 cfp.seek(0)
280 cfp.truncate()
280 cfp.truncate()
281 subject = None
281 subject = None
282 elif hgpatchheader:
282 elif hgpatchheader:
283 if line.startswith('# User '):
283 if line.startswith('# User '):
284 data['user'] = line[7:]
284 data['user'] = line[7:]
285 ui.debug('From: %s\n' % data['user'])
285 ui.debug('From: %s\n' % data['user'])
286 elif line.startswith("# Parent "):
286 elif line.startswith("# Parent "):
287 parents.append(line[9:].lstrip())
287 parents.append(line[9:].lstrip())
288 elif line.startswith("# "):
288 elif line.startswith("# "):
289 for header, key in patchheadermap:
289 for header, key in patchheadermap:
290 prefix = '# %s ' % header
290 prefix = '# %s ' % header
291 if line.startswith(prefix):
291 if line.startswith(prefix):
292 data[key] = line[len(prefix):]
292 data[key] = line[len(prefix):]
293 else:
293 else:
294 hgpatchheader = False
294 hgpatchheader = False
295 elif line == '---':
295 elif line == '---':
296 ignoretext = True
296 ignoretext = True
297 if not hgpatchheader and not ignoretext:
297 if not hgpatchheader and not ignoretext:
298 cfp.write(line)
298 cfp.write(line)
299 cfp.write('\n')
299 cfp.write('\n')
300 message = cfp.getvalue()
300 message = cfp.getvalue()
301 if tmpfp:
301 if tmpfp:
302 tmpfp.write(payload)
302 tmpfp.write(payload)
303 if not payload.endswith('\n'):
303 if not payload.endswith('\n'):
304 tmpfp.write('\n')
304 tmpfp.write('\n')
305 elif not diffs_seen and message and content_type == 'text/plain':
305 elif not diffs_seen and message and content_type == 'text/plain':
306 message += '\n' + payload
306 message += '\n' + payload
307
307
308 if subject and not message.startswith(subject):
308 if subject and not message.startswith(subject):
309 message = '%s\n%s' % (subject, message)
309 message = '%s\n%s' % (subject, message)
310 data['message'] = message
310 data['message'] = message
311 tmpfp.close()
311 tmpfp.close()
312 if parents:
312 if parents:
313 data['p1'] = parents.pop(0)
313 data['p1'] = parents.pop(0)
314 if parents:
314 if parents:
315 data['p2'] = parents.pop(0)
315 data['p2'] = parents.pop(0)
316
316
317 if diffs_seen:
317 if diffs_seen:
318 data['filename'] = tmpname
318 data['filename'] = tmpname
319
319
320 return data
320 return data
321
321
322 class patchmeta(object):
322 class patchmeta(object):
323 """Patched file metadata
323 """Patched file metadata
324
324
325 'op' is the performed operation within ADD, DELETE, RENAME, MODIFY
325 'op' is the performed operation within ADD, DELETE, RENAME, MODIFY
326 or COPY. 'path' is patched file path. 'oldpath' is set to the
326 or COPY. 'path' is patched file path. 'oldpath' is set to the
327 origin file when 'op' is either COPY or RENAME, None otherwise. If
327 origin file when 'op' is either COPY or RENAME, None otherwise. If
328 file mode is changed, 'mode' is a tuple (islink, isexec) where
328 file mode is changed, 'mode' is a tuple (islink, isexec) where
329 'islink' is True if the file is a symlink and 'isexec' is True if
329 'islink' is True if the file is a symlink and 'isexec' is True if
330 the file is executable. Otherwise, 'mode' is None.
330 the file is executable. Otherwise, 'mode' is None.
331 """
331 """
332 def __init__(self, path):
332 def __init__(self, path):
333 self.path = path
333 self.path = path
334 self.oldpath = None
334 self.oldpath = None
335 self.mode = None
335 self.mode = None
336 self.op = 'MODIFY'
336 self.op = 'MODIFY'
337 self.binary = False
337 self.binary = False
338
338
339 def setmode(self, mode):
339 def setmode(self, mode):
340 islink = mode & 0o20000
340 islink = mode & 0o20000
341 isexec = mode & 0o100
341 isexec = mode & 0o100
342 self.mode = (islink, isexec)
342 self.mode = (islink, isexec)
343
343
344 def copy(self):
344 def copy(self):
345 other = patchmeta(self.path)
345 other = patchmeta(self.path)
346 other.oldpath = self.oldpath
346 other.oldpath = self.oldpath
347 other.mode = self.mode
347 other.mode = self.mode
348 other.op = self.op
348 other.op = self.op
349 other.binary = self.binary
349 other.binary = self.binary
350 return other
350 return other
351
351
352 def _ispatchinga(self, afile):
352 def _ispatchinga(self, afile):
353 if afile == '/dev/null':
353 if afile == '/dev/null':
354 return self.op == 'ADD'
354 return self.op == 'ADD'
355 return afile == 'a/' + (self.oldpath or self.path)
355 return afile == 'a/' + (self.oldpath or self.path)
356
356
357 def _ispatchingb(self, bfile):
357 def _ispatchingb(self, bfile):
358 if bfile == '/dev/null':
358 if bfile == '/dev/null':
359 return self.op == 'DELETE'
359 return self.op == 'DELETE'
360 return bfile == 'b/' + self.path
360 return bfile == 'b/' + self.path
361
361
362 def ispatching(self, afile, bfile):
362 def ispatching(self, afile, bfile):
363 return self._ispatchinga(afile) and self._ispatchingb(bfile)
363 return self._ispatchinga(afile) and self._ispatchingb(bfile)
364
364
365 def __repr__(self):
365 def __repr__(self):
366 return "<patchmeta %s %r>" % (self.op, self.path)
366 return "<patchmeta %s %r>" % (self.op, self.path)
367
367
368 def readgitpatch(lr):
368 def readgitpatch(lr):
369 """extract git-style metadata about patches from <patchname>"""
369 """extract git-style metadata about patches from <patchname>"""
370
370
371 # Filter patch for git information
371 # Filter patch for git information
372 gp = None
372 gp = None
373 gitpatches = []
373 gitpatches = []
374 for line in lr:
374 for line in lr:
375 line = line.rstrip(' \r\n')
375 line = line.rstrip(' \r\n')
376 if line.startswith('diff --git a/'):
376 if line.startswith('diff --git a/'):
377 m = gitre.match(line)
377 m = gitre.match(line)
378 if m:
378 if m:
379 if gp:
379 if gp:
380 gitpatches.append(gp)
380 gitpatches.append(gp)
381 dst = m.group(2)
381 dst = m.group(2)
382 gp = patchmeta(dst)
382 gp = patchmeta(dst)
383 elif gp:
383 elif gp:
384 if line.startswith('--- '):
384 if line.startswith('--- '):
385 gitpatches.append(gp)
385 gitpatches.append(gp)
386 gp = None
386 gp = None
387 continue
387 continue
388 if line.startswith('rename from '):
388 if line.startswith('rename from '):
389 gp.op = 'RENAME'
389 gp.op = 'RENAME'
390 gp.oldpath = line[12:]
390 gp.oldpath = line[12:]
391 elif line.startswith('rename to '):
391 elif line.startswith('rename to '):
392 gp.path = line[10:]
392 gp.path = line[10:]
393 elif line.startswith('copy from '):
393 elif line.startswith('copy from '):
394 gp.op = 'COPY'
394 gp.op = 'COPY'
395 gp.oldpath = line[10:]
395 gp.oldpath = line[10:]
396 elif line.startswith('copy to '):
396 elif line.startswith('copy to '):
397 gp.path = line[8:]
397 gp.path = line[8:]
398 elif line.startswith('deleted file'):
398 elif line.startswith('deleted file'):
399 gp.op = 'DELETE'
399 gp.op = 'DELETE'
400 elif line.startswith('new file mode '):
400 elif line.startswith('new file mode '):
401 gp.op = 'ADD'
401 gp.op = 'ADD'
402 gp.setmode(int(line[-6:], 8))
402 gp.setmode(int(line[-6:], 8))
403 elif line.startswith('new mode '):
403 elif line.startswith('new mode '):
404 gp.setmode(int(line[-6:], 8))
404 gp.setmode(int(line[-6:], 8))
405 elif line.startswith('GIT binary patch'):
405 elif line.startswith('GIT binary patch'):
406 gp.binary = True
406 gp.binary = True
407 if gp:
407 if gp:
408 gitpatches.append(gp)
408 gitpatches.append(gp)
409
409
410 return gitpatches
410 return gitpatches
411
411
412 class linereader(object):
412 class linereader(object):
413 # simple class to allow pushing lines back into the input stream
413 # simple class to allow pushing lines back into the input stream
414 def __init__(self, fp):
414 def __init__(self, fp):
415 self.fp = fp
415 self.fp = fp
416 self.buf = []
416 self.buf = []
417
417
418 def push(self, line):
418 def push(self, line):
419 if line is not None:
419 if line is not None:
420 self.buf.append(line)
420 self.buf.append(line)
421
421
422 def readline(self):
422 def readline(self):
423 if self.buf:
423 if self.buf:
424 l = self.buf[0]
424 l = self.buf[0]
425 del self.buf[0]
425 del self.buf[0]
426 return l
426 return l
427 return self.fp.readline()
427 return self.fp.readline()
428
428
429 def __iter__(self):
429 def __iter__(self):
430 return iter(self.readline, '')
430 return iter(self.readline, '')
431
431
432 class abstractbackend(object):
432 class abstractbackend(object):
433 def __init__(self, ui):
433 def __init__(self, ui):
434 self.ui = ui
434 self.ui = ui
435
435
436 def getfile(self, fname):
436 def getfile(self, fname):
437 """Return target file data and flags as a (data, (islink,
437 """Return target file data and flags as a (data, (islink,
438 isexec)) tuple. Data is None if file is missing/deleted.
438 isexec)) tuple. Data is None if file is missing/deleted.
439 """
439 """
440 raise NotImplementedError
440 raise NotImplementedError
441
441
442 def setfile(self, fname, data, mode, copysource):
442 def setfile(self, fname, data, mode, copysource):
443 """Write data to target file fname and set its mode. mode is a
443 """Write data to target file fname and set its mode. mode is a
444 (islink, isexec) tuple. If data is None, the file content should
444 (islink, isexec) tuple. If data is None, the file content should
445 be left unchanged. If the file is modified after being copied,
445 be left unchanged. If the file is modified after being copied,
446 copysource is set to the original file name.
446 copysource is set to the original file name.
447 """
447 """
448 raise NotImplementedError
448 raise NotImplementedError
449
449
450 def unlink(self, fname):
450 def unlink(self, fname):
451 """Unlink target file."""
451 """Unlink target file."""
452 raise NotImplementedError
452 raise NotImplementedError
453
453
454 def writerej(self, fname, failed, total, lines):
454 def writerej(self, fname, failed, total, lines):
455 """Write rejected lines for fname. total is the number of hunks
455 """Write rejected lines for fname. total is the number of hunks
456 which failed to apply and total the total number of hunks for this
456 which failed to apply and total the total number of hunks for this
457 files.
457 files.
458 """
458 """
459
459
460 def exists(self, fname):
460 def exists(self, fname):
461 raise NotImplementedError
461 raise NotImplementedError
462
462
463 def close(self):
463 def close(self):
464 raise NotImplementedError
464 raise NotImplementedError
465
465
466 class fsbackend(abstractbackend):
466 class fsbackend(abstractbackend):
467 def __init__(self, ui, basedir):
467 def __init__(self, ui, basedir):
468 super(fsbackend, self).__init__(ui)
468 super(fsbackend, self).__init__(ui)
469 self.opener = vfsmod.vfs(basedir)
469 self.opener = vfsmod.vfs(basedir)
470
470
471 def getfile(self, fname):
471 def getfile(self, fname):
472 if self.opener.islink(fname):
472 if self.opener.islink(fname):
473 return (self.opener.readlink(fname), (True, False))
473 return (self.opener.readlink(fname), (True, False))
474
474
475 isexec = False
475 isexec = False
476 try:
476 try:
477 isexec = self.opener.lstat(fname).st_mode & 0o100 != 0
477 isexec = self.opener.lstat(fname).st_mode & 0o100 != 0
478 except OSError as e:
478 except OSError as e:
479 if e.errno != errno.ENOENT:
479 if e.errno != errno.ENOENT:
480 raise
480 raise
481 try:
481 try:
482 return (self.opener.read(fname), (False, isexec))
482 return (self.opener.read(fname), (False, isexec))
483 except IOError as e:
483 except IOError as e:
484 if e.errno != errno.ENOENT:
484 if e.errno != errno.ENOENT:
485 raise
485 raise
486 return None, None
486 return None, None
487
487
488 def setfile(self, fname, data, mode, copysource):
488 def setfile(self, fname, data, mode, copysource):
489 islink, isexec = mode
489 islink, isexec = mode
490 if data is None:
490 if data is None:
491 self.opener.setflags(fname, islink, isexec)
491 self.opener.setflags(fname, islink, isexec)
492 return
492 return
493 if islink:
493 if islink:
494 self.opener.symlink(data, fname)
494 self.opener.symlink(data, fname)
495 else:
495 else:
496 self.opener.write(fname, data)
496 self.opener.write(fname, data)
497 if isexec:
497 if isexec:
498 self.opener.setflags(fname, False, True)
498 self.opener.setflags(fname, False, True)
499
499
500 def unlink(self, fname):
500 def unlink(self, fname):
501 rmdir = self.ui.configbool('experimental', 'removeemptydirs')
501 rmdir = self.ui.configbool('experimental', 'removeemptydirs')
502 self.opener.unlinkpath(fname, ignoremissing=True, rmdir=rmdir)
502 self.opener.unlinkpath(fname, ignoremissing=True, rmdir=rmdir)
503
503
504 def writerej(self, fname, failed, total, lines):
504 def writerej(self, fname, failed, total, lines):
505 fname = fname + ".rej"
505 fname = fname + ".rej"
506 self.ui.warn(
506 self.ui.warn(
507 _("%d out of %d hunks FAILED -- saving rejects to file %s\n") %
507 _("%d out of %d hunks FAILED -- saving rejects to file %s\n") %
508 (failed, total, fname))
508 (failed, total, fname))
509 fp = self.opener(fname, 'w')
509 fp = self.opener(fname, 'w')
510 fp.writelines(lines)
510 fp.writelines(lines)
511 fp.close()
511 fp.close()
512
512
513 def exists(self, fname):
513 def exists(self, fname):
514 return self.opener.lexists(fname)
514 return self.opener.lexists(fname)
515
515
516 class workingbackend(fsbackend):
516 class workingbackend(fsbackend):
517 def __init__(self, ui, repo, similarity):
517 def __init__(self, ui, repo, similarity):
518 super(workingbackend, self).__init__(ui, repo.root)
518 super(workingbackend, self).__init__(ui, repo.root)
519 self.repo = repo
519 self.repo = repo
520 self.similarity = similarity
520 self.similarity = similarity
521 self.removed = set()
521 self.removed = set()
522 self.changed = set()
522 self.changed = set()
523 self.copied = []
523 self.copied = []
524
524
525 def _checkknown(self, fname):
525 def _checkknown(self, fname):
526 if self.repo.dirstate[fname] == '?' and self.exists(fname):
526 if self.repo.dirstate[fname] == '?' and self.exists(fname):
527 raise PatchError(_('cannot patch %s: file is not tracked') % fname)
527 raise PatchError(_('cannot patch %s: file is not tracked') % fname)
528
528
529 def setfile(self, fname, data, mode, copysource):
529 def setfile(self, fname, data, mode, copysource):
530 self._checkknown(fname)
530 self._checkknown(fname)
531 super(workingbackend, self).setfile(fname, data, mode, copysource)
531 super(workingbackend, self).setfile(fname, data, mode, copysource)
532 if copysource is not None:
532 if copysource is not None:
533 self.copied.append((copysource, fname))
533 self.copied.append((copysource, fname))
534 self.changed.add(fname)
534 self.changed.add(fname)
535
535
536 def unlink(self, fname):
536 def unlink(self, fname):
537 self._checkknown(fname)
537 self._checkknown(fname)
538 super(workingbackend, self).unlink(fname)
538 super(workingbackend, self).unlink(fname)
539 self.removed.add(fname)
539 self.removed.add(fname)
540 self.changed.add(fname)
540 self.changed.add(fname)
541
541
542 def close(self):
542 def close(self):
543 wctx = self.repo[None]
543 wctx = self.repo[None]
544 changed = set(self.changed)
544 changed = set(self.changed)
545 for src, dst in self.copied:
545 for src, dst in self.copied:
546 scmutil.dirstatecopy(self.ui, self.repo, wctx, src, dst)
546 scmutil.dirstatecopy(self.ui, self.repo, wctx, src, dst)
547 if self.removed:
547 if self.removed:
548 wctx.forget(sorted(self.removed))
548 wctx.forget(sorted(self.removed))
549 for f in self.removed:
549 for f in self.removed:
550 if f not in self.repo.dirstate:
550 if f not in self.repo.dirstate:
551 # File was deleted and no longer belongs to the
551 # File was deleted and no longer belongs to the
552 # dirstate, it was probably marked added then
552 # dirstate, it was probably marked added then
553 # deleted, and should not be considered by
553 # deleted, and should not be considered by
554 # marktouched().
554 # marktouched().
555 changed.discard(f)
555 changed.discard(f)
556 if changed:
556 if changed:
557 scmutil.marktouched(self.repo, changed, self.similarity)
557 scmutil.marktouched(self.repo, changed, self.similarity)
558 return sorted(self.changed)
558 return sorted(self.changed)
559
559
560 class filestore(object):
560 class filestore(object):
561 def __init__(self, maxsize=None):
561 def __init__(self, maxsize=None):
562 self.opener = None
562 self.opener = None
563 self.files = {}
563 self.files = {}
564 self.created = 0
564 self.created = 0
565 self.maxsize = maxsize
565 self.maxsize = maxsize
566 if self.maxsize is None:
566 if self.maxsize is None:
567 self.maxsize = 4*(2**20)
567 self.maxsize = 4*(2**20)
568 self.size = 0
568 self.size = 0
569 self.data = {}
569 self.data = {}
570
570
571 def setfile(self, fname, data, mode, copied=None):
571 def setfile(self, fname, data, mode, copied=None):
572 if self.maxsize < 0 or (len(data) + self.size) <= self.maxsize:
572 if self.maxsize < 0 or (len(data) + self.size) <= self.maxsize:
573 self.data[fname] = (data, mode, copied)
573 self.data[fname] = (data, mode, copied)
574 self.size += len(data)
574 self.size += len(data)
575 else:
575 else:
576 if self.opener is None:
576 if self.opener is None:
577 root = pycompat.mkdtemp(prefix='hg-patch-')
577 root = pycompat.mkdtemp(prefix='hg-patch-')
578 self.opener = vfsmod.vfs(root)
578 self.opener = vfsmod.vfs(root)
579 # Avoid filename issues with these simple names
579 # Avoid filename issues with these simple names
580 fn = '%d' % self.created
580 fn = '%d' % self.created
581 self.opener.write(fn, data)
581 self.opener.write(fn, data)
582 self.created += 1
582 self.created += 1
583 self.files[fname] = (fn, mode, copied)
583 self.files[fname] = (fn, mode, copied)
584
584
585 def getfile(self, fname):
585 def getfile(self, fname):
586 if fname in self.data:
586 if fname in self.data:
587 return self.data[fname]
587 return self.data[fname]
588 if not self.opener or fname not in self.files:
588 if not self.opener or fname not in self.files:
589 return None, None, None
589 return None, None, None
590 fn, mode, copied = self.files[fname]
590 fn, mode, copied = self.files[fname]
591 return self.opener.read(fn), mode, copied
591 return self.opener.read(fn), mode, copied
592
592
593 def close(self):
593 def close(self):
594 if self.opener:
594 if self.opener:
595 shutil.rmtree(self.opener.base)
595 shutil.rmtree(self.opener.base)
596
596
597 class repobackend(abstractbackend):
597 class repobackend(abstractbackend):
598 def __init__(self, ui, repo, ctx, store):
598 def __init__(self, ui, repo, ctx, store):
599 super(repobackend, self).__init__(ui)
599 super(repobackend, self).__init__(ui)
600 self.repo = repo
600 self.repo = repo
601 self.ctx = ctx
601 self.ctx = ctx
602 self.store = store
602 self.store = store
603 self.changed = set()
603 self.changed = set()
604 self.removed = set()
604 self.removed = set()
605 self.copied = {}
605 self.copied = {}
606
606
607 def _checkknown(self, fname):
607 def _checkknown(self, fname):
608 if fname not in self.ctx:
608 if fname not in self.ctx:
609 raise PatchError(_('cannot patch %s: file is not tracked') % fname)
609 raise PatchError(_('cannot patch %s: file is not tracked') % fname)
610
610
611 def getfile(self, fname):
611 def getfile(self, fname):
612 try:
612 try:
613 fctx = self.ctx[fname]
613 fctx = self.ctx[fname]
614 except error.LookupError:
614 except error.LookupError:
615 return None, None
615 return None, None
616 flags = fctx.flags()
616 flags = fctx.flags()
617 return fctx.data(), ('l' in flags, 'x' in flags)
617 return fctx.data(), ('l' in flags, 'x' in flags)
618
618
619 def setfile(self, fname, data, mode, copysource):
619 def setfile(self, fname, data, mode, copysource):
620 if copysource:
620 if copysource:
621 self._checkknown(copysource)
621 self._checkknown(copysource)
622 if data is None:
622 if data is None:
623 data = self.ctx[fname].data()
623 data = self.ctx[fname].data()
624 self.store.setfile(fname, data, mode, copysource)
624 self.store.setfile(fname, data, mode, copysource)
625 self.changed.add(fname)
625 self.changed.add(fname)
626 if copysource:
626 if copysource:
627 self.copied[fname] = copysource
627 self.copied[fname] = copysource
628
628
629 def unlink(self, fname):
629 def unlink(self, fname):
630 self._checkknown(fname)
630 self._checkknown(fname)
631 self.removed.add(fname)
631 self.removed.add(fname)
632
632
633 def exists(self, fname):
633 def exists(self, fname):
634 return fname in self.ctx
634 return fname in self.ctx
635
635
636 def close(self):
636 def close(self):
637 return self.changed | self.removed
637 return self.changed | self.removed
638
638
639 # @@ -start,len +start,len @@ or @@ -start +start @@ if len is 1
639 # @@ -start,len +start,len @@ or @@ -start +start @@ if len is 1
640 unidesc = re.compile('@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@')
640 unidesc = re.compile('@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@')
641 contextdesc = re.compile('(?:---|\*\*\*) (\d+)(?:,(\d+))? (?:---|\*\*\*)')
641 contextdesc = re.compile('(?:---|\*\*\*) (\d+)(?:,(\d+))? (?:---|\*\*\*)')
642 eolmodes = ['strict', 'crlf', 'lf', 'auto']
642 eolmodes = ['strict', 'crlf', 'lf', 'auto']
643
643
644 class patchfile(object):
644 class patchfile(object):
645 def __init__(self, ui, gp, backend, store, eolmode='strict'):
645 def __init__(self, ui, gp, backend, store, eolmode='strict'):
646 self.fname = gp.path
646 self.fname = gp.path
647 self.eolmode = eolmode
647 self.eolmode = eolmode
648 self.eol = None
648 self.eol = None
649 self.backend = backend
649 self.backend = backend
650 self.ui = ui
650 self.ui = ui
651 self.lines = []
651 self.lines = []
652 self.exists = False
652 self.exists = False
653 self.missing = True
653 self.missing = True
654 self.mode = gp.mode
654 self.mode = gp.mode
655 self.copysource = gp.oldpath
655 self.copysource = gp.oldpath
656 self.create = gp.op in ('ADD', 'COPY', 'RENAME')
656 self.create = gp.op in ('ADD', 'COPY', 'RENAME')
657 self.remove = gp.op == 'DELETE'
657 self.remove = gp.op == 'DELETE'
658 if self.copysource is None:
658 if self.copysource is None:
659 data, mode = backend.getfile(self.fname)
659 data, mode = backend.getfile(self.fname)
660 else:
660 else:
661 data, mode = store.getfile(self.copysource)[:2]
661 data, mode = store.getfile(self.copysource)[:2]
662 if data is not None:
662 if data is not None:
663 self.exists = self.copysource is None or backend.exists(self.fname)
663 self.exists = self.copysource is None or backend.exists(self.fname)
664 self.missing = False
664 self.missing = False
665 if data:
665 if data:
666 self.lines = mdiff.splitnewlines(data)
666 self.lines = mdiff.splitnewlines(data)
667 if self.mode is None:
667 if self.mode is None:
668 self.mode = mode
668 self.mode = mode
669 if self.lines:
669 if self.lines:
670 # Normalize line endings
670 # Normalize line endings
671 if self.lines[0].endswith('\r\n'):
671 if self.lines[0].endswith('\r\n'):
672 self.eol = '\r\n'
672 self.eol = '\r\n'
673 elif self.lines[0].endswith('\n'):
673 elif self.lines[0].endswith('\n'):
674 self.eol = '\n'
674 self.eol = '\n'
675 if eolmode != 'strict':
675 if eolmode != 'strict':
676 nlines = []
676 nlines = []
677 for l in self.lines:
677 for l in self.lines:
678 if l.endswith('\r\n'):
678 if l.endswith('\r\n'):
679 l = l[:-2] + '\n'
679 l = l[:-2] + '\n'
680 nlines.append(l)
680 nlines.append(l)
681 self.lines = nlines
681 self.lines = nlines
682 else:
682 else:
683 if self.create:
683 if self.create:
684 self.missing = False
684 self.missing = False
685 if self.mode is None:
685 if self.mode is None:
686 self.mode = (False, False)
686 self.mode = (False, False)
687 if self.missing:
687 if self.missing:
688 self.ui.warn(_("unable to find '%s' for patching\n") % self.fname)
688 self.ui.warn(_("unable to find '%s' for patching\n") % self.fname)
689 self.ui.warn(_("(use '--prefix' to apply patch relative to the "
689 self.ui.warn(_("(use '--prefix' to apply patch relative to the "
690 "current directory)\n"))
690 "current directory)\n"))
691
691
692 self.hash = {}
692 self.hash = {}
693 self.dirty = 0
693 self.dirty = 0
694 self.offset = 0
694 self.offset = 0
695 self.skew = 0
695 self.skew = 0
696 self.rej = []
696 self.rej = []
697 self.fileprinted = False
697 self.fileprinted = False
698 self.printfile(False)
698 self.printfile(False)
699 self.hunks = 0
699 self.hunks = 0
700
700
701 def writelines(self, fname, lines, mode):
701 def writelines(self, fname, lines, mode):
702 if self.eolmode == 'auto':
702 if self.eolmode == 'auto':
703 eol = self.eol
703 eol = self.eol
704 elif self.eolmode == 'crlf':
704 elif self.eolmode == 'crlf':
705 eol = '\r\n'
705 eol = '\r\n'
706 else:
706 else:
707 eol = '\n'
707 eol = '\n'
708
708
709 if self.eolmode != 'strict' and eol and eol != '\n':
709 if self.eolmode != 'strict' and eol and eol != '\n':
710 rawlines = []
710 rawlines = []
711 for l in lines:
711 for l in lines:
712 if l and l.endswith('\n'):
712 if l and l.endswith('\n'):
713 l = l[:-1] + eol
713 l = l[:-1] + eol
714 rawlines.append(l)
714 rawlines.append(l)
715 lines = rawlines
715 lines = rawlines
716
716
717 self.backend.setfile(fname, ''.join(lines), mode, self.copysource)
717 self.backend.setfile(fname, ''.join(lines), mode, self.copysource)
718
718
719 def printfile(self, warn):
719 def printfile(self, warn):
720 if self.fileprinted:
720 if self.fileprinted:
721 return
721 return
722 if warn or self.ui.verbose:
722 if warn or self.ui.verbose:
723 self.fileprinted = True
723 self.fileprinted = True
724 s = _("patching file %s\n") % self.fname
724 s = _("patching file %s\n") % self.fname
725 if warn:
725 if warn:
726 self.ui.warn(s)
726 self.ui.warn(s)
727 else:
727 else:
728 self.ui.note(s)
728 self.ui.note(s)
729
729
730
730
731 def findlines(self, l, linenum):
731 def findlines(self, l, linenum):
732 # looks through the hash and finds candidate lines. The
732 # looks through the hash and finds candidate lines. The
733 # result is a list of line numbers sorted based on distance
733 # result is a list of line numbers sorted based on distance
734 # from linenum
734 # from linenum
735
735
736 cand = self.hash.get(l, [])
736 cand = self.hash.get(l, [])
737 if len(cand) > 1:
737 if len(cand) > 1:
738 # resort our list of potentials forward then back.
738 # resort our list of potentials forward then back.
739 cand.sort(key=lambda x: abs(x - linenum))
739 cand.sort(key=lambda x: abs(x - linenum))
740 return cand
740 return cand
741
741
742 def write_rej(self):
742 def write_rej(self):
743 # our rejects are a little different from patch(1). This always
743 # our rejects are a little different from patch(1). This always
744 # creates rejects in the same form as the original patch. A file
744 # creates rejects in the same form as the original patch. A file
745 # header is inserted so that you can run the reject through patch again
745 # header is inserted so that you can run the reject through patch again
746 # without having to type the filename.
746 # without having to type the filename.
747 if not self.rej:
747 if not self.rej:
748 return
748 return
749 base = os.path.basename(self.fname)
749 base = os.path.basename(self.fname)
750 lines = ["--- %s\n+++ %s\n" % (base, base)]
750 lines = ["--- %s\n+++ %s\n" % (base, base)]
751 for x in self.rej:
751 for x in self.rej:
752 for l in x.hunk:
752 for l in x.hunk:
753 lines.append(l)
753 lines.append(l)
754 if l[-1:] != '\n':
754 if l[-1:] != '\n':
755 lines.append("\n\ No newline at end of file\n")
755 lines.append("\n\ No newline at end of file\n")
756 self.backend.writerej(self.fname, len(self.rej), self.hunks, lines)
756 self.backend.writerej(self.fname, len(self.rej), self.hunks, lines)
757
757
758 def apply(self, h):
758 def apply(self, h):
759 if not h.complete():
759 if not h.complete():
760 raise PatchError(_("bad hunk #%d %s (%d %d %d %d)") %
760 raise PatchError(_("bad hunk #%d %s (%d %d %d %d)") %
761 (h.number, h.desc, len(h.a), h.lena, len(h.b),
761 (h.number, h.desc, len(h.a), h.lena, len(h.b),
762 h.lenb))
762 h.lenb))
763
763
764 self.hunks += 1
764 self.hunks += 1
765
765
766 if self.missing:
766 if self.missing:
767 self.rej.append(h)
767 self.rej.append(h)
768 return -1
768 return -1
769
769
770 if self.exists and self.create:
770 if self.exists and self.create:
771 if self.copysource:
771 if self.copysource:
772 self.ui.warn(_("cannot create %s: destination already "
772 self.ui.warn(_("cannot create %s: destination already "
773 "exists\n") % self.fname)
773 "exists\n") % self.fname)
774 else:
774 else:
775 self.ui.warn(_("file %s already exists\n") % self.fname)
775 self.ui.warn(_("file %s already exists\n") % self.fname)
776 self.rej.append(h)
776 self.rej.append(h)
777 return -1
777 return -1
778
778
779 if isinstance(h, binhunk):
779 if isinstance(h, binhunk):
780 if self.remove:
780 if self.remove:
781 self.backend.unlink(self.fname)
781 self.backend.unlink(self.fname)
782 else:
782 else:
783 l = h.new(self.lines)
783 l = h.new(self.lines)
784 self.lines[:] = l
784 self.lines[:] = l
785 self.offset += len(l)
785 self.offset += len(l)
786 self.dirty = True
786 self.dirty = True
787 return 0
787 return 0
788
788
789 horig = h
789 horig = h
790 if (self.eolmode in ('crlf', 'lf')
790 if (self.eolmode in ('crlf', 'lf')
791 or self.eolmode == 'auto' and self.eol):
791 or self.eolmode == 'auto' and self.eol):
792 # If new eols are going to be normalized, then normalize
792 # If new eols are going to be normalized, then normalize
793 # hunk data before patching. Otherwise, preserve input
793 # hunk data before patching. Otherwise, preserve input
794 # line-endings.
794 # line-endings.
795 h = h.getnormalized()
795 h = h.getnormalized()
796
796
797 # fast case first, no offsets, no fuzz
797 # fast case first, no offsets, no fuzz
798 old, oldstart, new, newstart = h.fuzzit(0, False)
798 old, oldstart, new, newstart = h.fuzzit(0, False)
799 oldstart += self.offset
799 oldstart += self.offset
800 orig_start = oldstart
800 orig_start = oldstart
801 # if there's skew we want to emit the "(offset %d lines)" even
801 # if there's skew we want to emit the "(offset %d lines)" even
802 # when the hunk cleanly applies at start + skew, so skip the
802 # when the hunk cleanly applies at start + skew, so skip the
803 # fast case code
803 # fast case code
804 if self.skew == 0 and diffhelper.testhunk(old, self.lines, oldstart):
804 if self.skew == 0 and diffhelper.testhunk(old, self.lines, oldstart):
805 if self.remove:
805 if self.remove:
806 self.backend.unlink(self.fname)
806 self.backend.unlink(self.fname)
807 else:
807 else:
808 self.lines[oldstart:oldstart + len(old)] = new
808 self.lines[oldstart:oldstart + len(old)] = new
809 self.offset += len(new) - len(old)
809 self.offset += len(new) - len(old)
810 self.dirty = True
810 self.dirty = True
811 return 0
811 return 0
812
812
813 # ok, we couldn't match the hunk. Lets look for offsets and fuzz it
813 # ok, we couldn't match the hunk. Lets look for offsets and fuzz it
814 self.hash = {}
814 self.hash = {}
815 for x, s in enumerate(self.lines):
815 for x, s in enumerate(self.lines):
816 self.hash.setdefault(s, []).append(x)
816 self.hash.setdefault(s, []).append(x)
817
817
818 for fuzzlen in xrange(self.ui.configint("patch", "fuzz") + 1):
818 for fuzzlen in xrange(self.ui.configint("patch", "fuzz") + 1):
819 for toponly in [True, False]:
819 for toponly in [True, False]:
820 old, oldstart, new, newstart = h.fuzzit(fuzzlen, toponly)
820 old, oldstart, new, newstart = h.fuzzit(fuzzlen, toponly)
821 oldstart = oldstart + self.offset + self.skew
821 oldstart = oldstart + self.offset + self.skew
822 oldstart = min(oldstart, len(self.lines))
822 oldstart = min(oldstart, len(self.lines))
823 if old:
823 if old:
824 cand = self.findlines(old[0][1:], oldstart)
824 cand = self.findlines(old[0][1:], oldstart)
825 else:
825 else:
826 # Only adding lines with no or fuzzed context, just
826 # Only adding lines with no or fuzzed context, just
827 # take the skew in account
827 # take the skew in account
828 cand = [oldstart]
828 cand = [oldstart]
829
829
830 for l in cand:
830 for l in cand:
831 if not old or diffhelper.testhunk(old, self.lines, l):
831 if not old or diffhelper.testhunk(old, self.lines, l):
832 self.lines[l : l + len(old)] = new
832 self.lines[l : l + len(old)] = new
833 self.offset += len(new) - len(old)
833 self.offset += len(new) - len(old)
834 self.skew = l - orig_start
834 self.skew = l - orig_start
835 self.dirty = True
835 self.dirty = True
836 offset = l - orig_start - fuzzlen
836 offset = l - orig_start - fuzzlen
837 if fuzzlen:
837 if fuzzlen:
838 msg = _("Hunk #%d succeeded at %d "
838 msg = _("Hunk #%d succeeded at %d "
839 "with fuzz %d "
839 "with fuzz %d "
840 "(offset %d lines).\n")
840 "(offset %d lines).\n")
841 self.printfile(True)
841 self.printfile(True)
842 self.ui.warn(msg %
842 self.ui.warn(msg %
843 (h.number, l + 1, fuzzlen, offset))
843 (h.number, l + 1, fuzzlen, offset))
844 else:
844 else:
845 msg = _("Hunk #%d succeeded at %d "
845 msg = _("Hunk #%d succeeded at %d "
846 "(offset %d lines).\n")
846 "(offset %d lines).\n")
847 self.ui.note(msg % (h.number, l + 1, offset))
847 self.ui.note(msg % (h.number, l + 1, offset))
848 return fuzzlen
848 return fuzzlen
849 self.printfile(True)
849 self.printfile(True)
850 self.ui.warn(_("Hunk #%d FAILED at %d\n") % (h.number, orig_start))
850 self.ui.warn(_("Hunk #%d FAILED at %d\n") % (h.number, orig_start))
851 self.rej.append(horig)
851 self.rej.append(horig)
852 return -1
852 return -1
853
853
854 def close(self):
854 def close(self):
855 if self.dirty:
855 if self.dirty:
856 self.writelines(self.fname, self.lines, self.mode)
856 self.writelines(self.fname, self.lines, self.mode)
857 self.write_rej()
857 self.write_rej()
858 return len(self.rej)
858 return len(self.rej)
859
859
860 class header(object):
860 class header(object):
861 """patch header
861 """patch header
862 """
862 """
863 diffgit_re = re.compile('diff --git a/(.*) b/(.*)$')
863 diffgit_re = re.compile('diff --git a/(.*) b/(.*)$')
864 diff_re = re.compile('diff -r .* (.*)$')
864 diff_re = re.compile('diff -r .* (.*)$')
865 allhunks_re = re.compile('(?:index|deleted file) ')
865 allhunks_re = re.compile('(?:index|deleted file) ')
866 pretty_re = re.compile('(?:new file|deleted file) ')
866 pretty_re = re.compile('(?:new file|deleted file) ')
867 special_re = re.compile('(?:index|deleted|copy|rename) ')
867 special_re = re.compile('(?:index|deleted|copy|rename) ')
868 newfile_re = re.compile('(?:new file)')
868 newfile_re = re.compile('(?:new file)')
869
869
870 def __init__(self, header):
870 def __init__(self, header):
871 self.header = header
871 self.header = header
872 self.hunks = []
872 self.hunks = []
873
873
874 def binary(self):
874 def binary(self):
875 return any(h.startswith('index ') for h in self.header)
875 return any(h.startswith('index ') for h in self.header)
876
876
877 def pretty(self, fp):
877 def pretty(self, fp):
878 for h in self.header:
878 for h in self.header:
879 if h.startswith('index '):
879 if h.startswith('index '):
880 fp.write(_('this modifies a binary file (all or nothing)\n'))
880 fp.write(_('this modifies a binary file (all or nothing)\n'))
881 break
881 break
882 if self.pretty_re.match(h):
882 if self.pretty_re.match(h):
883 fp.write(h)
883 fp.write(h)
884 if self.binary():
884 if self.binary():
885 fp.write(_('this is a binary file\n'))
885 fp.write(_('this is a binary file\n'))
886 break
886 break
887 if h.startswith('---'):
887 if h.startswith('---'):
888 fp.write(_('%d hunks, %d lines changed\n') %
888 fp.write(_('%d hunks, %d lines changed\n') %
889 (len(self.hunks),
889 (len(self.hunks),
890 sum([max(h.added, h.removed) for h in self.hunks])))
890 sum([max(h.added, h.removed) for h in self.hunks])))
891 break
891 break
892 fp.write(h)
892 fp.write(h)
893
893
894 def write(self, fp):
894 def write(self, fp):
895 fp.write(''.join(self.header))
895 fp.write(''.join(self.header))
896
896
897 def allhunks(self):
897 def allhunks(self):
898 return any(self.allhunks_re.match(h) for h in self.header)
898 return any(self.allhunks_re.match(h) for h in self.header)
899
899
900 def files(self):
900 def files(self):
901 match = self.diffgit_re.match(self.header[0])
901 match = self.diffgit_re.match(self.header[0])
902 if match:
902 if match:
903 fromfile, tofile = match.groups()
903 fromfile, tofile = match.groups()
904 if fromfile == tofile:
904 if fromfile == tofile:
905 return [fromfile]
905 return [fromfile]
906 return [fromfile, tofile]
906 return [fromfile, tofile]
907 else:
907 else:
908 return self.diff_re.match(self.header[0]).groups()
908 return self.diff_re.match(self.header[0]).groups()
909
909
910 def filename(self):
910 def filename(self):
911 return self.files()[-1]
911 return self.files()[-1]
912
912
913 def __repr__(self):
913 def __repr__(self):
914 return '<header %s>' % (' '.join(map(repr, self.files())))
914 return '<header %s>' % (' '.join(map(repr, self.files())))
915
915
916 def isnewfile(self):
916 def isnewfile(self):
917 return any(self.newfile_re.match(h) for h in self.header)
917 return any(self.newfile_re.match(h) for h in self.header)
918
918
919 def special(self):
919 def special(self):
920 # Special files are shown only at the header level and not at the hunk
920 # Special files are shown only at the header level and not at the hunk
921 # level for example a file that has been deleted is a special file.
921 # level for example a file that has been deleted is a special file.
922 # The user cannot change the content of the operation, in the case of
922 # The user cannot change the content of the operation, in the case of
923 # the deleted file he has to take the deletion or not take it, he
923 # the deleted file he has to take the deletion or not take it, he
924 # cannot take some of it.
924 # cannot take some of it.
925 # Newly added files are special if they are empty, they are not special
925 # Newly added files are special if they are empty, they are not special
926 # if they have some content as we want to be able to change it
926 # if they have some content as we want to be able to change it
927 nocontent = len(self.header) == 2
927 nocontent = len(self.header) == 2
928 emptynewfile = self.isnewfile() and nocontent
928 emptynewfile = self.isnewfile() and nocontent
929 return emptynewfile or \
929 return emptynewfile or \
930 any(self.special_re.match(h) for h in self.header)
930 any(self.special_re.match(h) for h in self.header)
931
931
932 class recordhunk(object):
932 class recordhunk(object):
933 """patch hunk
933 """patch hunk
934
934
935 XXX shouldn't we merge this with the other hunk class?
935 XXX shouldn't we merge this with the other hunk class?
936 """
936 """
937
937
938 def __init__(self, header, fromline, toline, proc, before, hunk, after,
938 def __init__(self, header, fromline, toline, proc, before, hunk, after,
939 maxcontext=None):
939 maxcontext=None):
940 def trimcontext(lines, reverse=False):
940 def trimcontext(lines, reverse=False):
941 if maxcontext is not None:
941 if maxcontext is not None:
942 delta = len(lines) - maxcontext
942 delta = len(lines) - maxcontext
943 if delta > 0:
943 if delta > 0:
944 if reverse:
944 if reverse:
945 return delta, lines[delta:]
945 return delta, lines[delta:]
946 else:
946 else:
947 return delta, lines[:maxcontext]
947 return delta, lines[:maxcontext]
948 return 0, lines
948 return 0, lines
949
949
950 self.header = header
950 self.header = header
951 trimedbefore, self.before = trimcontext(before, True)
951 trimedbefore, self.before = trimcontext(before, True)
952 self.fromline = fromline + trimedbefore
952 self.fromline = fromline + trimedbefore
953 self.toline = toline + trimedbefore
953 self.toline = toline + trimedbefore
954 _trimedafter, self.after = trimcontext(after, False)
954 _trimedafter, self.after = trimcontext(after, False)
955 self.proc = proc
955 self.proc = proc
956 self.hunk = hunk
956 self.hunk = hunk
957 self.added, self.removed = self.countchanges(self.hunk)
957 self.added, self.removed = self.countchanges(self.hunk)
958
958
959 def __eq__(self, v):
959 def __eq__(self, v):
960 if not isinstance(v, recordhunk):
960 if not isinstance(v, recordhunk):
961 return False
961 return False
962
962
963 return ((v.hunk == self.hunk) and
963 return ((v.hunk == self.hunk) and
964 (v.proc == self.proc) and
964 (v.proc == self.proc) and
965 (self.fromline == v.fromline) and
965 (self.fromline == v.fromline) and
966 (self.header.files() == v.header.files()))
966 (self.header.files() == v.header.files()))
967
967
968 def __hash__(self):
968 def __hash__(self):
969 return hash((tuple(self.hunk),
969 return hash((tuple(self.hunk),
970 tuple(self.header.files()),
970 tuple(self.header.files()),
971 self.fromline,
971 self.fromline,
972 self.proc))
972 self.proc))
973
973
974 def countchanges(self, hunk):
974 def countchanges(self, hunk):
975 """hunk -> (n+,n-)"""
975 """hunk -> (n+,n-)"""
976 add = len([h for h in hunk if h.startswith('+')])
976 add = len([h for h in hunk if h.startswith('+')])
977 rem = len([h for h in hunk if h.startswith('-')])
977 rem = len([h for h in hunk if h.startswith('-')])
978 return add, rem
978 return add, rem
979
979
980 def reversehunk(self):
980 def reversehunk(self):
981 """return another recordhunk which is the reverse of the hunk
981 """return another recordhunk which is the reverse of the hunk
982
982
983 If this hunk is diff(A, B), the returned hunk is diff(B, A). To do
983 If this hunk is diff(A, B), the returned hunk is diff(B, A). To do
984 that, swap fromline/toline and +/- signs while keep other things
984 that, swap fromline/toline and +/- signs while keep other things
985 unchanged.
985 unchanged.
986 """
986 """
987 m = {'+': '-', '-': '+', '\\': '\\'}
987 m = {'+': '-', '-': '+', '\\': '\\'}
988 hunk = ['%s%s' % (m[l[0:1]], l[1:]) for l in self.hunk]
988 hunk = ['%s%s' % (m[l[0:1]], l[1:]) for l in self.hunk]
989 return recordhunk(self.header, self.toline, self.fromline, self.proc,
989 return recordhunk(self.header, self.toline, self.fromline, self.proc,
990 self.before, hunk, self.after)
990 self.before, hunk, self.after)
991
991
992 def write(self, fp):
992 def write(self, fp):
993 delta = len(self.before) + len(self.after)
993 delta = len(self.before) + len(self.after)
994 if self.after and self.after[-1] == '\\ No newline at end of file\n':
994 if self.after and self.after[-1] == '\\ No newline at end of file\n':
995 delta -= 1
995 delta -= 1
996 fromlen = delta + self.removed
996 fromlen = delta + self.removed
997 tolen = delta + self.added
997 tolen = delta + self.added
998 fp.write('@@ -%d,%d +%d,%d @@%s\n' %
998 fp.write('@@ -%d,%d +%d,%d @@%s\n' %
999 (self.fromline, fromlen, self.toline, tolen,
999 (self.fromline, fromlen, self.toline, tolen,
1000 self.proc and (' ' + self.proc)))
1000 self.proc and (' ' + self.proc)))
1001 fp.write(''.join(self.before + self.hunk + self.after))
1001 fp.write(''.join(self.before + self.hunk + self.after))
1002
1002
1003 pretty = write
1003 pretty = write
1004
1004
1005 def filename(self):
1005 def filename(self):
1006 return self.header.filename()
1006 return self.header.filename()
1007
1007
1008 def __repr__(self):
1008 def __repr__(self):
1009 return '<hunk %r@%d>' % (self.filename(), self.fromline)
1009 return '<hunk %r@%d>' % (self.filename(), self.fromline)
1010
1010
1011 def getmessages():
1011 def getmessages():
1012 return {
1012 return {
1013 'multiple': {
1013 'multiple': {
1014 'apply': _("apply change %d/%d to '%s'?"),
1014 'apply': _("apply change %d/%d to '%s'?"),
1015 'discard': _("discard change %d/%d to '%s'?"),
1015 'discard': _("discard change %d/%d to '%s'?"),
1016 'record': _("record change %d/%d to '%s'?"),
1016 'record': _("record change %d/%d to '%s'?"),
1017 },
1017 },
1018 'single': {
1018 'single': {
1019 'apply': _("apply this change to '%s'?"),
1019 'apply': _("apply this change to '%s'?"),
1020 'discard': _("discard this change to '%s'?"),
1020 'discard': _("discard this change to '%s'?"),
1021 'record': _("record this change to '%s'?"),
1021 'record': _("record this change to '%s'?"),
1022 },
1022 },
1023 'help': {
1023 'help': {
1024 'apply': _('[Ynesfdaq?]'
1024 'apply': _('[Ynesfdaq?]'
1025 '$$ &Yes, apply this change'
1025 '$$ &Yes, apply this change'
1026 '$$ &No, skip this change'
1026 '$$ &No, skip this change'
1027 '$$ &Edit this change manually'
1027 '$$ &Edit this change manually'
1028 '$$ &Skip remaining changes to this file'
1028 '$$ &Skip remaining changes to this file'
1029 '$$ Apply remaining changes to this &file'
1029 '$$ Apply remaining changes to this &file'
1030 '$$ &Done, skip remaining changes and files'
1030 '$$ &Done, skip remaining changes and files'
1031 '$$ Apply &all changes to all remaining files'
1031 '$$ Apply &all changes to all remaining files'
1032 '$$ &Quit, applying no changes'
1032 '$$ &Quit, applying no changes'
1033 '$$ &? (display help)'),
1033 '$$ &? (display help)'),
1034 'discard': _('[Ynesfdaq?]'
1034 'discard': _('[Ynesfdaq?]'
1035 '$$ &Yes, discard this change'
1035 '$$ &Yes, discard this change'
1036 '$$ &No, skip this change'
1036 '$$ &No, skip this change'
1037 '$$ &Edit this change manually'
1037 '$$ &Edit this change manually'
1038 '$$ &Skip remaining changes to this file'
1038 '$$ &Skip remaining changes to this file'
1039 '$$ Discard remaining changes to this &file'
1039 '$$ Discard remaining changes to this &file'
1040 '$$ &Done, skip remaining changes and files'
1040 '$$ &Done, skip remaining changes and files'
1041 '$$ Discard &all changes to all remaining files'
1041 '$$ Discard &all changes to all remaining files'
1042 '$$ &Quit, discarding no changes'
1042 '$$ &Quit, discarding no changes'
1043 '$$ &? (display help)'),
1043 '$$ &? (display help)'),
1044 'record': _('[Ynesfdaq?]'
1044 'record': _('[Ynesfdaq?]'
1045 '$$ &Yes, record this change'
1045 '$$ &Yes, record this change'
1046 '$$ &No, skip this change'
1046 '$$ &No, skip this change'
1047 '$$ &Edit this change manually'
1047 '$$ &Edit this change manually'
1048 '$$ &Skip remaining changes to this file'
1048 '$$ &Skip remaining changes to this file'
1049 '$$ Record remaining changes to this &file'
1049 '$$ Record remaining changes to this &file'
1050 '$$ &Done, skip remaining changes and files'
1050 '$$ &Done, skip remaining changes and files'
1051 '$$ Record &all changes to all remaining files'
1051 '$$ Record &all changes to all remaining files'
1052 '$$ &Quit, recording no changes'
1052 '$$ &Quit, recording no changes'
1053 '$$ &? (display help)'),
1053 '$$ &? (display help)'),
1054 }
1054 }
1055 }
1055 }
1056
1056
1057 def filterpatch(ui, headers, operation=None):
1057 def filterpatch(ui, headers, operation=None):
1058 """Interactively filter patch chunks into applied-only chunks"""
1058 """Interactively filter patch chunks into applied-only chunks"""
1059 messages = getmessages()
1059 messages = getmessages()
1060
1060
1061 if operation is None:
1061 if operation is None:
1062 operation = 'record'
1062 operation = 'record'
1063
1063
1064 def prompt(skipfile, skipall, query, chunk):
1064 def prompt(skipfile, skipall, query, chunk):
1065 """prompt query, and process base inputs
1065 """prompt query, and process base inputs
1066
1066
1067 - y/n for the rest of file
1067 - y/n for the rest of file
1068 - y/n for the rest
1068 - y/n for the rest
1069 - ? (help)
1069 - ? (help)
1070 - q (quit)
1070 - q (quit)
1071
1071
1072 Return True/False and possibly updated skipfile and skipall.
1072 Return True/False and possibly updated skipfile and skipall.
1073 """
1073 """
1074 newpatches = None
1074 newpatches = None
1075 if skipall is not None:
1075 if skipall is not None:
1076 return skipall, skipfile, skipall, newpatches
1076 return skipall, skipfile, skipall, newpatches
1077 if skipfile is not None:
1077 if skipfile is not None:
1078 return skipfile, skipfile, skipall, newpatches
1078 return skipfile, skipfile, skipall, newpatches
1079 while True:
1079 while True:
1080 resps = messages['help'][operation]
1080 resps = messages['help'][operation]
1081 r = ui.promptchoice("%s %s" % (query, resps))
1081 r = ui.promptchoice("%s %s" % (query, resps))
1082 ui.write("\n")
1082 ui.write("\n")
1083 if r == 8: # ?
1083 if r == 8: # ?
1084 for c, t in ui.extractchoices(resps)[1]:
1084 for c, t in ui.extractchoices(resps)[1]:
1085 ui.write('%s - %s\n' % (c, encoding.lower(t)))
1085 ui.write('%s - %s\n' % (c, encoding.lower(t)))
1086 continue
1086 continue
1087 elif r == 0: # yes
1087 elif r == 0: # yes
1088 ret = True
1088 ret = True
1089 elif r == 1: # no
1089 elif r == 1: # no
1090 ret = False
1090 ret = False
1091 elif r == 2: # Edit patch
1091 elif r == 2: # Edit patch
1092 if chunk is None:
1092 if chunk is None:
1093 ui.write(_('cannot edit patch for whole file'))
1093 ui.write(_('cannot edit patch for whole file'))
1094 ui.write("\n")
1094 ui.write("\n")
1095 continue
1095 continue
1096 if chunk.header.binary():
1096 if chunk.header.binary():
1097 ui.write(_('cannot edit patch for binary file'))
1097 ui.write(_('cannot edit patch for binary file'))
1098 ui.write("\n")
1098 ui.write("\n")
1099 continue
1099 continue
1100 # Patch comment based on the Git one (based on comment at end of
1100 # Patch comment based on the Git one (based on comment at end of
1101 # https://mercurial-scm.org/wiki/RecordExtension)
1101 # https://mercurial-scm.org/wiki/RecordExtension)
1102 phelp = '---' + _("""
1102 phelp = '---' + _("""
1103 To remove '-' lines, make them ' ' lines (context).
1103 To remove '-' lines, make them ' ' lines (context).
1104 To remove '+' lines, delete them.
1104 To remove '+' lines, delete them.
1105 Lines starting with # will be removed from the patch.
1105 Lines starting with # will be removed from the patch.
1106
1106
1107 If the patch applies cleanly, the edited hunk will immediately be
1107 If the patch applies cleanly, the edited hunk will immediately be
1108 added to the record list. If it does not apply cleanly, a rejects
1108 added to the record list. If it does not apply cleanly, a rejects
1109 file will be generated: you can use that when you try again. If
1109 file will be generated: you can use that when you try again. If
1110 all lines of the hunk are removed, then the edit is aborted and
1110 all lines of the hunk are removed, then the edit is aborted and
1111 the hunk is left unchanged.
1111 the hunk is left unchanged.
1112 """)
1112 """)
1113 (patchfd, patchfn) = pycompat.mkstemp(prefix="hg-editor-",
1113 (patchfd, patchfn) = pycompat.mkstemp(prefix="hg-editor-",
1114 suffix=".diff")
1114 suffix=".diff")
1115 ncpatchfp = None
1115 ncpatchfp = None
1116 try:
1116 try:
1117 # Write the initial patch
1117 # Write the initial patch
1118 f = util.nativeeolwriter(os.fdopen(patchfd, r'wb'))
1118 f = util.nativeeolwriter(os.fdopen(patchfd, r'wb'))
1119 chunk.header.write(f)
1119 chunk.header.write(f)
1120 chunk.write(f)
1120 chunk.write(f)
1121 f.write('\n'.join(['# ' + i for i in phelp.splitlines()]))
1121 f.write('\n'.join(['# ' + i for i in phelp.splitlines()]))
1122 f.close()
1122 f.close()
1123 # Start the editor and wait for it to complete
1123 # Start the editor and wait for it to complete
1124 editor = ui.geteditor()
1124 editor = ui.geteditor()
1125 ret = ui.system("%s \"%s\"" % (editor, patchfn),
1125 ret = ui.system("%s \"%s\"" % (editor, patchfn),
1126 environ={'HGUSER': ui.username()},
1126 environ={'HGUSER': ui.username()},
1127 blockedtag='filterpatch')
1127 blockedtag='filterpatch')
1128 if ret != 0:
1128 if ret != 0:
1129 ui.warn(_("editor exited with exit code %d\n") % ret)
1129 ui.warn(_("editor exited with exit code %d\n") % ret)
1130 continue
1130 continue
1131 # Remove comment lines
1131 # Remove comment lines
1132 patchfp = open(patchfn, r'rb')
1132 patchfp = open(patchfn, r'rb')
1133 ncpatchfp = stringio()
1133 ncpatchfp = stringio()
1134 for line in util.iterfile(patchfp):
1134 for line in util.iterfile(patchfp):
1135 line = util.fromnativeeol(line)
1135 line = util.fromnativeeol(line)
1136 if not line.startswith('#'):
1136 if not line.startswith('#'):
1137 ncpatchfp.write(line)
1137 ncpatchfp.write(line)
1138 patchfp.close()
1138 patchfp.close()
1139 ncpatchfp.seek(0)
1139 ncpatchfp.seek(0)
1140 newpatches = parsepatch(ncpatchfp)
1140 newpatches = parsepatch(ncpatchfp)
1141 finally:
1141 finally:
1142 os.unlink(patchfn)
1142 os.unlink(patchfn)
1143 del ncpatchfp
1143 del ncpatchfp
1144 # Signal that the chunk shouldn't be applied as-is, but
1144 # Signal that the chunk shouldn't be applied as-is, but
1145 # provide the new patch to be used instead.
1145 # provide the new patch to be used instead.
1146 ret = False
1146 ret = False
1147 elif r == 3: # Skip
1147 elif r == 3: # Skip
1148 ret = skipfile = False
1148 ret = skipfile = False
1149 elif r == 4: # file (Record remaining)
1149 elif r == 4: # file (Record remaining)
1150 ret = skipfile = True
1150 ret = skipfile = True
1151 elif r == 5: # done, skip remaining
1151 elif r == 5: # done, skip remaining
1152 ret = skipall = False
1152 ret = skipall = False
1153 elif r == 6: # all
1153 elif r == 6: # all
1154 ret = skipall = True
1154 ret = skipall = True
1155 elif r == 7: # quit
1155 elif r == 7: # quit
1156 raise error.Abort(_('user quit'))
1156 raise error.Abort(_('user quit'))
1157 return ret, skipfile, skipall, newpatches
1157 return ret, skipfile, skipall, newpatches
1158
1158
1159 seen = set()
1159 seen = set()
1160 applied = {} # 'filename' -> [] of chunks
1160 applied = {} # 'filename' -> [] of chunks
1161 skipfile, skipall = None, None
1161 skipfile, skipall = None, None
1162 pos, total = 1, sum(len(h.hunks) for h in headers)
1162 pos, total = 1, sum(len(h.hunks) for h in headers)
1163 for h in headers:
1163 for h in headers:
1164 pos += len(h.hunks)
1164 pos += len(h.hunks)
1165 skipfile = None
1165 skipfile = None
1166 fixoffset = 0
1166 fixoffset = 0
1167 hdr = ''.join(h.header)
1167 hdr = ''.join(h.header)
1168 if hdr in seen:
1168 if hdr in seen:
1169 continue
1169 continue
1170 seen.add(hdr)
1170 seen.add(hdr)
1171 if skipall is None:
1171 if skipall is None:
1172 h.pretty(ui)
1172 h.pretty(ui)
1173 msg = (_('examine changes to %s?') %
1173 msg = (_('examine changes to %s?') %
1174 _(' and ').join("'%s'" % f for f in h.files()))
1174 _(' and ').join("'%s'" % f for f in h.files()))
1175 r, skipfile, skipall, np = prompt(skipfile, skipall, msg, None)
1175 r, skipfile, skipall, np = prompt(skipfile, skipall, msg, None)
1176 if not r:
1176 if not r:
1177 continue
1177 continue
1178 applied[h.filename()] = [h]
1178 applied[h.filename()] = [h]
1179 if h.allhunks():
1179 if h.allhunks():
1180 applied[h.filename()] += h.hunks
1180 applied[h.filename()] += h.hunks
1181 continue
1181 continue
1182 for i, chunk in enumerate(h.hunks):
1182 for i, chunk in enumerate(h.hunks):
1183 if skipfile is None and skipall is None:
1183 if skipfile is None and skipall is None:
1184 chunk.pretty(ui)
1184 chunk.pretty(ui)
1185 if total == 1:
1185 if total == 1:
1186 msg = messages['single'][operation] % chunk.filename()
1186 msg = messages['single'][operation] % chunk.filename()
1187 else:
1187 else:
1188 idx = pos - len(h.hunks) + i
1188 idx = pos - len(h.hunks) + i
1189 msg = messages['multiple'][operation] % (idx, total,
1189 msg = messages['multiple'][operation] % (idx, total,
1190 chunk.filename())
1190 chunk.filename())
1191 r, skipfile, skipall, newpatches = prompt(skipfile,
1191 r, skipfile, skipall, newpatches = prompt(skipfile,
1192 skipall, msg, chunk)
1192 skipall, msg, chunk)
1193 if r:
1193 if r:
1194 if fixoffset:
1194 if fixoffset:
1195 chunk = copy.copy(chunk)
1195 chunk = copy.copy(chunk)
1196 chunk.toline += fixoffset
1196 chunk.toline += fixoffset
1197 applied[chunk.filename()].append(chunk)
1197 applied[chunk.filename()].append(chunk)
1198 elif newpatches is not None:
1198 elif newpatches is not None:
1199 for newpatch in newpatches:
1199 for newpatch in newpatches:
1200 for newhunk in newpatch.hunks:
1200 for newhunk in newpatch.hunks:
1201 if fixoffset:
1201 if fixoffset:
1202 newhunk.toline += fixoffset
1202 newhunk.toline += fixoffset
1203 applied[newhunk.filename()].append(newhunk)
1203 applied[newhunk.filename()].append(newhunk)
1204 else:
1204 else:
1205 fixoffset += chunk.removed - chunk.added
1205 fixoffset += chunk.removed - chunk.added
1206 return (sum([h for h in applied.itervalues()
1206 return (sum([h for h in applied.itervalues()
1207 if h[0].special() or len(h) > 1], []), {})
1207 if h[0].special() or len(h) > 1], []), {})
1208 class hunk(object):
1208 class hunk(object):
1209 def __init__(self, desc, num, lr, context):
1209 def __init__(self, desc, num, lr, context):
1210 self.number = num
1210 self.number = num
1211 self.desc = desc
1211 self.desc = desc
1212 self.hunk = [desc]
1212 self.hunk = [desc]
1213 self.a = []
1213 self.a = []
1214 self.b = []
1214 self.b = []
1215 self.starta = self.lena = None
1215 self.starta = self.lena = None
1216 self.startb = self.lenb = None
1216 self.startb = self.lenb = None
1217 if lr is not None:
1217 if lr is not None:
1218 if context:
1218 if context:
1219 self.read_context_hunk(lr)
1219 self.read_context_hunk(lr)
1220 else:
1220 else:
1221 self.read_unified_hunk(lr)
1221 self.read_unified_hunk(lr)
1222
1222
1223 def getnormalized(self):
1223 def getnormalized(self):
1224 """Return a copy with line endings normalized to LF."""
1224 """Return a copy with line endings normalized to LF."""
1225
1225
1226 def normalize(lines):
1226 def normalize(lines):
1227 nlines = []
1227 nlines = []
1228 for line in lines:
1228 for line in lines:
1229 if line.endswith('\r\n'):
1229 if line.endswith('\r\n'):
1230 line = line[:-2] + '\n'
1230 line = line[:-2] + '\n'
1231 nlines.append(line)
1231 nlines.append(line)
1232 return nlines
1232 return nlines
1233
1233
1234 # Dummy object, it is rebuilt manually
1234 # Dummy object, it is rebuilt manually
1235 nh = hunk(self.desc, self.number, None, None)
1235 nh = hunk(self.desc, self.number, None, None)
1236 nh.number = self.number
1236 nh.number = self.number
1237 nh.desc = self.desc
1237 nh.desc = self.desc
1238 nh.hunk = self.hunk
1238 nh.hunk = self.hunk
1239 nh.a = normalize(self.a)
1239 nh.a = normalize(self.a)
1240 nh.b = normalize(self.b)
1240 nh.b = normalize(self.b)
1241 nh.starta = self.starta
1241 nh.starta = self.starta
1242 nh.startb = self.startb
1242 nh.startb = self.startb
1243 nh.lena = self.lena
1243 nh.lena = self.lena
1244 nh.lenb = self.lenb
1244 nh.lenb = self.lenb
1245 return nh
1245 return nh
1246
1246
1247 def read_unified_hunk(self, lr):
1247 def read_unified_hunk(self, lr):
1248 m = unidesc.match(self.desc)
1248 m = unidesc.match(self.desc)
1249 if not m:
1249 if not m:
1250 raise PatchError(_("bad hunk #%d") % self.number)
1250 raise PatchError(_("bad hunk #%d") % self.number)
1251 self.starta, self.lena, self.startb, self.lenb = m.groups()
1251 self.starta, self.lena, self.startb, self.lenb = m.groups()
1252 if self.lena is None:
1252 if self.lena is None:
1253 self.lena = 1
1253 self.lena = 1
1254 else:
1254 else:
1255 self.lena = int(self.lena)
1255 self.lena = int(self.lena)
1256 if self.lenb is None:
1256 if self.lenb is None:
1257 self.lenb = 1
1257 self.lenb = 1
1258 else:
1258 else:
1259 self.lenb = int(self.lenb)
1259 self.lenb = int(self.lenb)
1260 self.starta = int(self.starta)
1260 self.starta = int(self.starta)
1261 self.startb = int(self.startb)
1261 self.startb = int(self.startb)
1262 try:
1262 try:
1263 diffhelper.addlines(lr, self.hunk, self.lena, self.lenb,
1263 diffhelper.addlines(lr, self.hunk, self.lena, self.lenb,
1264 self.a, self.b)
1264 self.a, self.b)
1265 except error.ParseError as e:
1265 except error.ParseError as e:
1266 raise PatchError(_("bad hunk #%d: %s") % (self.number, e))
1266 raise PatchError(_("bad hunk #%d: %s") % (self.number, e))
1267 # if we hit eof before finishing out the hunk, the last line will
1267 # if we hit eof before finishing out the hunk, the last line will
1268 # be zero length. Lets try to fix it up.
1268 # be zero length. Lets try to fix it up.
1269 while len(self.hunk[-1]) == 0:
1269 while len(self.hunk[-1]) == 0:
1270 del self.hunk[-1]
1270 del self.hunk[-1]
1271 del self.a[-1]
1271 del self.a[-1]
1272 del self.b[-1]
1272 del self.b[-1]
1273 self.lena -= 1
1273 self.lena -= 1
1274 self.lenb -= 1
1274 self.lenb -= 1
1275 self._fixnewline(lr)
1275 self._fixnewline(lr)
1276
1276
1277 def read_context_hunk(self, lr):
1277 def read_context_hunk(self, lr):
1278 self.desc = lr.readline()
1278 self.desc = lr.readline()
1279 m = contextdesc.match(self.desc)
1279 m = contextdesc.match(self.desc)
1280 if not m:
1280 if not m:
1281 raise PatchError(_("bad hunk #%d") % self.number)
1281 raise PatchError(_("bad hunk #%d") % self.number)
1282 self.starta, aend = m.groups()
1282 self.starta, aend = m.groups()
1283 self.starta = int(self.starta)
1283 self.starta = int(self.starta)
1284 if aend is None:
1284 if aend is None:
1285 aend = self.starta
1285 aend = self.starta
1286 self.lena = int(aend) - self.starta
1286 self.lena = int(aend) - self.starta
1287 if self.starta:
1287 if self.starta:
1288 self.lena += 1
1288 self.lena += 1
1289 for x in xrange(self.lena):
1289 for x in xrange(self.lena):
1290 l = lr.readline()
1290 l = lr.readline()
1291 if l.startswith('---'):
1291 if l.startswith('---'):
1292 # lines addition, old block is empty
1292 # lines addition, old block is empty
1293 lr.push(l)
1293 lr.push(l)
1294 break
1294 break
1295 s = l[2:]
1295 s = l[2:]
1296 if l.startswith('- ') or l.startswith('! '):
1296 if l.startswith('- ') or l.startswith('! '):
1297 u = '-' + s
1297 u = '-' + s
1298 elif l.startswith(' '):
1298 elif l.startswith(' '):
1299 u = ' ' + s
1299 u = ' ' + s
1300 else:
1300 else:
1301 raise PatchError(_("bad hunk #%d old text line %d") %
1301 raise PatchError(_("bad hunk #%d old text line %d") %
1302 (self.number, x))
1302 (self.number, x))
1303 self.a.append(u)
1303 self.a.append(u)
1304 self.hunk.append(u)
1304 self.hunk.append(u)
1305
1305
1306 l = lr.readline()
1306 l = lr.readline()
1307 if l.startswith('\ '):
1307 if l.startswith('\ '):
1308 s = self.a[-1][:-1]
1308 s = self.a[-1][:-1]
1309 self.a[-1] = s
1309 self.a[-1] = s
1310 self.hunk[-1] = s
1310 self.hunk[-1] = s
1311 l = lr.readline()
1311 l = lr.readline()
1312 m = contextdesc.match(l)
1312 m = contextdesc.match(l)
1313 if not m:
1313 if not m:
1314 raise PatchError(_("bad hunk #%d") % self.number)
1314 raise PatchError(_("bad hunk #%d") % self.number)
1315 self.startb, bend = m.groups()
1315 self.startb, bend = m.groups()
1316 self.startb = int(self.startb)
1316 self.startb = int(self.startb)
1317 if bend is None:
1317 if bend is None:
1318 bend = self.startb
1318 bend = self.startb
1319 self.lenb = int(bend) - self.startb
1319 self.lenb = int(bend) - self.startb
1320 if self.startb:
1320 if self.startb:
1321 self.lenb += 1
1321 self.lenb += 1
1322 hunki = 1
1322 hunki = 1
1323 for x in xrange(self.lenb):
1323 for x in xrange(self.lenb):
1324 l = lr.readline()
1324 l = lr.readline()
1325 if l.startswith('\ '):
1325 if l.startswith('\ '):
1326 # XXX: the only way to hit this is with an invalid line range.
1326 # XXX: the only way to hit this is with an invalid line range.
1327 # The no-eol marker is not counted in the line range, but I
1327 # The no-eol marker is not counted in the line range, but I
1328 # guess there are diff(1) out there which behave differently.
1328 # guess there are diff(1) out there which behave differently.
1329 s = self.b[-1][:-1]
1329 s = self.b[-1][:-1]
1330 self.b[-1] = s
1330 self.b[-1] = s
1331 self.hunk[hunki - 1] = s
1331 self.hunk[hunki - 1] = s
1332 continue
1332 continue
1333 if not l:
1333 if not l:
1334 # line deletions, new block is empty and we hit EOF
1334 # line deletions, new block is empty and we hit EOF
1335 lr.push(l)
1335 lr.push(l)
1336 break
1336 break
1337 s = l[2:]
1337 s = l[2:]
1338 if l.startswith('+ ') or l.startswith('! '):
1338 if l.startswith('+ ') or l.startswith('! '):
1339 u = '+' + s
1339 u = '+' + s
1340 elif l.startswith(' '):
1340 elif l.startswith(' '):
1341 u = ' ' + s
1341 u = ' ' + s
1342 elif len(self.b) == 0:
1342 elif len(self.b) == 0:
1343 # line deletions, new block is empty
1343 # line deletions, new block is empty
1344 lr.push(l)
1344 lr.push(l)
1345 break
1345 break
1346 else:
1346 else:
1347 raise PatchError(_("bad hunk #%d old text line %d") %
1347 raise PatchError(_("bad hunk #%d old text line %d") %
1348 (self.number, x))
1348 (self.number, x))
1349 self.b.append(s)
1349 self.b.append(s)
1350 while True:
1350 while True:
1351 if hunki >= len(self.hunk):
1351 if hunki >= len(self.hunk):
1352 h = ""
1352 h = ""
1353 else:
1353 else:
1354 h = self.hunk[hunki]
1354 h = self.hunk[hunki]
1355 hunki += 1
1355 hunki += 1
1356 if h == u:
1356 if h == u:
1357 break
1357 break
1358 elif h.startswith('-'):
1358 elif h.startswith('-'):
1359 continue
1359 continue
1360 else:
1360 else:
1361 self.hunk.insert(hunki - 1, u)
1361 self.hunk.insert(hunki - 1, u)
1362 break
1362 break
1363
1363
1364 if not self.a:
1364 if not self.a:
1365 # this happens when lines were only added to the hunk
1365 # this happens when lines were only added to the hunk
1366 for x in self.hunk:
1366 for x in self.hunk:
1367 if x.startswith('-') or x.startswith(' '):
1367 if x.startswith('-') or x.startswith(' '):
1368 self.a.append(x)
1368 self.a.append(x)
1369 if not self.b:
1369 if not self.b:
1370 # this happens when lines were only deleted from the hunk
1370 # this happens when lines were only deleted from the hunk
1371 for x in self.hunk:
1371 for x in self.hunk:
1372 if x.startswith('+') or x.startswith(' '):
1372 if x.startswith('+') or x.startswith(' '):
1373 self.b.append(x[1:])
1373 self.b.append(x[1:])
1374 # @@ -start,len +start,len @@
1374 # @@ -start,len +start,len @@
1375 self.desc = "@@ -%d,%d +%d,%d @@\n" % (self.starta, self.lena,
1375 self.desc = "@@ -%d,%d +%d,%d @@\n" % (self.starta, self.lena,
1376 self.startb, self.lenb)
1376 self.startb, self.lenb)
1377 self.hunk[0] = self.desc
1377 self.hunk[0] = self.desc
1378 self._fixnewline(lr)
1378 self._fixnewline(lr)
1379
1379
1380 def _fixnewline(self, lr):
1380 def _fixnewline(self, lr):
1381 l = lr.readline()
1381 l = lr.readline()
1382 if l.startswith('\ '):
1382 if l.startswith('\ '):
1383 diffhelper.fixnewline(self.hunk, self.a, self.b)
1383 diffhelper.fixnewline(self.hunk, self.a, self.b)
1384 else:
1384 else:
1385 lr.push(l)
1385 lr.push(l)
1386
1386
1387 def complete(self):
1387 def complete(self):
1388 return len(self.a) == self.lena and len(self.b) == self.lenb
1388 return len(self.a) == self.lena and len(self.b) == self.lenb
1389
1389
1390 def _fuzzit(self, old, new, fuzz, toponly):
1390 def _fuzzit(self, old, new, fuzz, toponly):
1391 # this removes context lines from the top and bottom of list 'l'. It
1391 # this removes context lines from the top and bottom of list 'l'. It
1392 # checks the hunk to make sure only context lines are removed, and then
1392 # checks the hunk to make sure only context lines are removed, and then
1393 # returns a new shortened list of lines.
1393 # returns a new shortened list of lines.
1394 fuzz = min(fuzz, len(old))
1394 fuzz = min(fuzz, len(old))
1395 if fuzz:
1395 if fuzz:
1396 top = 0
1396 top = 0
1397 bot = 0
1397 bot = 0
1398 hlen = len(self.hunk)
1398 hlen = len(self.hunk)
1399 for x in xrange(hlen - 1):
1399 for x in xrange(hlen - 1):
1400 # the hunk starts with the @@ line, so use x+1
1400 # the hunk starts with the @@ line, so use x+1
1401 if self.hunk[x + 1].startswith(' '):
1401 if self.hunk[x + 1].startswith(' '):
1402 top += 1
1402 top += 1
1403 else:
1403 else:
1404 break
1404 break
1405 if not toponly:
1405 if not toponly:
1406 for x in xrange(hlen - 1):
1406 for x in xrange(hlen - 1):
1407 if self.hunk[hlen - bot - 1].startswith(' '):
1407 if self.hunk[hlen - bot - 1].startswith(' '):
1408 bot += 1
1408 bot += 1
1409 else:
1409 else:
1410 break
1410 break
1411
1411
1412 bot = min(fuzz, bot)
1412 bot = min(fuzz, bot)
1413 top = min(fuzz, top)
1413 top = min(fuzz, top)
1414 return old[top:len(old) - bot], new[top:len(new) - bot], top
1414 return old[top:len(old) - bot], new[top:len(new) - bot], top
1415 return old, new, 0
1415 return old, new, 0
1416
1416
1417 def fuzzit(self, fuzz, toponly):
1417 def fuzzit(self, fuzz, toponly):
1418 old, new, top = self._fuzzit(self.a, self.b, fuzz, toponly)
1418 old, new, top = self._fuzzit(self.a, self.b, fuzz, toponly)
1419 oldstart = self.starta + top
1419 oldstart = self.starta + top
1420 newstart = self.startb + top
1420 newstart = self.startb + top
1421 # zero length hunk ranges already have their start decremented
1421 # zero length hunk ranges already have their start decremented
1422 if self.lena and oldstart > 0:
1422 if self.lena and oldstart > 0:
1423 oldstart -= 1
1423 oldstart -= 1
1424 if self.lenb and newstart > 0:
1424 if self.lenb and newstart > 0:
1425 newstart -= 1
1425 newstart -= 1
1426 return old, oldstart, new, newstart
1426 return old, oldstart, new, newstart
1427
1427
1428 class binhunk(object):
1428 class binhunk(object):
1429 'A binary patch file.'
1429 'A binary patch file.'
1430 def __init__(self, lr, fname):
1430 def __init__(self, lr, fname):
1431 self.text = None
1431 self.text = None
1432 self.delta = False
1432 self.delta = False
1433 self.hunk = ['GIT binary patch\n']
1433 self.hunk = ['GIT binary patch\n']
1434 self._fname = fname
1434 self._fname = fname
1435 self._read(lr)
1435 self._read(lr)
1436
1436
1437 def complete(self):
1437 def complete(self):
1438 return self.text is not None
1438 return self.text is not None
1439
1439
1440 def new(self, lines):
1440 def new(self, lines):
1441 if self.delta:
1441 if self.delta:
1442 return [applybindelta(self.text, ''.join(lines))]
1442 return [applybindelta(self.text, ''.join(lines))]
1443 return [self.text]
1443 return [self.text]
1444
1444
1445 def _read(self, lr):
1445 def _read(self, lr):
1446 def getline(lr, hunk):
1446 def getline(lr, hunk):
1447 l = lr.readline()
1447 l = lr.readline()
1448 hunk.append(l)
1448 hunk.append(l)
1449 return l.rstrip('\r\n')
1449 return l.rstrip('\r\n')
1450
1450
1451 size = 0
1451 size = 0
1452 while True:
1452 while True:
1453 line = getline(lr, self.hunk)
1453 line = getline(lr, self.hunk)
1454 if not line:
1454 if not line:
1455 raise PatchError(_('could not extract "%s" binary data')
1455 raise PatchError(_('could not extract "%s" binary data')
1456 % self._fname)
1456 % self._fname)
1457 if line.startswith('literal '):
1457 if line.startswith('literal '):
1458 size = int(line[8:].rstrip())
1458 size = int(line[8:].rstrip())
1459 break
1459 break
1460 if line.startswith('delta '):
1460 if line.startswith('delta '):
1461 size = int(line[6:].rstrip())
1461 size = int(line[6:].rstrip())
1462 self.delta = True
1462 self.delta = True
1463 break
1463 break
1464 dec = []
1464 dec = []
1465 line = getline(lr, self.hunk)
1465 line = getline(lr, self.hunk)
1466 while len(line) > 1:
1466 while len(line) > 1:
1467 l = line[0:1]
1467 l = line[0:1]
1468 if l <= 'Z' and l >= 'A':
1468 if l <= 'Z' and l >= 'A':
1469 l = ord(l) - ord('A') + 1
1469 l = ord(l) - ord('A') + 1
1470 else:
1470 else:
1471 l = ord(l) - ord('a') + 27
1471 l = ord(l) - ord('a') + 27
1472 try:
1472 try:
1473 dec.append(util.b85decode(line[1:])[:l])
1473 dec.append(util.b85decode(line[1:])[:l])
1474 except ValueError as e:
1474 except ValueError as e:
1475 raise PatchError(_('could not decode "%s" binary patch: %s')
1475 raise PatchError(_('could not decode "%s" binary patch: %s')
1476 % (self._fname, stringutil.forcebytestr(e)))
1476 % (self._fname, stringutil.forcebytestr(e)))
1477 line = getline(lr, self.hunk)
1477 line = getline(lr, self.hunk)
1478 text = zlib.decompress(''.join(dec))
1478 text = zlib.decompress(''.join(dec))
1479 if len(text) != size:
1479 if len(text) != size:
1480 raise PatchError(_('"%s" length is %d bytes, should be %d')
1480 raise PatchError(_('"%s" length is %d bytes, should be %d')
1481 % (self._fname, len(text), size))
1481 % (self._fname, len(text), size))
1482 self.text = text
1482 self.text = text
1483
1483
1484 def parsefilename(str):
1484 def parsefilename(str):
1485 # --- filename \t|space stuff
1485 # --- filename \t|space stuff
1486 s = str[4:].rstrip('\r\n')
1486 s = str[4:].rstrip('\r\n')
1487 i = s.find('\t')
1487 i = s.find('\t')
1488 if i < 0:
1488 if i < 0:
1489 i = s.find(' ')
1489 i = s.find(' ')
1490 if i < 0:
1490 if i < 0:
1491 return s
1491 return s
1492 return s[:i]
1492 return s[:i]
1493
1493
1494 def reversehunks(hunks):
1494 def reversehunks(hunks):
1495 '''reverse the signs in the hunks given as argument
1495 '''reverse the signs in the hunks given as argument
1496
1496
1497 This function operates on hunks coming out of patch.filterpatch, that is
1497 This function operates on hunks coming out of patch.filterpatch, that is
1498 a list of the form: [header1, hunk1, hunk2, header2...]. Example usage:
1498 a list of the form: [header1, hunk1, hunk2, header2...]. Example usage:
1499
1499
1500 >>> rawpatch = b"""diff --git a/folder1/g b/folder1/g
1500 >>> rawpatch = b"""diff --git a/folder1/g b/folder1/g
1501 ... --- a/folder1/g
1501 ... --- a/folder1/g
1502 ... +++ b/folder1/g
1502 ... +++ b/folder1/g
1503 ... @@ -1,7 +1,7 @@
1503 ... @@ -1,7 +1,7 @@
1504 ... +firstline
1504 ... +firstline
1505 ... c
1505 ... c
1506 ... 1
1506 ... 1
1507 ... 2
1507 ... 2
1508 ... + 3
1508 ... + 3
1509 ... -4
1509 ... -4
1510 ... 5
1510 ... 5
1511 ... d
1511 ... d
1512 ... +lastline"""
1512 ... +lastline"""
1513 >>> hunks = parsepatch([rawpatch])
1513 >>> hunks = parsepatch([rawpatch])
1514 >>> hunkscomingfromfilterpatch = []
1514 >>> hunkscomingfromfilterpatch = []
1515 >>> for h in hunks:
1515 >>> for h in hunks:
1516 ... hunkscomingfromfilterpatch.append(h)
1516 ... hunkscomingfromfilterpatch.append(h)
1517 ... hunkscomingfromfilterpatch.extend(h.hunks)
1517 ... hunkscomingfromfilterpatch.extend(h.hunks)
1518
1518
1519 >>> reversedhunks = reversehunks(hunkscomingfromfilterpatch)
1519 >>> reversedhunks = reversehunks(hunkscomingfromfilterpatch)
1520 >>> from . import util
1520 >>> from . import util
1521 >>> fp = util.stringio()
1521 >>> fp = util.stringio()
1522 >>> for c in reversedhunks:
1522 >>> for c in reversedhunks:
1523 ... c.write(fp)
1523 ... c.write(fp)
1524 >>> fp.seek(0) or None
1524 >>> fp.seek(0) or None
1525 >>> reversedpatch = fp.read()
1525 >>> reversedpatch = fp.read()
1526 >>> print(pycompat.sysstr(reversedpatch))
1526 >>> print(pycompat.sysstr(reversedpatch))
1527 diff --git a/folder1/g b/folder1/g
1527 diff --git a/folder1/g b/folder1/g
1528 --- a/folder1/g
1528 --- a/folder1/g
1529 +++ b/folder1/g
1529 +++ b/folder1/g
1530 @@ -1,4 +1,3 @@
1530 @@ -1,4 +1,3 @@
1531 -firstline
1531 -firstline
1532 c
1532 c
1533 1
1533 1
1534 2
1534 2
1535 @@ -2,6 +1,6 @@
1535 @@ -2,6 +1,6 @@
1536 c
1536 c
1537 1
1537 1
1538 2
1538 2
1539 - 3
1539 - 3
1540 +4
1540 +4
1541 5
1541 5
1542 d
1542 d
1543 @@ -6,3 +5,2 @@
1543 @@ -6,3 +5,2 @@
1544 5
1544 5
1545 d
1545 d
1546 -lastline
1546 -lastline
1547
1547
1548 '''
1548 '''
1549
1549
1550 newhunks = []
1550 newhunks = []
1551 for c in hunks:
1551 for c in hunks:
1552 if util.safehasattr(c, 'reversehunk'):
1552 if util.safehasattr(c, 'reversehunk'):
1553 c = c.reversehunk()
1553 c = c.reversehunk()
1554 newhunks.append(c)
1554 newhunks.append(c)
1555 return newhunks
1555 return newhunks
1556
1556
1557 def parsepatch(originalchunks, maxcontext=None):
1557 def parsepatch(originalchunks, maxcontext=None):
1558 """patch -> [] of headers -> [] of hunks
1558 """patch -> [] of headers -> [] of hunks
1559
1559
1560 If maxcontext is not None, trim context lines if necessary.
1560 If maxcontext is not None, trim context lines if necessary.
1561
1561
1562 >>> rawpatch = b'''diff --git a/folder1/g b/folder1/g
1562 >>> rawpatch = b'''diff --git a/folder1/g b/folder1/g
1563 ... --- a/folder1/g
1563 ... --- a/folder1/g
1564 ... +++ b/folder1/g
1564 ... +++ b/folder1/g
1565 ... @@ -1,8 +1,10 @@
1565 ... @@ -1,8 +1,10 @@
1566 ... 1
1566 ... 1
1567 ... 2
1567 ... 2
1568 ... -3
1568 ... -3
1569 ... 4
1569 ... 4
1570 ... 5
1570 ... 5
1571 ... 6
1571 ... 6
1572 ... +6.1
1572 ... +6.1
1573 ... +6.2
1573 ... +6.2
1574 ... 7
1574 ... 7
1575 ... 8
1575 ... 8
1576 ... +9'''
1576 ... +9'''
1577 >>> out = util.stringio()
1577 >>> out = util.stringio()
1578 >>> headers = parsepatch([rawpatch], maxcontext=1)
1578 >>> headers = parsepatch([rawpatch], maxcontext=1)
1579 >>> for header in headers:
1579 >>> for header in headers:
1580 ... header.write(out)
1580 ... header.write(out)
1581 ... for hunk in header.hunks:
1581 ... for hunk in header.hunks:
1582 ... hunk.write(out)
1582 ... hunk.write(out)
1583 >>> print(pycompat.sysstr(out.getvalue()))
1583 >>> print(pycompat.sysstr(out.getvalue()))
1584 diff --git a/folder1/g b/folder1/g
1584 diff --git a/folder1/g b/folder1/g
1585 --- a/folder1/g
1585 --- a/folder1/g
1586 +++ b/folder1/g
1586 +++ b/folder1/g
1587 @@ -2,3 +2,2 @@
1587 @@ -2,3 +2,2 @@
1588 2
1588 2
1589 -3
1589 -3
1590 4
1590 4
1591 @@ -6,2 +5,4 @@
1591 @@ -6,2 +5,4 @@
1592 6
1592 6
1593 +6.1
1593 +6.1
1594 +6.2
1594 +6.2
1595 7
1595 7
1596 @@ -8,1 +9,2 @@
1596 @@ -8,1 +9,2 @@
1597 8
1597 8
1598 +9
1598 +9
1599 """
1599 """
1600 class parser(object):
1600 class parser(object):
1601 """patch parsing state machine"""
1601 """patch parsing state machine"""
1602 def __init__(self):
1602 def __init__(self):
1603 self.fromline = 0
1603 self.fromline = 0
1604 self.toline = 0
1604 self.toline = 0
1605 self.proc = ''
1605 self.proc = ''
1606 self.header = None
1606 self.header = None
1607 self.context = []
1607 self.context = []
1608 self.before = []
1608 self.before = []
1609 self.hunk = []
1609 self.hunk = []
1610 self.headers = []
1610 self.headers = []
1611
1611
1612 def addrange(self, limits):
1612 def addrange(self, limits):
1613 fromstart, fromend, tostart, toend, proc = limits
1613 fromstart, fromend, tostart, toend, proc = limits
1614 self.fromline = int(fromstart)
1614 self.fromline = int(fromstart)
1615 self.toline = int(tostart)
1615 self.toline = int(tostart)
1616 self.proc = proc
1616 self.proc = proc
1617
1617
1618 def addcontext(self, context):
1618 def addcontext(self, context):
1619 if self.hunk:
1619 if self.hunk:
1620 h = recordhunk(self.header, self.fromline, self.toline,
1620 h = recordhunk(self.header, self.fromline, self.toline,
1621 self.proc, self.before, self.hunk, context, maxcontext)
1621 self.proc, self.before, self.hunk, context, maxcontext)
1622 self.header.hunks.append(h)
1622 self.header.hunks.append(h)
1623 self.fromline += len(self.before) + h.removed
1623 self.fromline += len(self.before) + h.removed
1624 self.toline += len(self.before) + h.added
1624 self.toline += len(self.before) + h.added
1625 self.before = []
1625 self.before = []
1626 self.hunk = []
1626 self.hunk = []
1627 self.context = context
1627 self.context = context
1628
1628
1629 def addhunk(self, hunk):
1629 def addhunk(self, hunk):
1630 if self.context:
1630 if self.context:
1631 self.before = self.context
1631 self.before = self.context
1632 self.context = []
1632 self.context = []
1633 self.hunk = hunk
1633 self.hunk = hunk
1634
1634
1635 def newfile(self, hdr):
1635 def newfile(self, hdr):
1636 self.addcontext([])
1636 self.addcontext([])
1637 h = header(hdr)
1637 h = header(hdr)
1638 self.headers.append(h)
1638 self.headers.append(h)
1639 self.header = h
1639 self.header = h
1640
1640
1641 def addother(self, line):
1641 def addother(self, line):
1642 pass # 'other' lines are ignored
1642 pass # 'other' lines are ignored
1643
1643
1644 def finished(self):
1644 def finished(self):
1645 self.addcontext([])
1645 self.addcontext([])
1646 return self.headers
1646 return self.headers
1647
1647
1648 transitions = {
1648 transitions = {
1649 'file': {'context': addcontext,
1649 'file': {'context': addcontext,
1650 'file': newfile,
1650 'file': newfile,
1651 'hunk': addhunk,
1651 'hunk': addhunk,
1652 'range': addrange},
1652 'range': addrange},
1653 'context': {'file': newfile,
1653 'context': {'file': newfile,
1654 'hunk': addhunk,
1654 'hunk': addhunk,
1655 'range': addrange,
1655 'range': addrange,
1656 'other': addother},
1656 'other': addother},
1657 'hunk': {'context': addcontext,
1657 'hunk': {'context': addcontext,
1658 'file': newfile,
1658 'file': newfile,
1659 'range': addrange},
1659 'range': addrange},
1660 'range': {'context': addcontext,
1660 'range': {'context': addcontext,
1661 'hunk': addhunk},
1661 'hunk': addhunk},
1662 'other': {'other': addother},
1662 'other': {'other': addother},
1663 }
1663 }
1664
1664
1665 p = parser()
1665 p = parser()
1666 fp = stringio()
1666 fp = stringio()
1667 fp.write(''.join(originalchunks))
1667 fp.write(''.join(originalchunks))
1668 fp.seek(0)
1668 fp.seek(0)
1669
1669
1670 state = 'context'
1670 state = 'context'
1671 for newstate, data in scanpatch(fp):
1671 for newstate, data in scanpatch(fp):
1672 try:
1672 try:
1673 p.transitions[state][newstate](p, data)
1673 p.transitions[state][newstate](p, data)
1674 except KeyError:
1674 except KeyError:
1675 raise PatchError('unhandled transition: %s -> %s' %
1675 raise PatchError('unhandled transition: %s -> %s' %
1676 (state, newstate))
1676 (state, newstate))
1677 state = newstate
1677 state = newstate
1678 del fp
1678 del fp
1679 return p.finished()
1679 return p.finished()
1680
1680
1681 def pathtransform(path, strip, prefix):
1681 def pathtransform(path, strip, prefix):
1682 '''turn a path from a patch into a path suitable for the repository
1682 '''turn a path from a patch into a path suitable for the repository
1683
1683
1684 prefix, if not empty, is expected to be normalized with a / at the end.
1684 prefix, if not empty, is expected to be normalized with a / at the end.
1685
1685
1686 Returns (stripped components, path in repository).
1686 Returns (stripped components, path in repository).
1687
1687
1688 >>> pathtransform(b'a/b/c', 0, b'')
1688 >>> pathtransform(b'a/b/c', 0, b'')
1689 ('', 'a/b/c')
1689 ('', 'a/b/c')
1690 >>> pathtransform(b' a/b/c ', 0, b'')
1690 >>> pathtransform(b' a/b/c ', 0, b'')
1691 ('', ' a/b/c')
1691 ('', ' a/b/c')
1692 >>> pathtransform(b' a/b/c ', 2, b'')
1692 >>> pathtransform(b' a/b/c ', 2, b'')
1693 ('a/b/', 'c')
1693 ('a/b/', 'c')
1694 >>> pathtransform(b'a/b/c', 0, b'd/e/')
1694 >>> pathtransform(b'a/b/c', 0, b'd/e/')
1695 ('', 'd/e/a/b/c')
1695 ('', 'd/e/a/b/c')
1696 >>> pathtransform(b' a//b/c ', 2, b'd/e/')
1696 >>> pathtransform(b' a//b/c ', 2, b'd/e/')
1697 ('a//b/', 'd/e/c')
1697 ('a//b/', 'd/e/c')
1698 >>> pathtransform(b'a/b/c', 3, b'')
1698 >>> pathtransform(b'a/b/c', 3, b'')
1699 Traceback (most recent call last):
1699 Traceback (most recent call last):
1700 PatchError: unable to strip away 1 of 3 dirs from a/b/c
1700 PatchError: unable to strip away 1 of 3 dirs from a/b/c
1701 '''
1701 '''
1702 pathlen = len(path)
1702 pathlen = len(path)
1703 i = 0
1703 i = 0
1704 if strip == 0:
1704 if strip == 0:
1705 return '', prefix + path.rstrip()
1705 return '', prefix + path.rstrip()
1706 count = strip
1706 count = strip
1707 while count > 0:
1707 while count > 0:
1708 i = path.find('/', i)
1708 i = path.find('/', i)
1709 if i == -1:
1709 if i == -1:
1710 raise PatchError(_("unable to strip away %d of %d dirs from %s") %
1710 raise PatchError(_("unable to strip away %d of %d dirs from %s") %
1711 (count, strip, path))
1711 (count, strip, path))
1712 i += 1
1712 i += 1
1713 # consume '//' in the path
1713 # consume '//' in the path
1714 while i < pathlen - 1 and path[i:i + 1] == '/':
1714 while i < pathlen - 1 and path[i:i + 1] == '/':
1715 i += 1
1715 i += 1
1716 count -= 1
1716 count -= 1
1717 return path[:i].lstrip(), prefix + path[i:].rstrip()
1717 return path[:i].lstrip(), prefix + path[i:].rstrip()
1718
1718
1719 def makepatchmeta(backend, afile_orig, bfile_orig, hunk, strip, prefix):
1719 def makepatchmeta(backend, afile_orig, bfile_orig, hunk, strip, prefix):
1720 nulla = afile_orig == "/dev/null"
1720 nulla = afile_orig == "/dev/null"
1721 nullb = bfile_orig == "/dev/null"
1721 nullb = bfile_orig == "/dev/null"
1722 create = nulla and hunk.starta == 0 and hunk.lena == 0
1722 create = nulla and hunk.starta == 0 and hunk.lena == 0
1723 remove = nullb and hunk.startb == 0 and hunk.lenb == 0
1723 remove = nullb and hunk.startb == 0 and hunk.lenb == 0
1724 abase, afile = pathtransform(afile_orig, strip, prefix)
1724 abase, afile = pathtransform(afile_orig, strip, prefix)
1725 gooda = not nulla and backend.exists(afile)
1725 gooda = not nulla and backend.exists(afile)
1726 bbase, bfile = pathtransform(bfile_orig, strip, prefix)
1726 bbase, bfile = pathtransform(bfile_orig, strip, prefix)
1727 if afile == bfile:
1727 if afile == bfile:
1728 goodb = gooda
1728 goodb = gooda
1729 else:
1729 else:
1730 goodb = not nullb and backend.exists(bfile)
1730 goodb = not nullb and backend.exists(bfile)
1731 missing = not goodb and not gooda and not create
1731 missing = not goodb and not gooda and not create
1732
1732
1733 # some diff programs apparently produce patches where the afile is
1733 # some diff programs apparently produce patches where the afile is
1734 # not /dev/null, but afile starts with bfile
1734 # not /dev/null, but afile starts with bfile
1735 abasedir = afile[:afile.rfind('/') + 1]
1735 abasedir = afile[:afile.rfind('/') + 1]
1736 bbasedir = bfile[:bfile.rfind('/') + 1]
1736 bbasedir = bfile[:bfile.rfind('/') + 1]
1737 if (missing and abasedir == bbasedir and afile.startswith(bfile)
1737 if (missing and abasedir == bbasedir and afile.startswith(bfile)
1738 and hunk.starta == 0 and hunk.lena == 0):
1738 and hunk.starta == 0 and hunk.lena == 0):
1739 create = True
1739 create = True
1740 missing = False
1740 missing = False
1741
1741
1742 # If afile is "a/b/foo" and bfile is "a/b/foo.orig" we assume the
1742 # If afile is "a/b/foo" and bfile is "a/b/foo.orig" we assume the
1743 # diff is between a file and its backup. In this case, the original
1743 # diff is between a file and its backup. In this case, the original
1744 # file should be patched (see original mpatch code).
1744 # file should be patched (see original mpatch code).
1745 isbackup = (abase == bbase and bfile.startswith(afile))
1745 isbackup = (abase == bbase and bfile.startswith(afile))
1746 fname = None
1746 fname = None
1747 if not missing:
1747 if not missing:
1748 if gooda and goodb:
1748 if gooda and goodb:
1749 if isbackup:
1749 if isbackup:
1750 fname = afile
1750 fname = afile
1751 else:
1751 else:
1752 fname = bfile
1752 fname = bfile
1753 elif gooda:
1753 elif gooda:
1754 fname = afile
1754 fname = afile
1755
1755
1756 if not fname:
1756 if not fname:
1757 if not nullb:
1757 if not nullb:
1758 if isbackup:
1758 if isbackup:
1759 fname = afile
1759 fname = afile
1760 else:
1760 else:
1761 fname = bfile
1761 fname = bfile
1762 elif not nulla:
1762 elif not nulla:
1763 fname = afile
1763 fname = afile
1764 else:
1764 else:
1765 raise PatchError(_("undefined source and destination files"))
1765 raise PatchError(_("undefined source and destination files"))
1766
1766
1767 gp = patchmeta(fname)
1767 gp = patchmeta(fname)
1768 if create:
1768 if create:
1769 gp.op = 'ADD'
1769 gp.op = 'ADD'
1770 elif remove:
1770 elif remove:
1771 gp.op = 'DELETE'
1771 gp.op = 'DELETE'
1772 return gp
1772 return gp
1773
1773
1774 def scanpatch(fp):
1774 def scanpatch(fp):
1775 """like patch.iterhunks, but yield different events
1775 """like patch.iterhunks, but yield different events
1776
1776
1777 - ('file', [header_lines + fromfile + tofile])
1777 - ('file', [header_lines + fromfile + tofile])
1778 - ('context', [context_lines])
1778 - ('context', [context_lines])
1779 - ('hunk', [hunk_lines])
1779 - ('hunk', [hunk_lines])
1780 - ('range', (-start,len, +start,len, proc))
1780 - ('range', (-start,len, +start,len, proc))
1781 """
1781 """
1782 lines_re = re.compile(br'@@ -(\d+),(\d+) \+(\d+),(\d+) @@\s*(.*)')
1782 lines_re = re.compile(br'@@ -(\d+),(\d+) \+(\d+),(\d+) @@\s*(.*)')
1783 lr = linereader(fp)
1783 lr = linereader(fp)
1784
1784
1785 def scanwhile(first, p):
1785 def scanwhile(first, p):
1786 """scan lr while predicate holds"""
1786 """scan lr while predicate holds"""
1787 lines = [first]
1787 lines = [first]
1788 for line in iter(lr.readline, ''):
1788 for line in iter(lr.readline, ''):
1789 if p(line):
1789 if p(line):
1790 lines.append(line)
1790 lines.append(line)
1791 else:
1791 else:
1792 lr.push(line)
1792 lr.push(line)
1793 break
1793 break
1794 return lines
1794 return lines
1795
1795
1796 for line in iter(lr.readline, ''):
1796 for line in iter(lr.readline, ''):
1797 if line.startswith('diff --git a/') or line.startswith('diff -r '):
1797 if line.startswith('diff --git a/') or line.startswith('diff -r '):
1798 def notheader(line):
1798 def notheader(line):
1799 s = line.split(None, 1)
1799 s = line.split(None, 1)
1800 return not s or s[0] not in ('---', 'diff')
1800 return not s or s[0] not in ('---', 'diff')
1801 header = scanwhile(line, notheader)
1801 header = scanwhile(line, notheader)
1802 fromfile = lr.readline()
1802 fromfile = lr.readline()
1803 if fromfile.startswith('---'):
1803 if fromfile.startswith('---'):
1804 tofile = lr.readline()
1804 tofile = lr.readline()
1805 header += [fromfile, tofile]
1805 header += [fromfile, tofile]
1806 else:
1806 else:
1807 lr.push(fromfile)
1807 lr.push(fromfile)
1808 yield 'file', header
1808 yield 'file', header
1809 elif line.startswith(' '):
1809 elif line.startswith(' '):
1810 cs = (' ', '\\')
1810 cs = (' ', '\\')
1811 yield 'context', scanwhile(line, lambda l: l.startswith(cs))
1811 yield 'context', scanwhile(line, lambda l: l.startswith(cs))
1812 elif line.startswith(('-', '+')):
1812 elif line.startswith(('-', '+')):
1813 cs = ('-', '+', '\\')
1813 cs = ('-', '+', '\\')
1814 yield 'hunk', scanwhile(line, lambda l: l.startswith(cs))
1814 yield 'hunk', scanwhile(line, lambda l: l.startswith(cs))
1815 else:
1815 else:
1816 m = lines_re.match(line)
1816 m = lines_re.match(line)
1817 if m:
1817 if m:
1818 yield 'range', m.groups()
1818 yield 'range', m.groups()
1819 else:
1819 else:
1820 yield 'other', line
1820 yield 'other', line
1821
1821
1822 def scangitpatch(lr, firstline):
1822 def scangitpatch(lr, firstline):
1823 """
1823 """
1824 Git patches can emit:
1824 Git patches can emit:
1825 - rename a to b
1825 - rename a to b
1826 - change b
1826 - change b
1827 - copy a to c
1827 - copy a to c
1828 - change c
1828 - change c
1829
1829
1830 We cannot apply this sequence as-is, the renamed 'a' could not be
1830 We cannot apply this sequence as-is, the renamed 'a' could not be
1831 found for it would have been renamed already. And we cannot copy
1831 found for it would have been renamed already. And we cannot copy
1832 from 'b' instead because 'b' would have been changed already. So
1832 from 'b' instead because 'b' would have been changed already. So
1833 we scan the git patch for copy and rename commands so we can
1833 we scan the git patch for copy and rename commands so we can
1834 perform the copies ahead of time.
1834 perform the copies ahead of time.
1835 """
1835 """
1836 pos = 0
1836 pos = 0
1837 try:
1837 try:
1838 pos = lr.fp.tell()
1838 pos = lr.fp.tell()
1839 fp = lr.fp
1839 fp = lr.fp
1840 except IOError:
1840 except IOError:
1841 fp = stringio(lr.fp.read())
1841 fp = stringio(lr.fp.read())
1842 gitlr = linereader(fp)
1842 gitlr = linereader(fp)
1843 gitlr.push(firstline)
1843 gitlr.push(firstline)
1844 gitpatches = readgitpatch(gitlr)
1844 gitpatches = readgitpatch(gitlr)
1845 fp.seek(pos)
1845 fp.seek(pos)
1846 return gitpatches
1846 return gitpatches
1847
1847
1848 def iterhunks(fp):
1848 def iterhunks(fp):
1849 """Read a patch and yield the following events:
1849 """Read a patch and yield the following events:
1850 - ("file", afile, bfile, firsthunk): select a new target file.
1850 - ("file", afile, bfile, firsthunk): select a new target file.
1851 - ("hunk", hunk): a new hunk is ready to be applied, follows a
1851 - ("hunk", hunk): a new hunk is ready to be applied, follows a
1852 "file" event.
1852 "file" event.
1853 - ("git", gitchanges): current diff is in git format, gitchanges
1853 - ("git", gitchanges): current diff is in git format, gitchanges
1854 maps filenames to gitpatch records. Unique event.
1854 maps filenames to gitpatch records. Unique event.
1855 """
1855 """
1856 afile = ""
1856 afile = ""
1857 bfile = ""
1857 bfile = ""
1858 state = None
1858 state = None
1859 hunknum = 0
1859 hunknum = 0
1860 emitfile = newfile = False
1860 emitfile = newfile = False
1861 gitpatches = None
1861 gitpatches = None
1862
1862
1863 # our states
1863 # our states
1864 BFILE = 1
1864 BFILE = 1
1865 context = None
1865 context = None
1866 lr = linereader(fp)
1866 lr = linereader(fp)
1867
1867
1868 for x in iter(lr.readline, ''):
1868 for x in iter(lr.readline, ''):
1869 if state == BFILE and (
1869 if state == BFILE and (
1870 (not context and x.startswith('@'))
1870 (not context and x.startswith('@'))
1871 or (context is not False and x.startswith('***************'))
1871 or (context is not False and x.startswith('***************'))
1872 or x.startswith('GIT binary patch')):
1872 or x.startswith('GIT binary patch')):
1873 gp = None
1873 gp = None
1874 if (gitpatches and
1874 if (gitpatches and
1875 gitpatches[-1].ispatching(afile, bfile)):
1875 gitpatches[-1].ispatching(afile, bfile)):
1876 gp = gitpatches.pop()
1876 gp = gitpatches.pop()
1877 if x.startswith('GIT binary patch'):
1877 if x.startswith('GIT binary patch'):
1878 h = binhunk(lr, gp.path)
1878 h = binhunk(lr, gp.path)
1879 else:
1879 else:
1880 if context is None and x.startswith('***************'):
1880 if context is None and x.startswith('***************'):
1881 context = True
1881 context = True
1882 h = hunk(x, hunknum + 1, lr, context)
1882 h = hunk(x, hunknum + 1, lr, context)
1883 hunknum += 1
1883 hunknum += 1
1884 if emitfile:
1884 if emitfile:
1885 emitfile = False
1885 emitfile = False
1886 yield 'file', (afile, bfile, h, gp and gp.copy() or None)
1886 yield 'file', (afile, bfile, h, gp and gp.copy() or None)
1887 yield 'hunk', h
1887 yield 'hunk', h
1888 elif x.startswith('diff --git a/'):
1888 elif x.startswith('diff --git a/'):
1889 m = gitre.match(x.rstrip(' \r\n'))
1889 m = gitre.match(x.rstrip(' \r\n'))
1890 if not m:
1890 if not m:
1891 continue
1891 continue
1892 if gitpatches is None:
1892 if gitpatches is None:
1893 # scan whole input for git metadata
1893 # scan whole input for git metadata
1894 gitpatches = scangitpatch(lr, x)
1894 gitpatches = scangitpatch(lr, x)
1895 yield 'git', [g.copy() for g in gitpatches
1895 yield 'git', [g.copy() for g in gitpatches
1896 if g.op in ('COPY', 'RENAME')]
1896 if g.op in ('COPY', 'RENAME')]
1897 gitpatches.reverse()
1897 gitpatches.reverse()
1898 afile = 'a/' + m.group(1)
1898 afile = 'a/' + m.group(1)
1899 bfile = 'b/' + m.group(2)
1899 bfile = 'b/' + m.group(2)
1900 while gitpatches and not gitpatches[-1].ispatching(afile, bfile):
1900 while gitpatches and not gitpatches[-1].ispatching(afile, bfile):
1901 gp = gitpatches.pop()
1901 gp = gitpatches.pop()
1902 yield 'file', ('a/' + gp.path, 'b/' + gp.path, None, gp.copy())
1902 yield 'file', ('a/' + gp.path, 'b/' + gp.path, None, gp.copy())
1903 if not gitpatches:
1903 if not gitpatches:
1904 raise PatchError(_('failed to synchronize metadata for "%s"')
1904 raise PatchError(_('failed to synchronize metadata for "%s"')
1905 % afile[2:])
1905 % afile[2:])
1906 gp = gitpatches[-1]
1906 gp = gitpatches[-1]
1907 newfile = True
1907 newfile = True
1908 elif x.startswith('---'):
1908 elif x.startswith('---'):
1909 # check for a unified diff
1909 # check for a unified diff
1910 l2 = lr.readline()
1910 l2 = lr.readline()
1911 if not l2.startswith('+++'):
1911 if not l2.startswith('+++'):
1912 lr.push(l2)
1912 lr.push(l2)
1913 continue
1913 continue
1914 newfile = True
1914 newfile = True
1915 context = False
1915 context = False
1916 afile = parsefilename(x)
1916 afile = parsefilename(x)
1917 bfile = parsefilename(l2)
1917 bfile = parsefilename(l2)
1918 elif x.startswith('***'):
1918 elif x.startswith('***'):
1919 # check for a context diff
1919 # check for a context diff
1920 l2 = lr.readline()
1920 l2 = lr.readline()
1921 if not l2.startswith('---'):
1921 if not l2.startswith('---'):
1922 lr.push(l2)
1922 lr.push(l2)
1923 continue
1923 continue
1924 l3 = lr.readline()
1924 l3 = lr.readline()
1925 lr.push(l3)
1925 lr.push(l3)
1926 if not l3.startswith("***************"):
1926 if not l3.startswith("***************"):
1927 lr.push(l2)
1927 lr.push(l2)
1928 continue
1928 continue
1929 newfile = True
1929 newfile = True
1930 context = True
1930 context = True
1931 afile = parsefilename(x)
1931 afile = parsefilename(x)
1932 bfile = parsefilename(l2)
1932 bfile = parsefilename(l2)
1933
1933
1934 if newfile:
1934 if newfile:
1935 newfile = False
1935 newfile = False
1936 emitfile = True
1936 emitfile = True
1937 state = BFILE
1937 state = BFILE
1938 hunknum = 0
1938 hunknum = 0
1939
1939
1940 while gitpatches:
1940 while gitpatches:
1941 gp = gitpatches.pop()
1941 gp = gitpatches.pop()
1942 yield 'file', ('a/' + gp.path, 'b/' + gp.path, None, gp.copy())
1942 yield 'file', ('a/' + gp.path, 'b/' + gp.path, None, gp.copy())
1943
1943
1944 def applybindelta(binchunk, data):
1944 def applybindelta(binchunk, data):
1945 """Apply a binary delta hunk
1945 """Apply a binary delta hunk
1946 The algorithm used is the algorithm from git's patch-delta.c
1946 The algorithm used is the algorithm from git's patch-delta.c
1947 """
1947 """
1948 def deltahead(binchunk):
1948 def deltahead(binchunk):
1949 i = 0
1949 i = 0
1950 for c in pycompat.bytestr(binchunk):
1950 for c in pycompat.bytestr(binchunk):
1951 i += 1
1951 i += 1
1952 if not (ord(c) & 0x80):
1952 if not (ord(c) & 0x80):
1953 return i
1953 return i
1954 return i
1954 return i
1955 out = ""
1955 out = ""
1956 s = deltahead(binchunk)
1956 s = deltahead(binchunk)
1957 binchunk = binchunk[s:]
1957 binchunk = binchunk[s:]
1958 s = deltahead(binchunk)
1958 s = deltahead(binchunk)
1959 binchunk = binchunk[s:]
1959 binchunk = binchunk[s:]
1960 i = 0
1960 i = 0
1961 while i < len(binchunk):
1961 while i < len(binchunk):
1962 cmd = ord(binchunk[i:i + 1])
1962 cmd = ord(binchunk[i:i + 1])
1963 i += 1
1963 i += 1
1964 if (cmd & 0x80):
1964 if (cmd & 0x80):
1965 offset = 0
1965 offset = 0
1966 size = 0
1966 size = 0
1967 if (cmd & 0x01):
1967 if (cmd & 0x01):
1968 offset = ord(binchunk[i:i + 1])
1968 offset = ord(binchunk[i:i + 1])
1969 i += 1
1969 i += 1
1970 if (cmd & 0x02):
1970 if (cmd & 0x02):
1971 offset |= ord(binchunk[i:i + 1]) << 8
1971 offset |= ord(binchunk[i:i + 1]) << 8
1972 i += 1
1972 i += 1
1973 if (cmd & 0x04):
1973 if (cmd & 0x04):
1974 offset |= ord(binchunk[i:i + 1]) << 16
1974 offset |= ord(binchunk[i:i + 1]) << 16
1975 i += 1
1975 i += 1
1976 if (cmd & 0x08):
1976 if (cmd & 0x08):
1977 offset |= ord(binchunk[i:i + 1]) << 24
1977 offset |= ord(binchunk[i:i + 1]) << 24
1978 i += 1
1978 i += 1
1979 if (cmd & 0x10):
1979 if (cmd & 0x10):
1980 size = ord(binchunk[i:i + 1])
1980 size = ord(binchunk[i:i + 1])
1981 i += 1
1981 i += 1
1982 if (cmd & 0x20):
1982 if (cmd & 0x20):
1983 size |= ord(binchunk[i:i + 1]) << 8
1983 size |= ord(binchunk[i:i + 1]) << 8
1984 i += 1
1984 i += 1
1985 if (cmd & 0x40):
1985 if (cmd & 0x40):
1986 size |= ord(binchunk[i:i + 1]) << 16
1986 size |= ord(binchunk[i:i + 1]) << 16
1987 i += 1
1987 i += 1
1988 if size == 0:
1988 if size == 0:
1989 size = 0x10000
1989 size = 0x10000
1990 offset_end = offset + size
1990 offset_end = offset + size
1991 out += data[offset:offset_end]
1991 out += data[offset:offset_end]
1992 elif cmd != 0:
1992 elif cmd != 0:
1993 offset_end = i + cmd
1993 offset_end = i + cmd
1994 out += binchunk[i:offset_end]
1994 out += binchunk[i:offset_end]
1995 i += cmd
1995 i += cmd
1996 else:
1996 else:
1997 raise PatchError(_('unexpected delta opcode 0'))
1997 raise PatchError(_('unexpected delta opcode 0'))
1998 return out
1998 return out
1999
1999
2000 def applydiff(ui, fp, backend, store, strip=1, prefix='', eolmode='strict'):
2000 def applydiff(ui, fp, backend, store, strip=1, prefix='', eolmode='strict'):
2001 """Reads a patch from fp and tries to apply it.
2001 """Reads a patch from fp and tries to apply it.
2002
2002
2003 Returns 0 for a clean patch, -1 if any rejects were found and 1 if
2003 Returns 0 for a clean patch, -1 if any rejects were found and 1 if
2004 there was any fuzz.
2004 there was any fuzz.
2005
2005
2006 If 'eolmode' is 'strict', the patch content and patched file are
2006 If 'eolmode' is 'strict', the patch content and patched file are
2007 read in binary mode. Otherwise, line endings are ignored when
2007 read in binary mode. Otherwise, line endings are ignored when
2008 patching then normalized according to 'eolmode'.
2008 patching then normalized according to 'eolmode'.
2009 """
2009 """
2010 return _applydiff(ui, fp, patchfile, backend, store, strip=strip,
2010 return _applydiff(ui, fp, patchfile, backend, store, strip=strip,
2011 prefix=prefix, eolmode=eolmode)
2011 prefix=prefix, eolmode=eolmode)
2012
2012
2013 def _canonprefix(repo, prefix):
2013 def _canonprefix(repo, prefix):
2014 if prefix:
2014 if prefix:
2015 prefix = pathutil.canonpath(repo.root, repo.getcwd(), prefix)
2015 prefix = pathutil.canonpath(repo.root, repo.getcwd(), prefix)
2016 if prefix != '':
2016 if prefix != '':
2017 prefix += '/'
2017 prefix += '/'
2018 return prefix
2018 return prefix
2019
2019
2020 def _applydiff(ui, fp, patcher, backend, store, strip=1, prefix='',
2020 def _applydiff(ui, fp, patcher, backend, store, strip=1, prefix='',
2021 eolmode='strict'):
2021 eolmode='strict'):
2022 prefix = _canonprefix(backend.repo, prefix)
2022 prefix = _canonprefix(backend.repo, prefix)
2023 def pstrip(p):
2023 def pstrip(p):
2024 return pathtransform(p, strip - 1, prefix)[1]
2024 return pathtransform(p, strip - 1, prefix)[1]
2025
2025
2026 rejects = 0
2026 rejects = 0
2027 err = 0
2027 err = 0
2028 current_file = None
2028 current_file = None
2029
2029
2030 for state, values in iterhunks(fp):
2030 for state, values in iterhunks(fp):
2031 if state == 'hunk':
2031 if state == 'hunk':
2032 if not current_file:
2032 if not current_file:
2033 continue
2033 continue
2034 ret = current_file.apply(values)
2034 ret = current_file.apply(values)
2035 if ret > 0:
2035 if ret > 0:
2036 err = 1
2036 err = 1
2037 elif state == 'file':
2037 elif state == 'file':
2038 if current_file:
2038 if current_file:
2039 rejects += current_file.close()
2039 rejects += current_file.close()
2040 current_file = None
2040 current_file = None
2041 afile, bfile, first_hunk, gp = values
2041 afile, bfile, first_hunk, gp = values
2042 if gp:
2042 if gp:
2043 gp.path = pstrip(gp.path)
2043 gp.path = pstrip(gp.path)
2044 if gp.oldpath:
2044 if gp.oldpath:
2045 gp.oldpath = pstrip(gp.oldpath)
2045 gp.oldpath = pstrip(gp.oldpath)
2046 else:
2046 else:
2047 gp = makepatchmeta(backend, afile, bfile, first_hunk, strip,
2047 gp = makepatchmeta(backend, afile, bfile, first_hunk, strip,
2048 prefix)
2048 prefix)
2049 if gp.op == 'RENAME':
2049 if gp.op == 'RENAME':
2050 backend.unlink(gp.oldpath)
2050 backend.unlink(gp.oldpath)
2051 if not first_hunk:
2051 if not first_hunk:
2052 if gp.op == 'DELETE':
2052 if gp.op == 'DELETE':
2053 backend.unlink(gp.path)
2053 backend.unlink(gp.path)
2054 continue
2054 continue
2055 data, mode = None, None
2055 data, mode = None, None
2056 if gp.op in ('RENAME', 'COPY'):
2056 if gp.op in ('RENAME', 'COPY'):
2057 data, mode = store.getfile(gp.oldpath)[:2]
2057 data, mode = store.getfile(gp.oldpath)[:2]
2058 if data is None:
2058 if data is None:
2059 # This means that the old path does not exist
2059 # This means that the old path does not exist
2060 raise PatchError(_("source file '%s' does not exist")
2060 raise PatchError(_("source file '%s' does not exist")
2061 % gp.oldpath)
2061 % gp.oldpath)
2062 if gp.mode:
2062 if gp.mode:
2063 mode = gp.mode
2063 mode = gp.mode
2064 if gp.op == 'ADD':
2064 if gp.op == 'ADD':
2065 # Added files without content have no hunk and
2065 # Added files without content have no hunk and
2066 # must be created
2066 # must be created
2067 data = ''
2067 data = ''
2068 if data or mode:
2068 if data or mode:
2069 if (gp.op in ('ADD', 'RENAME', 'COPY')
2069 if (gp.op in ('ADD', 'RENAME', 'COPY')
2070 and backend.exists(gp.path)):
2070 and backend.exists(gp.path)):
2071 raise PatchError(_("cannot create %s: destination "
2071 raise PatchError(_("cannot create %s: destination "
2072 "already exists") % gp.path)
2072 "already exists") % gp.path)
2073 backend.setfile(gp.path, data, mode, gp.oldpath)
2073 backend.setfile(gp.path, data, mode, gp.oldpath)
2074 continue
2074 continue
2075 try:
2075 try:
2076 current_file = patcher(ui, gp, backend, store,
2076 current_file = patcher(ui, gp, backend, store,
2077 eolmode=eolmode)
2077 eolmode=eolmode)
2078 except PatchError as inst:
2078 except PatchError as inst:
2079 ui.warn(str(inst) + '\n')
2079 ui.warn(str(inst) + '\n')
2080 current_file = None
2080 current_file = None
2081 rejects += 1
2081 rejects += 1
2082 continue
2082 continue
2083 elif state == 'git':
2083 elif state == 'git':
2084 for gp in values:
2084 for gp in values:
2085 path = pstrip(gp.oldpath)
2085 path = pstrip(gp.oldpath)
2086 data, mode = backend.getfile(path)
2086 data, mode = backend.getfile(path)
2087 if data is None:
2087 if data is None:
2088 # The error ignored here will trigger a getfile()
2088 # The error ignored here will trigger a getfile()
2089 # error in a place more appropriate for error
2089 # error in a place more appropriate for error
2090 # handling, and will not interrupt the patching
2090 # handling, and will not interrupt the patching
2091 # process.
2091 # process.
2092 pass
2092 pass
2093 else:
2093 else:
2094 store.setfile(path, data, mode)
2094 store.setfile(path, data, mode)
2095 else:
2095 else:
2096 raise error.Abort(_('unsupported parser state: %s') % state)
2096 raise error.Abort(_('unsupported parser state: %s') % state)
2097
2097
2098 if current_file:
2098 if current_file:
2099 rejects += current_file.close()
2099 rejects += current_file.close()
2100
2100
2101 if rejects:
2101 if rejects:
2102 return -1
2102 return -1
2103 return err
2103 return err
2104
2104
2105 def _externalpatch(ui, repo, patcher, patchname, strip, files,
2105 def _externalpatch(ui, repo, patcher, patchname, strip, files,
2106 similarity):
2106 similarity):
2107 """use <patcher> to apply <patchname> to the working directory.
2107 """use <patcher> to apply <patchname> to the working directory.
2108 returns whether patch was applied with fuzz factor."""
2108 returns whether patch was applied with fuzz factor."""
2109
2109
2110 fuzz = False
2110 fuzz = False
2111 args = []
2111 args = []
2112 cwd = repo.root
2112 cwd = repo.root
2113 if cwd:
2113 if cwd:
2114 args.append('-d %s' % procutil.shellquote(cwd))
2114 args.append('-d %s' % procutil.shellquote(cwd))
2115 cmd = ('%s %s -p%d < %s'
2115 cmd = ('%s %s -p%d < %s'
2116 % (patcher, ' '.join(args), strip, procutil.shellquote(patchname)))
2116 % (patcher, ' '.join(args), strip, procutil.shellquote(patchname)))
2117 ui.debug('Using external patch tool: %s\n' % cmd)
2117 ui.debug('Using external patch tool: %s\n' % cmd)
2118 fp = procutil.popen(cmd, 'rb')
2118 fp = procutil.popen(cmd, 'rb')
2119 try:
2119 try:
2120 for line in util.iterfile(fp):
2120 for line in util.iterfile(fp):
2121 line = line.rstrip()
2121 line = line.rstrip()
2122 ui.note(line + '\n')
2122 ui.note(line + '\n')
2123 if line.startswith('patching file '):
2123 if line.startswith('patching file '):
2124 pf = util.parsepatchoutput(line)
2124 pf = util.parsepatchoutput(line)
2125 printed_file = False
2125 printed_file = False
2126 files.add(pf)
2126 files.add(pf)
2127 elif line.find('with fuzz') >= 0:
2127 elif line.find('with fuzz') >= 0:
2128 fuzz = True
2128 fuzz = True
2129 if not printed_file:
2129 if not printed_file:
2130 ui.warn(pf + '\n')
2130 ui.warn(pf + '\n')
2131 printed_file = True
2131 printed_file = True
2132 ui.warn(line + '\n')
2132 ui.warn(line + '\n')
2133 elif line.find('saving rejects to file') >= 0:
2133 elif line.find('saving rejects to file') >= 0:
2134 ui.warn(line + '\n')
2134 ui.warn(line + '\n')
2135 elif line.find('FAILED') >= 0:
2135 elif line.find('FAILED') >= 0:
2136 if not printed_file:
2136 if not printed_file:
2137 ui.warn(pf + '\n')
2137 ui.warn(pf + '\n')
2138 printed_file = True
2138 printed_file = True
2139 ui.warn(line + '\n')
2139 ui.warn(line + '\n')
2140 finally:
2140 finally:
2141 if files:
2141 if files:
2142 scmutil.marktouched(repo, files, similarity)
2142 scmutil.marktouched(repo, files, similarity)
2143 code = fp.close()
2143 code = fp.close()
2144 if code:
2144 if code:
2145 raise PatchError(_("patch command failed: %s") %
2145 raise PatchError(_("patch command failed: %s") %
2146 procutil.explainexit(code))
2146 procutil.explainexit(code))
2147 return fuzz
2147 return fuzz
2148
2148
2149 def patchbackend(ui, backend, patchobj, strip, prefix, files=None,
2149 def patchbackend(ui, backend, patchobj, strip, prefix, files=None,
2150 eolmode='strict'):
2150 eolmode='strict'):
2151 if files is None:
2151 if files is None:
2152 files = set()
2152 files = set()
2153 if eolmode is None:
2153 if eolmode is None:
2154 eolmode = ui.config('patch', 'eol')
2154 eolmode = ui.config('patch', 'eol')
2155 if eolmode.lower() not in eolmodes:
2155 if eolmode.lower() not in eolmodes:
2156 raise error.Abort(_('unsupported line endings type: %s') % eolmode)
2156 raise error.Abort(_('unsupported line endings type: %s') % eolmode)
2157 eolmode = eolmode.lower()
2157 eolmode = eolmode.lower()
2158
2158
2159 store = filestore()
2159 store = filestore()
2160 try:
2160 try:
2161 fp = open(patchobj, 'rb')
2161 fp = open(patchobj, 'rb')
2162 except TypeError:
2162 except TypeError:
2163 fp = patchobj
2163 fp = patchobj
2164 try:
2164 try:
2165 ret = applydiff(ui, fp, backend, store, strip=strip, prefix=prefix,
2165 ret = applydiff(ui, fp, backend, store, strip=strip, prefix=prefix,
2166 eolmode=eolmode)
2166 eolmode=eolmode)
2167 finally:
2167 finally:
2168 if fp != patchobj:
2168 if fp != patchobj:
2169 fp.close()
2169 fp.close()
2170 files.update(backend.close())
2170 files.update(backend.close())
2171 store.close()
2171 store.close()
2172 if ret < 0:
2172 if ret < 0:
2173 raise PatchError(_('patch failed to apply'))
2173 raise PatchError(_('patch failed to apply'))
2174 return ret > 0
2174 return ret > 0
2175
2175
2176 def internalpatch(ui, repo, patchobj, strip, prefix='', files=None,
2176 def internalpatch(ui, repo, patchobj, strip, prefix='', files=None,
2177 eolmode='strict', similarity=0):
2177 eolmode='strict', similarity=0):
2178 """use builtin patch to apply <patchobj> to the working directory.
2178 """use builtin patch to apply <patchobj> to the working directory.
2179 returns whether patch was applied with fuzz factor."""
2179 returns whether patch was applied with fuzz factor."""
2180 backend = workingbackend(ui, repo, similarity)
2180 backend = workingbackend(ui, repo, similarity)
2181 return patchbackend(ui, backend, patchobj, strip, prefix, files, eolmode)
2181 return patchbackend(ui, backend, patchobj, strip, prefix, files, eolmode)
2182
2182
2183 def patchrepo(ui, repo, ctx, store, patchobj, strip, prefix, files=None,
2183 def patchrepo(ui, repo, ctx, store, patchobj, strip, prefix, files=None,
2184 eolmode='strict'):
2184 eolmode='strict'):
2185 backend = repobackend(ui, repo, ctx, store)
2185 backend = repobackend(ui, repo, ctx, store)
2186 return patchbackend(ui, backend, patchobj, strip, prefix, files, eolmode)
2186 return patchbackend(ui, backend, patchobj, strip, prefix, files, eolmode)
2187
2187
2188 def patch(ui, repo, patchname, strip=1, prefix='', files=None, eolmode='strict',
2188 def patch(ui, repo, patchname, strip=1, prefix='', files=None, eolmode='strict',
2189 similarity=0):
2189 similarity=0):
2190 """Apply <patchname> to the working directory.
2190 """Apply <patchname> to the working directory.
2191
2191
2192 'eolmode' specifies how end of lines should be handled. It can be:
2192 'eolmode' specifies how end of lines should be handled. It can be:
2193 - 'strict': inputs are read in binary mode, EOLs are preserved
2193 - 'strict': inputs are read in binary mode, EOLs are preserved
2194 - 'crlf': EOLs are ignored when patching and reset to CRLF
2194 - 'crlf': EOLs are ignored when patching and reset to CRLF
2195 - 'lf': EOLs are ignored when patching and reset to LF
2195 - 'lf': EOLs are ignored when patching and reset to LF
2196 - None: get it from user settings, default to 'strict'
2196 - None: get it from user settings, default to 'strict'
2197 'eolmode' is ignored when using an external patcher program.
2197 'eolmode' is ignored when using an external patcher program.
2198
2198
2199 Returns whether patch was applied with fuzz factor.
2199 Returns whether patch was applied with fuzz factor.
2200 """
2200 """
2201 patcher = ui.config('ui', 'patch')
2201 patcher = ui.config('ui', 'patch')
2202 if files is None:
2202 if files is None:
2203 files = set()
2203 files = set()
2204 if patcher:
2204 if patcher:
2205 return _externalpatch(ui, repo, patcher, patchname, strip,
2205 return _externalpatch(ui, repo, patcher, patchname, strip,
2206 files, similarity)
2206 files, similarity)
2207 return internalpatch(ui, repo, patchname, strip, prefix, files, eolmode,
2207 return internalpatch(ui, repo, patchname, strip, prefix, files, eolmode,
2208 similarity)
2208 similarity)
2209
2209
2210 def changedfiles(ui, repo, patchpath, strip=1, prefix=''):
2210 def changedfiles(ui, repo, patchpath, strip=1, prefix=''):
2211 backend = fsbackend(ui, repo.root)
2211 backend = fsbackend(ui, repo.root)
2212 prefix = _canonprefix(repo, prefix)
2212 prefix = _canonprefix(repo, prefix)
2213 with open(patchpath, 'rb') as fp:
2213 with open(patchpath, 'rb') as fp:
2214 changed = set()
2214 changed = set()
2215 for state, values in iterhunks(fp):
2215 for state, values in iterhunks(fp):
2216 if state == 'file':
2216 if state == 'file':
2217 afile, bfile, first_hunk, gp = values
2217 afile, bfile, first_hunk, gp = values
2218 if gp:
2218 if gp:
2219 gp.path = pathtransform(gp.path, strip - 1, prefix)[1]
2219 gp.path = pathtransform(gp.path, strip - 1, prefix)[1]
2220 if gp.oldpath:
2220 if gp.oldpath:
2221 gp.oldpath = pathtransform(gp.oldpath, strip - 1,
2221 gp.oldpath = pathtransform(gp.oldpath, strip - 1,
2222 prefix)[1]
2222 prefix)[1]
2223 else:
2223 else:
2224 gp = makepatchmeta(backend, afile, bfile, first_hunk, strip,
2224 gp = makepatchmeta(backend, afile, bfile, first_hunk, strip,
2225 prefix)
2225 prefix)
2226 changed.add(gp.path)
2226 changed.add(gp.path)
2227 if gp.op == 'RENAME':
2227 if gp.op == 'RENAME':
2228 changed.add(gp.oldpath)
2228 changed.add(gp.oldpath)
2229 elif state not in ('hunk', 'git'):
2229 elif state not in ('hunk', 'git'):
2230 raise error.Abort(_('unsupported parser state: %s') % state)
2230 raise error.Abort(_('unsupported parser state: %s') % state)
2231 return changed
2231 return changed
2232
2232
2233 class GitDiffRequired(Exception):
2233 class GitDiffRequired(Exception):
2234 pass
2234 pass
2235
2235
2236 diffopts = diffutil.diffallopts
2236 diffopts = diffutil.diffallopts
2237 diffallopts = diffutil.diffallopts
2237 diffallopts = diffutil.diffallopts
2238 difffeatureopts = diffutil.difffeatureopts
2238 difffeatureopts = diffutil.difffeatureopts
2239
2239
2240 def diff(repo, node1=None, node2=None, match=None, changes=None,
2240 def diff(repo, node1=None, node2=None, match=None, changes=None,
2241 opts=None, losedatafn=None, prefix='', relroot='', copy=None,
2241 opts=None, losedatafn=None, prefix='', relroot='', copy=None,
2242 hunksfilterfn=None):
2242 hunksfilterfn=None):
2243 '''yields diff of changes to files between two nodes, or node and
2243 '''yields diff of changes to files between two nodes, or node and
2244 working directory.
2244 working directory.
2245
2245
2246 if node1 is None, use first dirstate parent instead.
2246 if node1 is None, use first dirstate parent instead.
2247 if node2 is None, compare node1 with working directory.
2247 if node2 is None, compare node1 with working directory.
2248
2248
2249 losedatafn(**kwarg) is a callable run when opts.upgrade=True and
2249 losedatafn(**kwarg) is a callable run when opts.upgrade=True and
2250 every time some change cannot be represented with the current
2250 every time some change cannot be represented with the current
2251 patch format. Return False to upgrade to git patch format, True to
2251 patch format. Return False to upgrade to git patch format, True to
2252 accept the loss or raise an exception to abort the diff. It is
2252 accept the loss or raise an exception to abort the diff. It is
2253 called with the name of current file being diffed as 'fn'. If set
2253 called with the name of current file being diffed as 'fn'. If set
2254 to None, patches will always be upgraded to git format when
2254 to None, patches will always be upgraded to git format when
2255 necessary.
2255 necessary.
2256
2256
2257 prefix is a filename prefix that is prepended to all filenames on
2257 prefix is a filename prefix that is prepended to all filenames on
2258 display (used for subrepos).
2258 display (used for subrepos).
2259
2259
2260 relroot, if not empty, must be normalized with a trailing /. Any match
2260 relroot, if not empty, must be normalized with a trailing /. Any match
2261 patterns that fall outside it will be ignored.
2261 patterns that fall outside it will be ignored.
2262
2262
2263 copy, if not empty, should contain mappings {dst@y: src@x} of copy
2263 copy, if not empty, should contain mappings {dst@y: src@x} of copy
2264 information.
2264 information.
2265
2265
2266 hunksfilterfn, if not None, should be a function taking a filectx and
2266 hunksfilterfn, if not None, should be a function taking a filectx and
2267 hunks generator that may yield filtered hunks.
2267 hunks generator that may yield filtered hunks.
2268 '''
2268 '''
2269 for fctx1, fctx2, hdr, hunks in diffhunks(
2269 for fctx1, fctx2, hdr, hunks in diffhunks(
2270 repo, node1=node1, node2=node2,
2270 repo, node1=node1, node2=node2,
2271 match=match, changes=changes, opts=opts,
2271 match=match, changes=changes, opts=opts,
2272 losedatafn=losedatafn, prefix=prefix, relroot=relroot, copy=copy,
2272 losedatafn=losedatafn, prefix=prefix, relroot=relroot, copy=copy,
2273 ):
2273 ):
2274 if hunksfilterfn is not None:
2274 if hunksfilterfn is not None:
2275 # If the file has been removed, fctx2 is None; but this should
2275 # If the file has been removed, fctx2 is None; but this should
2276 # not occur here since we catch removed files early in
2276 # not occur here since we catch removed files early in
2277 # logcmdutil.getlinerangerevs() for 'hg log -L'.
2277 # logcmdutil.getlinerangerevs() for 'hg log -L'.
2278 assert fctx2 is not None, \
2278 assert fctx2 is not None, \
2279 'fctx2 unexpectly None in diff hunks filtering'
2279 'fctx2 unexpectly None in diff hunks filtering'
2280 hunks = hunksfilterfn(fctx2, hunks)
2280 hunks = hunksfilterfn(fctx2, hunks)
2281 text = ''.join(sum((list(hlines) for hrange, hlines in hunks), []))
2281 text = ''.join(sum((list(hlines) for hrange, hlines in hunks), []))
2282 if hdr and (text or len(hdr) > 1):
2282 if hdr and (text or len(hdr) > 1):
2283 yield '\n'.join(hdr) + '\n'
2283 yield '\n'.join(hdr) + '\n'
2284 if text:
2284 if text:
2285 yield text
2285 yield text
2286
2286
2287 def diffhunks(repo, node1=None, node2=None, match=None, changes=None,
2287 def diffhunks(repo, node1=None, node2=None, match=None, changes=None,
2288 opts=None, losedatafn=None, prefix='', relroot='', copy=None):
2288 opts=None, losedatafn=None, prefix='', relroot='', copy=None):
2289 """Yield diff of changes to files in the form of (`header`, `hunks`) tuples
2289 """Yield diff of changes to files in the form of (`header`, `hunks`) tuples
2290 where `header` is a list of diff headers and `hunks` is an iterable of
2290 where `header` is a list of diff headers and `hunks` is an iterable of
2291 (`hunkrange`, `hunklines`) tuples.
2291 (`hunkrange`, `hunklines`) tuples.
2292
2292
2293 See diff() for the meaning of parameters.
2293 See diff() for the meaning of parameters.
2294 """
2294 """
2295
2295
2296 if opts is None:
2296 if opts is None:
2297 opts = mdiff.defaultopts
2297 opts = mdiff.defaultopts
2298
2298
2299 if not node1 and not node2:
2299 if not node1 and not node2:
2300 node1 = repo.dirstate.p1()
2300 node1 = repo.dirstate.p1()
2301
2301
2302 def lrugetfilectx():
2302 def lrugetfilectx():
2303 cache = {}
2303 cache = {}
2304 order = collections.deque()
2304 order = collections.deque()
2305 def getfilectx(f, ctx):
2305 def getfilectx(f, ctx):
2306 fctx = ctx.filectx(f, filelog=cache.get(f))
2306 fctx = ctx.filectx(f, filelog=cache.get(f))
2307 if f not in cache:
2307 if f not in cache:
2308 if len(cache) > 20:
2308 if len(cache) > 20:
2309 del cache[order.popleft()]
2309 del cache[order.popleft()]
2310 cache[f] = fctx.filelog()
2310 cache[f] = fctx.filelog()
2311 else:
2311 else:
2312 order.remove(f)
2312 order.remove(f)
2313 order.append(f)
2313 order.append(f)
2314 return fctx
2314 return fctx
2315 return getfilectx
2315 return getfilectx
2316 getfilectx = lrugetfilectx()
2316 getfilectx = lrugetfilectx()
2317
2317
2318 ctx1 = repo[node1]
2318 ctx1 = repo[node1]
2319 ctx2 = repo[node2]
2319 ctx2 = repo[node2]
2320
2320
2321 relfiltered = False
2321 relfiltered = False
2322 if relroot != '' and match.always():
2322 if relroot != '' and match.always():
2323 # as a special case, create a new matcher with just the relroot
2323 # as a special case, create a new matcher with just the relroot
2324 pats = [relroot]
2324 pats = [relroot]
2325 match = scmutil.match(ctx2, pats, default='path')
2325 match = scmutil.match(ctx2, pats, default='path')
2326 relfiltered = True
2326 relfiltered = True
2327
2327
2328 if not changes:
2328 if not changes:
2329 changes = repo.status(ctx1, ctx2, match=match)
2329 changes = repo.status(ctx1, ctx2, match=match)
2330 modified, added, removed = changes[:3]
2330 modified, added, removed = changes[:3]
2331
2331
2332 if not modified and not added and not removed:
2332 if not modified and not added and not removed:
2333 return []
2333 return []
2334
2334
2335 if repo.ui.debugflag:
2335 if repo.ui.debugflag:
2336 hexfunc = hex
2336 hexfunc = hex
2337 else:
2337 else:
2338 hexfunc = short
2338 hexfunc = short
2339 revs = [hexfunc(node) for node in [ctx1.node(), ctx2.node()] if node]
2339 revs = [hexfunc(node) for node in [ctx1.node(), ctx2.node()] if node]
2340
2340
2341 if copy is None:
2341 if copy is None:
2342 copy = {}
2342 copy = {}
2343 if opts.git or opts.upgrade:
2343 if opts.git or opts.upgrade:
2344 copy = copies.pathcopies(ctx1, ctx2, match=match)
2344 copy = copies.pathcopies(ctx1, ctx2, match=match)
2345
2345
2346 if relroot is not None:
2346 if relroot is not None:
2347 if not relfiltered:
2347 if not relfiltered:
2348 # XXX this would ideally be done in the matcher, but that is
2348 # XXX this would ideally be done in the matcher, but that is
2349 # generally meant to 'or' patterns, not 'and' them. In this case we
2349 # generally meant to 'or' patterns, not 'and' them. In this case we
2350 # need to 'and' all the patterns from the matcher with relroot.
2350 # need to 'and' all the patterns from the matcher with relroot.
2351 def filterrel(l):
2351 def filterrel(l):
2352 return [f for f in l if f.startswith(relroot)]
2352 return [f for f in l if f.startswith(relroot)]
2353 modified = filterrel(modified)
2353 modified = filterrel(modified)
2354 added = filterrel(added)
2354 added = filterrel(added)
2355 removed = filterrel(removed)
2355 removed = filterrel(removed)
2356 relfiltered = True
2356 relfiltered = True
2357 # filter out copies where either side isn't inside the relative root
2357 # filter out copies where either side isn't inside the relative root
2358 copy = dict(((dst, src) for (dst, src) in copy.iteritems()
2358 copy = dict(((dst, src) for (dst, src) in copy.iteritems()
2359 if dst.startswith(relroot)
2359 if dst.startswith(relroot)
2360 and src.startswith(relroot)))
2360 and src.startswith(relroot)))
2361
2361
2362 modifiedset = set(modified)
2362 modifiedset = set(modified)
2363 addedset = set(added)
2363 addedset = set(added)
2364 removedset = set(removed)
2364 removedset = set(removed)
2365 for f in modified:
2365 for f in modified:
2366 if f not in ctx1:
2366 if f not in ctx1:
2367 # Fix up added, since merged-in additions appear as
2367 # Fix up added, since merged-in additions appear as
2368 # modifications during merges
2368 # modifications during merges
2369 modifiedset.remove(f)
2369 modifiedset.remove(f)
2370 addedset.add(f)
2370 addedset.add(f)
2371 for f in removed:
2371 for f in removed:
2372 if f not in ctx1:
2372 if f not in ctx1:
2373 # Merged-in additions that are then removed are reported as removed.
2373 # Merged-in additions that are then removed are reported as removed.
2374 # They are not in ctx1, so We don't want to show them in the diff.
2374 # They are not in ctx1, so We don't want to show them in the diff.
2375 removedset.remove(f)
2375 removedset.remove(f)
2376 modified = sorted(modifiedset)
2376 modified = sorted(modifiedset)
2377 added = sorted(addedset)
2377 added = sorted(addedset)
2378 removed = sorted(removedset)
2378 removed = sorted(removedset)
2379 for dst, src in list(copy.items()):
2379 for dst, src in list(copy.items()):
2380 if src not in ctx1:
2380 if src not in ctx1:
2381 # Files merged in during a merge and then copied/renamed are
2381 # Files merged in during a merge and then copied/renamed are
2382 # reported as copies. We want to show them in the diff as additions.
2382 # reported as copies. We want to show them in the diff as additions.
2383 del copy[dst]
2383 del copy[dst]
2384
2384
2385 prefetchmatch = scmutil.matchfiles(
2385 prefetchmatch = scmutil.matchfiles(
2386 repo, list(modifiedset | addedset | removedset))
2386 repo, list(modifiedset | addedset | removedset))
2387 scmutil.prefetchfiles(repo, [ctx1.rev(), ctx2.rev()], prefetchmatch)
2387 scmutil.prefetchfiles(repo, [ctx1.rev(), ctx2.rev()], prefetchmatch)
2388
2388
2389 def difffn(opts, losedata):
2389 def difffn(opts, losedata):
2390 return trydiff(repo, revs, ctx1, ctx2, modified, added, removed,
2390 return trydiff(repo, revs, ctx1, ctx2, modified, added, removed,
2391 copy, getfilectx, opts, losedata, prefix, relroot)
2391 copy, getfilectx, opts, losedata, prefix, relroot)
2392 if opts.upgrade and not opts.git:
2392 if opts.upgrade and not opts.git:
2393 try:
2393 try:
2394 def losedata(fn):
2394 def losedata(fn):
2395 if not losedatafn or not losedatafn(fn=fn):
2395 if not losedatafn or not losedatafn(fn=fn):
2396 raise GitDiffRequired
2396 raise GitDiffRequired
2397 # Buffer the whole output until we are sure it can be generated
2397 # Buffer the whole output until we are sure it can be generated
2398 return list(difffn(opts.copy(git=False), losedata))
2398 return list(difffn(opts.copy(git=False), losedata))
2399 except GitDiffRequired:
2399 except GitDiffRequired:
2400 return difffn(opts.copy(git=True), None)
2400 return difffn(opts.copy(git=True), None)
2401 else:
2401 else:
2402 return difffn(opts, None)
2402 return difffn(opts, None)
2403
2403
2404 def diffsinglehunk(hunklines):
2404 def diffsinglehunk(hunklines):
2405 """yield tokens for a list of lines in a single hunk"""
2405 """yield tokens for a list of lines in a single hunk"""
2406 for line in hunklines:
2406 for line in hunklines:
2407 # chomp
2407 # chomp
2408 chompline = line.rstrip('\n')
2408 chompline = line.rstrip('\r\n')
2409 # highlight tabs and trailing whitespace
2409 # highlight tabs and trailing whitespace
2410 stripline = chompline.rstrip()
2410 stripline = chompline.rstrip()
2411 if line.startswith('-'):
2411 if line.startswith('-'):
2412 label = 'diff.deleted'
2412 label = 'diff.deleted'
2413 elif line.startswith('+'):
2413 elif line.startswith('+'):
2414 label = 'diff.inserted'
2414 label = 'diff.inserted'
2415 else:
2415 else:
2416 raise error.ProgrammingError('unexpected hunk line: %s' % line)
2416 raise error.ProgrammingError('unexpected hunk line: %s' % line)
2417 for token in tabsplitter.findall(stripline):
2417 for token in tabsplitter.findall(stripline):
2418 if token.startswith('\t'):
2418 if token.startswith('\t'):
2419 yield (token, 'diff.tab')
2419 yield (token, 'diff.tab')
2420 else:
2420 else:
2421 yield (token, label)
2421 yield (token, label)
2422
2422
2423 if chompline != stripline:
2423 if chompline != stripline:
2424 yield (chompline[len(stripline):], 'diff.trailingwhitespace')
2424 yield (chompline[len(stripline):], 'diff.trailingwhitespace')
2425 if chompline != line:
2425 if chompline != line:
2426 yield (line[len(chompline):], '')
2426 yield (line[len(chompline):], '')
2427
2427
2428 def diffsinglehunkinline(hunklines):
2428 def diffsinglehunkinline(hunklines):
2429 """yield tokens for a list of lines in a single hunk, with inline colors"""
2429 """yield tokens for a list of lines in a single hunk, with inline colors"""
2430 # prepare deleted, and inserted content
2430 # prepare deleted, and inserted content
2431 a = ''
2431 a = ''
2432 b = ''
2432 b = ''
2433 for line in hunklines:
2433 for line in hunklines:
2434 if line[0] == '-':
2434 if line[0] == '-':
2435 a += line[1:]
2435 a += line[1:]
2436 elif line[0] == '+':
2436 elif line[0] == '+':
2437 b += line[1:]
2437 b += line[1:]
2438 else:
2438 else:
2439 raise error.ProgrammingError('unexpected hunk line: %s' % line)
2439 raise error.ProgrammingError('unexpected hunk line: %s' % line)
2440 # fast path: if either side is empty, use diffsinglehunk
2440 # fast path: if either side is empty, use diffsinglehunk
2441 if not a or not b:
2441 if not a or not b:
2442 for t in diffsinglehunk(hunklines):
2442 for t in diffsinglehunk(hunklines):
2443 yield t
2443 yield t
2444 return
2444 return
2445 # re-split the content into words
2445 # re-split the content into words
2446 al = wordsplitter.findall(a)
2446 al = wordsplitter.findall(a)
2447 bl = wordsplitter.findall(b)
2447 bl = wordsplitter.findall(b)
2448 # re-arrange the words to lines since the diff algorithm is line-based
2448 # re-arrange the words to lines since the diff algorithm is line-based
2449 aln = [s if s == '\n' else s + '\n' for s in al]
2449 aln = [s if s == '\n' else s + '\n' for s in al]
2450 bln = [s if s == '\n' else s + '\n' for s in bl]
2450 bln = [s if s == '\n' else s + '\n' for s in bl]
2451 an = ''.join(aln)
2451 an = ''.join(aln)
2452 bn = ''.join(bln)
2452 bn = ''.join(bln)
2453 # run the diff algorithm, prepare atokens and btokens
2453 # run the diff algorithm, prepare atokens and btokens
2454 atokens = []
2454 atokens = []
2455 btokens = []
2455 btokens = []
2456 blocks = mdiff.allblocks(an, bn, lines1=aln, lines2=bln)
2456 blocks = mdiff.allblocks(an, bn, lines1=aln, lines2=bln)
2457 for (a1, a2, b1, b2), btype in blocks:
2457 for (a1, a2, b1, b2), btype in blocks:
2458 changed = btype == '!'
2458 changed = btype == '!'
2459 for token in mdiff.splitnewlines(''.join(al[a1:a2])):
2459 for token in mdiff.splitnewlines(''.join(al[a1:a2])):
2460 atokens.append((changed, token))
2460 atokens.append((changed, token))
2461 for token in mdiff.splitnewlines(''.join(bl[b1:b2])):
2461 for token in mdiff.splitnewlines(''.join(bl[b1:b2])):
2462 btokens.append((changed, token))
2462 btokens.append((changed, token))
2463
2463
2464 # yield deleted tokens, then inserted ones
2464 # yield deleted tokens, then inserted ones
2465 for prefix, label, tokens in [('-', 'diff.deleted', atokens),
2465 for prefix, label, tokens in [('-', 'diff.deleted', atokens),
2466 ('+', 'diff.inserted', btokens)]:
2466 ('+', 'diff.inserted', btokens)]:
2467 nextisnewline = True
2467 nextisnewline = True
2468 for changed, token in tokens:
2468 for changed, token in tokens:
2469 if nextisnewline:
2469 if nextisnewline:
2470 yield (prefix, label)
2470 yield (prefix, label)
2471 nextisnewline = False
2471 nextisnewline = False
2472 # special handling line end
2472 # special handling line end
2473 isendofline = token.endswith('\n')
2473 isendofline = token.endswith('\n')
2474 if isendofline:
2474 if isendofline:
2475 chomp = token[:-1] # chomp
2475 chomp = token[:-1] # chomp
2476 if chomp.endswith('\r'):
2477 chomp = chomp[:-1]
2478 endofline = token[len(chomp):]
2476 token = chomp.rstrip() # detect spaces at the end
2479 token = chomp.rstrip() # detect spaces at the end
2477 endspaces = chomp[len(token):]
2480 endspaces = chomp[len(token):]
2478 # scan tabs
2481 # scan tabs
2479 for maybetab in tabsplitter.findall(token):
2482 for maybetab in tabsplitter.findall(token):
2480 if '\t' == maybetab[0]:
2483 if '\t' == maybetab[0]:
2481 currentlabel = 'diff.tab'
2484 currentlabel = 'diff.tab'
2482 else:
2485 else:
2483 if changed:
2486 if changed:
2484 currentlabel = label + '.changed'
2487 currentlabel = label + '.changed'
2485 else:
2488 else:
2486 currentlabel = label + '.unchanged'
2489 currentlabel = label + '.unchanged'
2487 yield (maybetab, currentlabel)
2490 yield (maybetab, currentlabel)
2488 if isendofline:
2491 if isendofline:
2489 if endspaces:
2492 if endspaces:
2490 yield (endspaces, 'diff.trailingwhitespace')
2493 yield (endspaces, 'diff.trailingwhitespace')
2491 yield ('\n', '')
2494 yield (endofline, '')
2492 nextisnewline = True
2495 nextisnewline = True
2493
2496
2494 def difflabel(func, *args, **kw):
2497 def difflabel(func, *args, **kw):
2495 '''yields 2-tuples of (output, label) based on the output of func()'''
2498 '''yields 2-tuples of (output, label) based on the output of func()'''
2496 if kw.get(r'opts') and kw[r'opts'].worddiff:
2499 if kw.get(r'opts') and kw[r'opts'].worddiff:
2497 dodiffhunk = diffsinglehunkinline
2500 dodiffhunk = diffsinglehunkinline
2498 else:
2501 else:
2499 dodiffhunk = diffsinglehunk
2502 dodiffhunk = diffsinglehunk
2500 headprefixes = [('diff', 'diff.diffline'),
2503 headprefixes = [('diff', 'diff.diffline'),
2501 ('copy', 'diff.extended'),
2504 ('copy', 'diff.extended'),
2502 ('rename', 'diff.extended'),
2505 ('rename', 'diff.extended'),
2503 ('old', 'diff.extended'),
2506 ('old', 'diff.extended'),
2504 ('new', 'diff.extended'),
2507 ('new', 'diff.extended'),
2505 ('deleted', 'diff.extended'),
2508 ('deleted', 'diff.extended'),
2506 ('index', 'diff.extended'),
2509 ('index', 'diff.extended'),
2507 ('similarity', 'diff.extended'),
2510 ('similarity', 'diff.extended'),
2508 ('---', 'diff.file_a'),
2511 ('---', 'diff.file_a'),
2509 ('+++', 'diff.file_b')]
2512 ('+++', 'diff.file_b')]
2510 textprefixes = [('@', 'diff.hunk'),
2513 textprefixes = [('@', 'diff.hunk'),
2511 # - and + are handled by diffsinglehunk
2514 # - and + are handled by diffsinglehunk
2512 ]
2515 ]
2513 head = False
2516 head = False
2514
2517
2515 # buffers a hunk, i.e. adjacent "-", "+" lines without other changes.
2518 # buffers a hunk, i.e. adjacent "-", "+" lines without other changes.
2516 hunkbuffer = []
2519 hunkbuffer = []
2517 def consumehunkbuffer():
2520 def consumehunkbuffer():
2518 if hunkbuffer:
2521 if hunkbuffer:
2519 for token in dodiffhunk(hunkbuffer):
2522 for token in dodiffhunk(hunkbuffer):
2520 yield token
2523 yield token
2521 hunkbuffer[:] = []
2524 hunkbuffer[:] = []
2522
2525
2523 for chunk in func(*args, **kw):
2526 for chunk in func(*args, **kw):
2524 lines = chunk.split('\n')
2527 lines = chunk.split('\n')
2525 linecount = len(lines)
2528 linecount = len(lines)
2526 for i, line in enumerate(lines):
2529 for i, line in enumerate(lines):
2527 if head:
2530 if head:
2528 if line.startswith('@'):
2531 if line.startswith('@'):
2529 head = False
2532 head = False
2530 else:
2533 else:
2531 if line and not line.startswith((' ', '+', '-', '@', '\\')):
2534 if line and not line.startswith((' ', '+', '-', '@', '\\')):
2532 head = True
2535 head = True
2533 diffline = False
2536 diffline = False
2534 if not head and line and line.startswith(('+', '-')):
2537 if not head and line and line.startswith(('+', '-')):
2535 diffline = True
2538 diffline = True
2536
2539
2537 prefixes = textprefixes
2540 prefixes = textprefixes
2538 if head:
2541 if head:
2539 prefixes = headprefixes
2542 prefixes = headprefixes
2540 if diffline:
2543 if diffline:
2541 # buffered
2544 # buffered
2542 bufferedline = line
2545 bufferedline = line
2543 if i + 1 < linecount:
2546 if i + 1 < linecount:
2544 bufferedline += "\n"
2547 bufferedline += "\n"
2545 hunkbuffer.append(bufferedline)
2548 hunkbuffer.append(bufferedline)
2546 else:
2549 else:
2547 # unbuffered
2550 # unbuffered
2548 for token in consumehunkbuffer():
2551 for token in consumehunkbuffer():
2549 yield token
2552 yield token
2550 stripline = line.rstrip()
2553 stripline = line.rstrip()
2551 for prefix, label in prefixes:
2554 for prefix, label in prefixes:
2552 if stripline.startswith(prefix):
2555 if stripline.startswith(prefix):
2553 yield (stripline, label)
2556 yield (stripline, label)
2554 if line != stripline:
2557 if line != stripline:
2555 yield (line[len(stripline):],
2558 yield (line[len(stripline):],
2556 'diff.trailingwhitespace')
2559 'diff.trailingwhitespace')
2557 break
2560 break
2558 else:
2561 else:
2559 yield (line, '')
2562 yield (line, '')
2560 if i + 1 < linecount:
2563 if i + 1 < linecount:
2561 yield ('\n', '')
2564 yield ('\n', '')
2562 for token in consumehunkbuffer():
2565 for token in consumehunkbuffer():
2563 yield token
2566 yield token
2564
2567
2565 def diffui(*args, **kw):
2568 def diffui(*args, **kw):
2566 '''like diff(), but yields 2-tuples of (output, label) for ui.write()'''
2569 '''like diff(), but yields 2-tuples of (output, label) for ui.write()'''
2567 return difflabel(diff, *args, **kw)
2570 return difflabel(diff, *args, **kw)
2568
2571
2569 def _filepairs(modified, added, removed, copy, opts):
2572 def _filepairs(modified, added, removed, copy, opts):
2570 '''generates tuples (f1, f2, copyop), where f1 is the name of the file
2573 '''generates tuples (f1, f2, copyop), where f1 is the name of the file
2571 before and f2 is the the name after. For added files, f1 will be None,
2574 before and f2 is the the name after. For added files, f1 will be None,
2572 and for removed files, f2 will be None. copyop may be set to None, 'copy'
2575 and for removed files, f2 will be None. copyop may be set to None, 'copy'
2573 or 'rename' (the latter two only if opts.git is set).'''
2576 or 'rename' (the latter two only if opts.git is set).'''
2574 gone = set()
2577 gone = set()
2575
2578
2576 copyto = dict([(v, k) for k, v in copy.items()])
2579 copyto = dict([(v, k) for k, v in copy.items()])
2577
2580
2578 addedset, removedset = set(added), set(removed)
2581 addedset, removedset = set(added), set(removed)
2579
2582
2580 for f in sorted(modified + added + removed):
2583 for f in sorted(modified + added + removed):
2581 copyop = None
2584 copyop = None
2582 f1, f2 = f, f
2585 f1, f2 = f, f
2583 if f in addedset:
2586 if f in addedset:
2584 f1 = None
2587 f1 = None
2585 if f in copy:
2588 if f in copy:
2586 if opts.git:
2589 if opts.git:
2587 f1 = copy[f]
2590 f1 = copy[f]
2588 if f1 in removedset and f1 not in gone:
2591 if f1 in removedset and f1 not in gone:
2589 copyop = 'rename'
2592 copyop = 'rename'
2590 gone.add(f1)
2593 gone.add(f1)
2591 else:
2594 else:
2592 copyop = 'copy'
2595 copyop = 'copy'
2593 elif f in removedset:
2596 elif f in removedset:
2594 f2 = None
2597 f2 = None
2595 if opts.git:
2598 if opts.git:
2596 # have we already reported a copy above?
2599 # have we already reported a copy above?
2597 if (f in copyto and copyto[f] in addedset
2600 if (f in copyto and copyto[f] in addedset
2598 and copy[copyto[f]] == f):
2601 and copy[copyto[f]] == f):
2599 continue
2602 continue
2600 yield f1, f2, copyop
2603 yield f1, f2, copyop
2601
2604
2602 def trydiff(repo, revs, ctx1, ctx2, modified, added, removed,
2605 def trydiff(repo, revs, ctx1, ctx2, modified, added, removed,
2603 copy, getfilectx, opts, losedatafn, prefix, relroot):
2606 copy, getfilectx, opts, losedatafn, prefix, relroot):
2604 '''given input data, generate a diff and yield it in blocks
2607 '''given input data, generate a diff and yield it in blocks
2605
2608
2606 If generating a diff would lose data like flags or binary data and
2609 If generating a diff would lose data like flags or binary data and
2607 losedatafn is not None, it will be called.
2610 losedatafn is not None, it will be called.
2608
2611
2609 relroot is removed and prefix is added to every path in the diff output.
2612 relroot is removed and prefix is added to every path in the diff output.
2610
2613
2611 If relroot is not empty, this function expects every path in modified,
2614 If relroot is not empty, this function expects every path in modified,
2612 added, removed and copy to start with it.'''
2615 added, removed and copy to start with it.'''
2613
2616
2614 def gitindex(text):
2617 def gitindex(text):
2615 if not text:
2618 if not text:
2616 text = ""
2619 text = ""
2617 l = len(text)
2620 l = len(text)
2618 s = hashlib.sha1('blob %d\0' % l)
2621 s = hashlib.sha1('blob %d\0' % l)
2619 s.update(text)
2622 s.update(text)
2620 return hex(s.digest())
2623 return hex(s.digest())
2621
2624
2622 if opts.noprefix:
2625 if opts.noprefix:
2623 aprefix = bprefix = ''
2626 aprefix = bprefix = ''
2624 else:
2627 else:
2625 aprefix = 'a/'
2628 aprefix = 'a/'
2626 bprefix = 'b/'
2629 bprefix = 'b/'
2627
2630
2628 def diffline(f, revs):
2631 def diffline(f, revs):
2629 revinfo = ' '.join(["-r %s" % rev for rev in revs])
2632 revinfo = ' '.join(["-r %s" % rev for rev in revs])
2630 return 'diff %s %s' % (revinfo, f)
2633 return 'diff %s %s' % (revinfo, f)
2631
2634
2632 def isempty(fctx):
2635 def isempty(fctx):
2633 return fctx is None or fctx.size() == 0
2636 return fctx is None or fctx.size() == 0
2634
2637
2635 date1 = dateutil.datestr(ctx1.date())
2638 date1 = dateutil.datestr(ctx1.date())
2636 date2 = dateutil.datestr(ctx2.date())
2639 date2 = dateutil.datestr(ctx2.date())
2637
2640
2638 gitmode = {'l': '120000', 'x': '100755', '': '100644'}
2641 gitmode = {'l': '120000', 'x': '100755', '': '100644'}
2639
2642
2640 if relroot != '' and (repo.ui.configbool('devel', 'all-warnings')
2643 if relroot != '' and (repo.ui.configbool('devel', 'all-warnings')
2641 or repo.ui.configbool('devel', 'check-relroot')):
2644 or repo.ui.configbool('devel', 'check-relroot')):
2642 for f in modified + added + removed + list(copy) + list(copy.values()):
2645 for f in modified + added + removed + list(copy) + list(copy.values()):
2643 if f is not None and not f.startswith(relroot):
2646 if f is not None and not f.startswith(relroot):
2644 raise AssertionError(
2647 raise AssertionError(
2645 "file %s doesn't start with relroot %s" % (f, relroot))
2648 "file %s doesn't start with relroot %s" % (f, relroot))
2646
2649
2647 for f1, f2, copyop in _filepairs(modified, added, removed, copy, opts):
2650 for f1, f2, copyop in _filepairs(modified, added, removed, copy, opts):
2648 content1 = None
2651 content1 = None
2649 content2 = None
2652 content2 = None
2650 fctx1 = None
2653 fctx1 = None
2651 fctx2 = None
2654 fctx2 = None
2652 flag1 = None
2655 flag1 = None
2653 flag2 = None
2656 flag2 = None
2654 if f1:
2657 if f1:
2655 fctx1 = getfilectx(f1, ctx1)
2658 fctx1 = getfilectx(f1, ctx1)
2656 if opts.git or losedatafn:
2659 if opts.git or losedatafn:
2657 flag1 = ctx1.flags(f1)
2660 flag1 = ctx1.flags(f1)
2658 if f2:
2661 if f2:
2659 fctx2 = getfilectx(f2, ctx2)
2662 fctx2 = getfilectx(f2, ctx2)
2660 if opts.git or losedatafn:
2663 if opts.git or losedatafn:
2661 flag2 = ctx2.flags(f2)
2664 flag2 = ctx2.flags(f2)
2662 # if binary is True, output "summary" or "base85", but not "text diff"
2665 # if binary is True, output "summary" or "base85", but not "text diff"
2663 if opts.text:
2666 if opts.text:
2664 binary = False
2667 binary = False
2665 else:
2668 else:
2666 binary = any(f.isbinary() for f in [fctx1, fctx2] if f is not None)
2669 binary = any(f.isbinary() for f in [fctx1, fctx2] if f is not None)
2667
2670
2668 if losedatafn and not opts.git:
2671 if losedatafn and not opts.git:
2669 if (binary or
2672 if (binary or
2670 # copy/rename
2673 # copy/rename
2671 f2 in copy or
2674 f2 in copy or
2672 # empty file creation
2675 # empty file creation
2673 (not f1 and isempty(fctx2)) or
2676 (not f1 and isempty(fctx2)) or
2674 # empty file deletion
2677 # empty file deletion
2675 (isempty(fctx1) and not f2) or
2678 (isempty(fctx1) and not f2) or
2676 # create with flags
2679 # create with flags
2677 (not f1 and flag2) or
2680 (not f1 and flag2) or
2678 # change flags
2681 # change flags
2679 (f1 and f2 and flag1 != flag2)):
2682 (f1 and f2 and flag1 != flag2)):
2680 losedatafn(f2 or f1)
2683 losedatafn(f2 or f1)
2681
2684
2682 path1 = f1 or f2
2685 path1 = f1 or f2
2683 path2 = f2 or f1
2686 path2 = f2 or f1
2684 path1 = posixpath.join(prefix, path1[len(relroot):])
2687 path1 = posixpath.join(prefix, path1[len(relroot):])
2685 path2 = posixpath.join(prefix, path2[len(relroot):])
2688 path2 = posixpath.join(prefix, path2[len(relroot):])
2686 header = []
2689 header = []
2687 if opts.git:
2690 if opts.git:
2688 header.append('diff --git %s%s %s%s' %
2691 header.append('diff --git %s%s %s%s' %
2689 (aprefix, path1, bprefix, path2))
2692 (aprefix, path1, bprefix, path2))
2690 if not f1: # added
2693 if not f1: # added
2691 header.append('new file mode %s' % gitmode[flag2])
2694 header.append('new file mode %s' % gitmode[flag2])
2692 elif not f2: # removed
2695 elif not f2: # removed
2693 header.append('deleted file mode %s' % gitmode[flag1])
2696 header.append('deleted file mode %s' % gitmode[flag1])
2694 else: # modified/copied/renamed
2697 else: # modified/copied/renamed
2695 mode1, mode2 = gitmode[flag1], gitmode[flag2]
2698 mode1, mode2 = gitmode[flag1], gitmode[flag2]
2696 if mode1 != mode2:
2699 if mode1 != mode2:
2697 header.append('old mode %s' % mode1)
2700 header.append('old mode %s' % mode1)
2698 header.append('new mode %s' % mode2)
2701 header.append('new mode %s' % mode2)
2699 if copyop is not None:
2702 if copyop is not None:
2700 if opts.showsimilarity:
2703 if opts.showsimilarity:
2701 sim = similar.score(ctx1[path1], ctx2[path2]) * 100
2704 sim = similar.score(ctx1[path1], ctx2[path2]) * 100
2702 header.append('similarity index %d%%' % sim)
2705 header.append('similarity index %d%%' % sim)
2703 header.append('%s from %s' % (copyop, path1))
2706 header.append('%s from %s' % (copyop, path1))
2704 header.append('%s to %s' % (copyop, path2))
2707 header.append('%s to %s' % (copyop, path2))
2705 elif revs and not repo.ui.quiet:
2708 elif revs and not repo.ui.quiet:
2706 header.append(diffline(path1, revs))
2709 header.append(diffline(path1, revs))
2707
2710
2708 # fctx.is | diffopts | what to | is fctx.data()
2711 # fctx.is | diffopts | what to | is fctx.data()
2709 # binary() | text nobinary git index | output? | outputted?
2712 # binary() | text nobinary git index | output? | outputted?
2710 # ------------------------------------|----------------------------
2713 # ------------------------------------|----------------------------
2711 # yes | no no no * | summary | no
2714 # yes | no no no * | summary | no
2712 # yes | no no yes * | base85 | yes
2715 # yes | no no yes * | base85 | yes
2713 # yes | no yes no * | summary | no
2716 # yes | no yes no * | summary | no
2714 # yes | no yes yes 0 | summary | no
2717 # yes | no yes yes 0 | summary | no
2715 # yes | no yes yes >0 | summary | semi [1]
2718 # yes | no yes yes >0 | summary | semi [1]
2716 # yes | yes * * * | text diff | yes
2719 # yes | yes * * * | text diff | yes
2717 # no | * * * * | text diff | yes
2720 # no | * * * * | text diff | yes
2718 # [1]: hash(fctx.data()) is outputted. so fctx.data() cannot be faked
2721 # [1]: hash(fctx.data()) is outputted. so fctx.data() cannot be faked
2719 if binary and (not opts.git or (opts.git and opts.nobinary and not
2722 if binary and (not opts.git or (opts.git and opts.nobinary and not
2720 opts.index)):
2723 opts.index)):
2721 # fast path: no binary content will be displayed, content1 and
2724 # fast path: no binary content will be displayed, content1 and
2722 # content2 are only used for equivalent test. cmp() could have a
2725 # content2 are only used for equivalent test. cmp() could have a
2723 # fast path.
2726 # fast path.
2724 if fctx1 is not None:
2727 if fctx1 is not None:
2725 content1 = b'\0'
2728 content1 = b'\0'
2726 if fctx2 is not None:
2729 if fctx2 is not None:
2727 if fctx1 is not None and not fctx1.cmp(fctx2):
2730 if fctx1 is not None and not fctx1.cmp(fctx2):
2728 content2 = b'\0' # not different
2731 content2 = b'\0' # not different
2729 else:
2732 else:
2730 content2 = b'\0\0'
2733 content2 = b'\0\0'
2731 else:
2734 else:
2732 # normal path: load contents
2735 # normal path: load contents
2733 if fctx1 is not None:
2736 if fctx1 is not None:
2734 content1 = fctx1.data()
2737 content1 = fctx1.data()
2735 if fctx2 is not None:
2738 if fctx2 is not None:
2736 content2 = fctx2.data()
2739 content2 = fctx2.data()
2737
2740
2738 if binary and opts.git and not opts.nobinary:
2741 if binary and opts.git and not opts.nobinary:
2739 text = mdiff.b85diff(content1, content2)
2742 text = mdiff.b85diff(content1, content2)
2740 if text:
2743 if text:
2741 header.append('index %s..%s' %
2744 header.append('index %s..%s' %
2742 (gitindex(content1), gitindex(content2)))
2745 (gitindex(content1), gitindex(content2)))
2743 hunks = (None, [text]),
2746 hunks = (None, [text]),
2744 else:
2747 else:
2745 if opts.git and opts.index > 0:
2748 if opts.git and opts.index > 0:
2746 flag = flag1
2749 flag = flag1
2747 if flag is None:
2750 if flag is None:
2748 flag = flag2
2751 flag = flag2
2749 header.append('index %s..%s %s' %
2752 header.append('index %s..%s %s' %
2750 (gitindex(content1)[0:opts.index],
2753 (gitindex(content1)[0:opts.index],
2751 gitindex(content2)[0:opts.index],
2754 gitindex(content2)[0:opts.index],
2752 gitmode[flag]))
2755 gitmode[flag]))
2753
2756
2754 uheaders, hunks = mdiff.unidiff(content1, date1,
2757 uheaders, hunks = mdiff.unidiff(content1, date1,
2755 content2, date2,
2758 content2, date2,
2756 path1, path2,
2759 path1, path2,
2757 binary=binary, opts=opts)
2760 binary=binary, opts=opts)
2758 header.extend(uheaders)
2761 header.extend(uheaders)
2759 yield fctx1, fctx2, header, hunks
2762 yield fctx1, fctx2, header, hunks
2760
2763
2761 def diffstatsum(stats):
2764 def diffstatsum(stats):
2762 maxfile, maxtotal, addtotal, removetotal, binary = 0, 0, 0, 0, False
2765 maxfile, maxtotal, addtotal, removetotal, binary = 0, 0, 0, 0, False
2763 for f, a, r, b in stats:
2766 for f, a, r, b in stats:
2764 maxfile = max(maxfile, encoding.colwidth(f))
2767 maxfile = max(maxfile, encoding.colwidth(f))
2765 maxtotal = max(maxtotal, a + r)
2768 maxtotal = max(maxtotal, a + r)
2766 addtotal += a
2769 addtotal += a
2767 removetotal += r
2770 removetotal += r
2768 binary = binary or b
2771 binary = binary or b
2769
2772
2770 return maxfile, maxtotal, addtotal, removetotal, binary
2773 return maxfile, maxtotal, addtotal, removetotal, binary
2771
2774
2772 def diffstatdata(lines):
2775 def diffstatdata(lines):
2773 diffre = re.compile('^diff .*-r [a-z0-9]+\s(.*)$')
2776 diffre = re.compile('^diff .*-r [a-z0-9]+\s(.*)$')
2774
2777
2775 results = []
2778 results = []
2776 filename, adds, removes, isbinary = None, 0, 0, False
2779 filename, adds, removes, isbinary = None, 0, 0, False
2777
2780
2778 def addresult():
2781 def addresult():
2779 if filename:
2782 if filename:
2780 results.append((filename, adds, removes, isbinary))
2783 results.append((filename, adds, removes, isbinary))
2781
2784
2782 # inheader is used to track if a line is in the
2785 # inheader is used to track if a line is in the
2783 # header portion of the diff. This helps properly account
2786 # header portion of the diff. This helps properly account
2784 # for lines that start with '--' or '++'
2787 # for lines that start with '--' or '++'
2785 inheader = False
2788 inheader = False
2786
2789
2787 for line in lines:
2790 for line in lines:
2788 if line.startswith('diff'):
2791 if line.startswith('diff'):
2789 addresult()
2792 addresult()
2790 # starting a new file diff
2793 # starting a new file diff
2791 # set numbers to 0 and reset inheader
2794 # set numbers to 0 and reset inheader
2792 inheader = True
2795 inheader = True
2793 adds, removes, isbinary = 0, 0, False
2796 adds, removes, isbinary = 0, 0, False
2794 if line.startswith('diff --git a/'):
2797 if line.startswith('diff --git a/'):
2795 filename = gitre.search(line).group(2)
2798 filename = gitre.search(line).group(2)
2796 elif line.startswith('diff -r'):
2799 elif line.startswith('diff -r'):
2797 # format: "diff -r ... -r ... filename"
2800 # format: "diff -r ... -r ... filename"
2798 filename = diffre.search(line).group(1)
2801 filename = diffre.search(line).group(1)
2799 elif line.startswith('@@'):
2802 elif line.startswith('@@'):
2800 inheader = False
2803 inheader = False
2801 elif line.startswith('+') and not inheader:
2804 elif line.startswith('+') and not inheader:
2802 adds += 1
2805 adds += 1
2803 elif line.startswith('-') and not inheader:
2806 elif line.startswith('-') and not inheader:
2804 removes += 1
2807 removes += 1
2805 elif (line.startswith('GIT binary patch') or
2808 elif (line.startswith('GIT binary patch') or
2806 line.startswith('Binary file')):
2809 line.startswith('Binary file')):
2807 isbinary = True
2810 isbinary = True
2808 addresult()
2811 addresult()
2809 return results
2812 return results
2810
2813
2811 def diffstat(lines, width=80):
2814 def diffstat(lines, width=80):
2812 output = []
2815 output = []
2813 stats = diffstatdata(lines)
2816 stats = diffstatdata(lines)
2814 maxname, maxtotal, totaladds, totalremoves, hasbinary = diffstatsum(stats)
2817 maxname, maxtotal, totaladds, totalremoves, hasbinary = diffstatsum(stats)
2815
2818
2816 countwidth = len(str(maxtotal))
2819 countwidth = len(str(maxtotal))
2817 if hasbinary and countwidth < 3:
2820 if hasbinary and countwidth < 3:
2818 countwidth = 3
2821 countwidth = 3
2819 graphwidth = width - countwidth - maxname - 6
2822 graphwidth = width - countwidth - maxname - 6
2820 if graphwidth < 10:
2823 if graphwidth < 10:
2821 graphwidth = 10
2824 graphwidth = 10
2822
2825
2823 def scale(i):
2826 def scale(i):
2824 if maxtotal <= graphwidth:
2827 if maxtotal <= graphwidth:
2825 return i
2828 return i
2826 # If diffstat runs out of room it doesn't print anything,
2829 # If diffstat runs out of room it doesn't print anything,
2827 # which isn't very useful, so always print at least one + or -
2830 # which isn't very useful, so always print at least one + or -
2828 # if there were at least some changes.
2831 # if there were at least some changes.
2829 return max(i * graphwidth // maxtotal, int(bool(i)))
2832 return max(i * graphwidth // maxtotal, int(bool(i)))
2830
2833
2831 for filename, adds, removes, isbinary in stats:
2834 for filename, adds, removes, isbinary in stats:
2832 if isbinary:
2835 if isbinary:
2833 count = 'Bin'
2836 count = 'Bin'
2834 else:
2837 else:
2835 count = '%d' % (adds + removes)
2838 count = '%d' % (adds + removes)
2836 pluses = '+' * scale(adds)
2839 pluses = '+' * scale(adds)
2837 minuses = '-' * scale(removes)
2840 minuses = '-' * scale(removes)
2838 output.append(' %s%s | %*s %s%s\n' %
2841 output.append(' %s%s | %*s %s%s\n' %
2839 (filename, ' ' * (maxname - encoding.colwidth(filename)),
2842 (filename, ' ' * (maxname - encoding.colwidth(filename)),
2840 countwidth, count, pluses, minuses))
2843 countwidth, count, pluses, minuses))
2841
2844
2842 if stats:
2845 if stats:
2843 output.append(_(' %d files changed, %d insertions(+), '
2846 output.append(_(' %d files changed, %d insertions(+), '
2844 '%d deletions(-)\n')
2847 '%d deletions(-)\n')
2845 % (len(stats), totaladds, totalremoves))
2848 % (len(stats), totaladds, totalremoves))
2846
2849
2847 return ''.join(output)
2850 return ''.join(output)
2848
2851
2849 def diffstatui(*args, **kw):
2852 def diffstatui(*args, **kw):
2850 '''like diffstat(), but yields 2-tuples of (output, label) for
2853 '''like diffstat(), but yields 2-tuples of (output, label) for
2851 ui.write()
2854 ui.write()
2852 '''
2855 '''
2853
2856
2854 for line in diffstat(*args, **kw).splitlines():
2857 for line in diffstat(*args, **kw).splitlines():
2855 if line and line[-1] in '+-':
2858 if line and line[-1] in '+-':
2856 name, graph = line.rsplit(' ', 1)
2859 name, graph = line.rsplit(' ', 1)
2857 yield (name + ' ', '')
2860 yield (name + ' ', '')
2858 m = re.search(br'\++', graph)
2861 m = re.search(br'\++', graph)
2859 if m:
2862 if m:
2860 yield (m.group(0), 'diffstat.inserted')
2863 yield (m.group(0), 'diffstat.inserted')
2861 m = re.search(br'-+', graph)
2864 m = re.search(br'-+', graph)
2862 if m:
2865 if m:
2863 yield (m.group(0), 'diffstat.deleted')
2866 yield (m.group(0), 'diffstat.deleted')
2864 else:
2867 else:
2865 yield (line, '')
2868 yield (line, '')
2866 yield ('\n', '')
2869 yield ('\n', '')
General Comments 0
You need to be logged in to leave comments. Login now