← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/patches.py

  • Committer: Tarmac
  • Author(s): Vincent Ladeuil
  • Date: 2017-01-30 14:42:05 UTC
  • mfrom: (6620.1.1 trunk)
  • Revision ID: tarmac-20170130144205-r8fh2xpmiuxyozpv
Merge  2.7 into trunk including fix for bug #1657238 [r=vila]

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/patches.py
1
 
# Copyright (C) 2004 - 2006 Aaron Bentley, Canonical Ltd
 
1
# Copyright (C) 2005-2010 Aaron Bentley, Canonical Ltd
2
2
# <aaron.bentley@utoronto.ca>
3
3
#
4
4
# This program is free software; you can redistribute it and/or modify
13
13
#
14
14
# You should have received a copy of the GNU General Public License
15
15
# along with this program; if not, write to the Free Software
16
 
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
16
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
17
 
 
18
from __future__ import absolute_import
 
19
 
 
20
from bzrlib.errors import (
 
21
    BinaryFiles,
 
22
    MalformedHunkHeader,
 
23
    MalformedLine,
 
24
    MalformedPatchHeader,
 
25
    PatchConflict,
 
26
    PatchSyntax,
 
27
    )
 
28
 
17
29
import re
18
30
 
19
31
 
20
 
class PatchSyntax(Exception):
21
 
    def __init__(self, msg):
22
 
        Exception.__init__(self, msg)
23
 
 
24
 
 
25
 
class MalformedPatchHeader(PatchSyntax):
26
 
    def __init__(self, desc, line):
27
 
        self.desc = desc
28
 
        self.line = line
29
 
        msg = "Malformed patch header.  %s\n%r" % (self.desc, self.line)
30
 
        PatchSyntax.__init__(self, msg)
31
 
 
32
 
 
33
 
class MalformedHunkHeader(PatchSyntax):
34
 
    def __init__(self, desc, line):
35
 
        self.desc = desc
36
 
        self.line = line
37
 
        msg = "Malformed hunk header.  %s\n%r" % (self.desc, self.line)
38
 
        PatchSyntax.__init__(self, msg)
39
 
 
40
 
 
41
 
class MalformedLine(PatchSyntax):
42
 
    def __init__(self, desc, line):
43
 
        self.desc = desc
44
 
        self.line = line
45
 
        msg = "Malformed line.  %s\n%s" % (self.desc, self.line)
46
 
        PatchSyntax.__init__(self, msg)
47
 
 
48
 
 
49
 
class PatchConflict(Exception):
50
 
    def __init__(self, line_no, orig_line, patch_line):
51
 
        orig = orig_line.rstrip('\n')
52
 
        patch = str(patch_line).rstrip('\n')
53
 
        msg = 'Text contents mismatch at line %d.  Original has "%s",'\
54
 
            ' but patch says it should be "%s"' % (line_no, orig, patch)
55
 
        Exception.__init__(self, msg)
 
32
binary_files_re = 'Binary files (.*) and (.*) differ\n'
56
33
 
57
34
 
58
35
def get_patch_names(iter_lines):
 
36
    line = iter_lines.next()
59
37
    try:
60
 
        line = iter_lines.next()
 
38
        match = re.match(binary_files_re, line)
 
39
        if match is not None:
 
40
            raise BinaryFiles(match.group(1), match.group(2))
61
41
        if not line.startswith("--- "):
62
42
            raise MalformedPatchHeader("No orig name", line)
63
43
        else:
93
73
    range = int(range)
94
74
    return (pos, range)
95
75
 
96
 
 
 
76
 
97
77
def hunk_from_header(line):
 
78
    import re
98
79
    matches = re.match(r'\@\@ ([^@]*) \@\@( (.*))?\n', line)
99
80
    if matches is None:
100
81
        raise MalformedHunkHeader("Does not match format.", line)
164
145
        return InsertLine(line[1:])
165
146
    elif line.startswith("-"):
166
147
        return RemoveLine(line[1:])
