/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 breezy/patches.py

  • Committer: Jelmer Vernooij
  • Date: 2017-07-23 22:06:41 UTC
  • mfrom: (6738 trunk)
  • mto: This revision was merged to the branch mainline in revision 6739.
  • Revision ID: jelmer@jelmer.uk-20170723220641-69eczax9bmv8d6kk
Merge trunk, address review comments.

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/patches.py
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
17
 
 
18
from __future__ import absolute_import
 
19
 
18
20
from .errors import (
19
21
    BzrError,
20
22
    )
21
23
 
22
 
import os
23
24
import re
24
25
 
25
26
 
26
 
binary_files_re = b'Binary files (.*) and (.*) differ\n'
 
27
binary_files_re = 'Binary files (.*) and (.*) differ\n'
27
28
 
28
29
 
29
30
class PatchSyntax(BzrError):
83
84
        match = re.match(binary_files_re, line)
84
85
        if match is not None:
85
86
            raise BinaryFiles(match.group(1), match.group(2))
86
 
        if not line.startswith(b"--- "):
 
87
        if not line.startswith("--- "):
87
88
            raise MalformedPatchHeader("No orig name", line)
88
89
        else:
89
 
            orig_name = line[4:].rstrip(b"\n")
 
90
            orig_name = line[4:].rstrip("\n")
90
91
    except StopIteration:
91
92
        raise MalformedPatchHeader("No orig line", "")
92
93
    try:
93
94
        line = next(iter_lines)
94
 
        if not line.startswith(b"+++ "):
 
95
        if not line.startswith("+++ "):
95
96
            raise PatchSyntax("No mod name")
96
97
        else:
97
 
            mod_name = line[4:].rstrip(b"\n")
 
98
            mod_name = line[4:].rstrip("\n")
98
99
    except StopIteration:
99
100
        raise MalformedPatchHeader("No mod line", "")
100
101
    return (orig_name, mod_name)
108
109
    :return: the position and range, as a tuple
109
110
    :rtype: (int, int)
