/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 bzrlib/merge.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2010-01-14 00:01:32 UTC
  • mfrom: (4957.1.1 jam-integration)
  • Revision ID: pqm@pqm.ubuntu.com-20100114000132-3p3rabnonjw3gzqb
(jam) Merge bzr.stable, bringing in bug fixes #175839, #504390

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
 
94
72
        self.show_base = False
95
73
        self.reprocess = False
96
74
        if pb is None:
97
 
            pb = DummyProgress()
 
75
            pb = progress.DummyProgress()
98
76
        self._pb = pb
99
77
        self.pp = None
100
78
        self.recurse = recurse
184
162
                base_revision_id, tree.branch.last_revision())):
185
163
                base_revision_id = None
186
164
            else:
187
 
                warning('Performing cherrypick')
 
165
                trace.warning('Performing cherrypick')
188
166
        merger = klass.from_revision_ids(pb, tree, other_revision_id,
189
167
                                         base_revision_id, revision_graph=
190
168
                                         revision_graph)
242
220
        if revno is None:
243
221
            tree = workingtree.WorkingTree.open_containing(location)[0]
244
222
            return tree.branch, tree
245
 
        branch = Branch.open_containing(location, possible_transports)[0]
 
223
        branch = _mod_branch.Branch.open_containing(
 
224
            location, possible_transports)[0]
246
225
        if revno == -1:
247
226
            revision_id = branch.last_revision()
248
227
        else:
249
228
            revision_id = branch.get_rev_id(revno)
250
 
        revision_id = ensure_null(revision_id)
 
229
        revision_id = _mod_revision.ensure_null(revision_id)
251
230
        return branch, self.revision_tree(revision_id, branch)
252
231
 
 
232
    @deprecated_method(deprecated_in((2, 1, 0)))
253
233
    def ensure_revision_trees(self):
254
234
        if self.this_revision_tree is None:
255
235
            self.this_basis_tree = self.revision_tree(self.this_basis)
259
239
        if self.other_rev_id is None:
260
240
            other_basis_tree = self.revision_tree(self.other_basis)
261
241
            if other_basis_tree.has_changes(self.other_tree):
262
 
                raise WorkingTreeNotRevision(self.this_tree)
 
242
                raise errors.WorkingTreeNotRevision(self.this_tree)
263
243
            other_rev_id = self.other_basis
264
244
            self.other_tree = other_basis_tree
265
245
 
 
246
    @deprecated_method(deprecated_in((2, 1, 0)))
266
247
    def file_revisions(self, file_id):
267
248
        self.ensure_revision_trees()
268
249
        def get_id(tree, file_id):
271
252
        if self.this_rev_id is None:
272
253
            if self.this_basis_tree.get_file_sha1(file_id) != \
273
254
                self.this_tree.get_file_sha1(file_id):
274
 
                raise WorkingTreeNotRevision(self.this_tree)
 
255
                raise errors.WorkingTreeNotRevision(self.this_tree)
275
256
 
276
257
        trees = (self.this_basis_tree, self.other_tree)
277
258
        return [get_id(tree, file_id) for tree in trees]
278
259
 
 
260
    @deprecated_method(deprecated_in((2, 1, 0)))
279
261
    def check_basis(self, check_clean, require_commits=True):
280
262
        if self.this_basis is None and require_commits is True:
281
 
            raise BzrCommandError("This branch has no commits."
282
 
                                  " (perhaps you would prefer 'bzr pull')")
 
263
            raise errors.BzrCommandError(
 
264
                "This branch has no commits."
 
265
                " (perhaps you would prefer 'bzr pull')")
283
266
        if check_clean:
284
267
            self.compare_basis()
285
268
            if self.this_basis != self.this_rev_id:
286
269
                raise errors.UncommittedChanges(self.this_tree)
287
270
 
 
271
    @deprecated_method(deprecated_in((2, 1, 0)))
288
272
    def compare_basis(self):
289
273
        try:
