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