← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/patches.py

  • Committer: Vincent Ladeuil
  • Date: 2010-02-03 07:18:36 UTC
  • mto: (5008.1.1 integration)
  • mto: This revision was merged to the branch mainline in revision 5009.
  • Revision ID: v.ladeuil+lp@free.fr-20100203071836-u9b86q68fr9ri5s6
Fix NEWS.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/patches.py
1
 
# Copyright (C) 2004 - 2006 Aaron Bentley
 
1
# Copyright (C) 2004 - 2006, 2008 Aaron Bentley, Canonical Ltd
2
2
# <aaron.bentley@utoronto.ca>
3
3
#
4
 
#    This program is free software; you can redistribute it and/or modify
5
 
#    it under the terms of the GNU General Public License as published by
6
 
#    the Free Software Foundation; either version 2 of the License, or
7
 
#    (at your option) any later version.
8
 
#
9
 
#    This program is distributed in the hope that it will be useful,
10
 
#    but WITHOUT ANY WARRANTY; without even the implied warranty of
11
 
#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12
 
#    GNU General Public License for more details.
13
 
#
14
 
#    You should have received a copy of the GNU General Public License
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
 
4
# This program is free software; you can redistribute it and/or modify
 
5
# it under the terms of the GNU General Public License as published by
 
6
# the Free Software Foundation; either version 2 of the License, or
 
7
# (at your option) any later version.
 
8
#
 
9
# This program is distributed in the hope that it will be useful,
 
10
# but WITHOUT ANY WARRANTY; without even the implied warranty of
 
11
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
12
# GNU General Public License for more details.
 
13
#
 
14
# You should have received a copy of the GNU General Public License
 
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.')
17
29
 
18
30
 
19
31
class PatchSyntax(Exception):
57
69
def get_patch_names(iter_lines):
58
70
    try:
59
71
        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))
60
75
        if not line.startswith("--- "):
61
76
            raise MalformedPatchHeader("No orig name", line)
62
77
        else:
92
107
    range = int(range)
93
108
    return (pos, range)
94
109
 
95
 
 
 
110
 
96
111
def hunk_from_header(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)
 
112
    import re
 
113
    matches = re.match(r'\@\@ ([^@]*) \@\@( (.*))?\n', line)
 
114
    if matches is None:
 
115
        raise MalformedHunkHeader("Does not match format.", line)
100
116
    try:
101
 
        (orig, mod) = line[3:-4].split(" ")
102
 
    except Exception, e:
 
117
        (orig, mod) = matches.group(1).split(" ")
 
118
    except (ValueError, IndexError), e:
103
119
        raise MalformedHunkHeader(str(e), line)
104
120
    if not orig.startswith('-') or not mod.startswith('+'):
105
121
        raise MalformedHunkHeader("Positions don't start with + or -.", line)
106
122
    try:
107
123
        (orig_pos, orig_range) = parse_range(orig[1:])
108
124
        (mod_pos, mod_range) = parse_range(mod[1:])
109
 
    except Exception, e:
 
125
    except (ValueError, IndexError), e:
110
126
        raise MalformedHunkHeader(str(e), line)
111
127
    if mod_range < 0 or orig_range < 0:
112
128
        raise MalformedHunkHeader("Hunk range is negative", line)
113
 
    return Hunk(orig_pos, orig_range, mod_pos, mod_range)
 
129
    tail = matches.group(3)
 
130
    return Hunk(orig_pos, orig_range, mod_pos, mod_range, tail)
114
131
 
115
132
 
116
133
class HunkLine:
162
179
        return InsertLine(line[1:])
163
180
    elif line.startswith("-"):
164
181
        return RemoveLine(line[1:])
165
 
    elif line == NO_NL:
166
 
        return NO_NL
167
182
    else:
168
183
        raise MalformedLine("Unknown line type", line)
169
184
__pychecker__=""
170
185
 
171
186
 
172
187
class Hunk:
173
 
    def __init__(self, orig_pos, orig_range, mod_pos, mod_range):
 
188
    def __init__(self, orig_pos, orig_range, mod_pos, mod_range, tail=None):
174
189
        self.orig_pos = orig_pos
175
190
        self.orig_range = orig_range
176
191
        self.mod_pos = mod_pos
177
192
        self.mod_range = mod_range
 
193
        self.tail = tail
178
194
        self.lines = []
179
195
 
180
196
    def get_header(self):
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))
 
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)
185
206
 
186
207
    def range_str(self, pos, range):