290
274
            basis_tree = self.revision_tree(self.this_tree.last_revision())
297
281
        self.interesting_files = file_list
298
282
 
299
283
    def set_pending(self):
300
 
        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):
301
286
            return
302
287
        self._add_parent()
303
288
 
333
318
            self.other_rev_id = _mod_revision.ensure_null(
334
319
                self.other_branch.last_revision())
335
320
            if _mod_revision.is_null(self.other_rev_id):
336
 
                raise NoCommits(self.other_branch)
 
321
                raise errors.NoCommits(self.other_branch)
337
322
            self.other_basis = self.other_rev_id
338
323
        elif other_revision[1] is not None:
339
324
            self.other_rev_id = self.other_branch.get_rev_id(other_revision[1])
342
327
            self.other_rev_id = None
343
328
            self.other_basis = self.other_branch.last_revision()
344
329
            if self.other_basis is None:
345
 
                raise NoCommits(self.other_branch)
 
330
                raise errors.NoCommits(self.other_branch)
346
331
        if self.other_rev_id is not None:
347
332
            self._cached_trees[self.other_rev_id] = self.other_tree
348
333
        self._maybe_fetch(self.other_branch,self.this_branch, self.other_basis)
375
360
            target.fetch(source, revision_id)
376
361
 
377
362
    def find_base(self):
378
 
        revisions = [ensure_null(self.this_basis),
379
 
                     ensure_null(self.other_basis)]
380
 
        if NULL_REVISION in revisions:
381
 
            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
382
367
            self.base_tree = self.revision_tree(self.base_rev_id)
383
368
            self._is_criss_cross = False
384
369
        else:
385
370
            lcas = self.revision_graph.find_lca(revisions[0], revisions[1])
386
371
            self._is_criss_cross = False
387
372
            if len(lcas) == 0:
388
 
                self.base_rev_id = NULL_REVISION
 
373
                self.base_rev_id = _mod_revision.NULL_REVISION
389
374
            elif len(lcas) == 1:
390
375
                self.base_rev_id = list(lcas)[0]
391
376
            else: # len(lcas) > 1
400
385
                    self.base_rev_id = self.revision_graph.find_unique_lca(
401
386
                                            *lcas)
402
387
                self._is_criss_cross = True
403
 
            if self.base_rev_id == NULL_REVISION:
404
 
                raise UnrelatedBranches()
 
388
            if self.base_rev_id == _mod_revision.NULL_REVISION:
 
389
                raise errors.UnrelatedBranches()
405
390
            if self._is_criss_cross:
406
 
                warning('Warning: criss-cross merge encountered.  See bzr'
407
 
                        ' help criss-cross.')
408
 
                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)
409
394
                interesting_revision_ids = [self.base_rev_id]
410
395
                interesting_revision_ids.extend(lcas)
411
396
                interesting_trees = dict((t.get_revision_id(), t)
421
406
                self.base_tree = self.revision_tree(self.base_rev_id)
422
407
        self.base_is_ancestor = True
423
408
        self.base_is_other_ancestor = True
424
 
        mutter('Base revid: %r' % self.base_rev_id)
 
409
        trace.mutter('Base revid: %r' % self.base_rev_id)
425
410
 
426
411
    def set_base(self, base_revision):
427
412
        """Set the base revision to use for the merge.
428
413
 
429
414
        :param base_revision: A 2-list containing a path and revision number.
430
415
        """
431
 
        mutter("doing merge() with no base_revision specified")
 
416
        trace.mutter("doing merge() with no base_revision specified")
432
417
        if base_revision == [None, None]:
433
418
            self.find_base()
434
419
        else:
454
439
        if self.merge_type.supports_reprocess:
455
440
            kwargs['reprocess'] = self.reprocess
456
441
        elif self.reprocess:
457
 
            raise BzrError("Conflict reduction is not supported for merge"
458
 
                                  " type %s." % self.merge_type)
 
442
            raise errors.BzrError(
 
443
                "Conflict reduction is not supported for merge"
 
444
                " type %s." % self.merge_type)
459
445
        if self.merge_type.supports_show_base:
460
446
            kwargs['show_base'] = self.show_base
461
447
        elif self.show_base:
462
 
            raise BzrError("Showing base is not supported for this"
463
 
                           " merge type. %s" % self.merge_type)
 
448
            raise errors.BzrError("Showing base is not supported for this"
 
449
                                  " merge type. %s" % self.merge_type)
464
450
        if (not getattr(self.merge_type, 'supports_reverse_cherrypick', True)
465
451
            and not self.base_is_other_ancestor):
466
452
            raise errors.CannotReverseCherrypick()
515
501
        finally:
516
502
            self.this_tree.unlock()
517
503
        if len(merge.cooked_conflicts) == 0:
518
 
            if not self.ignore_zero and not is_quiet():
519
 
                note("All changes applied successfully.")
 
504
            if not self.ignore_zero and not trace.is_quiet():
 
505
                trace.note("All changes applied successfully.")
520
506
        else:
521
 
            note("%d conflicts encountered." % len(merge.cooked_conflicts))
 
507
            trace.note("%d conflicts encountered."
 
508
                       % len(merge.cooked_conflicts))
522
509
 
523
510
        return len(merge.cooked_conflicts)
524
511
 
553
540
 
554
541
    def __init__(self, working_tree, this_tree, base_tree, other_tree,
555
542
                 interesting_ids=None, reprocess=False, show_base=False,
556
 
                 pb=DummyProgress(), pp=None, change_reporter=None,
 
543
                 pb=progress.DummyProgress(), pp=None, change_reporter=None,
557
544
                 interesting_files=None, do_merge=True,
558
545
                 cherrypick=False, lca_trees=None):
559
546
        """Initialize the merger object and perform the merge.
605
592
        self.change_reporter = change_reporter
606
593
        self.cherrypick = cherrypick
607
594
        if self.pp is None:
608
 
            self.pp = ProgressPhase("Merge phase", 3, self.pb)
 
595
            self.pp = progress.ProgressPhase("Merge phase", 3, self.pb)
609
596
        if do_merge:
610
597
            self.do_merge()
611
598
 
614
601
        self.base_tree.lock_read()
615
602
        self.other_tree.lock_read()
616
603
        try:
617
 
            self.tt = TreeTransform(self.this_tree, self.pb)
 
604
            self.tt = transform.TreeTransform(self.this_tree, self.pb)
618
605
            try:
619
606
                self.pp.next_phase()
620
607
                self._compute_transform()
623
610
                self.write_modified(results)
624
611
                try:
625
612
                    self.this_tree.add_conflicts(self.cooked_conflicts)
626
 
                except UnsupportedOperation:
 
613
                except errors.UnsupportedOperation:
627
614
                    pass
628
615
            finally:
629
616
                self.tt.finalize()
636
623
    def make_preview_transform(self):
637
624
        self.base_tree.lock_read()
638
625
        self.other_tree.lock_read()
639
 
        self.tt = TransformPreview(self.this_tree)
 
626
        self.tt = transform.TransformPreview(self.this_tree)
640
627
        try:
641
628
            self.pp.next_phase()
642
629
            self._compute_transform()
672
659
        self.pp.next_phase()
673
660
        child_pb = ui.ui_factory.nested_progress_bar()
674
661
        try:
675
 
            fs_conflicts = resolve_conflicts(self.tt, child_pb,
676
 
                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))
677
664
        finally:
678
665
            child_pb.finished()
679
666
        if self.change_reporter is not None:
682
669
                self.tt.iter_changes(), self.change_reporter)
683
670
        self.cook_conflicts(fs_conflicts)
684
671
        for conflict in self.cooked_conflicts:
685
 
            warning(conflict)
 
672
            trace.warning(conflict)
686
673
 
687
674
    def _entries3(self):
688
675
        """Gather data about files modified between three trees.
890
877
    def fix_root(self):
891
878
        try:
892
879
            self.tt.final_kind(self.tt.root)
893
 
        except NoSuchFile:
 
880
        except errors.NoSuchFile:
894
881
            self.tt.cancel_deletion(self.tt.root)
895
882
        if self.tt.final_file_id(self.tt.root) is None:
896
883
            self.tt.version_file(self.tt.tree_file_id(self.tt.root),
903
890
            return
904
891
        try:
905
892
            self.tt.final_kind(other_root)
906
 
        except NoSuchFile:
 
893
        except errors.NoSuchFile:
907
894
            return
908
895
        if self.other_tree.inventory.root.file_id in self.this_tree.inventory:
909
896
            # the other tree's root is a non-root in the current tree
1175
1162
                else:
1176
1163
                    # Skip the id2path lookup for older formats
1177
1164
                    filter_tree_path = None
1178
 
                create_from_tree(self.tt, trans_id,
 
1165
                transform.create_from_tree(self.tt, trans_id,
1179
1166
                                 self.other_tree, file_id,
1180
1167
                                 filter_tree_path=filter_tree_path)
1181
1168
                if not file_in_this:
1194
1181
                # have agreement that output should be a file.
1195
1182
                try:
1196
1183
                    self.text_merge(file_id, trans_id)
1197
 
                except BinaryFile:
 
1184
                except errors.BinaryFile:
1198
1185
                    return contents_conflict()
1199
1186
                if file_id not in self.this_tree:
1200
1187
                    self.tt.version_file(file_id, trans_id)
1201
1188
                try:
1202
1189
                    self.tt.tree_kind(trans_id)
1203
1190
                    self.tt.delete_contents(trans_id)
1204
 
                except NoSuchFile:
 
1191
                except errors.NoSuchFile:
1205
1192
                    pass
1206
1193
                return "modified"
1207
1194
            else:
1225
1212
            base_lines = []
1226
1213
        other_lines = self.get_lines(self.other_tree, file_id)
1227
1214
        this_lines = self.get_lines(self.this_tree, file_id)
1228
 
        m3 = Merge3(base_lines, this_lines, other_lines,
1229
 
                    is_cherrypick=self.cherrypick)
 
1215
        m3 = merge3.Merge3(base_lines, this_lines, other_lines,
 
1216
                           is_cherrypick=self.cherrypick)
1230
1217
        start_marker = "!START OF MERGE CONFLICT!" + "I HOPE THIS IS UNIQUE"
1231
1218
        if self.show_base is True:
1232
1219
            base_marker = '|' * 7
1301
1288
        """Emit a single conflict file."""
1302
1289
        name = name + '.' + suffix
1303
1290
        trans_id = self.tt.create_path(name, parent_id)
1304
 
        create_from_tree(self.tt, trans_id, tree, file_id, lines,
 
1291
        transform.create_from_tree(self.tt, trans_id, tree, file_id, lines,
1305
1292
            filter_tree_path)
1306
1293
        return trans_id
1307
1294
 
1332
1319
        try:
1333
1320
            if self.tt.final_kind(trans_id) != "file":
1334
1321
                return
1335
 
        except NoSuchFile:
 
1322
        except errors.NoSuchFile:
1336
1323
            return
1337
1324
        if winner == "this":
1338
1325
            executability = this_executable
1349
1336
 
1350
1337
    def cook_conflicts(self, fs_conflicts):
1351
1338
        """Convert all conflicts into a form that doesn't depend on trans_id"""
1352
 
        from conflicts import Conflict
1353
1339
        name_conflicts = {}
1354
 
        self.cooked_conflicts.extend(cook_conflicts(fs_conflicts, self.tt))
1355
 
        fp = FinalPaths(self.tt)
 
1340
        self.cooked_conflicts.extend(transform.cook_conflicts(
 
1341
                fs_conflicts, self.tt))
 
1342
        fp = transform.FinalPaths(self.tt)
1356
1343
        for conflict in self._raw_conflicts:
1357
1344
            conflict_type = conflict[0]
1358
1345
            if conflict_type in ('name conflict', 'parent conflict'):
1360
1347
                conflict_args = conflict[2:]
1361
1348
                if trans_id not in name_conflicts:
1362
1349
                    name_conflicts[trans_id] = {}
1363
 
                unique_add(name_conflicts[trans_id], conflict_type,
1364
 
                           conflict_args)
 
1350
                transform.unique_add(name_conflicts[trans_id], conflict_type,
 
1351
                                     conflict_args)
1365
1352
            if conflict_type == 'contents conflict':
1366
1353
                for trans_id in conflict[1]:
1367
1354
                    file_id = self.tt.final_file_id(trans_id)
1372
1359
                    if path.endswith(suffix):
1373
1360
                        path = path[:-len(suffix)]
1374
1361
                        break
1375
 
                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)
1376
1364
                self.cooked_conflicts.append(c)
1377
1365
            if conflict_type == 'text conflict':
1378
1366
                trans_id = conflict[1]
1379
1367
                path = fp.get_path(trans_id)
1380
1368
                file_id = self.tt.final_file_id(trans_id)
1381
 
                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)
1382
1371
                self.cooked_conflicts.append(c)
1383
1372
 
1384
1373
        for trans_id, conflicts in name_conflicts.iteritems():
1399
1388
            if this_parent is not None and this_name is not None:
1400
1389
                this_parent_path = \
1401
1390
                    fp.get_path(self.tt.trans_id_file_id(this_parent))
1402
 
                this_path = pathjoin(this_parent_path, this_name)
 
1391
                this_path = osutils.pathjoin(this_parent_path, this_name)
1403
1392
            else:
1404
1393
                this_path = "<deleted>"
1405
1394
            file_id = self.tt.final_file_id(trans_id)
1406
 
            c = Conflict.factory('path conflict', path=this_path,
1407
 
                                 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)
1408
1398
            self.cooked_conflicts.append(c)
1409
 
        self.cooked_conflicts.sort(key=Conflict.sort_key)
 
1399
        self.cooked_conflicts.sort(key=_mod_conflicts.Conflict.sort_key)
1410
1400
 
1411
1401
 
1412
1402
class WeaveMerger(Merge3Merger):
1416
1406
    supports_reverse_cherrypick = False
1417
1407
    history_based = True
1418
1408
 
1419
 
    def _merged_lines(self, file_id):
1420
 
        """Generate the merged lines.
1421
 
        There is no distinction between lines that are meant to contain <<<<<<<
1422
 
        and conflicts.
1423
 
        """
1424
 
        if self.cherrypick:
1425
 
            base = self.base_tree
1426
 
        else:
1427
 
            base = None
1428
 
        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,
1429
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)
1430
1423
        if 'merge' in debug.debug_flags:
1431
1424
            plan = list(plan)
1432
1425
            trans_id = self.tt.trans_id_file_id(file_id)
1433
1426
            name = self.tt.final_name(trans_id) + '.plan'
1434
 
            contents = ('%10s|%s' % l for l in plan)
 
1427
            contents = ('%11s|%s' % l for l in plan)
1435
1428
            self.tt.new_file(name, self.tt.final_parent(trans_id), contents)
1436
 
        textmerge = PlanWeaveMerge(plan, '<<<<<<< TREE\n',
1437
 
            '>>>>>>> MERGE-SOURCE\n')
1438
 
        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
1439
1437
 
1440
1438
    def text_merge(self, file_id, trans_id):
1441
1439
        """Perform a (weave) text merge for a given file and file-id.
1442
1440
        If conflicts are encountered, .THIS and .OTHER files will be emitted,
1443
1441
        and a conflict will be noted.
1444
1442
        """
1445
 
        lines, conflicts = self._merged_lines(file_id)
 
1443
        lines, base_lines = self._merged_lines(file_id)
1446
1444
        lines = list(lines)
1447
1445
        # Note we're checking whether the OUTPUT is binary in this case,
1448
1446
        # because we don't want to get into weave merge guts.
1449
 
        check_text_lines(lines)
 
1447
        textfile.check_text_lines(lines)
1450
1448
        self.tt.create_file(lines, trans_id)
1451
 
        if conflicts:
 
1449
        if base_lines is not None:
 
1450
            # Conflict
1452
1451
            self._raw_conflicts.append(('text conflict', trans_id))
1453
1452
            name = self.tt.final_name(trans_id)
1454
1453
            parent_id = self.tt.final_parent(trans_id)
1455
1454
            file_group = self._dump_conflicts(name, parent_id, file_id,
1456
 
                                              no_base=True)
 
1455
                                              no_base=False,
 
1456
                                              base_lines=base_lines)
