← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/patches.py

  • Committer: Patch Queue Manager
  • Date: 2016-02-01 19:13:13 UTC
  • mfrom: (6614.2.2 trunk)
  • Revision ID: pqm@pqm.ubuntu.com-20160201191313-wdfvmfff1djde6oq
(vila) Release 2.7.0 (Vincent Ladeuil)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/patches.py
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
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
32
binary_files_re = 'Binary files (.*) and (.*) differ\n'
21
33
 
22
34
 
23
 
class BinaryFiles(Exception):
24
 
 
25
 
    def __init__(self, orig_name, mod_name):
26
 
        self.orig_name = orig_name
27
 
        self.mod_name = mod_name
28
 
        Exception.__init__(self, 'Binary files section encountered.')
29
 
 
30
 
 
31
 
class PatchSyntax(Exception):
32
 
    def __init__(self, msg):
33
 
        Exception.__init__(self, msg)
34
 
 
35
 
 
36
 
class MalformedPatchHeader(PatchSyntax):
37
 
    def __init__(self, desc, line):
38
 
        self.desc = desc
39
 
        self.line = line
40
 
        msg = "Malformed patch header.  %s\n%r" % (self.desc, self.line)
41
 
        PatchSyntax.__init__(self, msg)
42
 
 
43
 
 
44
 
class MalformedHunkHeader(PatchSyntax):
45
 
    def __init__(self, desc, line):
46
 
        self.desc = desc
47
 
        self.line = line
48
 
        msg = "Malformed hunk header.  %s\n%r" % (self.desc, self.line)
49
 
        PatchSyntax.__init__(self, msg)
50
 
 
51
 
 
52
 
class MalformedLine(PatchSyntax):
53
 
    def __init__(self, desc, line):
54
 
        self.desc = desc
55
 
        self.line = line
56
 
        msg = "Malformed line.  %s\n%s" % (self.desc, self.line)
57
 
        PatchSyntax.__init__(self, msg)
58
 
 
59
 
 
60
 
class PatchConflict(Exception):
61
 
    def __init__(self, line_no, orig_line, patch_line):
62
 
        orig = orig_line.rstrip('\n')
63
 
        patch = str(patch_line).rstrip('\n')
64
 
        msg = 'Text contents mismatch at line %d.  Original has "%s",'\
65
 
            ' but patch says it should be "%s"' % (line_no, orig, patch)
66
 
        Exception.__init__(self, msg)
67
 
 
68
 
 
69
35
def get_patch_names(iter_lines):
 
36
    line = iter_lines.next()
70
37
    try:
71
 
        line = iter_lines.next()
72
38
        match = re.match(binary_files_re, line)
73
39
        if match is not None:
74
40
            raise BinaryFiles(match.group(1), match.group(2))
352
318
                if isinstance(line, ContextLine):
353
319
                    pos += 1
354
320
 
355
 
 
356
321
def parse_patch(iter_lines, allow_dirty=False):
357
322
    '''
358
323
    :arg iter_lines: iterable of lines to parse
371
336
        return patch
372
337
 
373
338
 
374
 
def iter_file_patch(iter_lines, allow_dirty=False):
 
339
def iter_file_patch(iter_lines, allow_dirty=False, keep_dirty=False):
375
340
    '''
376
341
    :arg iter_lines: iterable of lines to parse for patches
377
342
    :kwarg allow_dirty: If True, allow comments and other non-patch text
387
352
    # (as allow_dirty does).
388
353
    regex = re.compile(binary_files_re)
389
354
    saved_lines = []
 
355
    dirty_head = []
390
356
    orig_range = 0
391
357
    beginning = True
 
358
 
392
359
    for line in iter_lines:
393
 
        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('*** '):
394
372
            continue
395
373
        if line.startswith('#'):
396
374
            continue
404
382
                # parse the patch
405
383
                beginning = False
406
384
            elif len(saved_lines) > 0:
407
 
                yield saved_lines
 
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
408
391
            saved_lines = []
409
392
        elif line.startswith('@@'):
410
393
            hunk = hunk_from_header(line)
411
394
            orig_range = hunk.orig_range
412
395
        saved_lines.append(line)
413
396
    if len(saved_lines) > 0:
414
 
        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
415
402
 
416
403
 
417
404
def iter_lines_handle_nl(iter_lines):
435
422
        yield last_line
436
423
 
437
424
 
438
 
def parse_patches(iter_lines, allow_dirty=False):
 
425
def parse_patches(iter_lines, allow_dirty=False, keep_dirty=False):
439
426
    '''
440
427
    :arg iter_lines: iterable of lines to parse for patches
441
428
    :kwarg allow_dirty: If True, allow text that's not part of the patch at
442
429
        selected places.  This includes comments before and after a patch
443
430
        for instance.  Default False.
 
431
    :kwarg keep_dirty: If True, returns a dict of patches with dirty headers.
 
432
        Default False.
444
433
    '''
445
 
    return [parse_patch(f.__iter__(), allow_dirty) for f in
446
 
                        iter_file_patch(iter_lines, allow_dirty)]
 
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
447
443
 
448
444
 
449
445
def difference_index(atext, btext):