← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/merge.py

  • Committer: Gordon Tyler
  • Date: 2010-01-14 15:24:04 UTC
  • mto: (5037.3.1 integration)
  • mto: This revision was merged to the branch mainline in revision 5046.
  • Revision ID: gordon@doxxx.net-20100114152404-d64ik2afl96lcml0
Reverted changes to test_rules since the original should work now.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/merge.py
15
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
16
 
17
17
 
18
 
import errno
19
 
from itertools import chain
20
 
import os
21
 
import warnings
22
 
 
23
18
from bzrlib import (
 
19
    branch as _mod_branch,
 
20
    conflicts as _mod_conflicts,
24
21
    debug,
25
22
    errors,
26
23
    graph as _mod_graph,
 
24
    merge3,
27
25
    osutils,
28
26
    patiencediff,
29
 
    registry,
 
27
    progress,
30
28
    revision as _mod_revision,
 
29
    textfile,
 
30
    trace,
 
31
    transform,
31
32
    tree as _mod_tree,
32
33
    tsort,
33
 
    )
34
 
from bzrlib.branch import Branch
35
 
from bzrlib.conflicts import ConflictList, Conflict
36
 
from bzrlib.errors import (BzrCommandError,
37
 
                           BzrError,
38
 
                           NoCommonAncestor,
39
 
                           NoCommits,
40
 
                           NoSuchRevision,
41
 
                           NoSuchFile,
42
 
                           NotBranchError,
43
 
                           NotVersionedError,
44
 
                           UnrelatedBranches,
45
 
                           UnsupportedOperation,
46
 
                           WorkingTreeNotRevision,
47
 
                           BinaryFile,
48
 
                           )
49
 
from bzrlib.graph import Graph
50
 
from bzrlib.merge3 import Merge3
51
 
from bzrlib.osutils import rename, pathjoin
52
 
from progress import DummyProgress, ProgressPhase
53
 
from bzrlib.revision import (NULL_REVISION, ensure_null)
54
 
from bzrlib.textfile import check_text_lines
55
 
from bzrlib.trace import mutter, warning, note, is_quiet
56
 
from bzrlib.transform import (TransformPreview, TreeTransform,
57
 
                              resolve_conflicts, cook_conflicts,
58
 
                              conflict_pass, FinalPaths, create_from_tree,
59
 
                              unique_add, ROOT_PARENT)
60
 
from bzrlib.versionedfile import PlanWeaveMerge
61
 
from bzrlib import ui
62
 
 
 
34
    ui,
 
35
    versionedfile
 
36
    )
 
37
from bzrlib.symbol_versioning import (
 
38
    deprecated_in,
 
39
    deprecated_method,
 
40
    )
63
41
# TODO: Report back as changes are merged in
64
42
 
65
43
 
66
44
def transform_tree(from_tree, to_tree, interesting_ids=None):
67
 
    merge_inner(from_tree.branch, to_tree, from_tree, ignore_zero=True,
68
 
                interesting_ids=interesting_ids, this_tree=from_tree)
 
45
    from_tree.lock_tree_write()
 
46
    try:
 
47
        merge_inner(from_tree.branch, to_tree, from_tree, ignore_zero=True,
 
48
                    interesting_ids=interesting_ids, this_tree=from_tree)
 
49
    finally:
 
50
        from_tree.unlock()
69
51
 
70
52
 
71
53
class Merger(object):
90
72
        self.show_base = False
91
73
        self.reprocess = False
92
74
        if pb is None:
93
 
            pb = DummyProgress()
 
75
            pb = progress.DummyProgress()
94
76
        self._pb = pb
95
77
        self.pp = None
96
78
        self.recurse = recurse
102
84
        self._is_criss_cross = None
103
85
        self._lca_trees = None
104
86
 
 
87
    def cache_trees_with_revision_ids(self, trees):
 
88
        """Cache any tree in trees if it has a revision_id."""
 
89
        for maybe_tree in trees:
 
90
            if maybe_tree is None:
 
91
                continue
 
92
            try:
 
93
                rev_id = maybe_tree.get_revision_id()
 
94
            except AttributeError:
 
95
                continue
 
96
            self._cached_trees[rev_id] = maybe_tree
 
97
 
105
98
    @property
106
99
    def revision_graph(self):
107
100
        if self._revision_graph is None:
169
162
                base_revision_id, tree.branch.last_revision())):
170
163
                base_revision_id = None
171
164
            else:
172
 
                warning('Performing cherrypick')
 
165
                trace.warning('Performing cherrypick')
173
166
        merger = klass.from_revision_ids(pb, tree, other_revision_id,
174
167
                                         base_revision_id, revision_graph=
175
168
                                         revision_graph)
227
220
        if revno is None:
228
221
            tree = workingtree.WorkingTree.open_containing(location)[0]
229
222
            return tree.branch, tree
230
 
        branch = Branch.open_containing(location, possible_transports)[0]
 
223
        branch = _mod_branch.Branch.open_containing(
 
224
            location, possible_transports)[0]
231
225
        if revno == -1:
232
226
            revision_id = branch.last_revision()
233
227
        else:
234
228
            revision_id = branch.get_rev_id(revno)
235
 
        revision_id = ensure_null(revision_id)
 
229
        revision_id = _mod_revision.ensure_null(revision_id)
236
230
        return branch, self.revision_tree(revision_id, branch)
237
231
 
 
232
    @deprecated_method(deprecated_in((2, 1, 0)))
238
233
    def ensure_revision_trees(self):
239
234
        if self.this_revision_tree is None:
240
235
            self.this_basis_tree = self.revision_tree(self.this_basis)
243
238
 
244
239
        if self.other_rev_id is None:
245
240
            other_basis_tree = self.revision_tree(self.other_basis)
246
 
            changes = other_basis_tree.changes_from(self.other_tree)
247
 
            if changes.has_changed():
248
 
                raise WorkingTreeNotRevision(self.this_tree)
 
241
            if other_basis_tree.has_changes(self.other_tree):
 
242
                raise errors.WorkingTreeNotRevision(self.this_tree)
249
243
            other_rev_id = self.other_basis
250
244
            self.other_tree = other_basis_tree
251
245
 
 
246
    @deprecated_method(deprecated_in((2, 1, 0)))
252
247
    def file_revisions(self, file_id):
253
248
        self.ensure_revision_trees()
254
249
        def get_id(tree, file_id):
257
252
        if self.this_rev_id is None:
258
253
            if self.this_basis_tree.get_file_sha1(file_id) != \
259
254
                self.this_tree.get_file_sha1(file_id):
260
 
                raise WorkingTreeNotRevision(self.this_tree)
 
255
                raise errors.WorkingTreeNotRevision(self.this_tree)
261
256
 
262
257
        trees = (self.this_basis_tree, self.other_tree)
263
258
        return [get_id(tree, file_id) for tree in trees]
264
259
 
 
260
    @deprecated_method(deprecated_in((2, 1, 0)))
265
261
    def check_basis(self, check_clean, require_commits=True):
266
262
        if self.this_basis is None and require_commits is True:
267
 
            raise BzrCommandError("This branch has no commits."
268
 
                                  " (perhaps you would prefer 'bzr pull')")
 
263
            raise errors.BzrCommandError(
 
264
                "This branch has no commits."
 
265
                " (perhaps you would prefer 'bzr pull')")
269
266
        if check_clean:
270
267
            self.compare_basis()
271
268
            if self.this_basis != self.this_rev_id:
272
269
                raise errors.UncommittedChanges(self.this_tree)
273
270
 
 
271
    @deprecated_method(deprecated_in((2, 1, 0)))
274
272
    def compare_basis(self):
275
273
        try:
276
274
            basis_tree = self.revision_tree(self.this_tree.last_revision())
277
275
        except errors.NoSuchRevision:
278
276
            basis_tree = self.this_tree.basis_tree()
279
 
        changes = self.this_tree.changes_from(basis_tree)
280
 
        if not changes.has_changed():
 
277
        if not self.this_tree.has_changes(basis_tree):
281
278
            self.this_rev_id = self.this_basis
282
279
 
283
280
    def set_interesting_files(self, file_list):
284
281
        self.interesting_files = file_list
285
282
 
286
283
    def set_pending(self):
287
 
        if not self.base_is_ancestor or not self.base_is_other_ancestor or self.other_rev_id is None:
 
284
        if (not self.base_is_ancestor or not self.base_is_other_ancestor
 
285
            or self.other_rev_id is None):
288
286
            return
289
287
        self._add_parent()
290
288
 
320
318
            self.other_rev_id = _mod_revision.ensure_null(
321
319
                self.other_branch.last_revision())
322
320
            if _mod_revision.is_null(self.other_rev_id):
323
 
                raise NoCommits(self.other_branch)
 
321
                raise errors.NoCommits(self.other_branch)
324
322
            self.other_basis = self.other_rev_id
325
323
        elif other_revision[1] is not None:
326
324
            self.other_rev_id = self.other_branch.get_rev_id(other_revision[1])
329
327
            self.other_rev_id = None
330
328
            self.other_basis = self.other_branch.last_revision()
331
329
            if self.other_basis is None:
332
 
                raise NoCommits(self.other_branch)
 
330
                raise errors.NoCommits(self.other_branch)
333
331
        if self.other_rev_id is not None:
334
332
            self._cached_trees[self.other_rev_id] = self.other_tree
335
333
        self._maybe_fetch(self.other_branch,self.this_branch, self.other_basis)
362
360
            target.fetch(source, revision_id)
363
361
 
364
362
    def find_base(self):
