##// END OF EJS Templates
patch: refactor iterhunks() regular and binary files emission
Patrick Mezard -
r14383:1bd52cb1 default
parent child Browse files
Show More
@@ -1,1780 +1,1778 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 import cStringIO, email.Parser, os, errno, re
9 import cStringIO, email.Parser, os, errno, re
10 import tempfile, zlib
10 import tempfile, zlib
11
11
12 from i18n import _
12 from i18n import _
13 from node import hex, nullid, short
13 from node import hex, nullid, short
14 import base85, mdiff, scmutil, util, diffhelpers, copies, encoding
14 import base85, mdiff, scmutil, util, diffhelpers, copies, encoding
15
15
16 gitre = re.compile('diff --git a/(.*) b/(.*)')
16 gitre = re.compile('diff --git a/(.*) b/(.*)')
17
17
18 class PatchError(Exception):
18 class PatchError(Exception):
19 pass
19 pass
20
20
21
21
22 # public functions
22 # public functions
23
23
24 def split(stream):
24 def split(stream):
25 '''return an iterator of individual patches from a stream'''
25 '''return an iterator of individual patches from a stream'''
26 def isheader(line, inheader):
26 def isheader(line, inheader):
27 if inheader and line[0] in (' ', '\t'):
27 if inheader and line[0] in (' ', '\t'):
28 # continuation
28 # continuation
29 return True
29 return True
30 if line[0] in (' ', '-', '+'):
30 if line[0] in (' ', '-', '+'):
31 # diff line - don't check for header pattern in there
31 # diff line - don't check for header pattern in there
32 return False
32 return False
33 l = line.split(': ', 1)
33 l = line.split(': ', 1)
34 return len(l) == 2 and ' ' not in l[0]
34 return len(l) == 2 and ' ' not in l[0]
35
35
36 def chunk(lines):
36 def chunk(lines):
37 return cStringIO.StringIO(''.join(lines))
37 return cStringIO.StringIO(''.join(lines))
38
38
39 def hgsplit(stream, cur):
39 def hgsplit(stream, cur):
40 inheader = True
40 inheader = True
41
41
42 for line in stream:
42 for line in stream:
43 if not line.strip():
43 if not line.strip():
44 inheader = False
44 inheader = False
45 if not inheader and line.startswith('# HG changeset patch'):
45 if not inheader and line.startswith('# HG changeset patch'):
46 yield chunk(cur)
46 yield chunk(cur)
47 cur = []
47 cur = []
48 inheader = True
48 inheader = True
49
49
50 cur.append(line)
50 cur.append(line)
51
51
52 if cur:
52 if cur:
53 yield chunk(cur)
53 yield chunk(cur)
54
54
55 def mboxsplit(stream, cur):
55 def mboxsplit(stream, cur):
56 for line in stream:
56 for line in stream:
57 if line.startswith('From '):
57 if line.startswith('From '):
58 for c in split(chunk(cur[1:])):
58 for c in split(chunk(cur[1:])):
59 yield c
59 yield c
60 cur = []
60 cur = []
61
61
62 cur.append(line)
62 cur.append(line)
63
63
64 if cur:
64 if cur:
65 for c in split(chunk(cur[1:])):
65 for c in split(chunk(cur[1:])):
66 yield c
66 yield c
67
67
68 def mimesplit(stream, cur):
68 def mimesplit(stream, cur):
69 def msgfp(m):
69 def msgfp(m):
70 fp = cStringIO.StringIO()
70 fp = cStringIO.StringIO()
71 g = email.Generator.Generator(fp, mangle_from_=False)
71 g = email.Generator.Generator(fp, mangle_from_=False)
72 g.flatten(m)
72 g.flatten(m)
73 fp.seek(0)
73 fp.seek(0)
74 return fp
74 return fp
75
75
76 for line in stream:
76 for line in stream:
77 cur.append(line)
77 cur.append(line)
78 c = chunk(cur)
78 c = chunk(cur)
79
79
80 m = email.Parser.Parser().parse(c)
80 m = email.Parser.Parser().parse(c)
81 if not m.is_multipart():
81 if not m.is_multipart():
82 yield msgfp(m)
82 yield msgfp(m)
83 else:
83 else:
84 ok_types = ('text/plain', 'text/x-diff', 'text/x-patch')
84 ok_types = ('text/plain', 'text/x-diff', 'text/x-patch')
85 for part in m.walk():
85 for part in m.walk():
86 ct = part.get_content_type()
86 ct = part.get_content_type()
87 if ct not in ok_types:
87 if ct not in ok_types:
88 continue
88 continue
89 yield msgfp(part)
89 yield msgfp(part)
90
90
91 def headersplit(stream, cur):
91 def headersplit(stream, cur):
92 inheader = False
92 inheader = False
93
93
94 for line in stream:
94 for line in stream:
95 if not inheader and isheader(line, inheader):
95 if not inheader and isheader(line, inheader):
96 yield chunk(cur)
96 yield chunk(cur)
97 cur = []
97 cur = []
98 inheader = True
98 inheader = True
99 if inheader and not isheader(line, inheader):
99 if inheader and not isheader(line, inheader):
100 inheader = False
100 inheader = False
101
101
102 cur.append(line)
102 cur.append(line)
103
103
104 if cur:
104 if cur:
105 yield chunk(cur)
105 yield chunk(cur)
106
106
107 def remainder(cur):
107 def remainder(cur):
108 yield chunk(cur)
108 yield chunk(cur)
109
109
110 class fiter(object):
110 class fiter(object):
111 def __init__(self, fp):
111 def __init__(self, fp):
112 self.fp = fp
112 self.fp = fp
113
113
114 def __iter__(self):
114 def __iter__(self):
115 return self
115 return self
116
116
117 def next(self):
117 def next(self):
118 l = self.fp.readline()
118 l = self.fp.readline()
119 if not l:
119 if not l:
120 raise StopIteration
120 raise StopIteration
121 return l
121 return l
122
122
123 inheader = False
123 inheader = False
124 cur = []
124 cur = []
125
125
126 mimeheaders = ['content-type']
126 mimeheaders = ['content-type']
127
127
128 if not hasattr(stream, 'next'):
128 if not hasattr(stream, 'next'):
129 # http responses, for example, have readline but not next
129 # http responses, for example, have readline but not next
130 stream = fiter(stream)
130 stream = fiter(stream)
131
131
132 for line in stream:
132 for line in stream:
133 cur.append(line)
133 cur.append(line)
134 if line.startswith('# HG changeset patch'):
134 if line.startswith('# HG changeset patch'):
135 return hgsplit(stream, cur)
135 return hgsplit(stream, cur)
136 elif line.startswith('From '):
136 elif line.startswith('From '):
137 return mboxsplit(stream, cur)
137 return mboxsplit(stream, cur)
138 elif isheader(line, inheader):
138 elif isheader(line, inheader):
139 inheader = True
139 inheader = True
140 if line.split(':', 1)[0].lower() in mimeheaders:
140 if line.split(':', 1)[0].lower() in mimeheaders:
141 # let email parser handle this
141 # let email parser handle this
142 return mimesplit(stream, cur)
142 return mimesplit(stream, cur)
143 elif line.startswith('--- ') and inheader:
143 elif line.startswith('--- ') and inheader:
144 # No evil headers seen by diff start, split by hand
144 # No evil headers seen by diff start, split by hand
145 return headersplit(stream, cur)
145 return headersplit(stream, cur)
146 # Not enough info, keep reading
146 # Not enough info, keep reading
147
147
148 # if we are here, we have a very plain patch
148 # if we are here, we have a very plain patch
149 return remainder(cur)
149 return remainder(cur)
150
150
151 def extract(ui, fileobj):
151 def extract(ui, fileobj):
152 '''extract patch from data read from fileobj.
152 '''extract patch from data read from fileobj.
153
153
154 patch can be a normal patch or contained in an email message.
154 patch can be a normal patch or contained in an email message.
155
155
156 return tuple (filename, message, user, date, branch, node, p1, p2).
156 return tuple (filename, message, user, date, branch, node, p1, p2).
157 Any item in the returned tuple can be None. If filename is None,
157 Any item in the returned tuple can be None. If filename is None,
158 fileobj did not contain a patch. Caller must unlink filename when done.'''
158 fileobj did not contain a patch. Caller must unlink filename when done.'''
159
159
160 # attempt to detect the start of a patch
160 # attempt to detect the start of a patch
161 # (this heuristic is borrowed from quilt)
161 # (this heuristic is borrowed from quilt)
162 diffre = re.compile(r'^(?:Index:[ \t]|diff[ \t]|RCS file: |'
162 diffre = re.compile(r'^(?:Index:[ \t]|diff[ \t]|RCS file: |'
163 r'retrieving revision [0-9]+(\.[0-9]+)*$|'
163 r'retrieving revision [0-9]+(\.[0-9]+)*$|'
164 r'---[ \t].*?^\+\+\+[ \t]|'
164 r'---[ \t].*?^\+\+\+[ \t]|'
165 r'\*\*\*[ \t].*?^---[ \t])', re.MULTILINE|re.DOTALL)
165 r'\*\*\*[ \t].*?^---[ \t])', re.MULTILINE|re.DOTALL)
166
166
167 fd, tmpname = tempfile.mkstemp(prefix='hg-patch-')
167 fd, tmpname = tempfile.mkstemp(prefix='hg-patch-')
168 tmpfp = os.fdopen(fd, 'w')
168 tmpfp = os.fdopen(fd, 'w')
169 try:
169 try:
170 msg = email.Parser.Parser().parse(fileobj)
170 msg = email.Parser.Parser().parse(fileobj)
171
171
172 subject = msg['Subject']
172 subject = msg['Subject']
173 user = msg['From']
173 user = msg['From']
174 if not subject and not user:
174 if not subject and not user:
175 # Not an email, restore parsed headers if any
175 # Not an email, restore parsed headers if any
176 subject = '\n'.join(': '.join(h) for h in msg.items()) + '\n'
176 subject = '\n'.join(': '.join(h) for h in msg.items()) + '\n'
177
177
178 gitsendmail = 'git-send-email' in msg.get('X-Mailer', '')
178 gitsendmail = 'git-send-email' in msg.get('X-Mailer', '')
179 # should try to parse msg['Date']
179 # should try to parse msg['Date']
180 date = None
180 date = None
181 nodeid = None
181 nodeid = None
182 branch = None
182 branch = None
183 parents = []
183 parents = []
184
184
185 if subject:
185 if subject:
186 if subject.startswith('[PATCH'):
186 if subject.startswith('[PATCH'):
187 pend = subject.find(']')
187 pend = subject.find(']')
188 if pend >= 0:
188 if pend >= 0:
189 subject = subject[pend + 1:].lstrip()
189 subject = subject[pend + 1:].lstrip()
190 subject = subject.replace('\n\t', ' ')
190 subject = subject.replace('\n\t', ' ')
191 ui.debug('Subject: %s\n' % subject)
191 ui.debug('Subject: %s\n' % subject)
192 if user:
192 if user:
193 ui.debug('From: %s\n' % user)
193 ui.debug('From: %s\n' % user)
194 diffs_seen = 0
194 diffs_seen = 0
195 ok_types = ('text/plain', 'text/x-diff', 'text/x-patch')
195 ok_types = ('text/plain', 'text/x-diff', 'text/x-patch')
196 message = ''
196 message = ''
197 for part in msg.walk():
197 for part in msg.walk():
198 content_type = part.get_content_type()
198 content_type = part.get_content_type()
199 ui.debug('Content-Type: %s\n' % content_type)
199 ui.debug('Content-Type: %s\n' % content_type)
200 if content_type not in ok_types:
200 if content_type not in ok_types:
201 continue
201 continue
202 payload = part.get_payload(decode=True)
202 payload = part.get_payload(decode=True)
203 m = diffre.search(payload)
203 m = diffre.search(payload)
204 if m:
204 if m:
205 hgpatch = False
205 hgpatch = False
206 hgpatchheader = False
206 hgpatchheader = False
207 ignoretext = False
207 ignoretext = False
208
208
209 ui.debug('found patch at byte %d\n' % m.start(0))
209 ui.debug('found patch at byte %d\n' % m.start(0))
210 diffs_seen += 1
210 diffs_seen += 1
211 cfp = cStringIO.StringIO()
211 cfp = cStringIO.StringIO()
212 for line in payload[:m.start(0)].splitlines():
212 for line in payload[:m.start(0)].splitlines():
213 if line.startswith('# HG changeset patch') and not hgpatch:
213 if line.startswith('# HG changeset patch') and not hgpatch:
214 ui.debug('patch generated by hg export\n')
214 ui.debug('patch generated by hg export\n')
215 hgpatch = True
215 hgpatch = True
216 hgpatchheader = True
216 hgpatchheader = True
217 # drop earlier commit message content
217 # drop earlier commit message content
218 cfp.seek(0)
218 cfp.seek(0)
219 cfp.truncate()
219 cfp.truncate()
220 subject = None
220 subject = None
221 elif hgpatchheader:
221 elif hgpatchheader:
222 if line.startswith('# User '):
222 if line.startswith('# User '):
223 user = line[7:]
223 user = line[7:]
224 ui.debug('From: %s\n' % user)
224 ui.debug('From: %s\n' % user)
225 elif line.startswith("# Date "):
225 elif line.startswith("# Date "):
226 date = line[7:]
226 date = line[7:]
227 elif line.startswith("# Branch "):
227 elif line.startswith("# Branch "):
228 branch = line[9:]
228 branch = line[9:]
229 elif line.startswith("# Node ID "):
229 elif line.startswith("# Node ID "):
230 nodeid = line[10:]
230 nodeid = line[10:]
231 elif line.startswith("# Parent "):
231 elif line.startswith("# Parent "):
232 parents.append(line[10:])
232 parents.append(line[10:])
233 elif not line.startswith("# "):
233 elif not line.startswith("# "):
234 hgpatchheader = False
234 hgpatchheader = False
235 elif line == '---' and gitsendmail:
235 elif line == '---' and gitsendmail:
236 ignoretext = True
236 ignoretext = True
237 if not hgpatchheader and not ignoretext:
237 if not hgpatchheader and not ignoretext:
238 cfp.write(line)
238 cfp.write(line)
239 cfp.write('\n')
239 cfp.write('\n')
240 message = cfp.getvalue()
240 message = cfp.getvalue()
241 if tmpfp:
241 if tmpfp:
242 tmpfp.write(payload)
242 tmpfp.write(payload)
243 if not payload.endswith('\n'):
243 if not payload.endswith('\n'):
244 tmpfp.write('\n')
244 tmpfp.write('\n')
245 elif not diffs_seen and message and content_type == 'text/plain':
245 elif not diffs_seen and message and content_type == 'text/plain':
246 message += '\n' + payload
246 message += '\n' + payload
247 except:
247 except:
248 tmpfp.close()
248 tmpfp.close()
249 os.unlink(tmpname)
249 os.unlink(tmpname)
250 raise
250 raise
251
251
252 if subject and not message.startswith(subject):
252 if subject and not message.startswith(subject):
253 message = '%s\n%s' % (subject, message)
253 message = '%s\n%s' % (subject, message)
254 tmpfp.close()
254 tmpfp.close()
255 if not diffs_seen:
255 if not diffs_seen:
256 os.unlink(tmpname)
256 os.unlink(tmpname)
257 return None, message, user, date, branch, None, None, None
257 return None, message, user, date, branch, None, None, None
258 p1 = parents and parents.pop(0) or None
258 p1 = parents and parents.pop(0) or None
259 p2 = parents and parents.pop(0) or None
259 p2 = parents and parents.pop(0) or None
260 return tmpname, message, user, date, branch, nodeid, p1, p2
260 return tmpname, message, user, date, branch, nodeid, p1, p2
261
261
262 class patchmeta(object):
262 class patchmeta(object):
263 """Patched file metadata
263 """Patched file metadata
264
264
265 'op' is the performed operation within ADD, DELETE, RENAME, MODIFY
265 'op' is the performed operation within ADD, DELETE, RENAME, MODIFY
266 or COPY. 'path' is patched file path. 'oldpath' is set to the
266 or COPY. 'path' is patched file path. 'oldpath' is set to the
267 origin file when 'op' is either COPY or RENAME, None otherwise. If
267 origin file when 'op' is either COPY or RENAME, None otherwise. If
268 file mode is changed, 'mode' is a tuple (islink, isexec) where
268 file mode is changed, 'mode' is a tuple (islink, isexec) where
269 'islink' is True if the file is a symlink and 'isexec' is True if
269 'islink' is True if the file is a symlink and 'isexec' is True if
270 the file is executable. Otherwise, 'mode' is None.
270 the file is executable. Otherwise, 'mode' is None.
271 """
271 """
272 def __init__(self, path):
272 def __init__(self, path):
273 self.path = path
273 self.path = path
274 self.oldpath = None
274 self.oldpath = None
275 self.mode = None
275 self.mode = None
276 self.op = 'MODIFY'
276 self.op = 'MODIFY'
277 self.binary = False
277 self.binary = False
278
278
279 def setmode(self, mode):
279 def setmode(self, mode):
280 islink = mode & 020000
280 islink = mode & 020000
281 isexec = mode & 0100
281 isexec = mode & 0100
282 self.mode = (islink, isexec)
282 self.mode = (islink, isexec)
283
283
284 def __repr__(self):
284 def __repr__(self):
285 return "<patchmeta %s %r>" % (self.op, self.path)
285 return "<patchmeta %s %r>" % (self.op, self.path)
286
286
287 def readgitpatch(lr):
287 def readgitpatch(lr):
288 """extract git-style metadata about patches from <patchname>"""
288 """extract git-style metadata about patches from <patchname>"""
289
289
290 # Filter patch for git information
290 # Filter patch for git information
291 gp = None
291 gp = None
292 gitpatches = []
292 gitpatches = []
293 for line in lr:
293 for line in lr:
294 line = line.rstrip(' \r\n')
294 line = line.rstrip(' \r\n')
295 if line.startswith('diff --git'):
295 if line.startswith('diff --git'):
296 m = gitre.match(line)
296 m = gitre.match(line)
297 if m:
297 if m:
298 if gp:
298 if gp:
299 gitpatches.append(gp)
299 gitpatches.append(gp)
300 dst = m.group(2)
300 dst = m.group(2)
301 gp = patchmeta(dst)
301 gp = patchmeta(dst)
302 elif gp:
302 elif gp:
303 if line.startswith('--- '):
303 if line.startswith('--- '):
304 gitpatches.append(gp)
304 gitpatches.append(gp)
305 gp = None
305 gp = None
306 continue
306 continue
307 if line.startswith('rename from '):
307 if line.startswith('rename from '):
308 gp.op = 'RENAME'
308 gp.op = 'RENAME'
309 gp.oldpath = line[12:]
309 gp.oldpath = line[12:]
310 elif line.startswith('rename to '):
310 elif line.startswith('rename to '):
311 gp.path = line[10:]
311 gp.path = line[10:]
312 elif line.startswith('copy from '):
312 elif line.startswith('copy from '):
313 gp.op = 'COPY'
313 gp.op = 'COPY'
314 gp.oldpath = line[10:]
314 gp.oldpath = line[10:]
315 elif line.startswith('copy to '):
315 elif line.startswith('copy to '):
316 gp.path = line[8:]
316 gp.path = line[8:]
317 elif line.startswith('deleted file'):
317 elif line.startswith('deleted file'):
318 gp.op = 'DELETE'
318 gp.op = 'DELETE'
319 elif line.startswith('new file mode '):
319 elif line.startswith('new file mode '):
320 gp.op = 'ADD'
320 gp.op = 'ADD'
321 gp.setmode(int(line[-6:], 8))
321 gp.setmode(int(line[-6:], 8))
322 elif line.startswith('new mode '):
322 elif line.startswith('new mode '):
323 gp.setmode(int(line[-6:], 8))
323 gp.setmode(int(line[-6:], 8))
324 elif line.startswith('GIT binary patch'):
324 elif line.startswith('GIT binary patch'):
325 gp.binary = True
325 gp.binary = True
326 if gp:
326 if gp:
327 gitpatches.append(gp)
327 gitpatches.append(gp)
328
328
329 return gitpatches
329 return gitpatches
330
330
331 class linereader(object):
331 class linereader(object):
332 # simple class to allow pushing lines back into the input stream
332 # simple class to allow pushing lines back into the input stream
333 def __init__(self, fp, textmode=False):
333 def __init__(self, fp, textmode=False):
334 self.fp = fp
334 self.fp = fp
335 self.buf = []
335 self.buf = []
336 self.textmode = textmode
336 self.textmode = textmode
337 self.eol = None
337 self.eol = None
338
338
339 def push(self, line):
339 def push(self, line):
340 if line is not None:
340 if line is not None:
341 self.buf.append(line)
341 self.buf.append(line)
342
342
343 def readline(self):
343 def readline(self):
344 if self.buf:
344 if self.buf:
345 l = self.buf[0]
345 l = self.buf[0]
346 del self.buf[0]
346 del self.buf[0]
347 return l
347 return l
348 l = self.fp.readline()
348 l = self.fp.readline()
349 if not self.eol:
349 if not self.eol:
350 if l.endswith('\r\n'):
350 if l.endswith('\r\n'):
351 self.eol = '\r\n'
351 self.eol = '\r\n'
352 elif l.endswith('\n'):
352 elif l.endswith('\n'):
353 self.eol = '\n'
353 self.eol = '\n'
354 if self.textmode and l.endswith('\r\n'):
354 if self.textmode and l.endswith('\r\n'):
355 l = l[:-2] + '\n'
355 l = l[:-2] + '\n'
356 return l
356 return l
357
357
358 def __iter__(self):
358 def __iter__(self):
359 while 1:
359 while 1:
360 l = self.readline()
360 l = self.readline()
361 if not l:
361 if not l:
362 break
362 break
363 yield l
363 yield l
364
364
365 class abstractbackend(object):
365 class abstractbackend(object):
366 def __init__(self, ui):
366 def __init__(self, ui):
367 self.ui = ui
367 self.ui = ui
368
368
369 def readlines(self, fname):
369 def readlines(self, fname):
370 """Return target file lines, or its content as a single line
370 """Return target file lines, or its content as a single line
371 for symlinks.
371 for symlinks.
372 """
372 """
373 raise NotImplementedError
373 raise NotImplementedError
374
374
375 def writelines(self, fname, lines, mode):
375 def writelines(self, fname, lines, mode):
376 """Write lines to target file. mode is a (islink, isexec)
376 """Write lines to target file. mode is a (islink, isexec)
377 tuple, or None if there is no mode information.
377 tuple, or None if there is no mode information.
378 """
378 """
379 raise NotImplementedError
379 raise NotImplementedError
380
380
381 def unlink(self, fname):
381 def unlink(self, fname):
382 """Unlink target file."""
382 """Unlink target file."""
383 raise NotImplementedError
383 raise NotImplementedError
384
384
385 def writerej(self, fname, failed, total, lines):
385 def writerej(self, fname, failed, total, lines):
386 """Write rejected lines for fname. total is the number of hunks
386 """Write rejected lines for fname. total is the number of hunks
387 which failed to apply and total the total number of hunks for this
387 which failed to apply and total the total number of hunks for this
388 files.
388 files.
389 """
389 """
390 pass
390 pass
391
391
392 def copy(self, src, dst):
392 def copy(self, src, dst):
393 """Copy src file into dst file. Create intermediate directories if
393 """Copy src file into dst file. Create intermediate directories if
394 necessary. Files are specified relatively to the patching base
394 necessary. Files are specified relatively to the patching base
395 directory.
395 directory.
396 """
396 """
397 raise NotImplementedError
397 raise NotImplementedError
398
398
399 def exists(self, fname):
399 def exists(self, fname):
400 raise NotImplementedError
400 raise NotImplementedError
401
401
402 def setmode(self, fname, islink, isexec):
402 def setmode(self, fname, islink, isexec):
403 """Change target file mode."""
403 """Change target file mode."""
404 raise NotImplementedError
404 raise NotImplementedError
405
405
406 class fsbackend(abstractbackend):
406 class fsbackend(abstractbackend):
407 def __init__(self, ui, basedir):
407 def __init__(self, ui, basedir):
408 super(fsbackend, self).__init__(ui)
408 super(fsbackend, self).__init__(ui)
409 self.opener = scmutil.opener(basedir)
409 self.opener = scmutil.opener(basedir)
410
410
411 def _join(self, f):
411 def _join(self, f):
412 return os.path.join(self.opener.base, f)
412 return os.path.join(self.opener.base, f)
413
413
414 def readlines(self, fname):
414 def readlines(self, fname):
415 if os.path.islink(self._join(fname)):
415 if os.path.islink(self._join(fname)):
416 return [os.readlink(self._join(fname))]
416 return [os.readlink(self._join(fname))]
417 fp = self.opener(fname, 'r')
417 fp = self.opener(fname, 'r')
418 try:
418 try:
419 return list(fp)
419 return list(fp)
420 finally:
420 finally:
421 fp.close()
421 fp.close()
422
422
423 def writelines(self, fname, lines, mode):
423 def writelines(self, fname, lines, mode):
424 if not mode:
424 if not mode:
425 # Preserve mode information
425 # Preserve mode information
426 isexec, islink = False, False
426 isexec, islink = False, False
427 try:
427 try:
428 isexec = os.lstat(self._join(fname)).st_mode & 0100 != 0
428 isexec = os.lstat(self._join(fname)).st_mode & 0100 != 0
429 islink = os.path.islink(self._join(fname))
429 islink = os.path.islink(self._join(fname))
430 except OSError, e:
430 except OSError, e:
431 if e.errno != errno.ENOENT:
431 if e.errno != errno.ENOENT:
432 raise
432 raise
433 else:
433 else:
434 islink, isexec = mode
434 islink, isexec = mode
435 if islink:
435 if islink:
436 self.opener.symlink(''.join(lines), fname)
436 self.opener.symlink(''.join(lines), fname)
437 else:
437 else:
438 self.opener(fname, 'w').writelines(lines)
438 self.opener(fname, 'w').writelines(lines)
439 if isexec:
439 if isexec:
440 util.setflags(self._join(fname), False, True)
440 util.setflags(self._join(fname), False, True)
441
441
442 def unlink(self, fname):
442 def unlink(self, fname):
443 try:
443 try:
444 util.unlinkpath(self._join(fname))
444 util.unlinkpath(self._join(fname))
445 except OSError, inst:
445 except OSError, inst:
446 if inst.errno != errno.ENOENT:
446 if inst.errno != errno.ENOENT:
447 raise
447 raise
448
448
449 def writerej(self, fname, failed, total, lines):
449 def writerej(self, fname, failed, total, lines):
450 fname = fname + ".rej"
450 fname = fname + ".rej"
451 self.ui.warn(
451 self.ui.warn(
452 _("%d out of %d hunks FAILED -- saving rejects to file %s\n") %
452 _("%d out of %d hunks FAILED -- saving rejects to file %s\n") %
453 (failed, total, fname))
453 (failed, total, fname))
454 fp = self.opener(fname, 'w')
454 fp = self.opener(fname, 'w')
455 fp.writelines(lines)
455 fp.writelines(lines)
456 fp.close()
456 fp.close()
457
457
458 def copy(self, src, dst):
458 def copy(self, src, dst):
459 basedir = self.opener.base
459 basedir = self.opener.base
460 abssrc, absdst = [scmutil.canonpath(basedir, basedir, x)
460 abssrc, absdst = [scmutil.canonpath(basedir, basedir, x)
461 for x in [src, dst]]
461 for x in [src, dst]]
462 if os.path.lexists(absdst):
462 if os.path.lexists(absdst):
463 raise util.Abort(_("cannot create %s: destination already exists")
463 raise util.Abort(_("cannot create %s: destination already exists")
464 % dst)
464 % dst)
465 dstdir = os.path.dirname(absdst)
465 dstdir = os.path.dirname(absdst)
466 if dstdir and not os.path.isdir(dstdir):
466 if dstdir and not os.path.isdir(dstdir):
467 try:
467 try:
468 os.makedirs(dstdir)
468 os.makedirs(dstdir)
469 except IOError:
469 except IOError:
470 raise util.Abort(
470 raise util.Abort(
471 _("cannot create %s: unable to create destination directory")
471 _("cannot create %s: unable to create destination directory")
472 % dst)
472 % dst)
473 util.copyfile(abssrc, absdst)
473 util.copyfile(abssrc, absdst)
474
474
475 def exists(self, fname):
475 def exists(self, fname):
476 return os.path.lexists(self._join(fname))
476 return os.path.lexists(self._join(fname))
477
477
478 def setmode(self, fname, islink, isexec):
478 def setmode(self, fname, islink, isexec):
479 util.setflags(self._join(fname), islink, isexec)
479 util.setflags(self._join(fname), islink, isexec)
480
480
481 class workingbackend(fsbackend):
481 class workingbackend(fsbackend):
482 def __init__(self, ui, repo, similarity):
482 def __init__(self, ui, repo, similarity):
483 super(workingbackend, self).__init__(ui, repo.root)
483 super(workingbackend, self).__init__(ui, repo.root)
484 self.repo = repo
484 self.repo = repo
485 self.similarity = similarity
485 self.similarity = similarity
486 self.removed = set()
486 self.removed = set()
487 self.changed = set()
487 self.changed = set()
488 self.copied = []
488 self.copied = []
489
489
490 def writelines(self, fname, lines, mode):
490 def writelines(self, fname, lines, mode):
491 super(workingbackend, self).writelines(fname, lines, mode)
491 super(workingbackend, self).writelines(fname, lines, mode)
492 self.changed.add(fname)
492 self.changed.add(fname)
493
493
494 def unlink(self, fname):
494 def unlink(self, fname):
495 super(workingbackend, self).unlink(fname)
495 super(workingbackend, self).unlink(fname)
496 self.removed.add(fname)
496 self.removed.add(fname)
497 self.changed.add(fname)
497 self.changed.add(fname)
498
498
499 def copy(self, src, dst):
499 def copy(self, src, dst):
500 super(workingbackend, self).copy(src, dst)
500 super(workingbackend, self).copy(src, dst)
501 self.copied.append((src, dst))
501 self.copied.append((src, dst))
502 self.changed.add(dst)
502 self.changed.add(dst)
503
503
504 def setmode(self, fname, islink, isexec):
504 def setmode(self, fname, islink, isexec):
505 super(workingbackend, self).setmode(fname, islink, isexec)
505 super(workingbackend, self).setmode(fname, islink, isexec)
506 self.changed.add(fname)
506 self.changed.add(fname)
507
507
508 def close(self):
508 def close(self):
509 wctx = self.repo[None]
509 wctx = self.repo[None]
510 addremoved = set(self.changed)
510 addremoved = set(self.changed)
511 for src, dst in self.copied:
511 for src, dst in self.copied:
512 scmutil.dirstatecopy(self.ui, self.repo, wctx, src, dst)
512 scmutil.dirstatecopy(self.ui, self.repo, wctx, src, dst)
513 addremoved.discard(src)
513 addremoved.discard(src)
514 if (not self.similarity) and self.removed:
514 if (not self.similarity) and self.removed:
515 wctx.remove(sorted(self.removed))
515 wctx.remove(sorted(self.removed))
516 if addremoved:
516 if addremoved:
517 cwd = self.repo.getcwd()
517 cwd = self.repo.getcwd()
518 if cwd:
518 if cwd:
519 addremoved = [util.pathto(self.repo.root, cwd, f)
519 addremoved = [util.pathto(self.repo.root, cwd, f)
520 for f in addremoved]
520 for f in addremoved]
521 scmutil.addremove(self.repo, addremoved, similarity=self.similarity)
521 scmutil.addremove(self.repo, addremoved, similarity=self.similarity)
522 return sorted(self.changed)
522 return sorted(self.changed)
523
523
524 # @@ -start,len +start,len @@ or @@ -start +start @@ if len is 1
524 # @@ -start,len +start,len @@ or @@ -start +start @@ if len is 1
525 unidesc = re.compile('@@ -(\d+)(,(\d+))? \+(\d+)(,(\d+))? @@')
525 unidesc = re.compile('@@ -(\d+)(,(\d+))? \+(\d+)(,(\d+))? @@')
526 contextdesc = re.compile('(---|\*\*\*) (\d+)(,(\d+))? (---|\*\*\*)')
526 contextdesc = re.compile('(---|\*\*\*) (\d+)(,(\d+))? (---|\*\*\*)')
527 eolmodes = ['strict', 'crlf', 'lf', 'auto']
527 eolmodes = ['strict', 'crlf', 'lf', 'auto']
528
528
529 class patchfile(object):
529 class patchfile(object):
530 def __init__(self, ui, fname, backend, mode, missing=False,
530 def __init__(self, ui, fname, backend, mode, missing=False,
531 eolmode='strict'):
531 eolmode='strict'):
532 self.fname = fname
532 self.fname = fname
533 self.eolmode = eolmode
533 self.eolmode = eolmode
534 self.eol = None
534 self.eol = None
535 self.backend = backend
535 self.backend = backend
536 self.ui = ui
536 self.ui = ui
537 self.lines = []
537 self.lines = []
538 self.exists = False
538 self.exists = False
539 self.missing = missing
539 self.missing = missing
540 self.mode = mode
540 self.mode = mode
541 if not missing:
541 if not missing:
542 try:
542 try:
543 self.lines = self.backend.readlines(fname)
543 self.lines = self.backend.readlines(fname)
544 if self.lines:
544 if self.lines:
545 # Normalize line endings
545 # Normalize line endings
546 if self.lines[0].endswith('\r\n'):
546 if self.lines[0].endswith('\r\n'):
547 self.eol = '\r\n'
547 self.eol = '\r\n'
548 elif self.lines[0].endswith('\n'):
548 elif self.lines[0].endswith('\n'):
549 self.eol = '\n'
549 self.eol = '\n'
550 if eolmode != 'strict':
550 if eolmode != 'strict':
551 nlines = []
551 nlines = []
552 for l in self.lines:
552 for l in self.lines:
553 if l.endswith('\r\n'):
553 if l.endswith('\r\n'):
554 l = l[:-2] + '\n'
554 l = l[:-2] + '\n'
555 nlines.append(l)
555 nlines.append(l)
556 self.lines = nlines
556 self.lines = nlines
557 self.exists = True
557 self.exists = True
558 except IOError:
558 except IOError:
559 pass
559 pass
560 else:
560 else:
561 self.ui.warn(_("unable to find '%s' for patching\n") % self.fname)
561 self.ui.warn(_("unable to find '%s' for patching\n") % self.fname)
562
562
563 self.hash = {}
563 self.hash = {}
564 self.dirty = 0
564 self.dirty = 0
565 self.offset = 0
565 self.offset = 0
566 self.skew = 0
566 self.skew = 0
567 self.rej = []
567 self.rej = []
568 self.fileprinted = False
568 self.fileprinted = False
569 self.printfile(False)
569 self.printfile(False)
570 self.hunks = 0
570 self.hunks = 0
571
571
572 def writelines(self, fname, lines, mode):
572 def writelines(self, fname, lines, mode):
573 if self.eolmode == 'auto':
573 if self.eolmode == 'auto':
574 eol = self.eol
574 eol = self.eol
575 elif self.eolmode == 'crlf':
575 elif self.eolmode == 'crlf':
576 eol = '\r\n'
576 eol = '\r\n'
577 else:
577 else:
578 eol = '\n'
578 eol = '\n'
579
579
580 if self.eolmode != 'strict' and eol and eol != '\n':
580 if self.eolmode != 'strict' and eol and eol != '\n':
581 rawlines = []
581 rawlines = []
582 for l in lines:
582 for l in lines:
583 if l and l[-1] == '\n':
583 if l and l[-1] == '\n':
584 l = l[:-1] + eol
584 l = l[:-1] + eol
585 rawlines.append(l)
585 rawlines.append(l)
586 lines = rawlines
586 lines = rawlines
587
587
588 self.backend.writelines(fname, lines, mode)
588 self.backend.writelines(fname, lines, mode)
589
589
590 def printfile(self, warn):
590 def printfile(self, warn):
591 if self.fileprinted:
591 if self.fileprinted:
592 return
592 return
593 if warn or self.ui.verbose:
593 if warn or self.ui.verbose:
594 self.fileprinted = True
594 self.fileprinted = True
595 s = _("patching file %s\n") % self.fname
595 s = _("patching file %s\n") % self.fname
596 if warn:
596 if warn:
597 self.ui.warn(s)
597 self.ui.warn(s)
598 else:
598 else:
599 self.ui.note(s)
599 self.ui.note(s)
600
600
601
601
602 def findlines(self, l, linenum):
602 def findlines(self, l, linenum):
603 # looks through the hash and finds candidate lines. The
603 # looks through the hash and finds candidate lines. The
604 # result is a list of line numbers sorted based on distance
604 # result is a list of line numbers sorted based on distance
605 # from linenum
605 # from linenum
606
606
607 cand = self.hash.get(l, [])
607 cand = self.hash.get(l, [])
608 if len(cand) > 1:
608 if len(cand) > 1:
609 # resort our list of potentials forward then back.
609 # resort our list of potentials forward then back.
610 cand.sort(key=lambda x: abs(x - linenum))
610 cand.sort(key=lambda x: abs(x - linenum))
611 return cand
611 return cand
612
612
613 def write_rej(self):
613 def write_rej(self):
614 # our rejects are a little different from patch(1). This always
614 # our rejects are a little different from patch(1). This always
615 # creates rejects in the same form as the original patch. A file
615 # creates rejects in the same form as the original patch. A file
616 # header is inserted so that you can run the reject through patch again
616 # header is inserted so that you can run the reject through patch again
617 # without having to type the filename.
617 # without having to type the filename.
618 if not self.rej:
618 if not self.rej:
619 return
619 return
620 base = os.path.basename(self.fname)
620 base = os.path.basename(self.fname)
621 lines = ["--- %s\n+++ %s\n" % (base, base)]
621 lines = ["--- %s\n+++ %s\n" % (base, base)]
622 for x in self.rej:
622 for x in self.rej:
623 for l in x.hunk:
623 for l in x.hunk:
624 lines.append(l)
624 lines.append(l)
625 if l[-1] != '\n':
625 if l[-1] != '\n':
626 lines.append("\n\ No newline at end of file\n")
626 lines.append("\n\ No newline at end of file\n")
627 self.backend.writerej(self.fname, len(self.rej), self.hunks, lines)
627 self.backend.writerej(self.fname, len(self.rej), self.hunks, lines)
628
628
629 def apply(self, h):
629 def apply(self, h):
630 if not h.complete():
630 if not h.complete():
631 raise PatchError(_("bad hunk #%d %s (%d %d %d %d)") %
631 raise PatchError(_("bad hunk #%d %s (%d %d %d %d)") %
632 (h.number, h.desc, len(h.a), h.lena, len(h.b),
632 (h.number, h.desc, len(h.a), h.lena, len(h.b),
633 h.lenb))
633 h.lenb))
634
634
635 self.hunks += 1
635 self.hunks += 1
636
636
637 if self.missing:
637 if self.missing:
638 self.rej.append(h)
638 self.rej.append(h)
639 return -1
639 return -1
640
640
641 if self.exists and h.createfile():
641 if self.exists and h.createfile():
642 self.ui.warn(_("file %s already exists\n") % self.fname)
642 self.ui.warn(_("file %s already exists\n") % self.fname)
643 self.rej.append(h)
643 self.rej.append(h)
644 return -1
644 return -1
645
645
646 if isinstance(h, binhunk):
646 if isinstance(h, binhunk):
647 if h.rmfile():
647 if h.rmfile():
648 self.backend.unlink(self.fname)
648 self.backend.unlink(self.fname)
649 else:
649 else:
650 self.lines[:] = h.new()
650 self.lines[:] = h.new()
651 self.offset += len(h.new())
651 self.offset += len(h.new())
652 self.dirty = True
652 self.dirty = True
653 return 0
653 return 0
654
654
655 horig = h
655 horig = h
656 if (self.eolmode in ('crlf', 'lf')
656 if (self.eolmode in ('crlf', 'lf')
657 or self.eolmode == 'auto' and self.eol):
657 or self.eolmode == 'auto' and self.eol):
658 # If new eols are going to be normalized, then normalize
658 # If new eols are going to be normalized, then normalize
659 # hunk data before patching. Otherwise, preserve input
659 # hunk data before patching. Otherwise, preserve input
660 # line-endings.
660 # line-endings.
661 h = h.getnormalized()
661 h = h.getnormalized()
662
662
663 # fast case first, no offsets, no fuzz
663 # fast case first, no offsets, no fuzz
664 old = h.old()
664 old = h.old()
665 # patch starts counting at 1 unless we are adding the file
665 # patch starts counting at 1 unless we are adding the file
666 if h.starta == 0:
666 if h.starta == 0:
667 start = 0
667 start = 0
668 else:
668 else:
669 start = h.starta + self.offset - 1
669 start = h.starta + self.offset - 1
670 orig_start = start
670 orig_start = start
671 # if there's skew we want to emit the "(offset %d lines)" even
671 # if there's skew we want to emit the "(offset %d lines)" even
672 # when the hunk cleanly applies at start + skew, so skip the
672 # when the hunk cleanly applies at start + skew, so skip the
673 # fast case code
673 # fast case code
674 if self.skew == 0 and diffhelpers.testhunk(old, self.lines, start) == 0:
674 if self.skew == 0 and diffhelpers.testhunk(old, self.lines, start) == 0:
675 if h.rmfile():
675 if h.rmfile():
676 self.backend.unlink(self.fname)
676 self.backend.unlink(self.fname)
677 else:
677 else:
678 self.lines[start : start + h.lena] = h.new()
678 self.lines[start : start + h.lena] = h.new()
679 self.offset += h.lenb - h.lena
679 self.offset += h.lenb - h.lena
680 self.dirty = True
680 self.dirty = True
681 return 0
681 return 0
682
682
683 # ok, we couldn't match the hunk. Lets look for offsets and fuzz it
683 # ok, we couldn't match the hunk. Lets look for offsets and fuzz it
684 self.hash = {}
684 self.hash = {}
685 for x, s in enumerate(self.lines):
685 for x, s in enumerate(self.lines):
686 self.hash.setdefault(s, []).append(x)
686 self.hash.setdefault(s, []).append(x)
687 if h.hunk[-1][0] != ' ':
687 if h.hunk[-1][0] != ' ':
688 # if the hunk tried to put something at the bottom of the file
688 # if the hunk tried to put something at the bottom of the file
689 # override the start line and use eof here
689 # override the start line and use eof here
690 search_start = len(self.lines)
690 search_start = len(self.lines)
691 else:
691 else:
692 search_start = orig_start + self.skew
692 search_start = orig_start + self.skew
693
693
694 for fuzzlen in xrange(3):
694 for fuzzlen in xrange(3):
695 for toponly in [True, False]:
695 for toponly in [True, False]:
696 old = h.old(fuzzlen, toponly)
696 old = h.old(fuzzlen, toponly)
697
697
698 cand = self.findlines(old[0][1:], search_start)
698 cand = self.findlines(old[0][1:], search_start)
699 for l in cand:
699 for l in cand:
700 if diffhelpers.testhunk(old, self.lines, l) == 0:
700 if diffhelpers.testhunk(old, self.lines, l) == 0:
701 newlines = h.new(fuzzlen, toponly)
701 newlines = h.new(fuzzlen, toponly)
702 self.lines[l : l + len(old)] = newlines
702 self.lines[l : l + len(old)] = newlines
703 self.offset += len(newlines) - len(old)
703 self.offset += len(newlines) - len(old)
704 self.skew = l - orig_start
704 self.skew = l - orig_start
705 self.dirty = True
705 self.dirty = True
706 offset = l - orig_start - fuzzlen
706 offset = l - orig_start - fuzzlen
707 if fuzzlen:
707 if fuzzlen:
708 msg = _("Hunk #%d succeeded at %d "
708 msg = _("Hunk #%d succeeded at %d "
709 "with fuzz %d "
709 "with fuzz %d "
710 "(offset %d lines).\n")
710 "(offset %d lines).\n")
711 self.printfile(True)
711 self.printfile(True)
712 self.ui.warn(msg %
712 self.ui.warn(msg %
713 (h.number, l + 1, fuzzlen, offset))
713 (h.number, l + 1, fuzzlen, offset))
714 else:
714 else:
715 msg = _("Hunk #%d succeeded at %d "
715 msg = _("Hunk #%d succeeded at %d "
716 "(offset %d lines).\n")
716 "(offset %d lines).\n")
717 self.ui.note(msg % (h.number, l + 1, offset))
717 self.ui.note(msg % (h.number, l + 1, offset))
718 return fuzzlen
718 return fuzzlen
719 self.printfile(True)
719 self.printfile(True)
720 self.ui.warn(_("Hunk #%d FAILED at %d\n") % (h.number, orig_start))
720 self.ui.warn(_("Hunk #%d FAILED at %d\n") % (h.number, orig_start))
721 self.rej.append(horig)
721 self.rej.append(horig)
722 return -1
722 return -1
723
723
724 def close(self):
724 def close(self):
725 if self.dirty:
725 if self.dirty:
726 self.writelines(self.fname, self.lines, self.mode)
726 self.writelines(self.fname, self.lines, self.mode)
727 self.write_rej()
727 self.write_rej()
728 return len(self.rej)
728 return len(self.rej)
729
729
730 class hunk(object):
730 class hunk(object):
731 def __init__(self, desc, num, lr, context, create=False, remove=False):
731 def __init__(self, desc, num, lr, context, create=False, remove=False):
732 self.number = num
732 self.number = num
733 self.desc = desc
733 self.desc = desc
734 self.hunk = [desc]
734 self.hunk = [desc]
735 self.a = []
735 self.a = []
736 self.b = []
736 self.b = []
737 self.starta = self.lena = None
737 self.starta = self.lena = None
738 self.startb = self.lenb = None
738 self.startb = self.lenb = None
739 if lr is not None:
739 if lr is not None:
740 if context:
740 if context:
741 self.read_context_hunk(lr)
741 self.read_context_hunk(lr)
742 else:
742 else:
743 self.read_unified_hunk(lr)
743 self.read_unified_hunk(lr)
744 self.create = create
744 self.create = create
745 self.remove = remove and not create
745 self.remove = remove and not create
746
746
747 def getnormalized(self):
747 def getnormalized(self):
748 """Return a copy with line endings normalized to LF."""
748 """Return a copy with line endings normalized to LF."""
749
749
750 def normalize(lines):
750 def normalize(lines):
751 nlines = []
751 nlines = []
752 for line in lines:
752 for line in lines:
753 if line.endswith('\r\n'):
753 if line.endswith('\r\n'):
754 line = line[:-2] + '\n'
754 line = line[:-2] + '\n'
755 nlines.append(line)
755 nlines.append(line)
756 return nlines
756 return nlines
757
757
758 # Dummy object, it is rebuilt manually
758 # Dummy object, it is rebuilt manually
759 nh = hunk(self.desc, self.number, None, None, False, False)
759 nh = hunk(self.desc, self.number, None, None, False, False)
760 nh.number = self.number
760 nh.number = self.number
761 nh.desc = self.desc
761 nh.desc = self.desc
762 nh.hunk = self.hunk
762 nh.hunk = self.hunk
763 nh.a = normalize(self.a)
763 nh.a = normalize(self.a)
764 nh.b = normalize(self.b)
764 nh.b = normalize(self.b)
765 nh.starta = self.starta
765 nh.starta = self.starta
766 nh.startb = self.startb
766 nh.startb = self.startb
767 nh.lena = self.lena
767 nh.lena = self.lena
768 nh.lenb = self.lenb
768 nh.lenb = self.lenb
769 nh.create = self.create
769 nh.create = self.create
770 nh.remove = self.remove
770 nh.remove = self.remove
771 return nh
771 return nh
772
772
773 def read_unified_hunk(self, lr):
773 def read_unified_hunk(self, lr):
774 m = unidesc.match(self.desc)
774 m = unidesc.match(self.desc)
775 if not m:
775 if not m:
776 raise PatchError(_("bad hunk #%d") % self.number)
776 raise PatchError(_("bad hunk #%d") % self.number)
777 self.starta, foo, self.lena, self.startb, foo2, self.lenb = m.groups()
777 self.starta, foo, self.lena, self.startb, foo2, self.lenb = m.groups()
778 if self.lena is None:
778 if self.lena is None:
779 self.lena = 1
779 self.lena = 1
780 else:
780 else:
781 self.lena = int(self.lena)
781 self.lena = int(self.lena)
782 if self.lenb is None:
782 if self.lenb is None:
783 self.lenb = 1
783 self.lenb = 1
784 else:
784 else:
785 self.lenb = int(self.lenb)
785 self.lenb = int(self.lenb)
786 self.starta = int(self.starta)
786 self.starta = int(self.starta)
787 self.startb = int(self.startb)
787 self.startb = int(self.startb)
788 diffhelpers.addlines(lr, self.hunk, self.lena, self.lenb, self.a, self.b)
788 diffhelpers.addlines(lr, self.hunk, self.lena, self.lenb, self.a, self.b)
789 # if we hit eof before finishing out the hunk, the last line will
789 # if we hit eof before finishing out the hunk, the last line will
790 # be zero length. Lets try to fix it up.
790 # be zero length. Lets try to fix it up.
791 while len(self.hunk[-1]) == 0:
791 while len(self.hunk[-1]) == 0:
792 del self.hunk[-1]
792 del self.hunk[-1]
793 del self.a[-1]
793 del self.a[-1]
794 del self.b[-1]
794 del self.b[-1]
795 self.lena -= 1
795 self.lena -= 1
796 self.lenb -= 1
796 self.lenb -= 1
797 self._fixnewline(lr)
797 self._fixnewline(lr)
798
798
799 def read_context_hunk(self, lr):
799 def read_context_hunk(self, lr):
800 self.desc = lr.readline()
800 self.desc = lr.readline()
801 m = contextdesc.match(self.desc)
801 m = contextdesc.match(self.desc)
802 if not m:
802 if not m:
803 raise PatchError(_("bad hunk #%d") % self.number)
803 raise PatchError(_("bad hunk #%d") % self.number)
804 foo, self.starta, foo2, aend, foo3 = m.groups()
804 foo, self.starta, foo2, aend, foo3 = m.groups()
805 self.starta = int(self.starta)
805 self.starta = int(self.starta)
806 if aend is None:
806 if aend is None:
807 aend = self.starta
807 aend = self.starta
808 self.lena = int(aend) - self.starta
808 self.lena = int(aend) - self.starta
809 if self.starta:
809 if self.starta:
810 self.lena += 1
810 self.lena += 1
811 for x in xrange(self.lena):
811 for x in xrange(self.lena):
812 l = lr.readline()
812 l = lr.readline()
813 if l.startswith('---'):
813 if l.startswith('---'):
814 # lines addition, old block is empty
814 # lines addition, old block is empty
815 lr.push(l)
815 lr.push(l)
816 break
816 break
817 s = l[2:]
817 s = l[2:]
818 if l.startswith('- ') or l.startswith('! '):
818 if l.startswith('- ') or l.startswith('! '):
819 u = '-' + s
819 u = '-' + s
820 elif l.startswith(' '):
820 elif l.startswith(' '):
821 u = ' ' + s
821 u = ' ' + s
822 else:
822 else:
823 raise PatchError(_("bad hunk #%d old text line %d") %
823 raise PatchError(_("bad hunk #%d old text line %d") %
824 (self.number, x))
824 (self.number, x))
825 self.a.append(u)
825 self.a.append(u)
826 self.hunk.append(u)
826 self.hunk.append(u)
827
827
828 l = lr.readline()
828 l = lr.readline()
829 if l.startswith('\ '):
829 if l.startswith('\ '):
830 s = self.a[-1][:-1]
830 s = self.a[-1][:-1]
831 self.a[-1] = s
831 self.a[-1] = s
832 self.hunk[-1] = s
832 self.hunk[-1] = s
833 l = lr.readline()
833 l = lr.readline()
834 m = contextdesc.match(l)
834 m = contextdesc.match(l)
835 if not m:
835 if not m:
836 raise PatchError(_("bad hunk #%d") % self.number)
836 raise PatchError(_("bad hunk #%d") % self.number)
837 foo, self.startb, foo2, bend, foo3 = m.groups()
837 foo, self.startb, foo2, bend, foo3 = m.groups()
838 self.startb = int(self.startb)
838 self.startb = int(self.startb)
839 if bend is None:
839 if bend is None:
840 bend = self.startb
840 bend = self.startb
841 self.lenb = int(bend) - self.startb
841 self.lenb = int(bend) - self.startb
842 if self.startb:
842 if self.startb:
843 self.lenb += 1
843 self.lenb += 1
844 hunki = 1
844 hunki = 1
845 for x in xrange(self.lenb):
845 for x in xrange(self.lenb):
846 l = lr.readline()
846 l = lr.readline()
847 if l.startswith('\ '):
847 if l.startswith('\ '):
848 # XXX: the only way to hit this is with an invalid line range.
848 # XXX: the only way to hit this is with an invalid line range.
849 # The no-eol marker is not counted in the line range, but I
849 # The no-eol marker is not counted in the line range, but I
850 # guess there are diff(1) out there which behave differently.
850 # guess there are diff(1) out there which behave differently.
851 s = self.b[-1][:-1]
851 s = self.b[-1][:-1]
852 self.b[-1] = s
852 self.b[-1] = s
853 self.hunk[hunki - 1] = s
853 self.hunk[hunki - 1] = s
854 continue
854 continue
855 if not l:
855 if not l:
856 # line deletions, new block is empty and we hit EOF
856 # line deletions, new block is empty and we hit EOF
857 lr.push(l)
857 lr.push(l)
858 break
858 break
859 s = l[2:]
859 s = l[2:]
860 if l.startswith('+ ') or l.startswith('! '):
860 if l.startswith('+ ') or l.startswith('! '):
861 u = '+' + s
861 u = '+' + s
862 elif l.startswith(' '):
862 elif l.startswith(' '):
863 u = ' ' + s
863 u = ' ' + s
864 elif len(self.b) == 0:
864 elif len(self.b) == 0:
865 # line deletions, new block is empty
865 # line deletions, new block is empty
866 lr.push(l)
866 lr.push(l)
867 break
867 break
868 else:
868 else:
869 raise PatchError(_("bad hunk #%d old text line %d") %
869 raise PatchError(_("bad hunk #%d old text line %d") %
870 (self.number, x))
870 (self.number, x))
871 self.b.append(s)
871 self.b.append(s)
872 while True:
872 while True:
873 if hunki >= len(self.hunk):
873 if hunki >= len(self.hunk):
874 h = ""
874 h = ""
875 else:
875 else:
876 h = self.hunk[hunki]
876 h = self.hunk[hunki]
877 hunki += 1
877 hunki += 1
878 if h == u:
878 if h == u:
879 break
879 break
880 elif h.startswith('-'):
880 elif h.startswith('-'):
881 continue
881 continue
882 else:
882 else:
883 self.hunk.insert(hunki - 1, u)
883 self.hunk.insert(hunki - 1, u)
884 break
884 break
885
885
886 if not self.a:
886 if not self.a:
887 # this happens when lines were only added to the hunk
887 # this happens when lines were only added to the hunk
888 for x in self.hunk:
888 for x in self.hunk:
889 if x.startswith('-') or x.startswith(' '):
889 if x.startswith('-') or x.startswith(' '):
890 self.a.append(x)
890 self.a.append(x)
891 if not self.b:
891 if not self.b:
892 # this happens when lines were only deleted from the hunk
892 # this happens when lines were only deleted from the hunk
893 for x in self.hunk:
893 for x in self.hunk:
894 if x.startswith('+') or x.startswith(' '):
894 if x.startswith('+') or x.startswith(' '):
895 self.b.append(x[1:])
895 self.b.append(x[1:])
896 # @@ -start,len +start,len @@
896 # @@ -start,len +start,len @@
897 self.desc = "@@ -%d,%d +%d,%d @@\n" % (self.starta, self.lena,
897 self.desc = "@@ -%d,%d +%d,%d @@\n" % (self.starta, self.lena,
898 self.startb, self.lenb)
898 self.startb, self.lenb)
899 self.hunk[0] = self.desc
899 self.hunk[0] = self.desc
900 self._fixnewline(lr)
900 self._fixnewline(lr)
901
901
902 def _fixnewline(self, lr):
902 def _fixnewline(self, lr):
903 l = lr.readline()
903 l = lr.readline()
904 if l.startswith('\ '):
904 if l.startswith('\ '):
905 diffhelpers.fix_newline(self.hunk, self.a, self.b)
905 diffhelpers.fix_newline(self.hunk, self.a, self.b)
906 else:
906 else:
907 lr.push(l)
907 lr.push(l)
908
908
909 def complete(self):
909 def complete(self):
910 return len(self.a) == self.lena and len(self.b) == self.lenb
910 return len(self.a) == self.lena and len(self.b) == self.lenb
911
911
912 def createfile(self):
912 def createfile(self):
913 return self.starta == 0 and self.lena == 0 and self.create
913 return self.starta == 0 and self.lena == 0 and self.create
914
914
915 def rmfile(self):
915 def rmfile(self):
916 return self.startb == 0 and self.lenb == 0 and self.remove
916 return self.startb == 0 and self.lenb == 0 and self.remove
917
917
918 def fuzzit(self, l, fuzz, toponly):
918 def fuzzit(self, l, fuzz, toponly):
919 # this removes context lines from the top and bottom of list 'l'. It
919 # this removes context lines from the top and bottom of list 'l'. It
920 # checks the hunk to make sure only context lines are removed, and then
920 # checks the hunk to make sure only context lines are removed, and then
921 # returns a new shortened list of lines.
921 # returns a new shortened list of lines.
922 fuzz = min(fuzz, len(l)-1)
922 fuzz = min(fuzz, len(l)-1)
923 if fuzz:
923 if fuzz:
924 top = 0
924 top = 0
925 bot = 0
925 bot = 0
926 hlen = len(self.hunk)
926 hlen = len(self.hunk)
927 for x in xrange(hlen - 1):
927 for x in xrange(hlen - 1):
928 # the hunk starts with the @@ line, so use x+1
928 # the hunk starts with the @@ line, so use x+1
929 if self.hunk[x + 1][0] == ' ':
929 if self.hunk[x + 1][0] == ' ':
930 top += 1
930 top += 1
931 else:
931 else:
932 break
932 break
933 if not toponly:
933 if not toponly:
934 for x in xrange(hlen - 1):
934 for x in xrange(hlen - 1):
935 if self.hunk[hlen - bot - 1][0] == ' ':
935 if self.hunk[hlen - bot - 1][0] == ' ':
936 bot += 1
936 bot += 1
937 else:
937 else:
938 break
938 break
939
939
940 # top and bot now count context in the hunk
940 # top and bot now count context in the hunk
941 # adjust them if either one is short
941 # adjust them if either one is short
942 context = max(top, bot, 3)
942 context = max(top, bot, 3)
943 if bot < context:
943 if bot < context:
944 bot = max(0, fuzz - (context - bot))
944 bot = max(0, fuzz - (context - bot))
945 else:
945 else:
946 bot = min(fuzz, bot)
946 bot = min(fuzz, bot)
947 if top < context:
947 if top < context:
948 top = max(0, fuzz - (context - top))
948 top = max(0, fuzz - (context - top))
949 else:
949 else:
950 top = min(fuzz, top)
950 top = min(fuzz, top)
951
951
952 return l[top:len(l)-bot]
952 return l[top:len(l)-bot]
953 return l
953 return l
954
954
955 def old(self, fuzz=0, toponly=False):
955 def old(self, fuzz=0, toponly=False):
956 return self.fuzzit(self.a, fuzz, toponly)
956 return self.fuzzit(self.a, fuzz, toponly)
957
957
958 def new(self, fuzz=0, toponly=False):
958 def new(self, fuzz=0, toponly=False):
959 return self.fuzzit(self.b, fuzz, toponly)
959 return self.fuzzit(self.b, fuzz, toponly)
960
960
961 class binhunk:
961 class binhunk:
962 'A binary patch file. Only understands literals so far.'
962 'A binary patch file. Only understands literals so far.'
963 def __init__(self, gitpatch):
963 def __init__(self, gitpatch):
964 self.gitpatch = gitpatch
964 self.gitpatch = gitpatch
965 self.text = None
965 self.text = None
966 self.hunk = ['GIT binary patch\n']
966 self.hunk = ['GIT binary patch\n']
967
967
968 def createfile(self):
968 def createfile(self):
969 return self.gitpatch.op == 'ADD'
969 return self.gitpatch.op == 'ADD'
970
970
971 def rmfile(self):
971 def rmfile(self):
972 return self.gitpatch.op == 'DELETE'
972 return self.gitpatch.op == 'DELETE'
973
973
974 def complete(self):
974 def complete(self):
975 return self.text is not None
975 return self.text is not None
976
976
977 def new(self):
977 def new(self):
978 return [self.text]
978 return [self.text]
979
979
980 def extract(self, lr):
980 def extract(self, lr):
981 line = lr.readline()
981 line = lr.readline()
982 self.hunk.append(line)
982 self.hunk.append(line)
983 while line and not line.startswith('literal '):
983 while line and not line.startswith('literal '):
984 line = lr.readline()
984 line = lr.readline()
985 self.hunk.append(line)
985 self.hunk.append(line)
986 if not line:
986 if not line:
987 raise PatchError(_('could not extract binary patch'))
987 raise PatchError(_('could not extract binary patch'))
988 size = int(line[8:].rstrip())
988 size = int(line[8:].rstrip())
989 dec = []
989 dec = []
990 line = lr.readline()
990 line = lr.readline()
991 self.hunk.append(line)
991 self.hunk.append(line)
992 while len(line) > 1:
992 while len(line) > 1:
993 l = line[0]
993 l = line[0]
994 if l <= 'Z' and l >= 'A':
994 if l <= 'Z' and l >= 'A':
995 l = ord(l) - ord('A') + 1
995 l = ord(l) - ord('A') + 1
996 else:
996 else:
997 l = ord(l) - ord('a') + 27
997 l = ord(l) - ord('a') + 27
998 dec.append(base85.b85decode(line[1:-1])[:l])
998 dec.append(base85.b85decode(line[1:-1])[:l])
999 line = lr.readline()
999 line = lr.readline()
1000 self.hunk.append(line)
1000 self.hunk.append(line)
1001 text = zlib.decompress(''.join(dec))
1001 text = zlib.decompress(''.join(dec))
1002 if len(text) != size:
1002 if len(text) != size:
1003 raise PatchError(_('binary patch is %d bytes, not %d') %
1003 raise PatchError(_('binary patch is %d bytes, not %d') %
1004 len(text), size)
1004 len(text), size)
1005 self.text = text
1005 self.text = text
1006
1006
1007 def parsefilename(str):
1007 def parsefilename(str):
1008 # --- filename \t|space stuff
1008 # --- filename \t|space stuff
1009 s = str[4:].rstrip('\r\n')
1009 s = str[4:].rstrip('\r\n')
1010 i = s.find('\t')
1010 i = s.find('\t')
1011 if i < 0:
1011 if i < 0:
1012 i = s.find(' ')
1012 i = s.find(' ')
1013 if i < 0:
1013 if i < 0:
1014 return s
1014 return s
1015 return s[:i]
1015 return s[:i]
1016
1016
1017 def pathstrip(path, strip):
1017 def pathstrip(path, strip):
1018 pathlen = len(path)
1018 pathlen = len(path)
1019 i = 0
1019 i = 0
1020 if strip == 0:
1020 if strip == 0:
1021 return '', path.rstrip()
1021 return '', path.rstrip()
1022 count = strip
1022 count = strip
1023 while count > 0:
1023 while count > 0:
1024 i = path.find('/', i)
1024 i = path.find('/', i)
1025 if i == -1:
1025 if i == -1:
1026 raise PatchError(_("unable to strip away %d of %d dirs from %s") %
1026 raise PatchError(_("unable to strip away %d of %d dirs from %s") %
1027 (count, strip, path))
1027 (count, strip, path))
1028 i += 1
1028 i += 1
1029 # consume '//' in the path
1029 # consume '//' in the path
1030 while i < pathlen - 1 and path[i] == '/':
1030 while i < pathlen - 1 and path[i] == '/':
1031 i += 1
1031 i += 1
1032 count -= 1
1032 count -= 1
1033 return path[:i].lstrip(), path[i:].rstrip()
1033 return path[:i].lstrip(), path[i:].rstrip()
1034
1034
1035 def selectfile(backend, afile_orig, bfile_orig, hunk, strip):
1035 def selectfile(backend, afile_orig, bfile_orig, hunk, strip):
1036 nulla = afile_orig == "/dev/null"
1036 nulla = afile_orig == "/dev/null"
1037 nullb = bfile_orig == "/dev/null"
1037 nullb = bfile_orig == "/dev/null"
1038 abase, afile = pathstrip(afile_orig, strip)
1038 abase, afile = pathstrip(afile_orig, strip)
1039 gooda = not nulla and backend.exists(afile)
1039 gooda = not nulla and backend.exists(afile)
1040 bbase, bfile = pathstrip(bfile_orig, strip)
1040 bbase, bfile = pathstrip(bfile_orig, strip)
1041 if afile == bfile:
1041 if afile == bfile:
1042 goodb = gooda
1042 goodb = gooda
1043 else:
1043 else:
1044 goodb = not nullb and backend.exists(bfile)
1044 goodb = not nullb and backend.exists(bfile)
1045 createfunc = hunk.createfile
1045 createfunc = hunk.createfile
1046 missing = not goodb and not gooda and not createfunc()
1046 missing = not goodb and not gooda and not createfunc()
1047
1047
1048 # some diff programs apparently produce patches where the afile is
1048 # some diff programs apparently produce patches where the afile is
1049 # not /dev/null, but afile starts with bfile
1049 # not /dev/null, but afile starts with bfile
1050 abasedir = afile[:afile.rfind('/') + 1]
1050 abasedir = afile[:afile.rfind('/') + 1]
1051 bbasedir = bfile[:bfile.rfind('/') + 1]
1051 bbasedir = bfile[:bfile.rfind('/') + 1]
1052 if missing and abasedir == bbasedir and afile.startswith(bfile):
1052 if missing and abasedir == bbasedir and afile.startswith(bfile):
1053 # this isn't very pretty
1053 # this isn't very pretty
1054 hunk.create = True
1054 hunk.create = True
1055 if createfunc():
1055 if createfunc():
1056 missing = False
1056 missing = False
1057 else:
1057 else:
1058 hunk.create = False
1058 hunk.create = False
1059
1059
1060 # If afile is "a/b/foo" and bfile is "a/b/foo.orig" we assume the
1060 # If afile is "a/b/foo" and bfile is "a/b/foo.orig" we assume the
1061 # diff is between a file and its backup. In this case, the original
1061 # diff is between a file and its backup. In this case, the original
1062 # file should be patched (see original mpatch code).
1062 # file should be patched (see original mpatch code).
1063 isbackup = (abase == bbase and bfile.startswith(afile))
1063 isbackup = (abase == bbase and bfile.startswith(afile))
1064 fname = None
1064 fname = None
1065 if not missing:
1065 if not missing:
1066 if gooda and goodb:
1066 if gooda and goodb:
1067 fname = isbackup and afile or bfile
1067 fname = isbackup and afile or bfile
1068 elif gooda:
1068 elif gooda:
1069 fname = afile
1069 fname = afile
1070
1070
1071 if not fname:
1071 if not fname:
1072 if not nullb:
1072 if not nullb:
1073 fname = isbackup and afile or bfile
1073 fname = isbackup and afile or bfile
1074 elif not nulla:
1074 elif not nulla:
1075 fname = afile
1075 fname = afile
1076 else:
1076 else:
1077 raise PatchError(_("undefined source and destination files"))
1077 raise PatchError(_("undefined source and destination files"))
1078
1078
1079 return fname, missing
1079 return fname, missing
1080
1080
1081 def scangitpatch(lr, firstline):
1081 def scangitpatch(lr, firstline):
1082 """
1082 """
1083 Git patches can emit:
1083 Git patches can emit:
1084 - rename a to b
1084 - rename a to b
1085 - change b
1085 - change b
1086 - copy a to c
1086 - copy a to c
1087 - change c
1087 - change c
1088
1088
1089 We cannot apply this sequence as-is, the renamed 'a' could not be
1089 We cannot apply this sequence as-is, the renamed 'a' could not be
1090 found for it would have been renamed already. And we cannot copy
1090 found for it would have been renamed already. And we cannot copy
1091 from 'b' instead because 'b' would have been changed already. So
1091 from 'b' instead because 'b' would have been changed already. So
1092 we scan the git patch for copy and rename commands so we can
1092 we scan the git patch for copy and rename commands so we can
1093 perform the copies ahead of time.
1093 perform the copies ahead of time.
1094 """
1094 """
1095 pos = 0
1095 pos = 0
1096 try:
1096 try:
1097 pos = lr.fp.tell()
1097 pos = lr.fp.tell()
1098 fp = lr.fp
1098 fp = lr.fp
1099 except IOError:
1099 except IOError:
1100 fp = cStringIO.StringIO(lr.fp.read())
1100 fp = cStringIO.StringIO(lr.fp.read())
1101 gitlr = linereader(fp, lr.textmode)
1101 gitlr = linereader(fp, lr.textmode)
1102 gitlr.push(firstline)
1102 gitlr.push(firstline)
1103 gitpatches = readgitpatch(gitlr)
1103 gitpatches = readgitpatch(gitlr)
1104 fp.seek(pos)
1104 fp.seek(pos)
1105 return gitpatches
1105 return gitpatches
1106
1106
1107 def iterhunks(fp):
1107 def iterhunks(fp):
1108 """Read a patch and yield the following events:
1108 """Read a patch and yield the following events:
1109 - ("file", afile, bfile, firsthunk): select a new target file.
1109 - ("file", afile, bfile, firsthunk): select a new target file.
1110 - ("hunk", hunk): a new hunk is ready to be applied, follows a
1110 - ("hunk", hunk): a new hunk is ready to be applied, follows a
1111 "file" event.
1111 "file" event.
1112 - ("git", gitchanges): current diff is in git format, gitchanges
1112 - ("git", gitchanges): current diff is in git format, gitchanges
1113 maps filenames to gitpatch records. Unique event.
1113 maps filenames to gitpatch records. Unique event.
1114 """
1114 """
1115 changed = {}
1115 changed = {}
1116 afile = ""
1116 afile = ""
1117 bfile = ""
1117 bfile = ""
1118 state = None
1118 state = None
1119 hunknum = 0
1119 hunknum = 0
1120 emitfile = newfile = False
1120 emitfile = newfile = False
1121 git = False
1121 git = False
1122
1122
1123 # our states
1123 # our states
1124 BFILE = 1
1124 BFILE = 1
1125 context = None
1125 context = None
1126 lr = linereader(fp)
1126 lr = linereader(fp)
1127
1127
1128 while True:
1128 while True:
1129 x = lr.readline()
1129 x = lr.readline()
1130 if not x:
1130 if not x:
1131 break
1131 break
1132 if (state == BFILE and ((not context and x[0] == '@') or
1132 if state == BFILE and (
1133 ((context is not False) and x.startswith('***************')))):
1133 (not context and x[0] == '@')
1134 if context is None and x.startswith('***************'):
1134 or (context is not False and x.startswith('***************'))
1135 context = True
1135 or x.startswith('GIT binary patch')):
1136 gpatch = changed.get(bfile)
1136 gp = changed.get(bfile)
1137 create = afile == '/dev/null' or gpatch and gpatch.op == 'ADD'
1137 if x.startswith('GIT binary patch'):
1138 remove = bfile == '/dev/null' or gpatch and gpatch.op == 'DELETE'
1138 h = binhunk(gp)
1139 h = hunk(x, hunknum + 1, lr, context, create, remove)
1139 h.extract(lr)
1140 afile = 'a/' + afile
1141 bfile = 'b/' + bfile
1142 else:
1143 if context is None and x.startswith('***************'):
1144 context = True
1145 create = afile == '/dev/null' or gp and gp.op == 'ADD'
1146 remove = bfile == '/dev/null' or gp and gp.op == 'DELETE'
1147 h = hunk(x, hunknum + 1, lr, context, create, remove)
1140 hunknum += 1
1148 hunknum += 1
1141 if emitfile:
1149 if emitfile:
1142 emitfile = False
1150 emitfile = False
1143 yield 'file', (afile, bfile, h, gpatch and gpatch.mode or None)
1151 yield 'file', (afile, bfile, h, gp and gp.mode or None)
1144 yield 'hunk', h
1145 elif state == BFILE and x.startswith('GIT binary patch'):
1146 gpatch = changed[bfile]
1147 h = binhunk(gpatch)
1148 hunknum += 1
1149 if emitfile:
1150 emitfile = False
1151 yield 'file', ('a/' + afile, 'b/' + bfile, h,
1152 gpatch and gpatch.mode or None)
1153 h.extract(lr)
1154 yield 'hunk', h
1152 yield 'hunk', h
1155 elif x.startswith('diff --git'):
1153 elif x.startswith('diff --git'):
1156 # check for git diff, scanning the whole patch file if needed
1154 # check for git diff, scanning the whole patch file if needed
1157 m = gitre.match(x)
1155 m = gitre.match(x)
1158 if m:
1156 if m:
1159 afile, bfile = m.group(1, 2)
1157 afile, bfile = m.group(1, 2)
1160 if not git:
1158 if not git:
1161 git = True
1159 git = True
1162 gitpatches = scangitpatch(lr, x)
1160 gitpatches = scangitpatch(lr, x)
1163 yield 'git', gitpatches
1161 yield 'git', gitpatches
1164 for gp in gitpatches:
1162 for gp in gitpatches:
1165 changed[gp.path] = gp
1163 changed[gp.path] = gp
1166 # else error?
1164 # else error?
1167 # copy/rename + modify should modify target, not source
1165 # copy/rename + modify should modify target, not source
1168 gp = changed.get(bfile)
1166 gp = changed.get(bfile)
1169 if gp and (gp.op in ('COPY', 'DELETE', 'RENAME', 'ADD')
1167 if gp and (gp.op in ('COPY', 'DELETE', 'RENAME', 'ADD')
1170 or gp.mode):
1168 or gp.mode):
1171 afile = bfile
1169 afile = bfile
1172 newfile = True
1170 newfile = True
1173 elif x.startswith('---'):
1171 elif x.startswith('---'):
1174 # check for a unified diff
1172 # check for a unified diff
1175 l2 = lr.readline()
1173 l2 = lr.readline()
1176 if not l2.startswith('+++'):
1174 if not l2.startswith('+++'):
1177 lr.push(l2)
1175 lr.push(l2)
1178 continue
1176 continue
1179 newfile = True
1177 newfile = True
1180 context = False
1178 context = False
1181 afile = parsefilename(x)
1179 afile = parsefilename(x)
1182 bfile = parsefilename(l2)
1180 bfile = parsefilename(l2)
1183 elif x.startswith('***'):
1181 elif x.startswith('***'):
1184 # check for a context diff
1182 # check for a context diff
1185 l2 = lr.readline()
1183 l2 = lr.readline()
1186 if not l2.startswith('---'):
1184 if not l2.startswith('---'):
1187 lr.push(l2)
1185 lr.push(l2)
1188 continue
1186 continue
1189 l3 = lr.readline()
1187 l3 = lr.readline()
1190 lr.push(l3)
1188 lr.push(l3)
1191 if not l3.startswith("***************"):
1189 if not l3.startswith("***************"):
1192 lr.push(l2)
1190 lr.push(l2)
1193 continue
1191 continue
1194 newfile = True
1192 newfile = True
1195 context = True
1193 context = True
1196 afile = parsefilename(x)
1194 afile = parsefilename(x)
1197 bfile = parsefilename(l2)
1195 bfile = parsefilename(l2)
1198
1196
1199 if newfile:
1197 if newfile:
1200 newfile = False
1198 newfile = False
1201 emitfile = True
1199 emitfile = True
1202 state = BFILE
1200 state = BFILE
1203 hunknum = 0
1201 hunknum = 0
1204
1202
1205 def applydiff(ui, fp, changed, backend, strip=1, eolmode='strict'):
1203 def applydiff(ui, fp, changed, backend, strip=1, eolmode='strict'):
1206 """Reads a patch from fp and tries to apply it.
1204 """Reads a patch from fp and tries to apply it.
1207
1205
1208 The dict 'changed' is filled in with all of the filenames changed
1206 The dict 'changed' is filled in with all of the filenames changed
1209 by the patch. Returns 0 for a clean patch, -1 if any rejects were
1207 by the patch. Returns 0 for a clean patch, -1 if any rejects were
1210 found and 1 if there was any fuzz.
1208 found and 1 if there was any fuzz.
1211
1209
1212 If 'eolmode' is 'strict', the patch content and patched file are
1210 If 'eolmode' is 'strict', the patch content and patched file are
1213 read in binary mode. Otherwise, line endings are ignored when
1211 read in binary mode. Otherwise, line endings are ignored when
1214 patching then normalized according to 'eolmode'.
1212 patching then normalized according to 'eolmode'.
1215 """
1213 """
1216 return _applydiff(ui, fp, patchfile, backend, changed, strip=strip,
1214 return _applydiff(ui, fp, patchfile, backend, changed, strip=strip,
1217 eolmode=eolmode)
1215 eolmode=eolmode)
1218
1216
1219 def _applydiff(ui, fp, patcher, backend, changed, strip=1, eolmode='strict'):
1217 def _applydiff(ui, fp, patcher, backend, changed, strip=1, eolmode='strict'):
1220 rejects = 0
1218 rejects = 0
1221 err = 0
1219 err = 0
1222 current_file = None
1220 current_file = None
1223
1221
1224 for state, values in iterhunks(fp):
1222 for state, values in iterhunks(fp):
1225 if state == 'hunk':
1223 if state == 'hunk':
1226 if not current_file:
1224 if not current_file:
1227 continue
1225 continue
1228 ret = current_file.apply(values)
1226 ret = current_file.apply(values)
1229 if ret >= 0:
1227 if ret >= 0:
1230 changed.setdefault(current_file.fname, None)
1228 changed.setdefault(current_file.fname, None)
1231 if ret > 0:
1229 if ret > 0:
1232 err = 1
1230 err = 1
1233 elif state == 'file':
1231 elif state == 'file':
1234 if current_file:
1232 if current_file:
1235 rejects += current_file.close()
1233 rejects += current_file.close()
1236 afile, bfile, first_hunk, mode = values
1234 afile, bfile, first_hunk, mode = values
1237 try:
1235 try:
1238 current_file, missing = selectfile(backend, afile, bfile,
1236 current_file, missing = selectfile(backend, afile, bfile,
1239 first_hunk, strip)
1237 first_hunk, strip)
1240 current_file = patcher(ui, current_file, backend, mode,
1238 current_file = patcher(ui, current_file, backend, mode,
1241 missing=missing, eolmode=eolmode)
1239 missing=missing, eolmode=eolmode)
1242 except PatchError, inst:
1240 except PatchError, inst:
1243 ui.warn(str(inst) + '\n')
1241 ui.warn(str(inst) + '\n')
1244 current_file = None
1242 current_file = None
1245 rejects += 1
1243 rejects += 1
1246 continue
1244 continue
1247 elif state == 'git':
1245 elif state == 'git':
1248 for gp in values:
1246 for gp in values:
1249 gp.path = pathstrip(gp.path, strip - 1)[1]
1247 gp.path = pathstrip(gp.path, strip - 1)[1]
1250 if gp.oldpath:
1248 if gp.oldpath:
1251 gp.oldpath = pathstrip(gp.oldpath, strip - 1)[1]
1249 gp.oldpath = pathstrip(gp.oldpath, strip - 1)[1]
1252 if gp.op in ('COPY', 'RENAME'):
1250 if gp.op in ('COPY', 'RENAME'):
1253 backend.copy(gp.oldpath, gp.path)
1251 backend.copy(gp.oldpath, gp.path)
1254 changed[gp.path] = gp
1252 changed[gp.path] = gp
1255 else:
1253 else:
1256 raise util.Abort(_('unsupported parser state: %s') % state)
1254 raise util.Abort(_('unsupported parser state: %s') % state)
1257
1255
1258 if current_file:
1256 if current_file:
1259 rejects += current_file.close()
1257 rejects += current_file.close()
1260
1258
1261 # Handle mode changes without hunk
1259 # Handle mode changes without hunk
1262 removed = set()
1260 removed = set()
1263 for gp in changed.itervalues():
1261 for gp in changed.itervalues():
1264 if not gp:
1262 if not gp:
1265 continue
1263 continue
1266 if gp.op == 'DELETE':
1264 if gp.op == 'DELETE':
1267 removed.add(gp.path)
1265 removed.add(gp.path)
1268 continue
1266 continue
1269 if gp.op == 'RENAME':
1267 if gp.op == 'RENAME':
1270 removed.add(gp.oldpath)
1268 removed.add(gp.oldpath)
1271 if gp.mode:
1269 if gp.mode:
1272 if gp.op == 'ADD' and not backend.exists(gp.path):
1270 if gp.op == 'ADD' and not backend.exists(gp.path):
1273 # Added files without content have no hunk and must be created
1271 # Added files without content have no hunk and must be created
1274 backend.writelines(gp.path, [], gp.mode)
1272 backend.writelines(gp.path, [], gp.mode)
1275 else:
1273 else:
1276 backend.setmode(gp.path, gp.mode[0], gp.mode[1])
1274 backend.setmode(gp.path, gp.mode[0], gp.mode[1])
1277 for path in sorted(removed):
1275 for path in sorted(removed):
1278 backend.unlink(path)
1276 backend.unlink(path)
1279
1277
1280 if rejects:
1278 if rejects:
1281 return -1
1279 return -1
1282 return err
1280 return err
1283
1281
1284 def _externalpatch(ui, repo, patcher, patchname, strip, files,
1282 def _externalpatch(ui, repo, patcher, patchname, strip, files,
1285 similarity):
1283 similarity):
1286 """use <patcher> to apply <patchname> to the working directory.
1284 """use <patcher> to apply <patchname> to the working directory.
1287 returns whether patch was applied with fuzz factor."""
1285 returns whether patch was applied with fuzz factor."""
1288
1286
1289 fuzz = False
1287 fuzz = False
1290 args = []
1288 args = []
1291 cwd = repo.root
1289 cwd = repo.root
1292 if cwd:
1290 if cwd:
1293 args.append('-d %s' % util.shellquote(cwd))
1291 args.append('-d %s' % util.shellquote(cwd))
1294 fp = util.popen('%s %s -p%d < %s' % (patcher, ' '.join(args), strip,
1292 fp = util.popen('%s %s -p%d < %s' % (patcher, ' '.join(args), strip,
1295 util.shellquote(patchname)))
1293 util.shellquote(patchname)))
1296 try:
1294 try:
1297 for line in fp:
1295 for line in fp:
1298 line = line.rstrip()
1296 line = line.rstrip()
1299 ui.note(line + '\n')
1297 ui.note(line + '\n')
1300 if line.startswith('patching file '):
1298 if line.startswith('patching file '):
1301 pf = util.parsepatchoutput(line)
1299 pf = util.parsepatchoutput(line)
1302 printed_file = False
1300 printed_file = False
1303 files.setdefault(pf, None)
1301 files.setdefault(pf, None)
1304 elif line.find('with fuzz') >= 0:
1302 elif line.find('with fuzz') >= 0:
1305 fuzz = True
1303 fuzz = True
1306 if not printed_file:
1304 if not printed_file:
1307 ui.warn(pf + '\n')
1305 ui.warn(pf + '\n')
1308 printed_file = True
1306 printed_file = True
1309 ui.warn(line + '\n')
1307 ui.warn(line + '\n')
1310 elif line.find('saving rejects to file') >= 0:
1308 elif line.find('saving rejects to file') >= 0:
1311 ui.warn(line + '\n')
1309 ui.warn(line + '\n')
1312 elif line.find('FAILED') >= 0:
1310 elif line.find('FAILED') >= 0:
1313 if not printed_file:
1311 if not printed_file:
1314 ui.warn(pf + '\n')
1312 ui.warn(pf + '\n')
1315 printed_file = True
1313 printed_file = True
1316 ui.warn(line + '\n')
1314 ui.warn(line + '\n')
1317 finally:
1315 finally:
1318 if files:
1316 if files:
1319 cfiles = list(files)
1317 cfiles = list(files)
1320 cwd = repo.getcwd()
1318 cwd = repo.getcwd()
1321 if cwd:
1319 if cwd:
1322 cfiles = [util.pathto(repo.root, cwd, f)
1320 cfiles = [util.pathto(repo.root, cwd, f)
1323 for f in cfile]
1321 for f in cfile]
1324 scmutil.addremove(repo, cfiles, similarity=similarity)
1322 scmutil.addremove(repo, cfiles, similarity=similarity)
1325 code = fp.close()
1323 code = fp.close()
1326 if code:
1324 if code:
1327 raise PatchError(_("patch command failed: %s") %
1325 raise PatchError(_("patch command failed: %s") %
1328 util.explainexit(code)[0])
1326 util.explainexit(code)[0])
1329 return fuzz
1327 return fuzz
1330
1328
1331 def internalpatch(ui, repo, patchobj, strip, files=None, eolmode='strict',
1329 def internalpatch(ui, repo, patchobj, strip, files=None, eolmode='strict',
1332 similarity=0):
1330 similarity=0):
1333 """use builtin patch to apply <patchobj> to the working directory.
1331 """use builtin patch to apply <patchobj> to the working directory.
1334 returns whether patch was applied with fuzz factor."""
1332 returns whether patch was applied with fuzz factor."""
1335
1333
1336 if files is None:
1334 if files is None:
1337 files = {}
1335 files = {}
1338 if eolmode is None:
1336 if eolmode is None:
1339 eolmode = ui.config('patch', 'eol', 'strict')
1337 eolmode = ui.config('patch', 'eol', 'strict')
1340 if eolmode.lower() not in eolmodes:
1338 if eolmode.lower() not in eolmodes:
1341 raise util.Abort(_('unsupported line endings type: %s') % eolmode)
1339 raise util.Abort(_('unsupported line endings type: %s') % eolmode)
1342 eolmode = eolmode.lower()
1340 eolmode = eolmode.lower()
1343
1341
1344 backend = workingbackend(ui, repo, similarity)
1342 backend = workingbackend(ui, repo, similarity)
1345 try:
1343 try:
1346 fp = open(patchobj, 'rb')
1344 fp = open(patchobj, 'rb')
1347 except TypeError:
1345 except TypeError:
1348 fp = patchobj
1346 fp = patchobj
1349 try:
1347 try:
1350 ret = applydiff(ui, fp, files, backend, strip=strip, eolmode=eolmode)
1348 ret = applydiff(ui, fp, files, backend, strip=strip, eolmode=eolmode)
1351 finally:
1349 finally:
1352 if fp != patchobj:
1350 if fp != patchobj:
1353 fp.close()
1351 fp.close()
1354 files.update(dict.fromkeys(backend.close()))
1352 files.update(dict.fromkeys(backend.close()))
1355 if ret < 0:
1353 if ret < 0:
1356 raise PatchError(_('patch failed to apply'))
1354 raise PatchError(_('patch failed to apply'))
1357 return ret > 0
1355 return ret > 0
1358
1356
1359 def patch(ui, repo, patchname, strip=1, files=None, eolmode='strict',
1357 def patch(ui, repo, patchname, strip=1, files=None, eolmode='strict',
1360 similarity=0):
1358 similarity=0):
1361 """Apply <patchname> to the working directory.
1359 """Apply <patchname> to the working directory.
1362
1360
1363 'eolmode' specifies how end of lines should be handled. It can be:
1361 'eolmode' specifies how end of lines should be handled. It can be:
1364 - 'strict': inputs are read in binary mode, EOLs are preserved
1362 - 'strict': inputs are read in binary mode, EOLs are preserved
1365 - 'crlf': EOLs are ignored when patching and reset to CRLF
1363 - 'crlf': EOLs are ignored when patching and reset to CRLF
1366 - 'lf': EOLs are ignored when patching and reset to LF
1364 - 'lf': EOLs are ignored when patching and reset to LF
1367 - None: get it from user settings, default to 'strict'
1365 - None: get it from user settings, default to 'strict'
1368 'eolmode' is ignored when using an external patcher program.
1366 'eolmode' is ignored when using an external patcher program.
1369
1367
1370 Returns whether patch was applied with fuzz factor.
1368 Returns whether patch was applied with fuzz factor.
1371 """
1369 """
1372 patcher = ui.config('ui', 'patch')
1370 patcher = ui.config('ui', 'patch')
1373 if files is None:
1371 if files is None:
1374 files = {}
1372 files = {}
1375 try:
1373 try:
1376 if patcher:
1374 if patcher:
1377 return _externalpatch(ui, repo, patcher, patchname, strip,
1375 return _externalpatch(ui, repo, patcher, patchname, strip,
1378 files, similarity)
1376 files, similarity)
1379 return internalpatch(ui, repo, patchname, strip, files, eolmode,
1377 return internalpatch(ui, repo, patchname, strip, files, eolmode,
1380 similarity)
1378 similarity)
1381 except PatchError, err:
1379 except PatchError, err:
1382 raise util.Abort(str(err))
1380 raise util.Abort(str(err))
1383
1381
1384 def changedfiles(ui, repo, patchpath, strip=1):
1382 def changedfiles(ui, repo, patchpath, strip=1):
1385 backend = fsbackend(ui, repo.root)
1383 backend = fsbackend(ui, repo.root)
1386 fp = open(patchpath, 'rb')
1384 fp = open(patchpath, 'rb')
1387 try:
1385 try:
1388 changed = set()
1386 changed = set()
1389 for state, values in iterhunks(fp):
1387 for state, values in iterhunks(fp):
1390 if state == 'hunk':
1388 if state == 'hunk':
1391 continue
1389 continue
1392 elif state == 'file':
1390 elif state == 'file':
1393 afile, bfile, first_hunk, mode = values
1391 afile, bfile, first_hunk, mode = values
1394 current_file, missing = selectfile(backend, afile, bfile,
1392 current_file, missing = selectfile(backend, afile, bfile,
1395 first_hunk, strip)
1393 first_hunk, strip)
1396 changed.add(current_file)
1394 changed.add(current_file)
1397 elif state == 'git':
1395 elif state == 'git':
1398 for gp in values:
1396 for gp in values:
1399 gp.path = pathstrip(gp.path, strip - 1)[1]
1397 gp.path = pathstrip(gp.path, strip - 1)[1]
1400 changed.add(gp.path)
1398 changed.add(gp.path)
1401 if gp.oldpath:
1399 if gp.oldpath:
1402 gp.oldpath = pathstrip(gp.oldpath, strip - 1)[1]
1400 gp.oldpath = pathstrip(gp.oldpath, strip - 1)[1]
1403 if gp.op == 'RENAME':
1401 if gp.op == 'RENAME':
1404 changed.add(gp.oldpath)
1402 changed.add(gp.oldpath)
1405 else:
1403 else:
1406 raise util.Abort(_('unsupported parser state: %s') % state)
1404 raise util.Abort(_('unsupported parser state: %s') % state)
1407 return changed
1405 return changed
1408 finally:
1406 finally:
1409 fp.close()
1407 fp.close()
1410
1408
1411 def b85diff(to, tn):
1409 def b85diff(to, tn):
1412 '''print base85-encoded binary diff'''
1410 '''print base85-encoded binary diff'''
1413 def gitindex(text):
1411 def gitindex(text):
1414 if not text:
1412 if not text:
1415 return hex(nullid)
1413 return hex(nullid)
1416 l = len(text)
1414 l = len(text)
1417 s = util.sha1('blob %d\0' % l)
1415 s = util.sha1('blob %d\0' % l)
1418 s.update(text)
1416 s.update(text)
1419 return s.hexdigest()
1417 return s.hexdigest()
1420
1418
1421 def fmtline(line):
1419 def fmtline(line):
1422 l = len(line)
1420 l = len(line)
1423 if l <= 26:
1421 if l <= 26:
1424 l = chr(ord('A') + l - 1)
1422 l = chr(ord('A') + l - 1)
1425 else:
1423 else:
1426 l = chr(l - 26 + ord('a') - 1)
1424 l = chr(l - 26 + ord('a') - 1)
1427 return '%c%s\n' % (l, base85.b85encode(line, True))
1425 return '%c%s\n' % (l, base85.b85encode(line, True))
1428
1426
1429 def chunk(text, csize=52):
1427 def chunk(text, csize=52):
1430 l = len(text)
1428 l = len(text)
1431 i = 0
1429 i = 0
1432 while i < l:
1430 while i < l:
1433 yield text[i:i + csize]
1431 yield text[i:i + csize]
1434 i += csize
1432 i += csize
1435
1433
1436 tohash = gitindex(to)
1434 tohash = gitindex(to)
1437 tnhash = gitindex(tn)
1435 tnhash = gitindex(tn)
1438 if tohash == tnhash:
1436 if tohash == tnhash:
1439 return ""
1437 return ""
1440
1438
1441 # TODO: deltas
1439 # TODO: deltas
1442 ret = ['index %s..%s\nGIT binary patch\nliteral %s\n' %
1440 ret = ['index %s..%s\nGIT binary patch\nliteral %s\n' %
1443 (tohash, tnhash, len(tn))]
1441 (tohash, tnhash, len(tn))]
1444 for l in chunk(zlib.compress(tn)):
1442 for l in chunk(zlib.compress(tn)):
1445 ret.append(fmtline(l))
1443 ret.append(fmtline(l))
1446 ret.append('\n')
1444 ret.append('\n')
1447 return ''.join(ret)
1445 return ''.join(ret)
1448
1446
1449 class GitDiffRequired(Exception):
1447 class GitDiffRequired(Exception):
1450 pass
1448 pass
1451
1449
1452 def diffopts(ui, opts=None, untrusted=False):
1450 def diffopts(ui, opts=None, untrusted=False):
1453 def get(key, name=None, getter=ui.configbool):
1451 def get(key, name=None, getter=ui.configbool):
1454 return ((opts and opts.get(key)) or
1452 return ((opts and opts.get(key)) or
1455 getter('diff', name or key, None, untrusted=untrusted))
1453 getter('diff', name or key, None, untrusted=untrusted))
1456 return mdiff.diffopts(
1454 return mdiff.diffopts(
1457 text=opts and opts.get('text'),
1455 text=opts and opts.get('text'),
1458 git=get('git'),
1456 git=get('git'),
1459 nodates=get('nodates'),
1457 nodates=get('nodates'),
1460 showfunc=get('show_function', 'showfunc'),
1458 showfunc=get('show_function', 'showfunc'),
1461 ignorews=get('ignore_all_space', 'ignorews'),
1459 ignorews=get('ignore_all_space', 'ignorews'),
1462 ignorewsamount=get('ignore_space_change', 'ignorewsamount'),
1460 ignorewsamount=get('ignore_space_change', 'ignorewsamount'),
1463 ignoreblanklines=get('ignore_blank_lines', 'ignoreblanklines'),
1461 ignoreblanklines=get('ignore_blank_lines', 'ignoreblanklines'),
1464 context=get('unified', getter=ui.config))
1462 context=get('unified', getter=ui.config))
1465
1463
1466 def diff(repo, node1=None, node2=None, match=None, changes=None, opts=None,
1464 def diff(repo, node1=None, node2=None, match=None, changes=None, opts=None,
1467 losedatafn=None, prefix=''):
1465 losedatafn=None, prefix=''):
1468 '''yields diff of changes to files between two nodes, or node and
1466 '''yields diff of changes to files between two nodes, or node and
1469 working directory.
1467 working directory.
1470
1468
1471 if node1 is None, use first dirstate parent instead.
1469 if node1 is None, use first dirstate parent instead.
1472 if node2 is None, compare node1 with working directory.
1470 if node2 is None, compare node1 with working directory.
1473
1471
1474 losedatafn(**kwarg) is a callable run when opts.upgrade=True and
1472 losedatafn(**kwarg) is a callable run when opts.upgrade=True and
1475 every time some change cannot be represented with the current
1473 every time some change cannot be represented with the current
1476 patch format. Return False to upgrade to git patch format, True to
1474 patch format. Return False to upgrade to git patch format, True to
1477 accept the loss or raise an exception to abort the diff. It is
1475 accept the loss or raise an exception to abort the diff. It is
1478 called with the name of current file being diffed as 'fn'. If set
1476 called with the name of current file being diffed as 'fn'. If set
1479 to None, patches will always be upgraded to git format when
1477 to None, patches will always be upgraded to git format when
1480 necessary.
1478 necessary.
1481
1479
1482 prefix is a filename prefix that is prepended to all filenames on
1480 prefix is a filename prefix that is prepended to all filenames on
1483 display (used for subrepos).
1481 display (used for subrepos).
1484 '''
1482 '''
1485
1483
1486 if opts is None:
1484 if opts is None:
1487 opts = mdiff.defaultopts
1485 opts = mdiff.defaultopts
1488
1486
1489 if not node1 and not node2:
1487 if not node1 and not node2:
1490 node1 = repo.dirstate.p1()
1488 node1 = repo.dirstate.p1()
1491
1489
1492 def lrugetfilectx():
1490 def lrugetfilectx():
1493 cache = {}
1491 cache = {}
1494 order = []
1492 order = []
1495 def getfilectx(f, ctx):
1493 def getfilectx(f, ctx):
1496 fctx = ctx.filectx(f, filelog=cache.get(f))
1494 fctx = ctx.filectx(f, filelog=cache.get(f))
1497 if f not in cache:
1495 if f not in cache:
1498 if len(cache) > 20:
1496 if len(cache) > 20:
1499 del cache[order.pop(0)]
1497 del cache[order.pop(0)]
1500 cache[f] = fctx.filelog()
1498 cache[f] = fctx.filelog()
1501 else:
1499 else:
1502 order.remove(f)
1500 order.remove(f)
1503 order.append(f)
1501 order.append(f)
1504 return fctx
1502 return fctx
1505 return getfilectx
1503 return getfilectx
1506 getfilectx = lrugetfilectx()
1504 getfilectx = lrugetfilectx()
1507
1505
1508 ctx1 = repo[node1]
1506 ctx1 = repo[node1]
1509 ctx2 = repo[node2]
1507 ctx2 = repo[node2]
1510
1508
1511 if not changes:
1509 if not changes:
1512 changes = repo.status(ctx1, ctx2, match=match)
1510 changes = repo.status(ctx1, ctx2, match=match)
1513 modified, added, removed = changes[:3]
1511 modified, added, removed = changes[:3]
1514
1512
1515 if not modified and not added and not removed:
1513 if not modified and not added and not removed:
1516 return []
1514 return []
1517
1515
1518 revs = None
1516 revs = None
1519 if not repo.ui.quiet:
1517 if not repo.ui.quiet:
1520 hexfunc = repo.ui.debugflag and hex or short
1518 hexfunc = repo.ui.debugflag and hex or short
1521 revs = [hexfunc(node) for node in [node1, node2] if node]
1519 revs = [hexfunc(node) for node in [node1, node2] if node]
1522
1520
1523 copy = {}
1521 copy = {}
1524 if opts.git or opts.upgrade:
1522 if opts.git or opts.upgrade:
1525 copy = copies.copies(repo, ctx1, ctx2, repo[nullid])[0]
1523 copy = copies.copies(repo, ctx1, ctx2, repo[nullid])[0]
1526
1524
1527 difffn = lambda opts, losedata: trydiff(repo, revs, ctx1, ctx2,
1525 difffn = lambda opts, losedata: trydiff(repo, revs, ctx1, ctx2,
1528 modified, added, removed, copy, getfilectx, opts, losedata, prefix)
1526 modified, added, removed, copy, getfilectx, opts, losedata, prefix)
1529 if opts.upgrade and not opts.git:
1527 if opts.upgrade and not opts.git:
1530 try:
1528 try:
1531 def losedata(fn):
1529 def losedata(fn):
1532 if not losedatafn or not losedatafn(fn=fn):
1530 if not losedatafn or not losedatafn(fn=fn):
1533 raise GitDiffRequired()
1531 raise GitDiffRequired()
1534 # Buffer the whole output until we are sure it can be generated
1532 # Buffer the whole output until we are sure it can be generated
1535 return list(difffn(opts.copy(git=False), losedata))
1533 return list(difffn(opts.copy(git=False), losedata))
1536 except GitDiffRequired:
1534 except GitDiffRequired:
1537 return difffn(opts.copy(git=True), None)
1535 return difffn(opts.copy(git=True), None)
1538 else:
1536 else:
1539 return difffn(opts, None)
1537 return difffn(opts, None)
1540
1538
1541 def difflabel(func, *args, **kw):
1539 def difflabel(func, *args, **kw):
1542 '''yields 2-tuples of (output, label) based on the output of func()'''
1540 '''yields 2-tuples of (output, label) based on the output of func()'''
1543 prefixes = [('diff', 'diff.diffline'),
1541 prefixes = [('diff', 'diff.diffline'),
1544 ('copy', 'diff.extended'),
1542 ('copy', 'diff.extended'),
1545 ('rename', 'diff.extended'),
1543 ('rename', 'diff.extended'),
1546 ('old', 'diff.extended'),
1544 ('old', 'diff.extended'),
1547 ('new', 'diff.extended'),
1545 ('new', 'diff.extended'),
1548 ('deleted', 'diff.extended'),
1546 ('deleted', 'diff.extended'),
1549 ('---', 'diff.file_a'),
1547 ('---', 'diff.file_a'),
1550 ('+++', 'diff.file_b'),
1548 ('+++', 'diff.file_b'),
1551 ('@@', 'diff.hunk'),
1549 ('@@', 'diff.hunk'),
1552 ('-', 'diff.deleted'),
1550 ('-', 'diff.deleted'),
1553 ('+', 'diff.inserted')]
1551 ('+', 'diff.inserted')]
1554
1552
1555 for chunk in func(*args, **kw):
1553 for chunk in func(*args, **kw):
1556 lines = chunk.split('\n')
1554 lines = chunk.split('\n')
1557 for i, line in enumerate(lines):
1555 for i, line in enumerate(lines):
1558 if i != 0:
1556 if i != 0:
1559 yield ('\n', '')
1557 yield ('\n', '')
1560 stripline = line
1558 stripline = line
1561 if line and line[0] in '+-':
1559 if line and line[0] in '+-':
1562 # highlight trailing whitespace, but only in changed lines
1560 # highlight trailing whitespace, but only in changed lines
1563 stripline = line.rstrip()
1561 stripline = line.rstrip()
1564 for prefix, label in prefixes:
1562 for prefix, label in prefixes:
1565 if stripline.startswith(prefix):
1563 if stripline.startswith(prefix):
1566 yield (stripline, label)
1564 yield (stripline, label)
1567 break
1565 break
1568 else:
1566 else:
1569 yield (line, '')
1567 yield (line, '')
1570 if line != stripline:
1568 if line != stripline:
1571 yield (line[len(stripline):], 'diff.trailingwhitespace')
1569 yield (line[len(stripline):], 'diff.trailingwhitespace')
1572
1570
1573 def diffui(*args, **kw):
1571 def diffui(*args, **kw):
1574 '''like diff(), but yields 2-tuples of (output, label) for ui.write()'''
1572 '''like diff(), but yields 2-tuples of (output, label) for ui.write()'''
1575 return difflabel(diff, *args, **kw)
1573 return difflabel(diff, *args, **kw)
1576
1574
1577
1575
1578 def _addmodehdr(header, omode, nmode):
1576 def _addmodehdr(header, omode, nmode):
1579 if omode != nmode:
1577 if omode != nmode:
1580 header.append('old mode %s\n' % omode)
1578 header.append('old mode %s\n' % omode)
1581 header.append('new mode %s\n' % nmode)
1579 header.append('new mode %s\n' % nmode)
1582
1580
1583 def trydiff(repo, revs, ctx1, ctx2, modified, added, removed,
1581 def trydiff(repo, revs, ctx1, ctx2, modified, added, removed,
1584 copy, getfilectx, opts, losedatafn, prefix):
1582 copy, getfilectx, opts, losedatafn, prefix):
1585
1583
1586 def join(f):
1584 def join(f):
1587 return os.path.join(prefix, f)
1585 return os.path.join(prefix, f)
1588
1586
1589 date1 = util.datestr(ctx1.date())
1587 date1 = util.datestr(ctx1.date())
1590 man1 = ctx1.manifest()
1588 man1 = ctx1.manifest()
1591
1589
1592 gone = set()
1590 gone = set()
1593 gitmode = {'l': '120000', 'x': '100755', '': '100644'}
1591 gitmode = {'l': '120000', 'x': '100755', '': '100644'}
1594
1592
1595 copyto = dict([(v, k) for k, v in copy.items()])
1593 copyto = dict([(v, k) for k, v in copy.items()])
1596
1594
1597 if opts.git:
1595 if opts.git:
1598 revs = None
1596 revs = None
1599
1597
1600 for f in sorted(modified + added + removed):
1598 for f in sorted(modified + added + removed):
1601 to = None
1599 to = None
1602 tn = None
1600 tn = None
1603 dodiff = True
1601 dodiff = True
1604 header = []
1602 header = []
1605 if f in man1:
1603 if f in man1:
1606 to = getfilectx(f, ctx1).data()
1604 to = getfilectx(f, ctx1).data()
1607 if f not in removed:
1605 if f not in removed:
1608 tn = getfilectx(f, ctx2).data()
1606 tn = getfilectx(f, ctx2).data()
1609 a, b = f, f
1607 a, b = f, f
1610 if opts.git or losedatafn:
1608 if opts.git or losedatafn:
1611 if f in added:
1609 if f in added:
1612 mode = gitmode[ctx2.flags(f)]
1610 mode = gitmode[ctx2.flags(f)]
1613 if f in copy or f in copyto:
1611 if f in copy or f in copyto:
1614 if opts.git:
1612 if opts.git:
1615 if f in copy:
1613 if f in copy:
1616 a = copy[f]
1614 a = copy[f]
1617 else:
1615 else:
1618 a = copyto[f]
1616 a = copyto[f]
1619 omode = gitmode[man1.flags(a)]
1617 omode = gitmode[man1.flags(a)]
1620 _addmodehdr(header, omode, mode)
1618 _addmodehdr(header, omode, mode)
1621 if a in removed and a not in gone:
1619 if a in removed and a not in gone:
1622 op = 'rename'
1620 op = 'rename'
1623 gone.add(a)
1621 gone.add(a)
1624 else:
1622 else:
1625 op = 'copy'
1623 op = 'copy'
1626 header.append('%s from %s\n' % (op, join(a)))
1624 header.append('%s from %s\n' % (op, join(a)))
1627 header.append('%s to %s\n' % (op, join(f)))
1625 header.append('%s to %s\n' % (op, join(f)))
1628 to = getfilectx(a, ctx1).data()
1626 to = getfilectx(a, ctx1).data()
1629 else:
1627 else:
1630 losedatafn(f)
1628 losedatafn(f)
1631 else:
1629 else:
1632 if opts.git:
1630 if opts.git:
1633 header.append('new file mode %s\n' % mode)
1631 header.append('new file mode %s\n' % mode)
1634 elif ctx2.flags(f):
1632 elif ctx2.flags(f):
1635 losedatafn(f)
1633 losedatafn(f)
1636 # In theory, if tn was copied or renamed we should check
1634 # In theory, if tn was copied or renamed we should check
1637 # if the source is binary too but the copy record already
1635 # if the source is binary too but the copy record already
1638 # forces git mode.
1636 # forces git mode.
1639 if util.binary(tn):
1637 if util.binary(tn):
1640 if opts.git:
1638 if opts.git:
1641 dodiff = 'binary'
1639 dodiff = 'binary'
1642 else:
1640 else:
1643 losedatafn(f)
1641 losedatafn(f)
1644 if not opts.git and not tn:
1642 if not opts.git and not tn:
1645 # regular diffs cannot represent new empty file
1643 # regular diffs cannot represent new empty file
1646 losedatafn(f)
1644 losedatafn(f)
1647 elif f in removed:
1645 elif f in removed:
1648 if opts.git:
1646 if opts.git:
1649 # have we already reported a copy above?
1647 # have we already reported a copy above?
1650 if ((f in copy and copy[f] in added
1648 if ((f in copy and copy[f] in added
1651 and copyto[copy[f]] == f) or
1649 and copyto[copy[f]] == f) or
1652 (f in copyto and copyto[f] in added
1650 (f in copyto and copyto[f] in added
1653 and copy[copyto[f]] == f)):
1651 and copy[copyto[f]] == f)):
1654 dodiff = False
1652 dodiff = False
1655 else:
1653 else:
1656 header.append('deleted file mode %s\n' %
1654 header.append('deleted file mode %s\n' %
1657 gitmode[man1.flags(f)])
1655 gitmode[man1.flags(f)])
1658 elif not to or util.binary(to):
1656 elif not to or util.binary(to):
1659 # regular diffs cannot represent empty file deletion
1657 # regular diffs cannot represent empty file deletion
1660 losedatafn(f)
1658 losedatafn(f)
1661 else:
1659 else:
1662 oflag = man1.flags(f)
1660 oflag = man1.flags(f)
1663 nflag = ctx2.flags(f)
1661 nflag = ctx2.flags(f)
1664 binary = util.binary(to) or util.binary(tn)
1662 binary = util.binary(to) or util.binary(tn)
1665 if opts.git:
1663 if opts.git:
1666 _addmodehdr(header, gitmode[oflag], gitmode[nflag])
1664 _addmodehdr(header, gitmode[oflag], gitmode[nflag])
1667 if binary:
1665 if binary:
1668 dodiff = 'binary'
1666 dodiff = 'binary'
1669 elif binary or nflag != oflag:
1667 elif binary or nflag != oflag:
1670 losedatafn(f)
1668 losedatafn(f)
1671 if opts.git:
1669 if opts.git:
1672 header.insert(0, mdiff.diffline(revs, join(a), join(b), opts))
1670 header.insert(0, mdiff.diffline(revs, join(a), join(b), opts))
1673
1671
1674 if dodiff:
1672 if dodiff:
1675 if dodiff == 'binary':
1673 if dodiff == 'binary':
1676 text = b85diff(to, tn)
1674 text = b85diff(to, tn)
1677 else:
1675 else:
1678 text = mdiff.unidiff(to, date1,
1676 text = mdiff.unidiff(to, date1,
1679 # ctx2 date may be dynamic
1677 # ctx2 date may be dynamic
1680 tn, util.datestr(ctx2.date()),
1678 tn, util.datestr(ctx2.date()),
1681 join(a), join(b), revs, opts=opts)
1679 join(a), join(b), revs, opts=opts)
1682 if header and (text or len(header) > 1):
1680 if header and (text or len(header) > 1):
1683 yield ''.join(header)
1681 yield ''.join(header)
1684 if text:
1682 if text:
1685 yield text
1683 yield text
1686
1684
1687 def diffstatdata(lines):
1685 def diffstatdata(lines):
1688 diffre = re.compile('^diff .*-r [a-z0-9]+\s(.*)$')
1686 diffre = re.compile('^diff .*-r [a-z0-9]+\s(.*)$')
1689
1687
1690 filename, adds, removes = None, 0, 0
1688 filename, adds, removes = None, 0, 0
1691 for line in lines:
1689 for line in lines:
1692 if line.startswith('diff'):
1690 if line.startswith('diff'):
1693 if filename:
1691 if filename:
1694 isbinary = adds == 0 and removes == 0
1692 isbinary = adds == 0 and removes == 0
1695 yield (filename, adds, removes, isbinary)
1693 yield (filename, adds, removes, isbinary)
1696 # set numbers to 0 anyway when starting new file
1694 # set numbers to 0 anyway when starting new file
1697 adds, removes = 0, 0
1695 adds, removes = 0, 0
1698 if line.startswith('diff --git'):
1696 if line.startswith('diff --git'):
1699 filename = gitre.search(line).group(1)
1697 filename = gitre.search(line).group(1)
1700 elif line.startswith('diff -r'):
1698 elif line.startswith('diff -r'):
1701 # format: "diff -r ... -r ... filename"
1699 # format: "diff -r ... -r ... filename"
1702 filename = diffre.search(line).group(1)
1700 filename = diffre.search(line).group(1)
1703 elif line.startswith('+') and not line.startswith('+++'):
1701 elif line.startswith('+') and not line.startswith('+++'):
1704 adds += 1
1702 adds += 1
1705 elif line.startswith('-') and not line.startswith('---'):
1703 elif line.startswith('-') and not line.startswith('---'):
1706 removes += 1
1704 removes += 1
1707 if filename:
1705 if filename:
1708 isbinary = adds == 0 and removes == 0
1706 isbinary = adds == 0 and removes == 0
1709 yield (filename, adds, removes, isbinary)
1707 yield (filename, adds, removes, isbinary)
1710
1708
1711 def diffstat(lines, width=80, git=False):
1709 def diffstat(lines, width=80, git=False):
1712 output = []
1710 output = []
1713 stats = list(diffstatdata(lines))
1711 stats = list(diffstatdata(lines))
1714
1712
1715 maxtotal, maxname = 0, 0
1713 maxtotal, maxname = 0, 0
1716 totaladds, totalremoves = 0, 0
1714 totaladds, totalremoves = 0, 0
1717 hasbinary = False
1715 hasbinary = False
1718
1716
1719 sized = [(filename, adds, removes, isbinary, encoding.colwidth(filename))
1717 sized = [(filename, adds, removes, isbinary, encoding.colwidth(filename))
1720 for filename, adds, removes, isbinary in stats]
1718 for filename, adds, removes, isbinary in stats]
1721
1719
1722 for filename, adds, removes, isbinary, namewidth in sized:
1720 for filename, adds, removes, isbinary, namewidth in sized:
1723 totaladds += adds
1721 totaladds += adds
1724 totalremoves += removes
1722 totalremoves += removes
1725 maxname = max(maxname, namewidth)
1723 maxname = max(maxname, namewidth)
1726 maxtotal = max(maxtotal, adds + removes)
1724 maxtotal = max(maxtotal, adds + removes)
1727 if isbinary:
1725 if isbinary:
1728 hasbinary = True
1726 hasbinary = True
1729
1727
1730 countwidth = len(str(maxtotal))
1728 countwidth = len(str(maxtotal))
1731 if hasbinary and countwidth < 3:
1729 if hasbinary and countwidth < 3:
1732 countwidth = 3
1730 countwidth = 3
1733 graphwidth = width - countwidth - maxname - 6
1731 graphwidth = width - countwidth - maxname - 6
1734 if graphwidth < 10:
1732 if graphwidth < 10:
1735 graphwidth = 10
1733 graphwidth = 10
1736
1734
1737 def scale(i):
1735 def scale(i):
1738 if maxtotal <= graphwidth:
1736 if maxtotal <= graphwidth:
1739 return i
1737 return i
1740 # If diffstat runs out of room it doesn't print anything,
1738 # If diffstat runs out of room it doesn't print anything,
1741 # which isn't very useful, so always print at least one + or -
1739 # which isn't very useful, so always print at least one + or -
1742 # if there were at least some changes.
1740 # if there were at least some changes.
1743 return max(i * graphwidth // maxtotal, int(bool(i)))
1741 return max(i * graphwidth // maxtotal, int(bool(i)))
1744
1742
1745 for filename, adds, removes, isbinary, namewidth in sized:
1743 for filename, adds, removes, isbinary, namewidth in sized:
1746 if git and isbinary:
1744 if git and isbinary:
1747 count = 'Bin'
1745 count = 'Bin'
1748 else:
1746 else:
1749 count = adds + removes
1747 count = adds + removes
1750 pluses = '+' * scale(adds)
1748 pluses = '+' * scale(adds)
1751 minuses = '-' * scale(removes)
1749 minuses = '-' * scale(removes)
1752 output.append(' %s%s | %*s %s%s\n' %
1750 output.append(' %s%s | %*s %s%s\n' %
1753 (filename, ' ' * (maxname - namewidth),
1751 (filename, ' ' * (maxname - namewidth),
1754 countwidth, count,
1752 countwidth, count,
1755 pluses, minuses))
1753 pluses, minuses))
1756
1754
1757 if stats:
1755 if stats:
1758 output.append(_(' %d files changed, %d insertions(+), %d deletions(-)\n')
1756 output.append(_(' %d files changed, %d insertions(+), %d deletions(-)\n')
1759 % (len(stats), totaladds, totalremoves))
1757 % (len(stats), totaladds, totalremoves))
1760
1758
1761 return ''.join(output)
1759 return ''.join(output)
1762
1760
1763 def diffstatui(*args, **kw):
1761 def diffstatui(*args, **kw):
1764 '''like diffstat(), but yields 2-tuples of (output, label) for
1762 '''like diffstat(), but yields 2-tuples of (output, label) for
1765 ui.write()
1763 ui.write()
1766 '''
1764 '''
1767
1765
1768 for line in diffstat(*args, **kw).splitlines():
1766 for line in diffstat(*args, **kw).splitlines():
1769 if line and line[-1] in '+-':
1767 if line and line[-1] in '+-':
1770 name, graph = line.rsplit(' ', 1)
1768 name, graph = line.rsplit(' ', 1)
1771 yield (name + ' ', '')
1769 yield (name + ' ', '')
1772 m = re.search(r'\++', graph)
1770 m = re.search(r'\++', graph)
1773 if m:
1771 if m:
1774 yield (m.group(0), 'diffstat.inserted')
1772 yield (m.group(0), 'diffstat.inserted')
1775 m = re.search(r'-+', graph)
1773 m = re.search(r'-+', graph)
1776 if m:
1774 if m:
1777 yield (m.group(0), 'diffstat.deleted')
1775 yield (m.group(0), 'diffstat.deleted')
1778 else:
1776 else:
1779 yield (line, '')
1777 yield (line, '')
1780 yield ('\n', '')
1778 yield ('\n', '')
General Comments 0
You need to be logged in to leave comments. Login now