← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/patches.py

  • Committer: Alexander Belchenko
  • Date: 2008-02-07 07:53:19 UTC
  • mto: This revision was merged to the branch mainline in revision 3231.
  • Revision ID: bialix@ukr.net-20080207075319-d9jj7as8i5ztiff7
some cleanup in package_mf.py; mention about load_from_zip() deprecation in NEWS.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/patches.py
1
 
# Copyright (C) 2005-2010 Aaron Bentley, Canonical Ltd
 
1
# Copyright (C) 2004 - 2006 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., 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
 
 
 
16
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
29
17
import re
30
18
 
31
19
 
32
 
binary_files_re = 'Binary files (.*) and (.*) differ\n'
 
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)
33
56
 
34
57
 
35
58
def get_patch_names(iter_lines):
36
 
    line = iter_lines.next()
37
59
    try:
38
 
        match = re.match(binary_files_re, line)
39
 
        if match is not None:
40
 
            raise BinaryFiles(match.group(1), match.group(2))
 
60
        line = iter_lines.next()
41
61
        if not line.startswith("--- "):
42
62
            raise MalformedPatchHeader("No orig name", line)
43
63
        else:
73
93
    range = int(range)
74
94
    return (pos, range)
75
95
 
76
 
 
 
96
 
77
97
def hunk_from_header(line):
78
 
    import re
79
98
    matches = re.match(r'\@\@ ([^@]*) \@\@( (.*))?\n', line)
80
99
    if matches is None:
81
100
        raise MalformedHunkHeader("Does not match format.", line)
145
164
        return InsertLine(line[1:])
146
165
    elif line.startswith("-"):
147
166
        return RemoveLine(line[1:])
 
167
    elif line == NO_NL:
 
168
        return NO_NL
148
169
    else:
149
170
        raise MalformedLine("Unknown line type", line)
150
171
__pychecker__=""
199
220
            return self.shift_to_mod_lines(pos)
200
221
 
201
222
    def shift_to_mod_lines(self, pos):
 
223
        assert (pos >= self.orig_pos-1 and pos <= self.orig_pos+self.orig_range)
202
224
        position = self.orig_pos-1
203
225
        shift = 0
204
226
        for line in self.lines:
216
238
        return shift
217
239
 
218
240
 
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
 
    '''
 
241
def iter_hunks(iter_lines):
226
242
    hunk = None
227
243
    for line in iter_lines:
228
244
        if line == "\n":
232
248
            continue
233
249
        if hunk is not None:
234
250
            yield hunk
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
 
251
        hunk = hunk_from_header(line)
244
252
        orig_size = 0
245
253
        mod_size = 0
246
254
        while orig_size < hunk.orig_range or mod_size < hunk.mod_range:
254
262
        yield hunk
255
263
 
256
264
 
257
 
class BinaryPatch(object):
 
265
class Patch:
258
266
    def __init__(self, oldname, newname):
259
267
        self.oldname = oldname
260
268
        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)
270
269
        self.hunks = []
271
270
 
272
271
    def __str__(self):
273
 
        ret = self.get_header()
 
272
        ret = self.get_header() 
274
273
        ret += "".join([str(h) for h in self.hunks])
275
274
        return ret
276
275
 
277
276
    def get_header(self):
278
277
        return "--- %s\n+++ %s\n" % (self.oldname, self.newname)
279
278
 
280
 
    def stats_values(self):
281
 
        """Calculate the number of inserts and removes."""
 
279
    def stats_str(self):
 
280
        """Return a string of patch statistics"""
282
281
        removes = 0
283
282
        inserts = 0
284
283
        for hunk in self.hunks:
287
286
                     inserts+=1;
288
287
                elif isinstance(line, RemoveLine):
289
288
                     removes+=1;
290
 
        return (inserts, removes, len(self.hunks))
291
 
 
292
 
    def stats_str(self):
293
 
        """Return a string of patch statistics"""
294
289
        return "%i inserts, %i removes in %i hunks" % \
295
 
            self.stats_values()
 
290
            (inserts, removes, len(self.hunks))
296
291
 
297
292
    def pos_in_mod(self, position):
298
293
        newpos = position
302
297
                return None
303
298
            newpos += shift
304
299
        return newpos
305
 
 
 
300
            
306
301
    def iter_inserted(self):
307
302
        """Iteraties through inserted lines
308
 
 
 
303
        
309
304
        :return: Pair of line number, line
310
305
        :rtype: iterator of (int, InsertLine)
311
306
        """
318
313
                if isinstance(line, ContextLine):
319
314
                    pos += 1
320
315
 
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)
 
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):
354
326
    saved_lines = []
355
 
    dirty_head = []
356
327
    orig_range = 0
357
 
    beginning = True
358
 
 
359
328
    for line in iter_lines:
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('*** '):
 
329
        if line.startswith('=== ') or line.startswith('*** '):
372
330
            continue
373
331
        if line.startswith('#'):
374
332
            continue
375
333
        elif orig_range > 0:
376
334
            if line.startswith('-') or line.startswith(' '):
377
335
                orig_range -= 1
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
 
336
        elif line.startswith('--- '):
 
337
            if len(saved_lines) > 0:
 
338
                yield saved_lines
391
339
            saved_lines = []
392
340
        elif line.startswith('@@'):
393
341
            hunk = hunk_from_header(line)
394
342
            orig_range = hunk.orig_range
395
343
        saved_lines.append(line)
396
344
    if len(saved_lines) > 0:
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
 
345
        yield saved_lines
402
346
 
403
347
 
404
348
def iter_lines_handle_nl(iter_lines):
411
355
    last_line = None
412
356
    for line in iter_lines:
413
357
        if line == NO_NL:
414
 
            if not last_line.endswith('\n'):
415
 
                raise AssertionError()
 
358
            assert last_line.endswith('\n')
416
359
            last_line = last_line[:-1]
417
360
            line = None
418
361
        if last_line is not None:
422
365
        yield last_line
423
366
 
424
367
 
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
 
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)]
443
371
 
444
372
 
445
373
def difference_index(atext, btext):
465
393
    """Iterate through a series of lines with a patch applied.
466
394
    This handles a single file, and does exact, not fuzzy patching.
467
395
    """
468
 
    patch_lines = iter_lines_handle_nl(iter(patch_lines))
 
396
    if orig_lines is not None:
 
397
        orig_lines = orig_lines.__iter__()
 
398
    seen_patch = []
 
399
    patch_lines = iter_lines_handle_nl(patch_lines.__iter__())
469
400
    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
 
    """
480
 
    seen_patch = []
481
401
    line_no = 1
482
 
    if orig_lines is not None:
483
 
        orig_lines = iter(orig_lines)
484
 
    for hunk in hunks:
 
402
    for hunk in iter_hunks(patch_lines):
485
403
        while line_no < hunk.orig_pos:
486
404
            orig_line = orig_lines.next()
487
405
            yield orig_line
497
415
                if isinstance(hunk_line, ContextLine):
498
416
                    yield orig_line
499
417
                else:
500
 
                    if not isinstance(hunk_line, RemoveLine):
501
 
                        raise AssertionError(hunk_line)
 
418
                    assert isinstance(hunk_line, RemoveLine)
502
419
                line_no += 1
503
420
    if orig_lines is not None:
504
421
        for line in orig_lines: