← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/patches.py

Merge the 0.17 fixes back into bzr.dev

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
 
import re
18
 
 
19
 
 
20
 
binary_files_re = 'Binary files (.*) and (.*) differ\n'
21
 
 
22
 
 
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.')
 
16
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
29
17
 
30
18
 
31
19
class PatchSyntax(Exception):
69
57
def get_patch_names(iter_lines):
70
58
    try:
71
59
        line = iter_lines.next()
72
 
        match = re.match(binary_files_re, line)
73
 
        if match is not None:
74
 
            raise BinaryFiles(match.group(1), match.group(2))
75
60
        if not line.startswith("--- "):
76
61
            raise MalformedPatchHeader("No orig name", line)
77
62
        else:
107
92
    range = int(range)
108
93
    return (pos, range)
109
94
 
110
 
 
 
95
 
111
96
def hunk_from_header(line):
112
 
    import re
113
 
    matches = re.match(r'\@\@ ([^@]*) \@\@( (.*))?\n', line)
114
 
    if matches is None:
115
 
        raise MalformedHunkHeader("Does not match format.", line)
 
97
    if not line.startswith("@@") or not line.endswith("@@\n") \
 
98
        or not len(line) > 4:
 
99
        raise MalformedHunkHeader("Does not start and end with @@.", line)
116
100
    try:
117
 
        (orig, mod) = matches.group(1).split(" ")
118
 
    except (ValueError, IndexError), e:
 
101
        (orig, mod) = line[3:-4].split(" ")
 
102
    except Exception, e:
119
103
        raise MalformedHunkHeader(str(e), line)
120
104
    if not orig.startswith('-') or not mod.startswith('+'):
121
105
        raise MalformedHunkHeader("Positions don't start with + or -.", line)
122
106
    try:
123
107
        (orig_pos, orig_range) = parse_range(orig[1:])
124
108
        (mod_pos, mod_range) = parse_range(mod[1:])
125
 
    except (ValueError, IndexError), e:
 
109
    except Exception, e:
126
110
        raise MalformedHunkHeader(str(e), line)
127
111
    if mod_range < 0 or orig_range < 0:
128
112
        raise MalformedHunkHeader("Hunk range is negative", line)
129
 
    tail = matches.group(3)
130
 
    return Hunk(orig_pos, orig_range, mod_pos, mod_range, tail)
 
113
    return Hunk(orig_pos, orig_range, mod_pos, mod_range)
131
114
 
132
115
 
133
116
class HunkLine:
179
162
        return InsertLine(line[1:])
180
163
    elif line.startswith("-"):
181
164
        return RemoveLine(line[1:])
 
165
    elif line == NO_NL:
 
166
        return NO_NL
182
167
    else:
183
168
        raise MalformedLine("Unknown line type", line)
184
169
__pychecker__=""
185
170
 
186
171
 
187
172
class Hunk:
188
 
    def __init__(self, orig_pos, orig_range, mod_pos, mod_range, tail=None):
 
173
    def __init__(self, orig_pos, orig_range, mod_pos, mod_range):
189
174
        self.orig_pos = orig_pos
190
175
        self.orig_range = orig_range
191
176
        self.mod_pos = mod_pos
192
177
        self.mod_range = mod_range
193
 
        self.tail = tail
194
178
        self.lines = []
195
179
 
196
180
    def get_header(self):
197
 
        if self.tail is None:
198
 
            tail_str = ''
199
 
        else:
200
 
            tail_str = ' ' + self.tail
201
 
        return "@@ -%s +%s @@%s\n" % (self.range_str(self.orig_pos,
202
 
                                                     self.orig_range),
203
 
                                      self.range_str(self.mod_pos,
204
 
                                                     self.mod_range),
205
 
                                      tail_str)
 
181
        return "@@ -%s +%s @@\n" % (self.range_str(self.orig_pos, 
 
182
                                                   self.orig_range),
 
183
                                    self.range_str(self.mod_pos, 
 
184
                                                   self.mod_range))
206
185
 
207
186
    def range_str(self, pos, range):
208
187
        """Return a file range, special-casing for 1-line files.
233
212
            return self.shift_to_mod_lines(pos)
234
213
 
235
214
    def shift_to_mod_lines(self, pos):
 
215
        assert (pos >= self.orig_pos-1 and pos <= self.orig_pos+self.orig_range)
236
216
        position = self.orig_pos-1
237
217
        shift = 0
238
218
        for line in self.lines:
274
254
        yield hunk
275
255
 
276
256
 
277
 
class BinaryPatch(object):
 
257
class Patch:
278
258
    def __init__(self, oldname, newname):
279
259
        self.oldname = oldname
280
260
        self.newname = newname
281
 
 
282
 
    def __str__(self):
283
 
        return 'Binary files %s and %s differ\n' % (self.oldname, self.newname)
284
 
 
285
 
 
286
 
class Patch(BinaryPatch):
287
 
 
288
 
    def __init__(self, oldname, newname):
289
 
        BinaryPatch.__init__(self, oldname, newname)
290
261
        self.hunks = []
291
262
 
292
263
    def __str__(self):
293
 
        ret = self.get_header()
 
264
        ret = self.get_header() 
294
265
        ret += "".join([str(h) for h in self.hunks])
295
266
        return ret
296
267
 
297
268
    def get_header(self):
298
269
        return "--- %s\n+++ %s\n" % (self.oldname, self.newname)
299
270
 
300
 
    def stats_values(self):
301
 
        """Calculate the number of inserts and removes."""
 
271
    def stats_str(self):
 
272
        """Return a string of patch statistics"""
302
273
        removes = 0
303
274
        inserts = 0
304
275
        for hunk in self.hunks:
307
278
                     inserts+=1;
308
279
                elif isinstance(line, RemoveLine):
309
280
                     removes+=1;
310
 
        return (inserts, removes, len(self.hunks))
311
 
 
312
 
    def stats_str(self):
313
 
        """Return a string of patch statistics"""
314
281
        return "%i inserts, %i removes in %i hunks" % \
315
 
            self.stats_values()
 
282
            (inserts, removes, len(self.hunks))
316
283
 
317
284
    def pos_in_mod(self, position):
318
285
        newpos = position
322
289
                return None
323
290
            newpos += shift
324
291
        return newpos
325
 
 
 
292
            
326
293
    def iter_inserted(self):
327
294
        """Iteraties through inserted lines
328
 
 
 
295
        
329
296
        :return: Pair of line number, line
330
297
        :rtype: iterator of (int, InsertLine)
331
298
        """
340
307
 
341
308
 
342
309
def parse_patch(iter_lines):
343
 
    iter_lines = iter_lines_handle_nl(iter_lines)
344
 
    try:
345
 
        (orig_name, mod_name) = get_patch_names(iter_lines)
346
 
    except BinaryFiles, e:
347
 
        return BinaryPatch(e.orig_name, e.mod_name)
348
 
    else:
349
 
        patch = Patch(orig_name, mod_name)
350
 
        for hunk in iter_hunks(iter_lines):
351
 
            patch.hunks.append(hunk)
352
 
        return patch
 
310
    (orig_name, mod_name) = get_patch_names(iter_lines)
 
311
    patch = Patch(orig_name, mod_name)
 
312
    for hunk in iter_hunks(iter_lines):
 
313
        patch.hunks.append(hunk)
 
314
    return patch
353
315
 
354
316
 
355
317
def iter_file_patch(iter_lines):
356
 
    regex = re.compile(binary_files_re)
357
318
    saved_lines = []
358
319
    orig_range = 0
359
320
    for line in iter_lines:
364
325
        elif orig_range > 0:
365
326
            if line.startswith('-') or line.startswith(' '):
366
327
                orig_range -= 1
367
 
        elif line.startswith('--- ') or regex.match(line):
 
328
        elif line.startswith('--- '):
368
329
            if len(saved_lines) > 0:
369
330
                yield saved_lines
370
331
            saved_lines = []
386
347
    last_line = None
387
348
    for line in iter_lines:
388
349
        if line == NO_NL:
389
 
            if not last_line.endswith('\n'):
390
 
                raise AssertionError()
 
350
            assert last_line.endswith('\n')
391
351
            last_line = last_line[:-1]
392
352
            line = None
393
353
        if last_line is not None:
398
358
 
399
359
 
400
360
def parse_patches(iter_lines):
 
361
    iter_lines = iter_lines_handle_nl(iter_lines)
401
362
    return [parse_patch(f.__iter__()) for f in iter_file_patch(iter_lines)]
402
363
 
403
364
 
424
385
    """Iterate through a series of lines with a patch applied.
425
386
    This handles a single file, and does exact, not fuzzy patching.
426
387
    """
427
 
    patch_lines = iter_lines_handle_nl(iter(patch_lines))
 
388
    if orig_lines is not None:
 
389
        orig_lines = orig_lines.__iter__()
 
390
    seen_patch = []
 
391
    patch_lines = iter_lines_handle_nl(patch_lines.__iter__())
428
392
    get_patch_names(patch_lines)
429
 
    return iter_patched_from_hunks(orig_lines, iter_hunks(patch_lines))
430
 
 
431
 
 
432
 
def iter_patched_from_hunks(orig_lines, hunks):
433
 
    """Iterate through a series of lines with a patch applied.
434
 
    This handles a single file, and does exact, not fuzzy patching.
435
 
 
436
 
    :param orig_lines: The unpatched lines.
437
 
    :param hunks: An iterable of Hunk instances.
438
 
    """
439
 
    seen_patch = []
440
393
    line_no = 1
441
 
    if orig_lines is not None:
442
 
        orig_lines = iter(orig_lines)
443
 
    for hunk in hunks:
 
394
    for hunk in iter_hunks(patch_lines):
444
395
        while line_no < hunk.orig_pos:
445
396
            orig_line = orig_lines.next()
446
397
            yield orig_line
456
407
                if isinstance(hunk_line, ContextLine):
457
408
                    yield orig_line
458
409
                else:
459
 
                    if not isinstance(hunk_line, RemoveLine):
460
 
                        raise AssertionError(hunk_line)
 
410
                    assert isinstance(hunk_line, RemoveLine)
461
411
                line_no += 1
462
412
    if orig_lines is not None:
463
413
        for line in orig_lines: