← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/merge3.py

  • Committer: Aaron Bentley
  • Date: 2007-12-12 15:17:13 UTC
  • mto: This revision was merged to the branch mainline in revision 3113.
  • Revision ID: abentley@panoramicfeedback.com-20071212151713-ox5n8rlx8m3nsspy
Add support for reconfiguring repositories into branches or trees

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/merge3.py
1
 
# Copyright (C) 2004, 2005 by Canonical Ltd
2
 
 
 
1
# Copyright (C) 2004, 2005 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
23
22
from bzrlib.errors import CantReprocessAndShowBase
 
23
import bzrlib.patiencediff
 
24
from bzrlib.textfile import check_text_lines
 
25
 
24
26
 
25
27
def intersect(ra, rb):
26
28
    """Given two ranges return the range where they intersect or None.
66
68
    incorporating the changes from both BASE->OTHER and BASE->THIS.
67
69
    All three will typically be sequences of lines."""
68
70
    def __init__(self, base, a, b):
 
71
        check_text_lines(base)
 
72
        check_text_lines(a)
 
73
        check_text_lines(b)
69
74
        self.base = base
70
75
        self.a = a
71
76
        self.b = b
83
88
                    reprocess=False):
84
89
        """Return merge in cvs-like form.
85
90
        """
 
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'
86
97
        if base_marker and reprocess:
87
98
            raise CantReprocessAndShowBase()
88
99
        if name_a:
106
117
                for i in range(t[1], t[2]):
107
118
                    yield self.b[i]
108
119
            elif what == 'conflict':
109
 
                yield start_marker + '\n'
 
120
                yield start_marker + newline
110
121
                for i in range(t[3], t[4]):
111
122
                    yield self.a[i]
112
123
                if base_marker is not None:
113
 
                    yield base_marker + '\n'
 
124
                    yield base_marker + newline
114
125
                    for i in range(t[1], t[2]):
115
126
                        yield self.base[i]
116
 
                yield mid_marker + '\n'
 
127
                yield mid_marker + newline
117
128
                for i in range(t[5], t[6]):
118
129
                    yield self.b[i]
119
 
                yield end_marker + '\n'
 
130
                yield end_marker + newline
120
131
            else:
121
132
                raise ValueError(what)
122
133
        
289
300
            type, iz, zmatch, ia, amatch, ib, bmatch = region
290
301
            a_region = self.a[ia:amatch]
291
302
            b_region = self.b[ib:bmatch]
292
 
            matches = SequenceMatcher(None, a_region, 
293
 
                                      b_region).get_matching_blocks()
 
303
            matches = bzrlib.patiencediff.PatienceSequenceMatcher(
 
304
                    None, a_region, b_region).get_matching_blocks()
294
305
            next_a = ia
295
306
            next_b = ib
296
307
            for region_ia, region_ib, region_len in matches[:-1]:
322
333
        """
323
334
 
324
335
        ia = ib = 0
325
 
        amatches = SequenceMatcher(None, self.base, self.a).get_matching_blocks()
326
 
        bmatches = SequenceMatcher(None, self.base, self.b).get_matching_blocks()
 
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()
327
340
        len_a = len(amatches)
328
341
        len_b = len(bmatches)
329
342
 
379
392
 
380
393
    def find_unconflicted(self):
381
394
        """Return a list of ranges in base that are not conflicted."""
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()
 
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()
390
399
 
391
400
        unc = []
392
401