/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/patches.py

  • Committer: Robert Collins
  • Date: 2010-05-06 11:08:10 UTC
  • mto: This revision was merged to the branch mainline in revision 5223.
  • Revision ID: robertc@robertcollins.net-20100506110810-h3j07fh5gmw54s25
Cleaner matcher matching revised unlocking protocol.

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 .errors import (
21
 
    BzrError,
22
 
    )
23
 
 
24
17
import re
25
18
 
26
19
 
27
20
binary_files_re = 'Binary files (.*) and (.*) differ\n'
28
21
 
29
22
 
30
 
class PatchSyntax(BzrError):
31
 
    """Base class for patch syntax errors."""
32
 
 
33
 
 
34
 
class BinaryFiles(BzrError):
35
 
 
36
 
    _fmt = 'Binary files section encountered.'
 
23
class BinaryFiles(Exception):
37
24
 
38
25
    def __init__(self, orig_name, mod_name):
39
26
        self.orig_name = orig_name
40
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)
41
34
 
42
35
 
43
36
class MalformedPatchHeader(PatchSyntax):
44
 
 
45
 
    _fmt = "Malformed patch header.  %(desc)s\n%(line)r"
46
 
 
47
 
    def __init__(self, desc, line):
48
 
        self.desc = desc
49
 
        self.line = line
 
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
50
 
51
51
 
52
52
class MalformedLine(PatchSyntax):
53
 
 
54
 
    _fmt = "Malformed line.  %(desc)s\n%(line)r"
55
 
 
56
53
    def __init__(self, desc, line):
57
54
        self.desc = desc
58
55
        self.line = line
59
 
 
60
 
 
61
 
class PatchConflict(BzrError):
62
 
 
63
 
    _fmt = ('Text contents mismatch at line %(line_no)d.  Original has '
64
 
            '"%(orig_line)s", but patch says it should be "%(patch_line)s"')
65
 
 
 
56
        msg = "Malformed line.  %s\n%s" % (self.desc, self.line)
 
57
        PatchSyntax.__init__(self, msg)
 
58
 
 
59
 
 
60
class PatchConflict(Exception):
66
61
    def __init__(self, line_no, orig_line, patch_line):
67
 
        self.line_no = line_no
68
 
        self.orig_line = orig_line.rstrip('\n')
69
 
        self.patch_line = patch_line.rstrip('\n')
70
 
 
71
 
 
72
 
class MalformedHunkHeader(PatchSyntax):
73
 
 
74
 
    _fmt = "Malformed hunk header.  %(desc)s\n%(line)r"
75
 
 
76
 
    def __init__(self, desc, line):
77
 
        self.desc = desc
78
 
        self.line = 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)
79
67
 
80
68
 
81
69
def get_patch_names(iter_lines):
82
 
    line = next(iter_lines)
83
70
    try:
 
71
        line = iter_lines.next()
84
72
        match = re.match(binary_files_re, line)
85
73
        if match is not None:
86
74
            raise BinaryFiles(match.group(1), match.group(2))
91
79
    except StopIteration:
92
80
        raise MalformedPatchHeader("No orig line", "")
93
81
    try:
94
 
        line = next(iter_lines)
 
82
        line = iter_lines.next()
95
83
        if not line.startswith("+++ "):
96
84
            raise PatchSyntax("No mod name")
97
85
        else:
127
115
        raise MalformedHunkHeader("Does not match format.", line)
128
116
    try:
129
117
        (orig, mod) = matches.group(1).split(" ")
130
 
    except (ValueError, IndexError) as e:
 
118
    except (ValueError, IndexError), e:
131
119
        raise MalformedHunkHeader(str(e), line)
132
120
    if not orig.startswith('-') or not mod.startswith('+'):
133
121
        raise MalformedHunkHeader("Positions don't start with + or -.", line)
134
122
    try:
135
123
        (orig_pos, orig_range) = parse_range(orig[1:])
136
124
        (mod_pos, mod_range) = parse_range(mod[1:])
137
 
    except (ValueError, IndexError) as e:
 
125
    except (ValueError, IndexError), e:
138
126
        raise MalformedHunkHeader(str(e), line)
139
127
    if mod_range < 0 or orig_range < 0:
140
128
        raise MalformedHunkHeader("Hunk range is negative", line)
290
278
        orig_size = 0
291
279
        mod_size = 0
292
280
        while orig_size < hunk.orig_range or mod_size < hunk.mod_range:
293
 
            hunk_line = parse_line(next(iter_lines))
 
281
            hunk_line = parse_line(iter_lines.next())
294
282
            hunk.lines.append(hunk_line)
295
283
            if isinstance(hunk_line, (RemoveLine, ContextLine)):
296
284
                orig_size += 1
364
352
                if isinstance(line, ContextLine):
365
353
                    pos += 1
366
354
 
 
355
 