365
 
        revisions = [ensure_null(self.this_basis),
366
 
                     ensure_null(self.other_basis)]
367
 
        if NULL_REVISION in revisions:
368
 
            self.base_rev_id = NULL_REVISION
 
363
        revisions = [_mod_revision.ensure_null(self.this_basis),
 
364
                     _mod_revision.ensure_null(self.other_basis)]
 
365
        if _mod_revision.NULL_REVISION in revisions:
 
366
            self.base_rev_id = _mod_revision.NULL_REVISION
369
367
            self.base_tree = self.revision_tree(self.base_rev_id)
370
368
            self._is_criss_cross = False
371
369
        else:
372
370
            lcas = self.revision_graph.find_lca(revisions[0], revisions[1])
373
371
            self._is_criss_cross = False
374
372
            if len(lcas) == 0:
375
 
                self.base_rev_id = NULL_REVISION
 
373
                self.base_rev_id = _mod_revision.NULL_REVISION
376
374
            elif len(lcas) == 1:
377
375
                self.base_rev_id = list(lcas)[0]
378
376
            else: # len(lcas) > 1
387
385
                    self.base_rev_id = self.revision_graph.find_unique_lca(
388
386
                                            *lcas)
389
387
                self._is_criss_cross = True
390
 
            if self.base_rev_id == NULL_REVISION:
391
 
                raise UnrelatedBranches()
 
388
            if self.base_rev_id == _mod_revision.NULL_REVISION:
 
389
                raise errors.UnrelatedBranches()
392
390
            if self._is_criss_cross:
393
 
                warning('Warning: criss-cross merge encountered.  See bzr'
394
 
                        ' help criss-cross.')
395
 
                mutter('Criss-cross lcas: %r' % lcas)
 
391
                trace.warning('Warning: criss-cross merge encountered.  See bzr'
 
392
                              ' help criss-cross.')
 
393
                trace.mutter('Criss-cross lcas: %r' % lcas)
396
394
                interesting_revision_ids = [self.base_rev_id]
397
395
                interesting_revision_ids.extend(lcas)
398
396
                interesting_trees = dict((t.get_revision_id(), t)
408
406
                self.base_tree = self.revision_tree(self.base_rev_id)
409
407
        self.base_is_ancestor = True
410
408
        self.base_is_other_ancestor = True
411
 
        mutter('Base revid: %r' % self.base_rev_id)
 
409
        trace.mutter('Base revid: %r' % self.base_rev_id)
412
410
 
413
411
    def set_base(self, base_revision):
414
412
        """Set the base revision to use for the merge.
415
413
 
416
414
        :param base_revision: A 2-list containing a path and revision number.
417
415
        """
418
 
        mutter("doing merge() with no base_revision specified")
 
416
        trace.mutter("doing merge() with no base_revision specified")
419
417
        if base_revision == [None, None]:
420
418
            self.find_base()
421
419
        else:
441
439
        if self.merge_type.supports_reprocess:
442
440
            kwargs['reprocess'] = self.reprocess
443
441
        elif self.reprocess:
444
 
            raise BzrError("Conflict reduction is not supported for merge"
445
 
                                  " type %s." % self.merge_type)
 
442
            raise errors.BzrError(
 
443
                "Conflict reduction is not supported for merge"
 
444
                " type %s." % self.merge_type)
446
445
        if self.merge_type.supports_show_base:
447
446
            kwargs['show_base'] = self.show_base
448
447
        elif self.show_base:
449
 
            raise BzrError("Showing base is not supported for this"
450
 
                           " merge type. %s" % self.merge_type)
 
448
            raise errors.BzrError("Showing base is not supported for this"
 
449
                                  " merge type. %s" % self.merge_type)
451
450
        if (not getattr(self.merge_type, 'supports_reverse_cherrypick', True)
452
451
            and not self.base_is_other_ancestor):
453
452
            raise errors.CannotReverseCherrypick()
502
501
        finally:
503
502
            self.this_tree.unlock()
504
503
        if len(merge.cooked_conflicts) == 0:
505
 
            if not self.ignore_zero and not is_quiet():
506
 
                note("All changes applied successfully.")
 
504
            if not self.ignore_zero and not trace.is_quiet():
 
505
                trace.note("All changes applied successfully.")
507
506
        else:
508
 
            note("%d conflicts encountered." % len(merge.cooked_conflicts))
 
507
            trace.note("%d conflicts encountered."
 
508
                       % len(merge.cooked_conflicts))
509
509
 
510
510
        return len(merge.cooked_conflicts)
511
511
 
540
540
 
541
541
    def __init__(self, working_tree, this_tree, base_tree, other_tree,
542
542
                 interesting_ids=None, reprocess=False, show_base=False,
543
 
                 pb=DummyProgress(), pp=None, change_reporter=None,
 
543
                 pb=progress.DummyProgress(), pp=None, change_reporter=None,
544
544
                 interesting_files=None, do_merge=True,
545
545
                 cherrypick=False, lca_trees=None):
546
546
        """Initialize the merger object and perform the merge.
592
592
        self.change_reporter = change_reporter
593
593
        self.cherrypick = cherrypick
594
594
        if self.pp is None:
595
 
            self.pp = ProgressPhase("Merge phase", 3, self.pb)
 
595
            self.pp = progress.ProgressPhase("Merge phase", 3, self.pb)
596
596
        if do_merge:
597
597
            self.do_merge()
598
598
 
600
600
        self.this_tree.lock_tree_write()
601
601
        self.base_tree.lock_read()
602
602
        self.other_tree.lock_read()
603
 
        self.tt = TreeTransform(self.this_tree, self.pb)
604
603
        try:
605
 
            self.pp.next_phase()
606
 
            self._compute_transform()
607
 
            self.pp.next_phase()
608
 
            results = self.tt.apply(no_conflicts=True)
609
 
            self.write_modified(results)
 
604
            self.tt = transform.TreeTransform(self.this_tree, self.pb)
610
605
            try:
611
 
                self.this_tree.add_conflicts(self.cooked_conflicts)
612
 
            except UnsupportedOperation:
613
 
                pass
 
606
                self.pp.next_phase()
 
607
                self._compute_transform()
 
608
                self.pp.next_phase()
 
609
                results = self.tt.apply(no_conflicts=True)
 
610
                self.write_modified(results)
 
611
                try:
 
612
                    self.this_tree.add_conflicts(self.cooked_conflicts)
 
613
                except errors.UnsupportedOperation:
 
614
                    pass
 
615
            finally:
 
616
                self.tt.finalize()
614
617
        finally:
615
 
            self.tt.finalize()
616
618
            self.other_tree.unlock()
617
619
            self.base_tree.unlock()
618
620
            self.this_tree.unlock()
621
623
    def make_preview_transform(self):
622
624
        self.base_tree.lock_read()
623
625
        self.other_tree.lock_read()
624
 
        self.tt = TransformPreview(self.this_tree)
 
626
        self.tt = transform.TransformPreview(self.this_tree)
625
627
        try:
626
628
            self.pp.next_phase()
627
629
            self._compute_transform()
657
659
        self.pp.next_phase()
658
660
        child_pb = ui.ui_factory.nested_progress_bar()
659
661
        try:
660
 
            fs_conflicts = resolve_conflicts(self.tt, child_pb,
661
 
                lambda t, c: conflict_pass(t, c, self.other_tree))
 
662
            fs_conflicts = transform.resolve_conflicts(self.tt, child_pb,
 
663
                lambda t, c: transform.conflict_pass(t, c, self.other_tree))
662
664
        finally:
663
665
            child_pb.finished()
664
666
        if self.change_reporter is not None:
667
669
                self.tt.iter_changes(), self.change_reporter)
668
670
        self.cook_conflicts(fs_conflicts)
669
671
        for conflict in self.cooked_conflicts:
670
 
            warning(conflict)
 
672
            trace.warning(conflict)
671
673
 
672
674
    def _entries3(self):
673
675
        """Gather data about files modified between three trees.
875
877
    def fix_root(self):
876
878
        try:
877
879
            self.tt.final_kind(self.tt.root)
878
 
        except NoSuchFile:
 
880
        except errors.NoSuchFile:
879
881
            self.tt.cancel_deletion(self.tt.root)
880
882
        if self.tt.final_file_id(self.tt.root) is None:
881
883
            self.tt.version_file(self.tt.tree_file_id(self.tt.root),
888
890
            return
889
891
        try:
890
892
            self.tt.final_kind(other_root)
891
 
        except NoSuchFile:
 
893
        except errors.NoSuchFile:
892
894
            return
893
895
        if self.other_tree.inventory.root.file_id in self.this_tree.inventory:
894
896
            # the other tree's root is a non-root in the current tree
1147
1149
                self.tt.delete_contents(trans_id)
1148
1150
            if file_id in self.other_tree:
1149
1151
                # OTHER changed the file
1150
 
                create_from_tree(self.tt, trans_id,
1151
 
                                 self.other_tree, file_id)
 
1152
                wt = self.this_tree
 
1153
                if wt.supports_content_filtering():
 
1154
                    # We get the path from the working tree if it exists.
 
1155
                    # That fails though when OTHER is adding a file, so
 
1156
                    # we fall back to the other tree to find the path if
 
1157
                    # it doesn't exist locally.
 
1158
                    try:
 
1159
                        filter_tree_path = wt.id2path(file_id)
 
1160
                    except errors.NoSuchId:
 
1161
                        filter_tree_path = self.other_tree.id2path(file_id)
 
1162
                else:
 
1163
                    # Skip the id2path lookup for older formats
 
1164
                    filter_tree_path = None
 
1165
                transform.create_from_tree(self.tt, trans_id,
 
1166
                                 self.other_tree, file_id,
 
1167
                                 filter_tree_path=filter_tree_path)
1152
1168
                if not file_in_this:
1153
1169
                    self.tt.version_file(file_id, trans_id)
1154
1170
                return "modified"
1165
1181
                # have agreement that output should be a file.
1166
1182
                try:
1167
1183
                    self.text_merge(file_id, trans_id)
1168
 
                except BinaryFile:
 
1184
                except errors.BinaryFile:
1169
1185
                    return contents_conflict()
1170
1186
                if file_id not in self.this_tree:
1171
1187
                    self.tt.version_file(file_id, trans_id)
1172
1188
                try:
1173
1189
                    self.tt.tree_kind(trans_id)
1174
1190
                    self.tt.delete_contents(trans_id)
1175
 
                except NoSuchFile:
 
1191
                except errors.NoSuchFile:
1176
1192
                    pass
1177
1193
                return "modified"
1178
1194
            else:
1196
1212
            base_lines = []
1197
1213
        other_lines = self.get_lines(self.other_tree, file_id)
1198
1214
        this_lines = self.get_lines(self.this_tree, file_id)
1199
 
        m3 = Merge3(base_lines, this_lines, other_lines,
1200
 
                    is_cherrypick=self.cherrypick)
 
1215
        m3 = merge3.Merge3(base_lines, this_lines, other_lines,
 
1216
                           is_cherrypick=self.cherrypick)
1201
1217
        start_marker = "!START OF MERGE CONFLICT!" + "I HOPE THIS IS UNIQUE"
1202
1218
        if self.show_base is True:
1203
1219
            base_marker = '|' * 7
1241
1257
                ('THIS', self.this_tree, this_lines)]
1242
1258
        if not no_base:
1243
1259
            data.append(('BASE', self.base_tree, base_lines))
 
1260
 
 
1261
        # We need to use the actual path in the working tree of the file here,
 
1262
        # ignoring the conflict suffixes
 
1263
        wt = self.this_tree
 
1264
        if wt.supports_content_filtering():
 
1265
            try:
 
1266
                filter_tree_path = wt.id2path(file_id)
 
1267
            except errors.NoSuchId:
 
1268
                # file has been deleted
 
1269
                filter_tree_path = None
 
1270
        else:
 
1271
            # Skip the id2path lookup for older formats
 
1272
            filter_tree_path = None
 
1273
 
1244
1274
        versioned = False
1245
1275
        file_group = []
1246
1276
        for suffix, tree, lines in data:
1247
1277
            if file_id in tree:
1248
1278
                trans_id = self._conflict_file(name, parent_id, tree, file_id,
1249
 
                                               suffix, lines)
 
1279
                                               suffix, lines, filter_tree_path)
