← Back to branch summary

~abentley/bzrtools/bzrtools.dev

« back to all changes in this revision

Viewing changes to patches.py

  • Committer: Aaron Bentley
  • Date: 2005-07-27 17:57:32 UTC
  • Revision ID: abentley@panoramicfeedback.com-20050727175732-3637e3a9c1af9c33
Added iter_patched, handled files with no terminating newline

Show diffs side-by-side

added added

removed removed

Lines of Context:
patches.py
 
1
# Copyright (C) 2004, 2005 Aaron Bentley
 
2
# <aaron.bentley@utoronto.ca>
 
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
 
17
 
 
18
class PatchSyntax(Exception):
 
19
    def __init__(self, msg):
 
20
        Exception.__init__(self, msg)
 
21
 
 
22
 
 
23
class MalformedPatchHeader(PatchSyntax):
 
24
    def __init__(self, desc, line):
 
25
        self.desc = desc
 
26
        self.line = line
 
27
        msg = "Malformed patch header.  %s\n%r" % (self.desc, self.line)
 
28
        PatchSyntax.__init__(self, msg)
 
29
 
 
30
class MalformedHunkHeader(PatchSyntax):
 
31
    def __init__(self, desc, line):
 
32
        self.desc = desc
 
33
        self.line = line
 
34
        msg = "Malformed hunk header.  %s\n%r" % (self.desc, self.line)
 
35
        PatchSyntax.__init__(self, msg)
 
36
 
 
37
class MalformedLine(PatchSyntax):
 
38
    def __init__(self, desc, line):
 
39
        self.desc = desc
 
40
        self.line = line
 
41
        msg = "Malformed line.  %s\n%s" % (self.desc, self.line)
 
42
        PatchSyntax.__init__(self, msg)
 
43
 
 
44
def get_patch_names(iter_lines):
 
45
    try:
 
46
        line = iter_lines.next()
 
47
        if not line.startswith("--- "):
 
48
            raise MalformedPatchHeader("No orig name", line)
 
49
        else:
 
50
            orig_name = line[4:].rstrip("\n")
 
51
    except StopIteration:
 
52
        raise MalformedPatchHeader("No orig line", "")
 
53
    try:
 
54
        line = iter_lines.next()
 
55
        if not line.startswith("+++ "):
 
56
            raise PatchSyntax("No mod name")
 
57
        else:
 
58
            mod_name = line[4:].rstrip("\n")
 
59
    except StopIteration:
 
60
        raise MalformedPatchHeader("No mod line", "")
 
61
    return (orig_name, mod_name)
 
62
 
 
63
def parse_range(textrange):
 
64
    """Parse a patch range, handling the "1" special-case
 
65
 
 
66
    :param textrange: The text to parse
 
67
    :type textrange: str
 
68
    :return: the position and range, as a tuple
 
69
    :rtype: (int, int)
 
70
    """
 
71
    tmp = textrange.split(',')
 
72
    if len(tmp) == 1:
 
73
        pos = tmp[0]
 
74
        range = "1"
 
75
    else:
 
76
        (pos, range) = tmp
 
77
    pos = int(pos)
 
78
    range = int(range)
 
79
    return (pos, range)
 
80
 
 
81
 
 
82
def hunk_from_header(line):
 
83
    if not line.startswith("@@") or not line.endswith("@@\n") \
 
84
        or not len(line) > 4:
 
85
        raise MalformedHunkHeader("Does not start and end with @@.", line)
 
86
    try:
 
87
        (orig, mod) = line[3:-4].split(" ")
 
88
    except Exception, e:
 
89
        raise MalformedHunkHeader(str(e), line)
 
90
    if not orig.startswith('-') or not mod.startswith('+'):
 
91
        raise MalformedHunkHeader("Positions don't start with + or -.", line)
 
92
    try:
 
93
        (orig_pos, orig_range) = parse_range(orig[1:])
 
94
        (mod_pos, mod_range) = parse_range(mod[1:])
 
95
    except Exception, e:
 
96
        raise MalformedHunkHeader(str(e), line)
 
97
    if mod_range < 0 or orig_range < 0:
 
98
        raise MalformedHunkHeader("Hunk range is negative", line)
 
99
    return Hunk(orig_pos, orig_range, mod_pos, mod_range)
 
100
 
 
101
 
 
102
class HunkLine:
 
103
    def __init__(self, contents):
 
104
        self.contents = contents
 
105
 
 
106
    def get_str(self, leadchar):
 
107
        if self.contents == "\n" and leadchar == " " and False:
 
108
            return "\n"
 
109
        if not self.contents.endswith('\n'):
 
110
            terminator = '\n' + NO_NL
 
111
        else:
 
112
            terminator = ''
 
113
        return leadchar + self.contents + terminator
 
114
 
 
115
    def no_nl(self):
 
116
        assert self.contents.endswith('\n')
 
117
        self.contents = self.contents[:-1]
 
118
 
 
119
class ContextLine(HunkLine):
 
120
    def __init__(self, contents):
 
121
        HunkLine.__init__(self, contents)
 
122
 
 
123
    def __str__(self):
 
124
        return self.get_str(" ")
 
125
 
 
126
 
 
127
class InsertLine(HunkLine):
 
128
    def __init__(self, contents):
 
129
        HunkLine.__init__(self, contents)
 
130
 
 
131
    def __str__(self):
 
132
        return self.get_str("+")
 
133
 
 
134
 
 
135
class RemoveLine(HunkLine):
 
136
    def __init__(self, contents):
 
137
        HunkLine.__init__(self, contents)
 
138
 
 
139
    def __str__(self):
 
140
        return self.get_str("-")
 
141
 
 
142
NO_NL = '\\ No newline at end of file\n'
 
143
__pychecker__="no-returnvalues"
 
144
 
 
145
def parse_line(line):
 
146
    if line.startswith("\n"):
 
147
        return ContextLine(line)
 
148
    elif line.startswith(" "):
 
149
        return ContextLine(line[1:])
 
150
    elif line.startswith("+"):
 
151
        return InsertLine(line[1:])
 
152
    elif line.startswith("-"):
 
153
        return RemoveLine(line[1:])
 
154
    elif line == NO_NL:
 
155
        return NO_NL
 
156
    else:
 
157
        raise MalformedLine("Unknown line type", line)
 
158
__pychecker__=""
 
159
 
 
160
 
 
161
class Hunk:
 
162
    def __init__(self, orig_pos, orig_range, mod_pos, mod_range):
 
163
        self.orig_pos = orig_pos
 
164
        self.orig_range = orig_range
 
165
        self.mod_pos = mod_pos
 
166
        self.mod_range = mod_range
 
167
        self.lines = []
 
168
 
 
169
    def get_header(self):
 
170
        return "@@ -%s +%s @@\n" % (self.range_str(self.orig_pos, 
 
171
                                                   self.orig_range),
 
172
                                    self.range_str(self.mod_pos, 
 
173
                                                   self.mod_range))
 
174
 
 
175
    def range_str(self, pos, range):
 
176
        """Return a file range, special-casing for 1-line files.
 
177
 
 
178
        :param pos: The position in the file
 
179
        :type pos: int
 
180
        :range: The range in the file
 
181
        :type range: int
 
182
        :return: a string in the format 1,4 except when range == pos == 1
 
183
        """
 
184
        if range == 1:
 
185
            return "%i" % pos
 
186
        else:
 
187
            return "%i,%i" % (pos, range)
 
188
 
 
189
    def __str__(self):
 
190
        lines = [self.get_header()]
 
191
        for line in self.lines:
 
192
            lines.append(str(line))
 
193
        return "".join(lines)
 
194
 
 
195
    def shift_to_mod(self, pos):
 
196
        if pos < self.orig_pos-1:
 
197
            return 0
 
198
        elif pos > self.orig_pos+self.orig_range:
 
199
            return self.mod_range - self.orig_range
 
200
        else:
 
201
            return self.shift_to_mod_lines(pos)
 
202
 
 
203
    def shift_to_mod_lines(self, pos):
 
204
        assert (pos >= self.orig_pos-1 and pos <= self.orig_pos+self.orig_range)
 
205
        position = self.orig_pos-1
 
206
        shift = 0
 
207
        for line in self.lines:
 
208
            if isinstance(line, InsertLine):
 
209
                shift += 1
 
210
            elif isinstance(line, RemoveLine):
 
211
                if position == pos:
 
212
                    return None
 
213
                shift -= 1
 
214
                position += 1
 
215
            elif isinstance(line, ContextLine):
 
216
                position += 1
 
217
            if position > pos:
 
218
                break
 
219
        return shift
 
220
 
 
221
def iter_hunks(iter_lines):
 
222
    hunk = None
 
223
    for line in iter_lines:
 
224
        if line == NO_NL:
 
225
            hunk.lines[-1].no_nl()
 
226
            yield hunk
 
227
            hunk = None
 
228
            continue
 
229
        elif line == "\n":
 
230
            if hunk is not None:
 
231
                yield hunk
 
232
                hunk = None
 
233
            continue
 
234
        if hunk is not None:
 
235
            yield hunk
 
236
        hunk = hunk_from_header(line)
 
237
        orig_size = 0
 
238
        mod_size = 0
 
239
        while orig_size < hunk.orig_range or mod_size < hunk.mod_range:
 
240
            hunk_line = parse_line(iter_lines.next())
 
241
            if hunk_line is NO_NL:
 
242
                hunk.lines[-1].no_nl()
 
243
            else:
 
244
                hunk.lines.append(hunk_line)
 
245
            if isinstance(hunk_line, (RemoveLine, ContextLine)):
 
246
                orig_size += 1
 
247
            if isinstance(hunk_line, (InsertLine, ContextLine)):
 
248
                mod_size += 1
 
249
    if hunk is not None:
 
250
        yield hunk
 
251
 
 
252
class Patch:
 
253
    def __init__(self, oldname, newname):
 
254
        self.oldname = oldname
 
255
        self.newname = newname
 
256
        self.hunks = []
 
257
 
 
258
    def __str__(self):
 
259
        ret =  "--- %s\n+++ %s\n" % (self.oldname, self.newname) 
 
260
        ret += "".join([str(h) for h in self.hunks])
 
261
        return ret
 
262
 
 
263
    def stats_str(self):
 
264
        """Return a string of patch statistics"""
 
265
        removes = 0
 
266
        inserts = 0
 
267
        for hunk in self.hunks:
 
268
            for line in hunk.lines:
 
269
                if isinstance(line, InsertLine):
 
270
                     inserts+=1;
 
271
                elif isinstance(line, RemoveLine):
 
272
                     removes+=1;
 
273
        return "%i inserts, %i removes in %i hunks" % \
 
274
            (inserts, removes, len(self.hunks))
 
275
 
 
276
    def pos_in_mod(self, position):
 
277
        newpos = position
 
278
        for hunk in self.hunks:
 
279
            shift = hunk.shift_to_mod(position)
 
280
            if shift is None:
 
281
                return None
 
282
            newpos += shift
 
283
        return newpos
 
284
            
 
285
    def iter_inserted(self):
 
286
        """Iteraties through inserted lines
 
287
        
 
288
        :return: Pair of line number, line
 
289
        :rtype: iterator of (int, InsertLine)
 
290
        """
 
291
        for hunk in self.hunks:
 
292
            pos = hunk.mod_pos - 1;
 
293
            for line in hunk.lines:
 
294
                if isinstance(line, InsertLine):
 
295
                    yield (pos, line)
 
296
                    pos += 1
 
297
                if isinstance(line, ContextLine):
 
298
                    pos += 1
 
299
 
 
300
def parse_patch(iter_lines):
 
301
    (orig_name, mod_name) = get_patch_names(iter_lines)
 
302
    patch = Patch(orig_name, mod_name)
 
303
    for hunk in iter_hunks(iter_lines):
 
304
        patch.hunks.append(hunk)
 
305
    return patch
 
306
 
 
307
 
 
308
def iter_file_patch(iter_lines):
 
309
    saved_lines = []
 
310
    for line in iter_lines:
 
311
        if line.startswith('*** '):
 
312
            continue
 
313
        elif line.startswith('--- '):
 
314
            if len(saved_lines) > 0:
 
315
                yield saved_lines
 
316
            saved_lines = []
 
317
        saved_lines.append(line)
 
318
    if len(saved_lines) > 0:
 
319
        yield saved_lines
 
320
 
 
321
 
 
322
def parse_patches(iter_lines):
 
323
    return [parse_patch(f.__iter__()) for f in iter_file_patch(iter_lines)]
 
324
 
 
325
 
 
326
def difference_index(atext, btext):
 
327
    """Find the indext of the first character that differs betweeen two texts
 
328
 
 
329
    :param atext: The first text
 
330
    :type atext: str
 
331
    :param btext: The second text
 
332
    :type str: str
 
333
    :return: The index, or None if there are no differences within the range
 
334
    :rtype: int or NoneType
 
335
    """
 
336
    length = len(atext)
 
337
    if len(btext) < length:
 
338
        length = len(btext)
 
339
    for i in range(length):
 
340
        if atext[i] != btext[i]:
 
341
            return i;
 
342
    return None
 
343
 
 
344
class PatchConflict(Exception):
 
345
    def __init__(self, line_no, orig_line, patch_line):
 
346
        orig = orig_line.rstrip('\n')
 
347
        patch = str(patch_line).rstrip('\n')
 
348
        msg = 'Text contents mismatch at line %d.  Original has "%s",'\
 
349
            ' but patch says it should be "%s"' % (line_no, orig, patch)
 
350
        Exception.__init__(self, msg)
 
351
 
 
352
 
 
353
def iter_patched(orig_lines, patch_lines):
 
354
    """Iterate through a series of lines with a patch applied.
 
355
    This handles a single file, and does exact, not fuzzy patching.
 
356
    """
 
357
    if orig_lines is not None:
 
358
        orig_lines = orig_lines.__iter__()
 
359
    seen_patch = []
 
360
    patch_lines = patch_lines.__iter__()
 
361
    get_patch_names(patch_lines)
 
362
    line_no = 1
 
363
    for hunk in iter_hunks(patch_lines):
 
364
        while line_no < hunk.orig_pos:
 
365
            orig_line = orig_lines.next()
 
366
            yield orig_line
 
367
            line_no += 1
 
368
        for hunk_line in hunk.lines:
 
369
            seen_patch.append(str(hunk_line))
 
370
            if isinstance(hunk_line, InsertLine):
 
371
                yield hunk_line.contents
 
372
            elif isinstance(hunk_line, (ContextLine, RemoveLine)):
 
373
                orig_line = orig_lines.next()
 
374
                if orig_line != hunk_line.contents:
 
375
                    raise PatchConflict(line_no, orig_line, "".join(seen_patch))
 
376
                if isinstance(hunk_line, ContextLine):
 
377
                    yield orig_line
 
378
                else:
 
379
                    assert isinstance(hunk_line, RemoveLine)
 
380
                line_no += 1
 
381
                    
 
382
def test():
 
383
    import unittest
 
384
    class PatchesTester(unittest.TestCase):
 
385
        def testValidPatchHeader(self):
 
386
            """Parse a valid patch header"""
 
387
            lines = "--- orig/commands.py\n+++ mod/dommands.py\n".split('\n')
 
388
            (orig, mod) = get_patch_names(lines.__iter__())
 
389
            assert(orig == "orig/commands.py")
 
390
            assert(mod == "mod/dommands.py")
 
391
 
 
392
        def testInvalidPatchHeader(self):
 
393
            """Parse an invalid patch header"""
 
394
            lines = "-- orig/commands.py\n+++ mod/dommands.py".split('\n')
 
395
            self.assertRaises(MalformedPatchHeader, get_patch_names,
 
396
                              lines.__iter__())
 
397
 
 
398
        def testValidHunkHeader(self):
 
399
            """Parse a valid hunk header"""
 
400
            header = "@@ -34,11 +50,6 @@\n"
 
401
            hunk = hunk_from_header(header);
 
402
            assert (hunk.orig_pos == 34)
 
403
            assert (hunk.orig_range == 11)
 
404
            assert (hunk.mod_pos == 50)
 
405
            assert (hunk.mod_range == 6)
 
406
            assert (str(hunk) == header)
 
407
 
 
408
        def testValidHunkHeader2(self):
 
409
            """Parse a tricky, valid hunk header"""
 
410
            header = "@@ -1 +0,0 @@\n"
 
411
            hunk = hunk_from_header(header);
 
412
            assert (hunk.orig_pos == 1)
 
413
            assert (hunk.orig_range == 1)
 
414
            assert (hunk.mod_pos == 0)
 
415
            assert (hunk.mod_range == 0)
 
416
            assert (str(hunk) == header)
 
417
 
 
418
        def makeMalformed(self, header):
 
419
            self.assertRaises(MalformedHunkHeader, hunk_from_header, header)
 
420
 
 
421
        def testInvalidHeader(self):
 
422
            """Parse an invalid hunk header"""
 
423
            self.makeMalformed(" -34,11 +50,6 \n")
 
424
            self.makeMalformed("@@ +50,6 -34,11 @@\n")
 
425
            self.makeMalformed("@@ -34,11 +50,6 @@")
 
426
            self.makeMalformed("@@ -34.5,11 +50,6 @@\n")
 
427
            self.makeMalformed("@@-34,11 +50,6@@\n")
 
428
            self.makeMalformed("@@ 34,11 50,6 @@\n")
 
429
            self.makeMalformed("@@ -34,11 @@\n")
 
430
            self.makeMalformed("@@ -34,11 +50,6.5 @@\n")
 
431
            self.makeMalformed("@@ -34,11 +50,-6 @@\n")
 
432
 
 
433
        def lineThing(self,text, type):
 
434
            line = parse_line(text)
 
435
            assert(isinstance(line, type))
 
436
            assert(str(line)==text)
 
437
 
 
438
        def makeMalformedLine(self, text):
 
439
            self.assertRaises(MalformedLine, parse_line, text)
 
440
 
 
441
        def testValidLine(self):
 
442
            """Parse a valid hunk line"""
 
443
            self.lineThing(" hello\n", ContextLine)
 
444
            self.lineThing("+hello\n", InsertLine)
 
445
            self.lineThing("-hello\n", RemoveLine)
 
446
        
 
447
        def testMalformedLine(self):
 
448
            """Parse invalid valid hunk lines"""
 
449
            self.makeMalformedLine("hello\n")
 
450
        
 
451
        def compare_parsed(self, patchtext):
 
452
            lines = patchtext.splitlines(True)
 
453
            patch = parse_patch(lines.__iter__())
 
454
            pstr = str(patch)
 
455
            i = difference_index(patchtext, pstr)
 
456
            if i is not None:
 
457
                print "%i: \"%s\" != \"%s\"" % (i, patchtext[i], pstr[i])
 
458
            self.assertEqual (patchtext, str(patch))
 
459
 
 
460
        def testAll(self):
 
461
            """Test parsing a whole patch"""
 
462
            patchtext = """--- orig/commands.py
 
463
+++ mod/commands.py
 
464
@@ -1337,7 +1337,8 @@
 
465
 
 
466
     def set_title(self, command=None):
 
467
         try:
 
468
-            version = self.tree.tree_version.nonarch
 
469
+            version = pylon.alias_or_version(self.tree.tree_version, self.tree,
 
470
+                                             full=False)
 
471
         except:
 
472
             version = "[no version]"
 
473
         if command is None:
 
474
@@ -1983,7 +1984,11 @@
 
475
                                          version)
 
476
         if len(new_merges) > 0:
 
477
             if cmdutil.prompt("Log for merge"):
 
478
-                mergestuff = cmdutil.log_for_merge(tree, comp_version)
 
479
+                if cmdutil.prompt("changelog for merge"):
 
480
+                    mergestuff = "Patches applied:\\n"
 
481
+                    mergestuff += pylon.changelog_for_merge(new_merges)
 
482
+                else:
 
483
+                    mergestuff = cmdutil.log_for_merge(tree, comp_version)
 
484
                 log.description += mergestuff
 
485
         log.save()
 
486
     try:
 
487
"""
 
488
            self.compare_parsed(patchtext)
 
489
 
 
490
        def testInit(self):
 
491
            """Handle patches missing half the position, range tuple"""
 
492
            patchtext = \
 
493
"""--- orig/__init__.py
 
494
+++ mod/__init__.py
 
495
@@ -1 +1,2 @@
 
496
 __docformat__ = "restructuredtext en"
 
497
+__doc__ = An alternate Arch commandline interface
 
498
"""
 
499
            self.compare_parsed(patchtext)
 
500
            
 
501
 
 
502
 
 
503
        def testLineLookup(self):
 
504
            import sys
 
505
            """Make sure we can accurately look up mod line from orig"""
 
506
            patch = parse_patch(open("testdata/diff"))
 
507
            orig = list(open("testdata/orig"))
 
508
            mod = list(open("testdata/mod"))
 
509
            removals = []
 
510
            for i in range(len(orig)):
 
511
                mod_pos = patch.pos_in_mod(i)
 
512
                if mod_pos is None:
 
513
                    removals.append(orig[i])
 
514
                    continue
 
515
                assert(mod[mod_pos]==orig[i])
 
516
            rem_iter = removals.__iter__()
 
517
            for hunk in patch.hunks:
 
518
                for line in hunk.lines:
 
519
                    if isinstance(line, RemoveLine):
 
520
                        next = rem_iter.next()
 
521
                        if line.contents != next:
 
522
                            sys.stdout.write(" orig:%spatch:%s" % (next,
 
523
                                             line.contents))
 
524
                        assert(line.contents == next)
 
525
            self.assertRaises(StopIteration, rem_iter.next)
 
526
 
 
527
        def testFirstLineRenumber(self):
 
528
            """Make sure we handle lines at the beginning of the hunk"""
 
529
            patch = parse_patch(open("testdata/insert_top.patch"))
 
530
            assert (patch.pos_in_mod(0)==1)
 
531
    
 
532
            
 
533
    patchesTestSuite = unittest.makeSuite(PatchesTester,'test')
 
534
    runner = unittest.TextTestRunner(verbosity=0)
 
535
    return runner.run(patchesTestSuite)
 
536
    
 
537
 
 
538
if __name__ == "__main__":
 
539
    test()
 
540
# arch-tag: d1541a25-eac5-4de9-a476-08a7cecd5683