← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/merge3.py

  • Committer: Martin Pool
  • Date: 2006-03-21 12:26:54 UTC
  • mto: This revision was merged to the branch mainline in revision 1621.
  • Revision ID: mbp@sourcefrog.net-20060321122654-514047ed65795a17
New developer commands 'weave-list' and 'weave-join'.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/merge3.py
1
 
# Copyright (C) 2004, 2005 Canonical Ltd
2
 
#
 
1
# Copyright (C) 2004, 2005 by Canonical Ltd
 
2
 
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
5
5
# the Free Software Foundation; either version 2 of the License, or
6
6
# (at your option) any later version.
7
 
#
 
7
 
8
8
# This program is distributed in the hope that it will be useful,
9
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
11
11
# GNU General Public License for more details.
12
 
#
 
12
 
13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
19
19
# s: "i hate that."
20
20
 
21
21
 
 
22
from difflib import SequenceMatcher
22
23
from bzrlib.errors import CantReprocessAndShowBase
23
 
import bzrlib.patiencediff
24
 
from bzrlib.textfile import check_text_lines
25
 
 
26
24
 
27
25
def intersect(ra, rb):
28
26
    """Given two ranges return the range where they intersect or None.
68
66
    incorporating the changes from both BASE->OTHER and BASE->THIS.
69
67
    All three will typically be sequences of lines."""
70
68
    def __init__(self, base, a, b):
71
 
        check_text_lines(base)
72
 
        check_text_lines(a)
73
 
        check_text_lines(b)
74
69
        self.base = base
75
70
        self.a = a
76
71
        self.b = b
88
83
                    reprocess=False):
89
84
        """Return merge in cvs-like form.
90
85
        """
91
 
        newline = '\n'
92
 
        if len(self.a) > 0:
93
 
            if self.a[0].endswith('\r\n'):
94
 
                newline = '\r\n'
95
 
            elif self.a[0].endswith('\r'):
96
 
                newline = '\r'
97
86
        if base_marker and reprocess:
98
87
            raise CantReprocessAndShowBase()
99
88
        if name_a:
117
106
                for i in range(t[1], t[2]):
118
107
                    yield self.b[i]
119
108
            elif what == 'conflict':
120
 
                yield start_marker + newline
 
109
                yield start_marker + '\n'
121
110
                for i in range(t[3], t[4]):
122
111
                    yield self.a[i]
123
112
                if base_marker is not None:
124
 
                    yield base_marker + newline
 
113
                    yield base_marker + '\n'
125
114
                    for i in range(t[1], t[2]):
126
115
                        yield self.base[i]
127
 
                yield mid_marker + newline
 
116
                yield mid_marker + '\n'
128
117
                for i in range(t[5], t[6]):
129
118
                    yield self.b[i]
130
 
                yield end_marker + newline
 
119
                yield end_marker + '\n'
131
120
            else:
132
121
                raise ValueError(what)
133
122
        
300
289
            type, iz, zmatch, ia, amatch, ib, bmatch = region
301
290
            a_region = self.a[ia:amatch]
302
291
            b_region = self.b[ib:bmatch]
303
 
            matches = bzrlib.patiencediff.PatienceSequenceMatcher(
304
 
                    None, a_region, b_region).get_matching_blocks()
 
292
            matches = SequenceMatcher(None, a_region, 
 
293
                                      b_region).get_matching_blocks()
305
294
            next_a = ia
306
295
            next_b = ib
307
296
            for region_ia, region_ib, region_len in matches[:-1]:
333
322
        """
334
323
 
335
324
        ia = ib = 0
336
 
        amatches = bzrlib.patiencediff.PatienceSequenceMatcher(
337
 
                None, self.base, self.a).get_matching_blocks()
338
 
        bmatches = bzrlib.patiencediff.PatienceSequenceMatcher(
339
 
                None, self.base, self.b).get_matching_blocks()
 
325
        amatches = SequenceMatcher(None, self.base, self.a).get_matching_blocks()
 
326
        bmatches = SequenceMatcher(None, self.base, self.b).get_matching_blocks()
340
327
        len_a = len(amatches)
341
328
        len_b = len(bmatches)
342
329
 
392
379
 
393
380
    def find_unconflicted(self):
394
381
        """Return a list of ranges in base that are not conflicted."""
395
 
        am = bzrlib.patiencediff.PatienceSequenceMatcher(
396
 
                None, self.base, self.a).get_matching_blocks()
397
 
        bm = bzrlib.patiencediff.PatienceSequenceMatcher(
398
 
                None, self.base, self.b).get_matching_blocks()
 
382
 
 
383
        import re
 
384
 
 
385
        # don't sync-up on lines containing only blanks or pounds
 
386
        junk_re = re.compile(r'^[ \t#]*$')
 
387
        
 
388
        am = SequenceMatcher(junk_re.match, self.base, self.a).get_matching_blocks()
 
389
        bm = SequenceMatcher(junk_re.match, self.base, self.b).get_matching_blocks()
399
390
 
400
391
        unc = []
401
392