1250
1280
                file_group.append(trans_id)
1251
1281
                if set_version and not versioned:
1252
1282
                    self.tt.version_file(file_id, trans_id)
1254
1284
        return file_group
1255
1285
 
1256
1286
    def _conflict_file(self, name, parent_id, tree, file_id, suffix,
1257
 
                       lines=None):
 
1287
                       lines=None, filter_tree_path=None):
1258
1288
        """Emit a single conflict file."""
1259
1289
        name = name + '.' + suffix
1260
1290
        trans_id = self.tt.create_path(name, parent_id)
1261
 
        create_from_tree(self.tt, trans_id, tree, file_id, lines)
 
1291
        transform.create_from_tree(self.tt, trans_id, tree, file_id, lines,
 
1292
            filter_tree_path)
1262
1293
        return trans_id
1263
1294
 
1264
1295
    def merge_executable(self, file_id, file_status):
1288
1319
        try:
1289
1320
            if self.tt.final_kind(trans_id) != "file":
1290
1321
                return
1291
 
        except NoSuchFile:
 
1322
        except errors.NoSuchFile:
1292
1323
            return
1293
1324
        if winner == "this":
1294
1325
            executability = this_executable
1305
1336
 
1306
1337
    def cook_conflicts(self, fs_conflicts):
1307
1338
        """Convert all conflicts into a form that doesn't depend on trans_id"""
1308
 
        from conflicts import Conflict
1309
1339
        name_conflicts = {}
1310
 
        self.cooked_conflicts.extend(cook_conflicts(fs_conflicts, self.tt))
1311
 
        fp = FinalPaths(self.tt)
 
1340
        self.cooked_conflicts.extend(transform.cook_conflicts(
 
1341
                fs_conflicts, self.tt))
 
1342
        fp = transform.FinalPaths(self.tt)
1312
1343
        for conflict in self._raw_conflicts:
1313
1344
            conflict_type = conflict[0]
1314
1345
            if conflict_type in ('name conflict', 'parent conflict'):
1316
1347
                conflict_args = conflict[2:]
1317
1348
                if trans_id not in name_conflicts:
1318
1349
                    name_conflicts[trans_id] = {}
1319
 
                unique_add(name_conflicts[trans_id], conflict_type,
1320
 
                           conflict_args)
 
1350
                transform.unique_add(name_conflicts[trans_id], conflict_type,
 
1351
                                     conflict_args)
1321
1352
            if conflict_type == 'contents conflict':
1322
1353
                for trans_id in conflict[1]:
1323
1354
                    file_id = self.tt.final_file_id(trans_id)
1328
1359
                    if path.endswith(suffix):
1329
1360
                        path = path[:-len(suffix)]
1330
1361
                        break
1331
 
                c = Conflict.factory(conflict_type, path=path, file_id=file_id)
 
1362
                c = _mod_conflicts.Conflict.factory(conflict_type,
 
1363
                                                    path=path, file_id=file_id)
1332
1364
                self.cooked_conflicts.append(c)
1333
1365
            if conflict_type == 'text conflict':
1334
1366
                trans_id = conflict[1]
1335
1367
                path = fp.get_path(trans_id)
1336
1368
                file_id = self.tt.final_file_id(trans_id)
1337
 
                c = Conflict.factory(conflict_type, path=path, file_id=file_id)
 
1369
                c = _mod_conflicts.Conflict.factory(conflict_type,
 
1370
                                                    path=path, file_id=file_id)
1338
1371
                self.cooked_conflicts.append(c)
1339
1372
 
1340
1373
        for trans_id, conflicts in name_conflicts.iteritems():
1355
1388
            if this_parent is not None and this_name is not None:
1356
1389
                this_parent_path = \
1357
1390
                    fp.get_path(self.tt.trans_id_file_id(this_parent))
1358
 
                this_path = pathjoin(this_parent_path, this_name)
 
1391
                this_path = osutils.pathjoin(this_parent_path, this_name)
1359
1392
            else:
1360
1393
                this_path = "<deleted>"
1361
1394
            file_id = self.tt.final_file_id(trans_id)
1362
 
            c = Conflict.factory('path conflict', path=this_path,
1363
 
                                 conflict_path=other_path, file_id=file_id)
 
1395
            c = _mod_conflicts.Conflict.factory('path conflict', path=this_path,
 
1396
                                                conflict_path=other_path,
 
1397
                                                file_id=file_id)
1364
1398
            self.cooked_conflicts.append(c)
1365
 
        self.cooked_conflicts.sort(key=Conflict.sort_key)
 
1399
        self.cooked_conflicts.sort(key=_mod_conflicts.Conflict.sort_key)
1366
1400
 
1367
1401
 
1368
1402
class WeaveMerger(Merge3Merger):
1372
1406
    supports_reverse_cherrypick = False
1373
1407
    history_based = True
1374
1408
 
1375
 
    def _merged_lines(self, file_id):
1376
 
        """Generate the merged lines.
1377
 
        There is no distinction between lines that are meant to contain <<<<<<<
1378
 
        and conflicts.
1379
 
        """
1380
 
        if self.cherrypick:
1381
 
            base = self.base_tree
1382
 
        else:
1383
 
            base = None
1384
 
        plan = self.this_tree.plan_file_merge(file_id, self.other_tree,
 
1409
    def _generate_merge_plan(self, file_id, base):
 
1410
        return self.this_tree.plan_file_merge(file_id, self.other_tree,
1385
1411
                                              base=base)
 
1412
 
 
1413
    def _merged_lines(self, file_id):
 
1414
        """Generate the merged lines.
 
1415
        There is no distinction between lines that are meant to contain <<<<<<<
 
1416
        and conflicts.
 
1417
        """
 
1418
        if self.cherrypick:
 
1419
            base = self.base_tree
 
1420
        else:
 
1421
            base = None
 
1422
        plan = self._generate_merge_plan(file_id, base)
1386
1423
        if 'merge' in debug.debug_flags:
1387
1424
            plan = list(plan)
1388
1425
            trans_id = self.tt.trans_id_file_id(file_id)
1389
1426
            name = self.tt.final_name(trans_id) + '.plan'
1390
 
            contents = ('%10s|%s' % l for l in plan)
 
1427
            contents = ('%11s|%s' % l for l in plan)
1391
1428
            self.tt.new_file(name, self.tt.final_parent(trans_id), contents)
1392
 
        textmerge = PlanWeaveMerge(plan, '<<<<<<< TREE\n',
1393
 
            '>>>>>>> MERGE-SOURCE\n')
1394
 
        return textmerge.merge_lines(self.reprocess)
 
1429
        textmerge = versionedfile.PlanWeaveMerge(plan, '<<<<<<< TREE\n',
 
1430
                                                 '>>>>>>> MERGE-SOURCE\n')
 
1431
        lines, conflicts = textmerge.merge_lines(self.reprocess)
 
1432
        if conflicts:
 
1433
            base_lines = textmerge.base_from_plan()
 
1434
        else:
 
1435
            base_lines = None
 
1436
        return lines, base_lines
1395
1437
 
1396
1438
    def text_merge(self, file_id, trans_id):
1397
1439
        """Perform a (weave) text merge for a given file and file-id.
1398
1440
        If conflicts are encountered, .THIS and .OTHER files will be emitted,
1399
1441
        and a conflict will be noted.
1400
1442
        """
1401
 
        lines, conflicts = self._merged_lines(file_id)
 
1443
        lines, base_lines = self._merged_lines(file_id)
1402
1444
        lines = list(lines)
1403
1445
        # Note we're checking whether the OUTPUT is binary in this case,
1404
1446
        # because we don't want to get into weave merge guts.
1405
 
        check_text_lines(lines)
 
1447
        textfile.check_text_lines(lines)
1406
1448
        self.tt.create_file(lines, trans_id)
1407
 
        if conflicts:
 
1449
        if base_lines is not None:
 
1450
            # Conflict
1408
1451
            self._raw_conflicts.append(('text conflict', trans_id))
1409
1452
            name = self.tt.final_name(trans_id)
1410
1453
            parent_id = self.tt.final_parent(trans_id)
1411
1454
            file_group = self._dump_conflicts(name, parent_id, file_id,
1412
 
                                              no_base=True)
 
1455
                                              no_base=False,
 
1456
                                              base_lines=base_lines)