167
 
    elif line == NO_NL:
168
 
        return NO_NL
169
148
    else:
170
149
        raise MalformedLine("Unknown line type", line)
171
150
__pychecker__=""
220
199
            return self.shift_to_mod_lines(pos)
221
200
 
222
201
    def shift_to_mod_lines(self, pos):
223
 
        assert (pos >= self.orig_pos-1 and pos <= self.orig_pos+self.orig_range)
224
202
        position = self.orig_pos-1
225
203
        shift = 0
226
204
        for line in self.lines:
238
216
        return shift
239
217
 
240
218
 
241
 
def iter_hunks(iter_lines):
 
219
def iter_hunks(iter_lines, allow_dirty=False):
 
220
    '''
 
221
    :arg iter_lines: iterable of lines to parse for hunks
 
222
    :kwarg allow_dirty: If True, when we encounter something that is not
 
223
        a hunk header when we're looking for one, assume the rest of the lines
 
224
        are not part of the patch (comments or other junk).  Default False
 
225
    '''
242
226
    hunk = None
243
227
    for line in iter_lines:
244
228
        if line == "\n":
248
232
            continue
249
233
        if hunk is not None:
250
234
            yield hunk
251
 
        hunk = hunk_from_header(line)
 
235
        try:
 
236
            hunk = hunk_from_header(line)
 
237
        except MalformedHunkHeader:
 
238
            if allow_dirty:
 
239
                # If the line isn't a hunk header, then we've reached the end
 
240
                # of this patch and there's "junk" at the end.  Ignore the
 
241
                # rest of this patch.
 
242
                return
 
243
            raise
252
244
        orig_size = 0
253
245
        mod_size = 0
254
246
        while orig_size < hunk.orig_range or mod_size < hunk.mod_range:
262
254
        yield hunk
263
255
 
264
256
 
265
 
class Patch:
 
257
class BinaryPatch(object):
266
258
    def __init__(self, oldname, newname):
267
259
        self.oldname = oldname
268
260
        self.newname = newname
 
261
 
 
262
    def __str__(self):
 
263
        return 'Binary files %s and %s differ\n' % (self.oldname, self.newname)
 
264
 
 
265
 
 
266
class Patch(BinaryPatch):
 
267
 
 
268
    def __init__(self, oldname, newname):
 
269
        BinaryPatch.__init__(self, oldname, newname)
269
270
        self.hunks = []
270
271
 
271
272
    def __str__(self):
272
 
        ret = self.get_header() 
 
273
        ret = self.get_header()
273
274
        ret += "".join([str(h) for h in self.hunks])
274
275
        return ret
275
276
 
276
277
    def get_header(self):
277
278
        return "--- %s\n+++ %s\n" % (self.oldname, self.newname)
278
279
 
279
 
    def stats_str(self):
280
 
        """Return a string of patch statistics"""
 
280
    def stats_values(self):
 
281
        """Calculate the number of inserts and removes."""
281
282
        removes = 0
282
283
        inserts = 0
283
284
        for hunk in self.hunks:
286
287
                     inserts+=1;
287
288
                elif isinstance(line, RemoveLine):
288
289
                     removes+=1;
 
290
        return (inserts, removes, len(self.hunks))
 
291
 
 
292
    def stats_str(self):
 
293
        """Return a string of patch statistics"""
289
294
        return "%i inserts, %i removes in %i hunks" % \
290
 
            (inserts, removes, len(self.hunks))
 
295
            self.stats_values()
291
296
 
292
297
    def pos_in_mod(self, position):
293
298
        newpos = position
297
302
                return None
298
303
            newpos += shift
299
304
        return newpos
300
 
            
 
305
 
301
306
    def iter_inserted(self):
302
307
        """Iteraties through inserted lines
303
 
        
 
308
 
304
309
        :return: Pair of line number, line
305
310
        :rtype: iterator of (int, InsertLine)
306
311
        """
313
318
                if isinstance(line, ContextLine):
314
319
                    pos += 1
315
320
 
316
 
 
317
 
def parse_patch(iter_lines):
318
 
    (orig_name, mod_name) = get_patch_names(iter_lines)
319
 
    patch = Patch(orig_name, mod_name)
320
 
    for hunk in iter_hunks(iter_lines):
321
 
        patch.hunks.append(hunk)
322
 
    return patch
323
 
 
324
 
 
325
 
def iter_file_patch(iter_lines):
 
321
def parse_patch(iter_lines, allow_dirty=False):
 
322
    '''
 
323
    :arg iter_lines: iterable of lines to parse
 
324
    :kwarg allow_dirty: If True, allow the patch to have trailing junk.
 
325
        Default False
 
326
    '''
 
327
    iter_lines = iter_lines_handle_nl(iter_lines)
 
328
    try:
 
329
        (orig_name, mod_name) = get_patch_names(iter_lines)
 
330
    except BinaryFiles, e:
 
331
        return BinaryPatch(e.orig_name, e.mod_name)
 
332
    else:
 
333
        patch = Patch(orig_name, mod_name)
 
334
        for hunk in iter_hunks(iter_lines, allow_dirty):
 
335
            patch.hunks.append(hunk)
 
336
        return patch
 
337
 
 
338
 
 
339
def iter_file_patch(iter_lines, allow_dirty=False, keep_dirty=False):
 
340
    '''
 
341
    :arg iter_lines: iterable of lines to parse for patches
 
342
    :kwarg allow_dirty: If True, allow comments and other non-patch text
 
343
        before the first patch.  Note that the algorithm here can only find
 
344
        such text before any patches have been found.  Comments after the
 
345
        first patch are stripped away in iter_hunks() if it is also passed
 
346
        allow_dirty=True.  Default False.
 
347
    '''
 
348
    ### FIXME: Docstring is not quite true.  We allow certain comments no
 
349
    # matter what, If they startwith '===', '***', or '#' Someone should
 
350
    # reexamine this logic and decide if we should include those in
 
351
    # allow_dirty or restrict those to only being before the patch is found
 
352
    # (as allow_dirty does).
 
353
    regex = re.compile(binary_files_re)
326
354
    saved_lines = []
 
355
    dirty_head = []
327
356
    orig_range = 0
 
357
    beginning = True
 
358
 
328
359
    for line in iter_lines:
329
 
        if line.startswith('=== ') or line.startswith('*** '):
 
360
        if line.startswith('=== '):
 
361
            if len(saved_lines) > 0:
 
362
                if keep_dirty and len(dirty_head) > 0:
 
363
                    yield {'saved_lines': saved_lines,
 
364
                           'dirty_head': dirty_head}
 
365
                    dirty_head = []
 
366
                else:
 
367
                    yield saved_lines
 
368
                saved_lines = []
 
369
            dirty_head.append(line)
 
370
            continue
 
371
        if line.startswith('*** '):
330
372
            continue
331
373
        if line.startswith('#'):
332
374
            continue
333
375
        elif orig_range > 0:
334
376
            if line.startswith('-') or line.startswith(' '):
335
377
                orig_range -= 1
336
 
        elif line.startswith('--- '):
337
 
            if len(saved_lines) > 0:
338
 
                yield saved_lines
 
378
        elif line.startswith('--- ') or regex.match(line):
 
379
            if allow_dirty and beginning:
 
380
                # Patches can have "junk" at the beginning
 
381
                # Stripping junk from the end of patches is handled when we
 
382
                # parse the patch
 
383
                beginning = False
 
384
            elif len(saved_lines) > 0:
 
385
                if keep_dirty and len(dirty_head) > 0:
 
386
                    yield {'saved_lines': saved_lines,
 
387
                           'dirty_head': dirty_head}
 
388
                    dirty_head = []
 
389
                else:
 
390
                    yield saved_lines
339
391
            saved_lines = []
340
392
        elif line.startswith('@@'):
341
393
            hunk = hunk_from_header(line)
342
394
            orig_range = hunk.orig_range
343
395
        saved_lines.append(line)
344
396
    if len(saved_lines) > 0:
345
 
        yield saved_lines
 
397
        if keep_dirty and len(dirty_head) > 0:
 
398
            yield {'saved_lines': saved_lines,
 
399
                   'dirty_head': dirty_head}
 
400
        else:
 
401
            yield saved_lines
346
402
 
347
403
 
348
404
def iter_lines_handle_nl(iter_lines):
355
411
    last_line = None
356
412
    for line in iter_lines:
357
413
        if line == NO_NL:
358
 
            assert last_line.endswith('\n')
 
414
            if not last_line.endswith('\n'):
 
415
                raise AssertionError()
359
416
            last_line = last_line[:-1]
360
417
            line = None
361
418
        if last_line is not None:
365
422
        yield last_line
366
423
 
367
424
 
368
 
def parse_patches(iter_lines):
369
 
    iter_lines = iter_lines_handle_nl(iter_lines)
370
 
    return [parse_patch(f.__iter__()) for f in iter_file_patch(iter_lines)]
 
425
def parse_patches(iter_lines, allow_dirty=False, keep_dirty=False):
 
426
    '''
 
427
    :arg iter_lines: iterable of lines to parse for patches
 
428
    :kwarg allow_dirty: If True, allow text that's not part of the patch at
 
429
        selected places.  This includes comments before and after a patch
 
430
        for instance.  Default False.
 
431
    :kwarg keep_dirty: If True, returns a dict of patches with dirty headers.
 
432
        Default False.
 
433
    '''
 
434
    patches = []
 
435
    for patch_lines in iter_file_patch(iter_lines, allow_dirty, keep_dirty):
 
436
        if 'dirty_head' in patch_lines:
 
437
            patches.append({'patch': parse_patch(
 
438
                patch_lines['saved_lines'], allow_dirty),
 
439
                            'dirty_head': patch_lines['dirty_head']})
 
440
        else:
 
441
            patches.append(parse_patch(patch_lines, allow_dirty))
 
442
    return patches
371
443
 
372
444
 
373
445
def difference_index(atext, btext):
393
465
    """Iterate through a series of lines with a patch applied.
394
466
    This handles a single file, and does exact, not fuzzy patching.
395
467
    """
396
 
    if orig_lines is not None:
397
 
        orig_lines = orig_lines.__iter__()
 
468
    patch_lines = iter_lines_handle_nl(iter(patch_lines))
 
469
    get_patch_names(patch_lines)
 
470
    return iter_patched_from_hunks(orig_lines, iter_hunks(patch_lines))
 
471
 
 
472
 
 
473
def iter_patched_from_hunks(orig_lines, hunks):
 
474
    """Iterate through a series of lines with a patch applied.
 
475
    This handles a single file, and does exact, not fuzzy patching.
 
476
 
 
477
    :param orig_lines: The unpatched lines.
 
478
    :param hunks: An iterable of Hunk instances.
 
479
    """
398
480
    seen_patch = []
399
 
    patch_lines = iter_lines_handle_nl(patch_lines.__iter__())
400
 
    get_patch_names(patch_lines)
401
481
    line_no = 1
402
 
    for hunk in iter_hunks(patch_lines):
 
482
    if orig_lines is not None:
 
483
        orig_lines = iter(orig_lines)
 
484
    for hunk in hunks:
403
485
        while line_no < hunk.orig_pos:
404
486
            orig_line = orig_lines.next()
405
487
            yield orig_line
415
497
                if isinstance(hunk_line, ContextLine):
416
498
                    yield orig_line
417
499
                else:
418
 
                    assert isinstance(hunk_line, RemoveLine)
 
500
                    if not isinstance(hunk_line, RemoveLine):
 
501
                        raise AssertionError(hunk_line)
419
502
                line_no += 1
420
503
    if orig_lines is not None:
421
504
        for line in orig_lines: