##// END OF EJS Templates
patch.diffopts: use a dict for initialization...
Siddharth Agarwal -
r23429:f35526b9 default
parent child Browse files
Show More
@@ -1,1958 +1,1961 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 diffopts(ui, opts=None, untrusted=False, section='diff'):
1561 def diffopts(ui, opts=None, untrusted=False, section='diff'):
1562 def get(key, name=None, getter=ui.configbool, forceplain=None):
1562 def get(key, name=None, getter=ui.configbool, forceplain=None):
1563 if opts:
1563 if opts:
1564 v = opts.get(key)
1564 v = opts.get(key)
1565 if v:
1565 if v:
1566 return v
1566 return v
1567 if forceplain is not None and ui.plain():
1567 if forceplain is not None and ui.plain():
1568 return forceplain
1568 return forceplain
1569 return getter(section, name or key, None, untrusted=untrusted)
1569 return getter(section, name or key, None, untrusted=untrusted)
1570
1570
1571 return mdiff.diffopts(
1571 buildopts = {
1572 text=opts and opts.get('text'),
1572 'text': opts and opts.get('text'),
1573 git=get('git'),
1573 'git': get('git'),
1574 nodates=get('nodates'),
1574 'nodates': get('nodates'),
1575 nobinary=get('nobinary'),
1575 'nobinary': get('nobinary'),
1576 noprefix=get('noprefix', forceplain=False),
1576 'noprefix': get('noprefix', forceplain=False),
1577 showfunc=get('show_function', 'showfunc'),
1577 'showfunc': get('show_function', 'showfunc'),
1578 ignorews=get('ignore_all_space', 'ignorews'),
1578 'ignorews': get('ignore_all_space', 'ignorews'),
1579 ignorewsamount=get('ignore_space_change', 'ignorewsamount'),
1579 'ignorewsamount': get('ignore_space_change', 'ignorewsamount'),
1580 ignoreblanklines=get('ignore_blank_lines', 'ignoreblanklines'),
1580 'ignoreblanklines': get('ignore_blank_lines', 'ignoreblanklines'),
1581 context=get('unified', getter=ui.config))
1581 'context': get('unified', getter=ui.config),
1582 }
1583
1584 return mdiff.diffopts(**buildopts)
1582
1585
1583 def diff(repo, node1=None, node2=None, match=None, changes=None, opts=None,
1586 def diff(repo, node1=None, node2=None, match=None, changes=None, opts=None,
1584 losedatafn=None, prefix=''):
1587 losedatafn=None, prefix=''):
1585 '''yields diff of changes to files between two nodes, or node and
1588 '''yields diff of changes to files between two nodes, or node and
1586 working directory.
1589 working directory.
1587
1590
1588 if node1 is None, use first dirstate parent instead.
1591 if node1 is None, use first dirstate parent instead.
1589 if node2 is None, compare node1 with working directory.
1592 if node2 is None, compare node1 with working directory.
1590
1593
1591 losedatafn(**kwarg) is a callable run when opts.upgrade=True and
1594 losedatafn(**kwarg) is a callable run when opts.upgrade=True and
1592 every time some change cannot be represented with the current
1595 every time some change cannot be represented with the current
1593 patch format. Return False to upgrade to git patch format, True to
1596 patch format. Return False to upgrade to git patch format, True to
1594 accept the loss or raise an exception to abort the diff. It is
1597 accept the loss or raise an exception to abort the diff. It is
1595 called with the name of current file being diffed as 'fn'. If set
1598 called with the name of current file being diffed as 'fn'. If set
1596 to None, patches will always be upgraded to git format when
1599 to None, patches will always be upgraded to git format when
1597 necessary.
1600 necessary.
1598
1601
1599 prefix is a filename prefix that is prepended to all filenames on
1602 prefix is a filename prefix that is prepended to all filenames on
1600 display (used for subrepos).
1603 display (used for subrepos).
1601 '''
1604 '''
1602
1605
1603 if opts is None:
1606 if opts is None:
1604 opts = mdiff.defaultopts
1607 opts = mdiff.defaultopts
1605
1608
1606 if not node1 and not node2:
1609 if not node1 and not node2:
1607 node1 = repo.dirstate.p1()
1610 node1 = repo.dirstate.p1()
1608
1611
1609 def lrugetfilectx():
1612 def lrugetfilectx():
1610 cache = {}
1613 cache = {}
1611 order = util.deque()
1614 order = util.deque()
1612 def getfilectx(f, ctx):
1615 def getfilectx(f, ctx):
1613 fctx = ctx.filectx(f, filelog=cache.get(f))
1616 fctx = ctx.filectx(f, filelog=cache.get(f))
1614 if f not in cache:
1617 if f not in cache:
1615 if len(cache) > 20:
1618 if len(cache) > 20:
1616 del cache[order.popleft()]
1619 del cache[order.popleft()]
1617 cache[f] = fctx.filelog()
1620 cache[f] = fctx.filelog()
1618 else:
1621 else:
1619 order.remove(f)
1622 order.remove(f)
1620 order.append(f)
1623 order.append(f)
1621 return fctx
1624 return fctx
1622 return getfilectx
1625 return getfilectx
1623 getfilectx = lrugetfilectx()
1626 getfilectx = lrugetfilectx()
1624
1627
1625 ctx1 = repo[node1]
1628 ctx1 = repo[node1]
1626 ctx2 = repo[node2]
1629 ctx2 = repo[node2]
1627
1630
1628 if not changes:
1631 if not changes:
1629 changes = repo.status(ctx1, ctx2, match=match)
1632 changes = repo.status(ctx1, ctx2, match=match)
1630 modified, added, removed = changes[:3]
1633 modified, added, removed = changes[:3]
1631
1634
1632 if not modified and not added and not removed:
1635 if not modified and not added and not removed:
1633 return []
1636 return []
1634
1637
1635 revs = None
1638 revs = None
1636 hexfunc = repo.ui.debugflag and hex or short
1639 hexfunc = repo.ui.debugflag and hex or short
1637 revs = [hexfunc(node) for node in [ctx1.node(), ctx2.node()] if node]
1640 revs = [hexfunc(node) for node in [ctx1.node(), ctx2.node()] if node]
1638
1641
1639 copy = {}
1642 copy = {}
1640 if opts.git or opts.upgrade:
1643 if opts.git or opts.upgrade:
1641 copy = copies.pathcopies(ctx1, ctx2)
1644 copy = copies.pathcopies(ctx1, ctx2)
1642
1645
1643 def difffn(opts, losedata):
1646 def difffn(opts, losedata):
1644 return trydiff(repo, revs, ctx1, ctx2, modified, added, removed,
1647 return trydiff(repo, revs, ctx1, ctx2, modified, added, removed,
1645 copy, getfilectx, opts, losedata, prefix)
1648 copy, getfilectx, opts, losedata, prefix)
1646 if opts.upgrade and not opts.git:
1649 if opts.upgrade and not opts.git:
1647 try:
1650 try:
1648 def losedata(fn):
1651 def losedata(fn):
1649 if not losedatafn or not losedatafn(fn=fn):
1652 if not losedatafn or not losedatafn(fn=fn):
1650 raise GitDiffRequired
1653 raise GitDiffRequired
1651 # Buffer the whole output until we are sure it can be generated
1654 # Buffer the whole output until we are sure it can be generated
1652 return list(difffn(opts.copy(git=False), losedata))
1655 return list(difffn(opts.copy(git=False), losedata))
1653 except GitDiffRequired:
1656 except GitDiffRequired:
1654 return difffn(opts.copy(git=True), None)
1657 return difffn(opts.copy(git=True), None)
1655 else:
1658 else:
1656 return difffn(opts, None)
1659 return difffn(opts, None)
1657
1660
1658 def difflabel(func, *args, **kw):
1661 def difflabel(func, *args, **kw):
1659 '''yields 2-tuples of (output, label) based on the output of func()'''
1662 '''yields 2-tuples of (output, label) based on the output of func()'''
1660 headprefixes = [('diff', 'diff.diffline'),
1663 headprefixes = [('diff', 'diff.diffline'),
1661 ('copy', 'diff.extended'),
1664 ('copy', 'diff.extended'),
1662 ('rename', 'diff.extended'),
1665 ('rename', 'diff.extended'),
1663 ('old', 'diff.extended'),
1666 ('old', 'diff.extended'),
1664 ('new', 'diff.extended'),
1667 ('new', 'diff.extended'),
1665 ('deleted', 'diff.extended'),
1668 ('deleted', 'diff.extended'),
1666 ('---', 'diff.file_a'),
1669 ('---', 'diff.file_a'),
1667 ('+++', 'diff.file_b')]
1670 ('+++', 'diff.file_b')]
1668 textprefixes = [('@', 'diff.hunk'),
1671 textprefixes = [('@', 'diff.hunk'),
1669 ('-', 'diff.deleted'),
1672 ('-', 'diff.deleted'),
1670 ('+', 'diff.inserted')]
1673 ('+', 'diff.inserted')]
1671 head = False
1674 head = False
1672 for chunk in func(*args, **kw):
1675 for chunk in func(*args, **kw):
1673 lines = chunk.split('\n')
1676 lines = chunk.split('\n')
1674 for i, line in enumerate(lines):
1677 for i, line in enumerate(lines):
1675 if i != 0:
1678 if i != 0:
1676 yield ('\n', '')
1679 yield ('\n', '')
1677 if head:
1680 if head:
1678 if line.startswith('@'):
1681 if line.startswith('@'):
1679 head = False
1682 head = False
1680 else:
1683 else:
1681 if line and line[0] not in ' +-@\\':
1684 if line and line[0] not in ' +-@\\':
1682 head = True
1685 head = True
1683 stripline = line
1686 stripline = line
1684 diffline = False
1687 diffline = False
1685 if not head and line and line[0] in '+-':
1688 if not head and line and line[0] in '+-':
1686 # highlight tabs and trailing whitespace, but only in
1689 # highlight tabs and trailing whitespace, but only in
1687 # changed lines
1690 # changed lines
1688 stripline = line.rstrip()
1691 stripline = line.rstrip()
1689 diffline = True
1692 diffline = True
1690
1693
1691 prefixes = textprefixes
1694 prefixes = textprefixes
1692 if head:
1695 if head:
1693 prefixes = headprefixes
1696 prefixes = headprefixes
1694 for prefix, label in prefixes:
1697 for prefix, label in prefixes:
1695 if stripline.startswith(prefix):
1698 if stripline.startswith(prefix):
1696 if diffline:
1699 if diffline:
1697 for token in tabsplitter.findall(stripline):
1700 for token in tabsplitter.findall(stripline):
1698 if '\t' == token[0]:
1701 if '\t' == token[0]:
1699 yield (token, 'diff.tab')
1702 yield (token, 'diff.tab')
1700 else:
1703 else:
1701 yield (token, label)
1704 yield (token, label)
1702 else:
1705 else:
1703 yield (stripline, label)
1706 yield (stripline, label)
1704 break
1707 break
1705 else:
1708 else:
1706 yield (line, '')
1709 yield (line, '')
1707 if line != stripline:
1710 if line != stripline:
1708 yield (line[len(stripline):], 'diff.trailingwhitespace')
1711 yield (line[len(stripline):], 'diff.trailingwhitespace')
1709
1712
1710 def diffui(*args, **kw):
1713 def diffui(*args, **kw):
1711 '''like diff(), but yields 2-tuples of (output, label) for ui.write()'''
1714 '''like diff(), but yields 2-tuples of (output, label) for ui.write()'''
1712 return difflabel(diff, *args, **kw)
1715 return difflabel(diff, *args, **kw)
1713
1716
1714 def trydiff(repo, revs, ctx1, ctx2, modified, added, removed,
1717 def trydiff(repo, revs, ctx1, ctx2, modified, added, removed,
1715 copy, getfilectx, opts, losedatafn, prefix):
1718 copy, getfilectx, opts, losedatafn, prefix):
1716
1719
1717 def join(f):
1720 def join(f):
1718 return posixpath.join(prefix, f)
1721 return posixpath.join(prefix, f)
1719
1722
1720 def addmodehdr(header, omode, nmode):
1723 def addmodehdr(header, omode, nmode):
1721 if omode != nmode:
1724 if omode != nmode:
1722 header.append('old mode %s\n' % omode)
1725 header.append('old mode %s\n' % omode)
1723 header.append('new mode %s\n' % nmode)
1726 header.append('new mode %s\n' % nmode)
1724
1727
1725 def addindexmeta(meta, revs):
1728 def addindexmeta(meta, revs):
1726 if opts.git:
1729 if opts.git:
1727 i = len(revs)
1730 i = len(revs)
1728 if i==2:
1731 if i==2:
1729 meta.append('index %s..%s\n' % tuple(revs))
1732 meta.append('index %s..%s\n' % tuple(revs))
1730 elif i==3:
1733 elif i==3:
1731 meta.append('index %s,%s..%s\n' % tuple(revs))
1734 meta.append('index %s,%s..%s\n' % tuple(revs))
1732
1735
1733 def gitindex(text):
1736 def gitindex(text):
1734 if not text:
1737 if not text:
1735 text = ""
1738 text = ""
1736 l = len(text)
1739 l = len(text)
1737 s = util.sha1('blob %d\0' % l)
1740 s = util.sha1('blob %d\0' % l)
1738 s.update(text)
1741 s.update(text)
1739 return s.hexdigest()
1742 return s.hexdigest()
1740
1743
1741 if opts.noprefix:
1744 if opts.noprefix:
1742 aprefix = bprefix = ''
1745 aprefix = bprefix = ''
1743 else:
1746 else:
1744 aprefix = 'a/'
1747 aprefix = 'a/'
1745 bprefix = 'b/'
1748 bprefix = 'b/'
1746
1749
1747 def diffline(a, b, revs):
1750 def diffline(a, b, revs):
1748 if opts.git:
1751 if opts.git:
1749 line = 'diff --git %s%s %s%s\n' % (aprefix, a, bprefix, b)
1752 line = 'diff --git %s%s %s%s\n' % (aprefix, a, bprefix, b)
1750 elif not repo.ui.quiet:
1753 elif not repo.ui.quiet:
1751 if revs:
1754 if revs:
1752 revinfo = ' '.join(["-r %s" % rev for rev in revs])
1755 revinfo = ' '.join(["-r %s" % rev for rev in revs])
1753 line = 'diff %s %s\n' % (revinfo, a)
1756 line = 'diff %s %s\n' % (revinfo, a)
1754 else:
1757 else:
1755 line = 'diff %s\n' % a
1758 line = 'diff %s\n' % a
1756 else:
1759 else:
1757 line = ''
1760 line = ''
1758 return line
1761 return line
1759
1762
1760 date1 = util.datestr(ctx1.date())
1763 date1 = util.datestr(ctx1.date())
1761 man1 = ctx1.manifest()
1764 man1 = ctx1.manifest()
1762
1765
1763 gone = set()
1766 gone = set()
1764 gitmode = {'l': '120000', 'x': '100755', '': '100644'}
1767 gitmode = {'l': '120000', 'x': '100755', '': '100644'}
1765
1768
1766 copyto = dict([(v, k) for k, v in copy.items()])
1769 copyto = dict([(v, k) for k, v in copy.items()])
1767
1770
1768 if opts.git:
1771 if opts.git:
1769 revs = None
1772 revs = None
1770
1773
1771 for f in sorted(modified + added + removed):
1774 for f in sorted(modified + added + removed):
1772 to = None
1775 to = None
1773 tn = None
1776 tn = None
1774 dodiff = True
1777 dodiff = True
1775 header = []
1778 header = []
1776 if f in man1:
1779 if f in man1:
1777 to = getfilectx(f, ctx1).data()
1780 to = getfilectx(f, ctx1).data()
1778 if f not in removed:
1781 if f not in removed:
1779 tn = getfilectx(f, ctx2).data()
1782 tn = getfilectx(f, ctx2).data()
1780 a, b = f, f
1783 a, b = f, f
1781 if opts.git or losedatafn:
1784 if opts.git or losedatafn:
1782 if f in added or (f in modified and to is None):
1785 if f in added or (f in modified and to is None):
1783 mode = gitmode[ctx2.flags(f)]
1786 mode = gitmode[ctx2.flags(f)]
1784 if f in copy or f in copyto:
1787 if f in copy or f in copyto:
1785 if opts.git:
1788 if opts.git:
1786 if f in copy:
1789 if f in copy:
1787 a = copy[f]
1790 a = copy[f]
1788 else:
1791 else:
1789 a = copyto[f]
1792 a = copyto[f]
1790 omode = gitmode[man1.flags(a)]
1793 omode = gitmode[man1.flags(a)]
1791 addmodehdr(header, omode, mode)
1794 addmodehdr(header, omode, mode)
1792 if a in removed and a not in gone:
1795 if a in removed and a not in gone:
1793 op = 'rename'
1796 op = 'rename'
1794 gone.add(a)
1797 gone.add(a)
1795 else:
1798 else:
1796 op = 'copy'
1799 op = 'copy'
1797 header.append('%s from %s\n' % (op, join(a)))
1800 header.append('%s from %s\n' % (op, join(a)))
1798 header.append('%s to %s\n' % (op, join(f)))
1801 header.append('%s to %s\n' % (op, join(f)))
1799 to = getfilectx(a, ctx1).data()
1802 to = getfilectx(a, ctx1).data()
1800 else:
1803 else:
1801 losedatafn(f)
1804 losedatafn(f)
1802 else:
1805 else:
1803 if opts.git:
1806 if opts.git:
1804 header.append('new file mode %s\n' % mode)
1807 header.append('new file mode %s\n' % mode)
1805 elif ctx2.flags(f):
1808 elif ctx2.flags(f):
1806 losedatafn(f)
1809 losedatafn(f)
1807 # In theory, if tn was copied or renamed we should check
1810 # In theory, if tn was copied or renamed we should check
1808 # if the source is binary too but the copy record already
1811 # if the source is binary too but the copy record already
1809 # forces git mode.
1812 # forces git mode.
1810 if util.binary(tn):
1813 if util.binary(tn):
1811 if opts.git:
1814 if opts.git:
1812 dodiff = 'binary'
1815 dodiff = 'binary'
1813 else:
1816 else:
1814 losedatafn(f)
1817 losedatafn(f)
1815 if not opts.git and not tn:
1818 if not opts.git and not tn:
1816 # regular diffs cannot represent new empty file
1819 # regular diffs cannot represent new empty file
1817 losedatafn(f)
1820 losedatafn(f)
1818 elif f in removed or (f in modified and tn is None):
1821 elif f in removed or (f in modified and tn is None):
1819 if opts.git:
1822 if opts.git:
1820 # have we already reported a copy above?
1823 # have we already reported a copy above?
1821 if ((f in copy and copy[f] in added
1824 if ((f in copy and copy[f] in added
1822 and copyto[copy[f]] == f) or
1825 and copyto[copy[f]] == f) or
1823 (f in copyto and copyto[f] in added
1826 (f in copyto and copyto[f] in added
1824 and copy[copyto[f]] == f)):
1827 and copy[copyto[f]] == f)):
1825 dodiff = False
1828 dodiff = False
1826 else:
1829 else:
1827 header.append('deleted file mode %s\n' %
1830 header.append('deleted file mode %s\n' %
1828 gitmode[man1.flags(f)])
1831 gitmode[man1.flags(f)])
1829 if util.binary(to):
1832 if util.binary(to):
1830 dodiff = 'binary'
1833 dodiff = 'binary'
1831 elif not to or util.binary(to):
1834 elif not to or util.binary(to):
1832 # regular diffs cannot represent empty file deletion
1835 # regular diffs cannot represent empty file deletion
1833 losedatafn(f)
1836 losedatafn(f)
1834 else:
1837 else:
1835 oflag = man1.flags(f)
1838 oflag = man1.flags(f)
1836 nflag = ctx2.flags(f)
1839 nflag = ctx2.flags(f)
1837 binary = util.binary(to) or util.binary(tn)
1840 binary = util.binary(to) or util.binary(tn)
1838 if opts.git:
1841 if opts.git:
1839 addmodehdr(header, gitmode[oflag], gitmode[nflag])
1842 addmodehdr(header, gitmode[oflag], gitmode[nflag])
1840 if binary:
1843 if binary:
1841 dodiff = 'binary'
1844 dodiff = 'binary'
1842 elif binary or nflag != oflag:
1845 elif binary or nflag != oflag:
1843 losedatafn(f)
1846 losedatafn(f)
1844
1847
1845 if dodiff:
1848 if dodiff:
1846 if opts.git or revs:
1849 if opts.git or revs:
1847 header.insert(0, diffline(join(a), join(b), revs))
1850 header.insert(0, diffline(join(a), join(b), revs))
1848 if dodiff == 'binary' and not opts.nobinary:
1851 if dodiff == 'binary' and not opts.nobinary:
1849 text = mdiff.b85diff(to, tn)
1852 text = mdiff.b85diff(to, tn)
1850 if text:
1853 if text:
1851 addindexmeta(header, [gitindex(to), gitindex(tn)])
1854 addindexmeta(header, [gitindex(to), gitindex(tn)])
1852 else:
1855 else:
1853 text = mdiff.unidiff(to, date1,
1856 text = mdiff.unidiff(to, date1,
1854 # ctx2 date may be dynamic
1857 # ctx2 date may be dynamic
1855 tn, util.datestr(ctx2.date()),
1858 tn, util.datestr(ctx2.date()),
1856 join(a), join(b), opts=opts)
1859 join(a), join(b), opts=opts)
1857 if header and (text or len(header) > 1):
1860 if header and (text or len(header) > 1):
1858 yield ''.join(header)
1861 yield ''.join(header)
1859 if text:
1862 if text:
1860 yield text
1863 yield text
1861
1864
1862 def diffstatsum(stats):
1865 def diffstatsum(stats):
1863 maxfile, maxtotal, addtotal, removetotal, binary = 0, 0, 0, 0, False
1866 maxfile, maxtotal, addtotal, removetotal, binary = 0, 0, 0, 0, False
1864 for f, a, r, b in stats:
1867 for f, a, r, b in stats:
1865 maxfile = max(maxfile, encoding.colwidth(f))
1868 maxfile = max(maxfile, encoding.colwidth(f))
1866 maxtotal = max(maxtotal, a + r)
1869 maxtotal = max(maxtotal, a + r)
1867 addtotal += a
1870 addtotal += a
1868 removetotal += r
1871 removetotal += r
1869 binary = binary or b
1872 binary = binary or b
1870
1873
1871 return maxfile, maxtotal, addtotal, removetotal, binary
1874 return maxfile, maxtotal, addtotal, removetotal, binary
1872
1875
1873 def diffstatdata(lines):
1876 def diffstatdata(lines):
1874 diffre = re.compile('^diff .*-r [a-z0-9]+\s(.*)$')
1877 diffre = re.compile('^diff .*-r [a-z0-9]+\s(.*)$')
1875
1878
1876 results = []
1879 results = []
1877 filename, adds, removes, isbinary = None, 0, 0, False
1880 filename, adds, removes, isbinary = None, 0, 0, False
1878
1881
1879 def addresult():
1882 def addresult():
1880 if filename:
1883 if filename:
1881 results.append((filename, adds, removes, isbinary))
1884 results.append((filename, adds, removes, isbinary))
1882
1885
1883 for line in lines:
1886 for line in lines:
1884 if line.startswith('diff'):
1887 if line.startswith('diff'):
1885 addresult()
1888 addresult()
1886 # set numbers to 0 anyway when starting new file
1889 # set numbers to 0 anyway when starting new file
1887 adds, removes, isbinary = 0, 0, False
1890 adds, removes, isbinary = 0, 0, False
1888 if line.startswith('diff --git a/'):
1891 if line.startswith('diff --git a/'):
1889 filename = gitre.search(line).group(2)
1892 filename = gitre.search(line).group(2)
1890 elif line.startswith('diff -r'):
1893 elif line.startswith('diff -r'):
1891 # format: "diff -r ... -r ... filename"
1894 # format: "diff -r ... -r ... filename"
1892 filename = diffre.search(line).group(1)
1895 filename = diffre.search(line).group(1)
1893 elif line.startswith('+') and not line.startswith('+++ '):
1896 elif line.startswith('+') and not line.startswith('+++ '):
1894 adds += 1
1897 adds += 1
1895 elif line.startswith('-') and not line.startswith('--- '):
1898 elif line.startswith('-') and not line.startswith('--- '):
1896 removes += 1
1899 removes += 1
1897 elif (line.startswith('GIT binary patch') or
1900 elif (line.startswith('GIT binary patch') or
1898 line.startswith('Binary file')):
1901 line.startswith('Binary file')):
1899 isbinary = True
1902 isbinary = True
1900 addresult()
1903 addresult()
1901 return results
1904 return results
1902
1905
1903 def diffstat(lines, width=80, git=False):
1906 def diffstat(lines, width=80, git=False):
1904 output = []
1907 output = []
1905 stats = diffstatdata(lines)
1908 stats = diffstatdata(lines)
1906 maxname, maxtotal, totaladds, totalremoves, hasbinary = diffstatsum(stats)
1909 maxname, maxtotal, totaladds, totalremoves, hasbinary = diffstatsum(stats)
1907
1910
1908 countwidth = len(str(maxtotal))
1911 countwidth = len(str(maxtotal))
1909 if hasbinary and countwidth < 3:
1912 if hasbinary and countwidth < 3:
1910 countwidth = 3
1913 countwidth = 3
1911 graphwidth = width - countwidth - maxname - 6
1914 graphwidth = width - countwidth - maxname - 6
1912 if graphwidth < 10:
1915 if graphwidth < 10:
1913 graphwidth = 10
1916 graphwidth = 10
1914
1917
1915 def scale(i):
1918 def scale(i):
1916 if maxtotal <= graphwidth:
1919 if maxtotal <= graphwidth:
1917 return i
1920 return i
1918 # If diffstat runs out of room it doesn't print anything,
1921 # If diffstat runs out of room it doesn't print anything,
1919 # which isn't very useful, so always print at least one + or -
1922 # which isn't very useful, so always print at least one + or -
1920 # if there were at least some changes.
1923 # if there were at least some changes.
1921 return max(i * graphwidth // maxtotal, int(bool(i)))
1924 return max(i * graphwidth // maxtotal, int(bool(i)))
1922
1925
1923 for filename, adds, removes, isbinary in stats:
1926 for filename, adds, removes, isbinary in stats:
1924 if isbinary:
1927 if isbinary:
1925 count = 'Bin'
1928 count = 'Bin'
1926 else:
1929 else:
1927 count = adds + removes
1930 count = adds + removes
1928 pluses = '+' * scale(adds)
1931 pluses = '+' * scale(adds)
1929 minuses = '-' * scale(removes)
1932 minuses = '-' * scale(removes)
1930 output.append(' %s%s | %*s %s%s\n' %
1933 output.append(' %s%s | %*s %s%s\n' %
1931 (filename, ' ' * (maxname - encoding.colwidth(filename)),
1934 (filename, ' ' * (maxname - encoding.colwidth(filename)),
1932 countwidth, count, pluses, minuses))
1935 countwidth, count, pluses, minuses))
1933
1936
1934 if stats:
1937 if stats:
1935 output.append(_(' %d files changed, %d insertions(+), '
1938 output.append(_(' %d files changed, %d insertions(+), '
1936 '%d deletions(-)\n')
1939 '%d deletions(-)\n')
1937 % (len(stats), totaladds, totalremoves))
1940 % (len(stats), totaladds, totalremoves))
1938
1941
1939 return ''.join(output)
1942 return ''.join(output)
1940
1943
1941 def diffstatui(*args, **kw):
1944 def diffstatui(*args, **kw):
1942 '''like diffstat(), but yields 2-tuples of (output, label) for
1945 '''like diffstat(), but yields 2-tuples of (output, label) for
1943 ui.write()
1946 ui.write()
1944 '''
1947 '''
1945
1948
1946 for line in diffstat(*args, **kw).splitlines():
1949 for line in diffstat(*args, **kw).splitlines():
1947 if line and line[-1] in '+-':
1950 if line and line[-1] in '+-':
1948 name, graph = line.rsplit(' ', 1)
1951 name, graph = line.rsplit(' ', 1)
1949 yield (name + ' ', '')
1952 yield (name + ' ', '')
1950 m = re.search(r'\++', graph)
1953 m = re.search(r'\++', graph)
1951 if m:
1954 if m:
1952 yield (m.group(0), 'diffstat.inserted')
1955 yield (m.group(0), 'diffstat.inserted')
1953 m = re.search(r'-+', graph)
1956 m = re.search(r'-+', graph)
1954 if m:
1957 if m:
1955 yield (m.group(0), 'diffstat.deleted')
1958 yield (m.group(0), 'diffstat.deleted')
1956 else:
1959 else:
1957 yield (line, '')
1960 yield (line, '')
1958 yield ('\n', '')
1961 yield ('\n', '')
General Comments 0
You need to be logged in to leave comments. Login now