1413
1457
            file_group.append(trans_id)
1414
1458
 
1415
1459
 
1416
1460
class LCAMerger(WeaveMerger):
1417
1461
 
1418
 
    def _merged_lines(self, file_id):
1419
 
        """Generate the merged lines.
1420
 
        There is no distinction between lines that are meant to contain <<<<<<<
1421
 
        and conflicts.
1422
 
        """
1423
 
        if self.cherrypick:
1424
 
            base = self.base_tree
1425
 
        else:
1426
 
            base = None
1427
 
        plan = self.this_tree.plan_file_lca_merge(file_id, self.other_tree,
 
1462
    def _generate_merge_plan(self, file_id, base):
 
1463
        return self.this_tree.plan_file_lca_merge(file_id, self.other_tree,
1428
1464
                                                  base=base)
1429
 
        if 'merge' in debug.debug_flags:
1430
 
            plan = list(plan)
1431
 
            trans_id = self.tt.trans_id_file_id(file_id)
1432
 
            name = self.tt.final_name(trans_id) + '.plan'
1433
 
            contents = ('%10s|%s' % l for l in plan)
1434
 
            self.tt.new_file(name, self.tt.final_parent(trans_id), contents)
1435
 
        textmerge = PlanWeaveMerge(plan, '<<<<<<< TREE\n',
1436
 
            '>>>>>>> MERGE-SOURCE\n')
1437
 
        return textmerge.merge_lines(self.reprocess)
1438
 
 
1439
1465
 
1440
1466
class Diff3Merger(Merge3Merger):
1441
1467
    """Three-way merger using external diff3 for text merging"""
1442
1468
 
1443
1469
    def dump_file(self, temp_dir, name, tree, file_id):
1444
 
        out_path = pathjoin(temp_dir, name)
 
1470
        out_path = osutils.pathjoin(temp_dir, name)
1445
1471
        out_file = open(out_path, "wb")
1446
1472
        try:
1447
1473
            in_file = tree.get_file(file_id)
1459
1485
        import bzrlib.patch
1460
1486
        temp_dir = osutils.mkdtemp(prefix="bzr-")
1461
1487
        try:
1462
 
            new_file = pathjoin(temp_dir, "new")
 
1488
            new_file = osutils.pathjoin(temp_dir, "new")
1463
1489
            this = self.dump_file(temp_dir, "this", self.this_tree, file_id)
1464
1490
            base = self.dump_file(temp_dir, "base", self.base_tree, file_id)
1465
1491
            other = self.dump_file(temp_dir, "other", self.other_tree, file_id)
1466
1492
            status = bzrlib.patch.diff3(new_file, this, base, other)
1467
1493
            if status not in (0, 1):
1468
 
                raise BzrError("Unhandled diff3 exit code")
 
1494
                raise errors.BzrError("Unhandled diff3 exit code")
1469
1495
            f = open(new_file, 'rb')
1470
1496
            try:
1471
1497
                self.tt.create_file(f, trans_id)
1489
1515
                other_rev_id=None,
1490
1516
                interesting_files=None,
1491
1517
                this_tree=None,
1492
 
                pb=DummyProgress(),
 
1518
                pb=progress.DummyProgress(),
1493
1519
                change_reporter=None):
1494
1520
    """Primary interface for merging.
1495
1521
 
1498
1524
                     branch.get_revision_tree(base_revision))'
1499
1525
        """
1500
1526
    if this_tree is None:
1501
 
        raise BzrError("bzrlib.merge.merge_inner requires a this_tree "
1502
 
            "parameter as of bzrlib version 0.8.")
 
1527
        raise errors.BzrError("bzrlib.merge.merge_inner requires a this_tree "
 
1528
                              "parameter as of bzrlib version 0.8.")
1503
1529
    merger = Merger(this_branch, other_tree, base_tree, this_tree=this_tree,
1504
1530
                    pb=pb, change_reporter=change_reporter)
1505
1531
    merger.backup_files = backup_files
1518
1544
    get_revision_id = getattr(base_tree, 'get_revision_id', None)
1519
1545
    if get_revision_id is None:
1520
1546
        get_revision_id = base_tree.last_revision
 
1547
    merger.cache_trees_with_revision_ids([other_tree, base_tree, this_tree])
1521
1548
    merger.set_base_revision(get_revision_id(), this_branch)
1522
1549
    return merger.do_merge()
1523
1550
 
1722
1749
        super(_PlanMerge, self).__init__(a_rev, b_rev, vf, key_prefix)
1723
1750
        self.a_key = self._key_prefix + (self.a_rev,)
1724
1751
        self.b_key = self._key_prefix + (self.b_rev,)
1725
 
        self.graph = Graph(self.vf)
 
1752
        self.graph = _mod_graph.Graph(self.vf)
1726
1753
        heads = self.graph.heads((self.a_key, self.b_key))
1727
1754
        if len(heads) == 1:
1728
1755
            # one side dominates, so we can just return its values, yay for
1733
1760
                other = b_rev
1734
1761
            else:
1735
1762
                other = a_rev
1736
 
            mutter('found dominating revision for %s\n%s > %s', self.vf,
1737
 
                   self._head_key[-1], other)
 
1763
            trace.mutter('found dominating revision for %s\n%s > %s', self.vf,
 
1764
                         self._head_key[-1], other)
1738
1765
            self._weave = None
1739
1766
        else:
1740
1767
            self._head_key = None
1754
1781
        while True:
1755
1782
            next_lcas = self.graph.find_lca(*cur_ancestors)
1756
1783
            # Map a plain NULL_REVISION to a simple no-ancestors
1757
 
            if next_lcas == set([NULL_REVISION]):
 
1784
            if next_lcas == set([_mod_revision.NULL_REVISION]):
1758
1785
                next_lcas = ()
1759
1786
            # Order the lca's based on when they were merged into the tip
1760
1787
            # While the actual merge portion of weave merge uses a set() of
1772
1799
            elif len(next_lcas) > 2:
1773
1800
                # More than 2 lca's, fall back to grabbing all nodes between
1774
1801
                # this and the unique lca.
1775
 
                mutter('More than 2 LCAs, falling back to all nodes for:'
1776
 
                       ' %s, %s\n=> %s', self.a_key, self.b_key, cur_ancestors)
 
1802
                trace.mutter('More than 2 LCAs, falling back to all nodes for:'
 
1803
                             ' %s, %s\n=> %s',
 
1804
                             self.a_key, self.b_key, cur_ancestors)
1777
1805
                cur_lcas = next_lcas
1778
1806
                while len(cur_lcas) > 1:
1779
1807
                    cur_lcas = self.graph.find_lca(*cur_lcas)
1782
1810
                    unique_lca = None
1783
1811
                else:
1784
1812
                    unique_lca = list(cur_lcas)[0]
1785
 
                    if unique_lca == NULL_REVISION:
 
1813
                    if unique_lca == _mod_revision.NULL_REVISION:
1786
1814
                        # find_lca will return a plain 'NULL_REVISION' rather
1787
1815
                        # than a key tuple when there is no common ancestor, we
1788
1816
                        # prefer to just use None, because it doesn't confuse
1811
1839
            # We remove NULL_REVISION because it isn't a proper tuple key, and
1812
1840
            # thus confuses things like _get_interesting_texts, and our logic
1813
1841
            # to add the texts into the memory weave.
1814
 
            if NULL_REVISION in parent_map:
1815
 
                parent_map.pop(NULL_REVISION)
 
1842
            if _mod_revision.NULL_REVISION in parent_map:
 
1843
                parent_map.pop(_mod_revision.NULL_REVISION)
1816
1844
        else:
1817
1845
            interesting = set()
1818
1846
            for tip in tip_keys:
1970
1998
        lcas = graph.find_lca(key_prefix + (a_rev,), key_prefix + (b_rev,))
1971
1999
        self.lcas = set()
1972
2000
        for lca in lcas:
1973
 
            if lca == NULL_REVISION:
 
2001
            if lca == _mod_revision.NULL_REVISION:
1974
2002
                self.lcas.add(lca)
1975
2003
            else:
1976
2004
                self.lcas.add(lca[-1])