1457
1457
            file_group.append(trans_id)
1458
1458
 
1459
1459
 
1460
1460
class LCAMerger(WeaveMerger):
1461
1461
 
1462
 
    def _merged_lines(self, file_id):
1463
 
        """Generate the merged lines.
1464
 
        There is no distinction between lines that are meant to contain <<<<<<<
1465
 
        and conflicts.
1466
 
        """
1467
 
        if self.cherrypick:
1468
 
            base = self.base_tree
1469
 
        else:
1470
 
            base = None
1471
 
        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,
1472
1464
                                                  base=base)
1473
 
        if 'merge' in debug.debug_flags:
1474
 
            plan = list(plan)
1475
 
            trans_id = self.tt.trans_id_file_id(file_id)
1476
 
            name = self.tt.final_name(trans_id) + '.plan'
1477
 
            contents = ('%10s|%s' % l for l in plan)
1478
 
            self.tt.new_file(name, self.tt.final_parent(trans_id), contents)
1479
 
        textmerge = PlanWeaveMerge(plan, '<<<<<<< TREE\n',
1480
 
            '>>>>>>> MERGE-SOURCE\n')
1481
 
        return textmerge.merge_lines(self.reprocess)
1482
 
 
1483
1465
 
1484
1466
class Diff3Merger(Merge3Merger):
1485
1467
    """Three-way merger using external diff3 for text merging"""
1486
1468
 
1487
1469
    def dump_file(self, temp_dir, name, tree, file_id):
1488
 
        out_path = pathjoin(temp_dir, name)
 
1470
        out_path = osutils.pathjoin(temp_dir, name)
1489
1471
        out_file = open(out_path, "wb")
1490
1472
        try:
1491
1473
            in_file = tree.get_file(file_id)
1503
1485
        import bzrlib.patch
1504
1486
        temp_dir = osutils.mkdtemp(prefix="bzr-")
1505
1487
        try:
1506
 
            new_file = pathjoin(temp_dir, "new")
 
1488
            new_file = osutils.pathjoin(temp_dir, "new")
1507
1489
            this = self.dump_file(temp_dir, "this", self.this_tree, file_id)
1508
1490
            base = self.dump_file(temp_dir, "base", self.base_tree, file_id)
1509
1491
            other = self.dump_file(temp_dir, "other", self.other_tree, file_id)
1510
1492
            status = bzrlib.patch.diff3(new_file, this, base, other)
1511
1493
            if status not in (0, 1):
1512
 
                raise BzrError("Unhandled diff3 exit code")
 
1494
                raise errors.BzrError("Unhandled diff3 exit code")
1513
1495
            f = open(new_file, 'rb')
1514
1496
            try:
1515
1497
                self.tt.create_file(f, trans_id)
1533
1515
                other_rev_id=None,
1534
1516
                interesting_files=None,
1535
1517
                this_tree=None,
1536
 
                pb=DummyProgress(),
 
1518
                pb=progress.DummyProgress(),
1537
1519
                change_reporter=None):
1538
1520
    """Primary interface for merging.
1539
1521
 
1542
1524
                     branch.get_revision_tree(base_revision))'
1543
1525
        """
1544
1526
    if this_tree is None:
1545
 
        raise BzrError("bzrlib.merge.merge_inner requires a this_tree "
1546
 
            "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.")
1547
1529
    merger = Merger(this_branch, other_tree, base_tree, this_tree=this_tree,
1548
1530
                    pb=pb, change_reporter=change_reporter)
1549
1531
    merger.backup_files = backup_files
1767
1749
        super(_PlanMerge, self).__init__(a_rev, b_rev, vf, key_prefix)
1768
1750
        self.a_key = self._key_prefix + (self.a_rev,)
1769
1751
        self.b_key = self._key_prefix + (self.b_rev,)
1770
 
        self.graph = Graph(self.vf)
 
1752
        self.graph = _mod_graph.Graph(self.vf)
1771
1753
        heads = self.graph.heads((self.a_key, self.b_key))
1772
1754
        if len(heads) == 1:
1773
1755
            # one side dominates, so we can just return its values, yay for
1778
1760
                other = b_rev
1779
1761
            else:
1780
1762
                other = a_rev
1781
 
            mutter('found dominating revision for %s\n%s > %s', self.vf,
1782
 
                   self._head_key[-1], other)
 
1763
            trace.mutter('found dominating revision for %s\n%s > %s', self.vf,
 
1764
                         self._head_key[-1], other)
1783
1765
            self._weave = None
1784
1766
        else:
1785
1767
            self._head_key = None
1799
1781
        while True:
1800
1782
            next_lcas = self.graph.find_lca(*cur_ancestors)
1801
1783
            # Map a plain NULL_REVISION to a simple no-ancestors
1802
 
            if next_lcas == set([NULL_REVISION]):
 
1784
            if next_lcas == set([_mod_revision.NULL_REVISION]):
1803
1785
                next_lcas = ()
1804
1786
            # Order the lca's based on when they were merged into the tip
1805
1787
            # While the actual merge portion of weave merge uses a set() of
1817
1799
            elif len(next_lcas) > 2:
1818
1800
                # More than 2 lca's, fall back to grabbing all nodes between
1819
1801
                # this and the unique lca.
1820
 
                mutter('More than 2 LCAs, falling back to all nodes for:'
1821
 
                       ' %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)
1822
1805
                cur_lcas = next_lcas
1823
1806
                while len(cur_lcas) > 1:
1824
1807
                    cur_lcas = self.graph.find_lca(*cur_lcas)
1827
1810
                    unique_lca = None
1828
1811
                else:
1829
1812
                    unique_lca = list(cur_lcas)[0]
1830
 
                    if unique_lca == NULL_REVISION:
 
1813
                    if unique_lca == _mod_revision.NULL_REVISION:
1831
1814
                        # find_lca will return a plain 'NULL_REVISION' rather
1832
1815
                        # than a key tuple when there is no common ancestor, we
1833
1816
                        # prefer to just use None, because it doesn't confuse
1856
1839
            # We remove NULL_REVISION because it isn't a proper tuple key, and
1857
1840
            # thus confuses things like _get_interesting_texts, and our logic
1858
1841
            # to add the texts into the memory weave.
1859
 
            if NULL_REVISION in parent_map:
1860
 
                parent_map.pop(NULL_REVISION)
 
1842
            if _mod_revision.NULL_REVISION in parent_map:
 
1843
                parent_map.pop(_mod_revision.NULL_REVISION)
1861
1844
        else:
1862
1845
            interesting = set()
1863
1846
            for tip in tip_keys:
2015
1998
        lcas = graph.find_lca(key_prefix + (a_rev,), key_prefix + (b_rev,))
2016
1999
        self.lcas = set()
2017
2000
        for lca in lcas:
2018
 
            if lca == NULL_REVISION:
 
2001
            if lca == _mod_revision.NULL_REVISION:
2019
2002
                self.lcas.add(lca)
2020
2003
            else:
2021
2004
                self.lcas.add(lca[-1])