110
111
    """
111
 
    tmp = textrange.split(b',')
 
112
    tmp = textrange.split(',')
112
113
    if len(tmp) == 1:
113
114
        pos = tmp[0]
114
 
        range = b"1"
 
115
        range = "1"
115
116
    else:
116
117
        (pos, range) = tmp
117
118
    pos = int(pos)
121
122
 
122
123
def hunk_from_header(line):
123
124
    import re
124
 
    matches = re.match(br'\@\@ ([^@]*) \@\@( (.*))?\n', line)
 
125
    matches = re.match(r'\@\@ ([^@]*) \@\@( (.*))?\n', line)
125
126
    if matches is None:
126
127
        raise MalformedHunkHeader("Does not match format.", line)
127
128
    try:
128
 
        (orig, mod) = matches.group(1).split(b" ")
 
129
        (orig, mod) = matches.group(1).split(" ")
129
130
    except (ValueError, IndexError) as e:
130
131
        raise MalformedHunkHeader(str(e), line)
131
 
    if not orig.startswith(b'-') or not mod.startswith(b'+'):
 
132
    if not orig.startswith('-') or not mod.startswith('+'):
132
133
        raise MalformedHunkHeader("Positions don't start with + or -.", line)
133
134
    try:
134
135
        (orig_pos, orig_range) = parse_range(orig[1:])
141
142
    return Hunk(orig_pos, orig_range, mod_pos, mod_range, tail)
142
143
 
143
144
 
144
 
class HunkLine(object):
145
 
 
 
145
class HunkLine:
146
146
    def __init__(self, contents):
147
147
        self.contents = contents
148
148
 
149
149
    def get_str(self, leadchar):
150
 
        if self.contents == b"\n" and leadchar == b" " and False:
151
 
            return b"\n"
152
 
        if not self.contents.endswith(b'\n'):
153
 
            terminator = b'\n' + NO_NL
 
150
        if self.contents == "\n" and leadchar == " " and False:
 
151
            return "\n"
 
152
        if not self.contents.endswith('\n'):
 
153
            terminator = '\n' + NO_NL
154
154
        else:
155
 
            terminator = b''
 
155
            terminator = ''
156
156
        return leadchar + self.contents + terminator
157
157
 
158
 
    def as_bytes(self):
159
 
        raise NotImplementedError
160
 
 
161
158
 
162
159
class ContextLine(HunkLine):
163
 
 
164
160
    def __init__(self, contents):
165
161
        HunkLine.__init__(self, contents)
166
162
 
167
 
    def as_bytes(self):
168
 
        return self.get_str(b" ")
 
163
    def __str__(self):
 
164
        return self.get_str(" ")
169
165
 
170
166
 
171
167
class InsertLine(HunkLine):
172
168
    def __init__(self, contents):
173
169
        HunkLine.__init__(self, contents)
174
170
 
175
 
    def as_bytes(self):
176
 
        return self.get_str(b"+")
 
171
    def __str__(self):
 
172
        return self.get_str("+")
177
173
 
178
174
 
179
175
class RemoveLine(HunkLine):
180
176
    def __init__(self, contents):
181
177
        HunkLine.__init__(self, contents)
182
178
 
183
 
    def as_bytes(self):
184
 
        return self.get_str(b"-")
185
 
 
186
 
 
187
 
NO_NL = b'\\ No newline at end of file\n'
188
 
__pychecker__ = "no-returnvalues"
189
 
 
 
179
    def __str__(self):
 
180
        return self.get_str("-")
 
181
 
 
182
NO_NL = '\\ No newline at end of file\n'
 
183
__pychecker__="no-returnvalues"
190
184
 
191
185
def parse_line(line):
192
 
    if line.startswith(b"\n"):
 
186
    if line.startswith("\n"):
193
187
        return ContextLine(line)
194
 
    elif line.startswith(b" "):
 
188
    elif line.startswith(" "):
195
189
        return ContextLine(line[1:])
196
 
    elif line.startswith(b"+"):
 
190
    elif line.startswith("+"):
197
191
        return InsertLine(line[1:])
198
 
    elif line.startswith(b"-"):
 
192
    elif line.startswith("-"):
199
193
        return RemoveLine(line[1:])
200
194
    else:
201
195
        raise MalformedLine("Unknown line type", line)
202
 
 
203
 
 
204
 
__pychecker__ = ""
205
 
 
206
 
 
207
 
class Hunk(object):
208
 
 
 
196
__pychecker__=""
 
197
 
 
198
 
 
199
class Hunk:
209
200
    def __init__(self, orig_pos, orig_range, mod_pos, mod_range, tail=None):
210
201
        self.orig_pos = orig_pos
211
202
        self.orig_range = orig_range
216
207
 
217
208
    def get_header(self):
218
209
        if self.tail is None:
219
 
            tail_str = b''
 
210
            tail_str = ''
220
211
        else:
221
 
            tail_str = b' ' + self.tail
222
 
        return b"@@ -%s +%s @@%s\n" % (self.range_str(self.orig_pos,
223
 
                                                      self.orig_range),
224
 
                                       self.range_str(self.mod_pos,
225
 
                                                      self.mod_range),
226
 
                                       tail_str)
 
212
            tail_str = ' ' + self.tail
 
213
        return "@@ -%s +%s @@%s\n" % (self.range_str(self.orig_pos,
 
214
                                                     self.orig_range),
 
215
                                      self.range_str(self.mod_pos,
 
216
                                                     self.mod_range),
 
217
                                      tail_str)
227
218
 
228
219
    def range_str(self, pos, range):
229
220
        """Return a file range, special-casing for 1-line files.
235
226
        :return: a string in the format 1,4 except when range == pos == 1
236
227
        """
237
228
        if range == 1:
238
 
            return b"%i" % pos
 
229
            return "%i" % pos
239
230
        else:
240
 
            return b"%i,%i" % (pos, range)
 
231
            return "%i,%i" % (pos, range)
241
232
 
242
 
    def as_bytes(self):
 
233
    def __str__(self):
243
234
        lines = [self.get_header()]
244
235
        for line in self.lines:
245
 
            lines.append(line.as_bytes())
246
 
        return b"".join(lines)
247
 
 
248
 
    __bytes__ = as_bytes
 
236
            lines.append(str(line))
 
237
        return "".join(lines)
249
238
 
250
239
    def shift_to_mod(self, pos):
251
 
        if pos < self.orig_pos - 1:
 
240
        if pos < self.orig_pos-1:
252
241
            return 0
253
 
        elif pos > self.orig_pos + self.orig_range:
 
242
        elif pos > self.orig_pos+self.orig_range:
254
243
            return self.mod_range - self.orig_range
255
244
        else:
256
245
            return self.shift_to_mod_lines(pos)
257
246
 
258
247
    def shift_to_mod_lines(self, pos):
259
 
        position = self.orig_pos - 1
 
248
        position = self.orig_pos-1
260
249
        shift = 0
261
250
        for line in self.lines:
262
251
            if isinstance(line, InsertLine):
282
271
    '''
283
272
    hunk = None
284
273
    for line in iter_lines:
285
 
        if line == b"\n":
 
274
        if line == "\n":
286
275
            if hunk is not None:
287
276
                yield hunk
288
277
                hunk = None
312
301
 
313
302
 
314
303
class BinaryPatch(object):
315
 
 
316
304
    def __init__(self, oldname, newname):
317
305
        self.oldname = oldname
318
306
        self.newname = newname
319
307
 
320
 
    def as_bytes(self):
321
 
        return b'Binary files %s and %s differ\n' % (self.oldname, self.newname)
 
308
    def __str__(self):
 
309
        return 'Binary files %s and %s differ\n' % (self.oldname, self.newname)
322
310
 
323
311
 
324
312
class Patch(BinaryPatch):
327
315
        BinaryPatch.__init__(self, oldname, newname)
328
316
        self.hunks = []
329
317
 
330
 
    def as_bytes(self):
 
318
    def __str__(self):
331
319
        ret = self.get_header()
332
 
        ret += b"".join([h.as_bytes() for h in self.hunks])
 
320
        ret += "".join([str(h) for h in self.hunks])
333
321
        return ret
334
322
 
335
323
    def get_header(self):
336
 
        return b"--- %s\n+++ %s\n" % (self.oldname, self.newname)
 
324
        return "--- %s\n+++ %s\n" % (self.oldname, self.newname)
337
325
 
338
326
    def stats_values(self):
339
327
        """Calculate the number of inserts and removes."""
342
330
        for hunk in self.hunks:
343
331
            for line in hunk.lines:
344
332
                if isinstance(line, InsertLine):
345
 
                    inserts += 1
 
333
                     inserts+=1;
346
334
                elif isinstance(line, RemoveLine):
347
 
                    removes += 1
 
335
                     removes+=1;
348
336
        return (inserts, removes, len(self.hunks))
349
337
 
350
338
    def stats_str(self):
368
356
        :rtype: iterator of (int, InsertLine)
369
357
        """
370
358
        for hunk in self.hunks:
371
 
            pos = hunk.mod_pos - 1
 
359
            pos = hunk.mod_pos - 1;
372
360
            for line in hunk.lines:
373
361
                if isinstance(line, InsertLine):
374
362
                    yield (pos, line)
376
364
                if isinstance(line, ContextLine):
377
365
                    pos += 1
378
366
 
379
 
 
380
367
def parse_patch(iter_lines, allow_dirty=False):
381
368
    '''
382
369
    :arg iter_lines: iterable of lines to parse
404
391
        first patch are stripped away in iter_hunks() if it is also passed
405
392
        allow_dirty=True.  Default False.
406
393
    '''
407
 
    # FIXME: Docstring is not quite true.  We allow certain comments no
 
394
    ### FIXME: Docstring is not quite true.  We allow certain comments no
408
395
    # matter what, If they startwith '===', '***', or '#' Someone should
409
396
    # reexamine this logic and decide if we should include those in
410
397
    # allow_dirty or restrict those to only being before the patch is found
416
403
    beginning = True
417
404
 
418
405
    for line in iter_lines:
419
 
        if line.startswith(b'=== '):
 
406
        if line.startswith('=== '):
420
407
            if len(saved_lines) > 0:
421
408
                if keep_dirty and len(dirty_head) > 0:
422
409
                    yield {'saved_lines': saved_lines,
427
414
                saved_lines = []
428
415
            dirty_head.append(line)
429
416
            continue
430
 
        if line.startswith(b'*** '):
 
417
        if line.startswith('*** '):
431
418
            continue
432
 
        if line.startswith(b'#'):
 
419
        if line.startswith('#'):
433
420
            continue
434
421
        elif orig_range > 0:
435
 
            if line.startswith(b'-') or line.startswith(b' '):
 
422
            if line.startswith('-') or line.startswith(' '):
436
423
                orig_range -= 1
437
 
        elif line.startswith(b'--- ') or regex.match(line):
 
424
        elif line.startswith('--- ') or regex.match(line):
438
425
            if allow_dirty and beginning:
439
426
                # Patches can have "junk" at the beginning
440
427
                # Stripping junk from the end of patches is handled when we
448
435
                else:
449
436
                    yield saved_lines
450
437
            saved_lines = []
451
 
        elif line.startswith(b'@@'):
 
438
        elif line.startswith('@@'):
452
439
            hunk = hunk_from_header(line)
453
440
            orig_range = hunk.orig_range
454
441
        saved_lines.append(line)
470
457
    last_line = None
471
458
    for line in iter_lines:
472
459
        if line == NO_NL:
473
 
            if not last_line.endswith(b'\n'):
 
460
            if not last_line.endswith('\n'):
474
461
                raise AssertionError()
475
462
            last_line = last_line[:-1]
476
463
            line = None
490
477
    :kwarg keep_dirty: If True, returns a dict of patches with dirty headers.
491
478
        Default False.
492
479
    '''
 
480
    patches = []
493
481
    for patch_lines in iter_file_patch(iter_lines, allow_dirty, keep_dirty):
494
482
        if 'dirty_head' in patch_lines:
495
 
            yield ({'patch': parse_patch(patch_lines['saved_lines'], allow_dirty),
496
 
                    'dirty_head': patch_lines['dirty_head']})
 
483
            patches.append({'patch': parse_patch(
 
484
                patch_lines['saved_lines'], allow_dirty),
 
485
                            'dirty_head': patch_lines['dirty_head']})
497
486
        else:
498
 
            yield parse_patch(patch_lines, allow_dirty)
 
487
            patches.append(parse_patch(patch_lines, allow_dirty))
 
488
    return patches
499
489
 
500
490
 
501
491
def difference_index(atext, btext):
513
503
        length = len(btext)
514
504
    for i in range(length):
515
505
        if atext[i] != btext[i]:
516
 
            return i
 
506
            return i;
517
507
    return None
518
508
 
519
509
 
543
533
            yield orig_line
544
534
            line_no += 1
545
535
        for hunk_line in hunk.lines:
546
 
            seen_patch.append(hunk_line.contents)
 
536
            seen_patch.append(str(hunk_line))
547
537
            if isinstance(hunk_line, InsertLine):
548
538
                yield hunk_line.contents
549
539
            elif isinstance(hunk_line, (ContextLine, RemoveLine)):
550
540
                orig_line = next(orig_lines)
551
541
                if orig_line != hunk_line.contents:
552
 
                    raise PatchConflict(line_no, orig_line,
553
 
                                        b''.join(seen_patch))
 
542
                    raise PatchConflict(line_no, orig_line, "".join(seen_patch))
554
543
                if isinstance(hunk_line, ContextLine):
555
544
                    yield orig_line
556
545
                else:
560
549
    if orig_lines is not None:
561
550
        for line in orig_lines:
562
551
            yield line
563
 
 
564
 
 
565
 
def apply_patches(tt, patches, prefix=1):
566
 
    """Apply patches to a TreeTransform.
567
 
 
568
 
    :param tt: TreeTransform instance
569
 
    :param patches: List of patches
570
 
    :param prefix: Number leading path segments to strip
571
 
    """
572
 
    def strip_prefix(p):
573
 
        return '/'.join(p.split('/')[1:])
574
 
 
575
 
    from breezy.bzr.generate_ids import gen_file_id
576
 
    # TODO(jelmer): Extract and set mode
577
 
    for patch in patches:
578
 
        if patch.oldname == b'/dev/null':
579
 
            trans_id = None
580
 
            orig_contents = b''
581
 
        else:
582
 
            oldname = strip_prefix(patch.oldname.decode())
583
 
            trans_id = tt.trans_id_tree_path(oldname)
584
 
            orig_contents = tt._tree.get_file_text(oldname)
585
 
            tt.delete_contents(trans_id)
586
 
 
587
 
        if patch.newname != b'/dev/null':
588
 
            newname = strip_prefix(patch.newname.decode())
589
 
            new_contents = iter_patched_from_hunks(
590
 
                orig_contents.splitlines(True), patch.hunks)
591
 
            if trans_id is None:
592
 
                parts = os.path.split(newname)
593
 
                trans_id = tt.root
594
 
                for part in parts[1:-1]:
595
 
                    trans_id = tt.new_directory(part, trans_id)
596
 
                tt.new_file(
597
 
                    parts[-1], trans_id, new_contents,
598
 
                    file_id=gen_file_id(newname))
599
 
            else:
600
 
                tt.create_file(new_contents, trans_id)
601
 
 
602
 
 
603
 
class AppliedPatches(object):
604
 
    """Context that provides access to a tree with patches applied.
605
 
    """
606
 
 
607
 
    def __init__(self, tree, patches, prefix=1):
608
 
        self.tree = tree
609
 
        self.patches = patches
610
 
        self.prefix = prefix
611
 
 
612
 
    def __enter__(self):
613
 
        self._tt = self.tree.preview_transform()
614
 
        apply_patches(self._tt, self.patches, prefix=self.prefix)
615
 
        return self._tt.get_preview_tree()
616
 
 
617
 
    def __exit__(self, exc_type, exc_value, exc_tb):
618
 
        self._tt.finalize()
619
 
        return False