367
356
def parse_patch(iter_lines, allow_dirty=False):
368
357
    '''
369
358
    :arg iter_lines: iterable of lines to parse
373
362
    iter_lines = iter_lines_handle_nl(iter_lines)
374
363
    try:
375
364
        (orig_name, mod_name) = get_patch_names(iter_lines)
376
 
    except BinaryFiles as e:
 
365
    except BinaryFiles, e:
377
366
        return BinaryPatch(e.orig_name, e.mod_name)
378
367
    else:
379
368
        patch = Patch(orig_name, mod_name)
382
371
        return patch
383
372
 
384
373
 
385
 
def iter_file_patch(iter_lines, allow_dirty=False, keep_dirty=False):
 
374
def iter_file_patch(iter_lines, allow_dirty=False):
386
375
    '''
387
376
    :arg iter_lines: iterable of lines to parse for patches
388
377
    :kwarg allow_dirty: If True, allow comments and other non-patch text
398
387
    # (as allow_dirty does).
399
388
    regex = re.compile(binary_files_re)
400
389
    saved_lines = []
401
 
    dirty_head = []
402
390
    orig_range = 0
403
391
    beginning = True
404
 
 
405
392
    for line in iter_lines:
406
 
        if line.startswith('=== '):
407
 
            if len(saved_lines) > 0:
408
 
                if keep_dirty and len(dirty_head) > 0:
409
 
                    yield {'saved_lines': saved_lines,
410
 
                           'dirty_head': dirty_head}
411
 
                    dirty_head = []
412
 
                else:
413
 
                    yield saved_lines
414
 
                saved_lines = []
415
 
            dirty_head.append(line)
416
 
            continue
417
 
        if line.startswith('*** '):
 
393
        if line.startswith('=== ') or line.startswith('*** '):
418
394
            continue
419
395
        if line.startswith('#'):
420
396
            continue
428
404
                # parse the patch
429
405
                beginning = False
430
406
            elif len(saved_lines) > 0:
431
 
                if keep_dirty and len(dirty_head) > 0:
432
 
                    yield {'saved_lines': saved_lines,
433
 
                           'dirty_head': dirty_head}
434
 
                    dirty_head = []
435
 
                else:
436
 
                    yield saved_lines
 
407
                yield saved_lines
437
408
            saved_lines = []
438
409
        elif line.startswith('@@'):
439
410
            hunk = hunk_from_header(line)
440
411
            orig_range = hunk.orig_range
441
412
        saved_lines.append(line)
442
413
    if len(saved_lines) > 0:
443
 
        if keep_dirty and len(dirty_head) > 0:
444
 
            yield {'saved_lines': saved_lines,
445
 
                   'dirty_head': dirty_head}
446
 
        else:
447
 
            yield saved_lines
 
414
        yield saved_lines
448
415
 
449
416
 
450
417
def iter_lines_handle_nl(iter_lines):
468
435
        yield last_line
469
436
 
470
437
 
471
 
def parse_patches(iter_lines, allow_dirty=False, keep_dirty=False):
 
438
def parse_patches(iter_lines, allow_dirty=False):
472
439
    '''
473
440
    :arg iter_lines: iterable of lines to parse for patches
474
441
    :kwarg allow_dirty: If True, allow text that's not part of the patch at
475
442
        selected places.  This includes comments before and after a patch
476
443
        for instance.  Default False.
477
 
    :kwarg keep_dirty: If True, returns a dict of patches with dirty headers.
478
 
        Default False.
479
444
    '''
480
 
    patches = []
481
 
    for patch_lines in iter_file_patch(iter_lines, allow_dirty, keep_dirty):
482
 
        if 'dirty_head' in patch_lines:
483
 
            patches.append({'patch': parse_patch(
484
 
                patch_lines['saved_lines'], allow_dirty),
485
 
                            'dirty_head': patch_lines['dirty_head']})
486
 
        else:
487
 
            patches.append(parse_patch(patch_lines, allow_dirty))
488
 
    return patches
 
445
    return [parse_patch(f.__iter__(), allow_dirty) for f in
 
446
                        iter_file_patch(iter_lines, allow_dirty)]
489
447
 
490
448
 
491
449
def difference_index(atext, btext):
529
487
        orig_lines = iter(orig_lines)
530
488
    for hunk in hunks:
531
489
        while line_no < hunk.orig_pos:
532
 
            orig_line = next(orig_lines)
 
490
            orig_line = orig_lines.next()
533
491
            yield orig_line
534
492
            line_no += 1
535
493
        for hunk_line in hunk.lines:
537
495
            if isinstance(hunk_line, InsertLine):
538
496
                yield hunk_line.contents
539
497
            elif isinstance(hunk_line, (ContextLine, RemoveLine)):
540
 
                orig_line = next(orig_lines)
 
498
                orig_line = orig_lines.next()
541
499
                if orig_line != hunk_line.contents:
542
500
                    raise PatchConflict(line_no, orig_line, "".join(seen_patch))
543
501
                if isinstance(hunk_line, ContextLine):