187
208
        """Return a file range, special-casing for 1-line files.
212
233
            return self.shift_to_mod_lines(pos)
213
234
 
214
235
    def shift_to_mod_lines(self, pos):
215
 
        assert (pos >= self.orig_pos-1 and pos <= self.orig_pos+self.orig_range)
216
236
        position = self.orig_pos-1
217
237
        shift = 0
218
238
        for line in self.lines:
254
274
        yield hunk
255
275
 
256
276
 
257
 
class Patch:
 
277
class BinaryPatch(object):
258
278
    def __init__(self, oldname, newname):
259
279
        self.oldname = oldname
260
280
        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)
261
290
        self.hunks = []
262
291
 
263
292
    def __str__(self):
264
 
        ret = self.get_header() 
 
293
        ret = self.get_header()
265
294
        ret += "".join([str(h) for h in self.hunks])
266
295
        return ret
267
296
 
268
297
    def get_header(self):
269
298
        return "--- %s\n+++ %s\n" % (self.oldname, self.newname)
270
299
 
271
 
    def stats_str(self):
272
 
        """Return a string of patch statistics"""
 
300
    def stats_values(self):
 
301
        """Calculate the number of inserts and removes."""
273
302
        removes = 0
274
303
        inserts = 0
275
304
        for hunk in self.hunks:
278
307
                     inserts+=1;
279
308
                elif isinstance(line, RemoveLine):
280
309
                     removes+=1;
 
310
        return (inserts, removes, len(self.hunks))
 
311
 
 
312
    def stats_str(self):
 
313
        """Return a string of patch statistics"""
281
314
        return "%i inserts, %i removes in %i hunks" % \
282
 
            (inserts, removes, len(self.hunks))
 
315
            self.stats_values()
283
316
 
284
317
    def pos_in_mod(self, position):
285
318
        newpos = position
289
322
                return None
290
323
            newpos += shift
291
324
        return newpos
292
 
            
 
325
 
293
326
    def iter_inserted(self):
294
327
        """Iteraties through inserted lines
295
 
        
 
328
 
296
329
        :return: Pair of line number, line
297
330
        :rtype: iterator of (int, InsertLine)
298
331
        """
307
340
 
308
341
 
309
342
def parse_patch(iter_lines):
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
 
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
315
353
 
316
354
 
317
355
def iter_file_patch(iter_lines):
 
356
    regex = re.compile(binary_files_re)
318
357
    saved_lines = []
 
358
    orig_range = 0
319
359
    for line in iter_lines:
320
360
        if line.startswith('=== ') or line.startswith('*** '):
321
361
            continue
322
362
        if line.startswith('#'):
323
363
            continue
324
 
        elif line.startswith('--- '):
 
364
        elif orig_range > 0:
 
365
            if line.startswith('-') or line.startswith(' '):
 
366
                orig_range -= 1
 
367
        elif line.startswith('--- ') or regex.match(line):
325
368
            if len(saved_lines) > 0:
326
369
                yield saved_lines
327
370
            saved_lines = []
 
371
        elif line.startswith('@@'):
 
372
            hunk = hunk_from_header(line)
 
373
            orig_range = hunk.orig_range
328
374
        saved_lines.append(line)
329
375
    if len(saved_lines) > 0:
330
376
        yield saved_lines
340
386
    last_line = None
341
387
    for line in iter_lines:
342
388
        if line == NO_NL:
343
 
            assert last_line.endswith('\n')
 
389
            if not last_line.endswith('\n'):
 
390
                raise AssertionError()
344
391
            last_line = last_line[:-1]
345
392
            line = None
346
393
        if last_line is not None:
351
398
 
352
399
 
353
400
def parse_patches(iter_lines):
354
 
    iter_lines = iter_lines_handle_nl(iter_lines)
355
401
    return [parse_patch(f.__iter__()) for f in iter_file_patch(iter_lines)]
356
402
 
357
403
 
378
424
    """Iterate through a series of lines with a patch applied.
379
425
    This handles a single file, and does exact, not fuzzy patching.
380
426
    """
381
 
    if orig_lines is not None:
382
 
        orig_lines = orig_lines.__iter__()
 
427
    patch_lines = iter_lines_handle_nl(iter(patch_lines))
 
428
    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
    """
383
439
    seen_patch = []
384
 
    patch_lines = iter_lines_handle_nl(patch_lines.__iter__())
385
 
    get_patch_names(patch_lines)
386
440
    line_no = 1
387
 
    for hunk in iter_hunks(patch_lines):
 
441
    if orig_lines is not None:
 
442
        orig_lines = iter(orig_lines)
 
443
    for hunk in hunks:
388
444
        while line_no < hunk.orig_pos:
389
445
            orig_line = orig_lines.next()
390
446
            yield orig_line
400
456
                if isinstance(hunk_line, ContextLine):
401
457
                    yield orig_line
402
458
                else:
403
 
                    assert isinstance(hunk_line, RemoveLine)
 
459
                    if not isinstance(hunk_line, RemoveLine):
 
460
                        raise AssertionError(hunk_line)
404
461
                line_no += 1
405
462
    if orig_lines is not None:
406
463
        for line in orig_lines: