/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: 2009-12-21 06:03:07 UTC
  • mfrom: (4665.7.3 serve-init)
  • Revision ID: pqm@pqm.ubuntu.com-20091221060307-uvja3vdy1o6dzzy0
(mbp) example debian init script

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
 
613
600
        self.this_tree.lock_tree_write()
614
601
        self.base_tree.lock_read()
615
602
        self.other_tree.lock_read()
616
 
        self.tt = TreeTransform(self.this_tree, self.pb)
617
603
        try:
618
 
            self.pp.next_phase()
619
 
            self._compute_transform()
620
 
            self.pp.next_phase()
621
 
            results = self.tt.apply(no_conflicts=True)
622
 
            self.write_modified(results)
 
604
            self.tt = transform.TreeTransform(self.this_tree, self.pb)
623
605
            try:
624
 
                self.this_tree.add_conflicts(self.cooked_conflicts)
625
 
            except UnsupportedOperation:
626
 
                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()
627
617
        finally:
628
 
            self.tt.finalize()
629
618
            self.other_tree.unlock()
630
619
            self.base_tree.unlock()
631
620
            self.this_tree.unlock()
634
623
    def make_preview_transform(self):
635
624
        self.base_tree.lock_read()
636
625
        self.other_tree.lock_read()
637
 
        self.tt = TransformPreview(self.this_tree)
 
626
        self.tt = transform.TransformPreview(self.this_tree)
638
627
        try:
639
628
            self.pp.next_phase()
640
629
            self._compute_transform()
670
659
        self.pp.next_phase()
671
660
        child_pb = ui.ui_factory.nested_progress_bar()
672
661
        try:
673
 
            fs_conflicts = resolve_conflicts(self.tt, child_pb,
674
 
                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))
675
664
        finally:
676
665
            child_pb.finished()
677
666
        if self.change_reporter is not None:
680
669
                self.tt.iter_changes(), self.change_reporter)
681
670
        self.cook_conflicts(fs_conflicts)
682
671
        for conflict in self.cooked_conflicts:
683
 
            warning(conflict)
 
672
            trace.warning(conflict)
684
673
 
685
674
    def _entries3(self):
686
675
        """Gather data about files modified between three trees.
888
877
    def fix_root(self):
889
878
        try:
890
879
            self.tt.final_kind(self.tt.root)
891
 
        except NoSuchFile:
 
880
        except errors.NoSuchFile:
892
881
            self.tt.cancel_deletion(self.tt.root)
893
882
        if self.tt.final_file_id(self.tt.root) is None:
894
883
            self.tt.version_file(self.tt.tree_file_id(self.tt.root),
901
890
            return
902
891
        try:
903
892
            self.tt.final_kind(other_root)
904
 
        except NoSuchFile:
 
893
        except errors.NoSuchFile:
905
894
            return
906
895
        if self.other_tree.inventory.root.file_id in self.this_tree.inventory:
907
896
            # the other tree's root is a non-root in the current tree
1160
1149
                self.tt.delete_contents(trans_id)
1161
1150
            if file_id in self.other_tree:
1162
1151
                # OTHER changed the file
1163
 
                create_from_tree(self.tt, trans_id,
1164
 
                                 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)
1165
1168
                if not file_in_this:
1166
1169
                    self.tt.version_file(file_id, trans_id)
1167
1170
                return "modified"
1178
1181
                # have agreement that output should be a file.
1179
1182
                try:
1180
1183
                    self.text_merge(file_id, trans_id)
1181
 
                except BinaryFile:
 
1184
                except errors.BinaryFile:
1182
1185
                    return contents_conflict()
1183
1186
                if file_id not in self.this_tree:
1184
1187
                    self.tt.version_file(file_id, trans_id)
1185
1188
                try:
1186
1189
                    self.tt.tree_kind(trans_id)
1187
1190
                    self.tt.delete_contents(trans_id)
1188
 
                except NoSuchFile:
 
1191
                except errors.NoSuchFile:
1189
1192
                    pass
1190
1193
                return "modified"
1191
1194
            else:
1209
1212
            base_lines = []
1210
1213
        other_lines = self.get_lines(self.other_tree, file_id)
1211
1214
        this_lines = self.get_lines(self.this_tree, file_id)
1212
 
        m3 = Merge3(base_lines, this_lines, other_lines,
1213
 
                    is_cherrypick=self.cherrypick)
 
1215
        m3 = merge3.Merge3(base_lines, this_lines, other_lines,
 
1216
                           is_cherrypick=self.cherrypick)
1214
1217
        start_marker = "!START OF MERGE CONFLICT!" + "I HOPE THIS IS UNIQUE"
1215
1218
        if self.show_base is True:
1216
1219
            base_marker = '|' * 7
1254
1257
                ('THIS', self.this_tree, this_lines)]
1255
1258
        if not no_base:
1256
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
 
1257
1274
        versioned = False
1258
1275
        file_group = []
1259
1276
        for suffix, tree, lines in data:
1260
1277
            if file_id in tree:
1261
1278
                trans_id = self._conflict_file(name, parent_id, tree, file_id,
1262
 
                                               suffix, lines)
 
1279
                                               suffix, lines, filter_tree_path)
1263
1280
                file_group.append(trans_id)
1264
1281
                if set_version and not versioned:
1265
1282
                    self.tt.version_file(file_id, trans_id)
1267
1284
        return file_group
1268
1285
 
1269
1286
    def _conflict_file(self, name, parent_id, tree, file_id, suffix,
1270
 
                       lines=None):
 
1287
                       lines=None, filter_tree_path=None):
1271
1288
        """Emit a single conflict file."""
1272
1289
        name = name + '.' + suffix
1273
1290
        trans_id = self.tt.create_path(name, parent_id)
1274
 
        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)
1275
1293
        return trans_id
1276
1294
 
1277
1295
    def merge_executable(self, file_id, file_status):
1301
1319
        try:
1302
1320
            if self.tt.final_kind(trans_id) != "file":
1303
1321
                return
1304
 
        except NoSuchFile:
 
1322
        except errors.NoSuchFile:
1305
1323
            return
1306
1324
        if winner == "this":
1307
1325
            executability = this_executable
1318
1336
 
1319
1337
    def cook_conflicts(self, fs_conflicts):
1320
1338
        """Convert all conflicts into a form that doesn't depend on trans_id"""
1321
 
        from conflicts import Conflict
1322
1339
        name_conflicts = {}
1323
 
        self.cooked_conflicts.extend(cook_conflicts(fs_conflicts, self.tt))
1324
 
        fp = FinalPaths(self.tt)
 
1340
        self.cooked_conflicts.extend(transform.cook_conflicts(
 
1341
                fs_conflicts, self.tt))
 
1342
        fp = transform.FinalPaths(self.tt)
1325
1343
        for conflict in self._raw_conflicts:
1326
1344
            conflict_type = conflict[0]
1327
1345
            if conflict_type in ('name conflict', 'parent conflict'):
1329
1347
                conflict_args = conflict[2:]
1330
1348
                if trans_id not in name_conflicts:
1331
1349
                    name_conflicts[trans_id] = {}
1332
 
                unique_add(name_conflicts[trans_id], conflict_type,
1333
 
                           conflict_args)
 
1350
                transform.unique_add(name_conflicts[trans_id], conflict_type,
 
1351
                                     conflict_args)
1334
1352
            if conflict_type == 'contents conflict':
1335
1353
                for trans_id in conflict[1]:
1336
1354
                    file_id = self.tt.final_file_id(trans_id)
1341
1359
                    if path.endswith(suffix):
1342
1360
                        path = path[:-len(suffix)]
1343
1361
                        break
1344
 
                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)
1345
1364
                self.cooked_conflicts.append(c)
1346
1365
            if conflict_type == 'text conflict':
1347
1366
                trans_id = conflict[1]
1348
1367
                path = fp.get_path(trans_id)
1349
1368
                file_id = self.tt.final_file_id(trans_id)
1350
 
                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)
1351
1371
                self.cooked_conflicts.append(c)
1352
1372
 
1353
1373
        for trans_id, conflicts in name_conflicts.iteritems():
1368
1388
            if this_parent is not None and this_name is not None:
1369
1389
                this_parent_path = \
1370
1390
                    fp.get_path(self.tt.trans_id_file_id(this_parent))
1371
 
                this_path = pathjoin(this_parent_path, this_name)
 
1391
                this_path = osutils.pathjoin(this_parent_path, this_name)
1372
1392
            else:
1373
1393
                this_path = "<deleted>"
1374
1394
            file_id = self.tt.final_file_id(trans_id)
1375
 
            c = Conflict.factory('path conflict', path=this_path,
1376
 
                                 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)
1377
1398
            self.cooked_conflicts.append(c)
1378
 
        self.cooked_conflicts.sort(key=Conflict.sort_key)
 
1399
        self.cooked_conflicts.sort(key=_mod_conflicts.Conflict.sort_key)
1379
1400
 
1380
1401
 
1381
1402
class WeaveMerger(Merge3Merger):
1385
1406
    supports_reverse_cherrypick = False
1386
1407
    history_based = True
1387
1408
 
1388
 
    def _merged_lines(self, file_id):
1389
 
        """Generate the merged lines.
1390
 
        There is no distinction between lines that are meant to contain <<<<<<<
1391
 
        and conflicts.
1392
 
        """
1393
 
        if self.cherrypick:
1394
 
            base = self.base_tree
1395
 
        else:
1396
 
            base = None
1397
 
        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,
1398
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)
1399
1423
        if 'merge' in debug.debug_flags:
1400
1424
            plan = list(plan)
1401
1425
            trans_id = self.tt.trans_id_file_id(file_id)
1402
1426
            name = self.tt.final_name(trans_id) + '.plan'
1403
 
            contents = ('%10s|%s' % l for l in plan)
 
1427
            contents = ('%11s|%s' % l for l in plan)
1404
1428
            self.tt.new_file(name, self.tt.final_parent(trans_id), contents)
1405
 
        textmerge = PlanWeaveMerge(plan, '<<<<<<< TREE\n',
1406
 
            '>>>>>>> MERGE-SOURCE\n')
1407
 
        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
1408
1437
 
1409
1438
    def text_merge(self, file_id, trans_id):
1410
1439
        """Perform a (weave) text merge for a given file and file-id.
1411
1440
        If conflicts are encountered, .THIS and .OTHER files will be emitted,
1412
1441
        and a conflict will be noted.
1413
1442
        """
1414
 
        lines, conflicts = self._merged_lines(file_id)
 
1443
        lines, base_lines = self._merged_lines(file_id)
1415
1444
        lines = list(lines)
1416
1445
        # Note we're checking whether the OUTPUT is binary in this case,
1417
1446
        # because we don't want to get into weave merge guts.
1418
 
        check_text_lines(lines)
 
1447
        textfile.check_text_lines(lines)
1419
1448
        self.tt.create_file(lines, trans_id)
1420
 
        if conflicts:
 
1449
        if base_lines is not None:
 
1450
            # Conflict
1421
1451
            self._raw_conflicts.append(('text conflict', trans_id))
1422
1452
            name = self.tt.final_name(trans_id)
1423
1453
            parent_id = self.tt.final_parent(trans_id)
1424
1454
            file_group = self._dump_conflicts(name, parent_id, file_id,
1425
 
                                              no_base=True)
 
1455
                                              no_base=False,
 
1456
                                              base_lines=base_lines)
1426
1457
            file_group.append(trans_id)
1427
1458
 
1428
1459
 
1429
1460
class LCAMerger(WeaveMerger):
1430
1461
 
1431
 
    def _merged_lines(self, file_id):
1432
 
        """Generate the merged lines.
1433
 
        There is no distinction between lines that are meant to contain <<<<<<<
1434
 
        and conflicts.
1435
 
        """
1436
 
        if self.cherrypick:
1437
 
            base = self.base_tree
1438
 
        else:
1439
 
            base = None
1440
 
        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,
1441
1464
                                                  base=base)
1442
 
        if 'merge' in debug.debug_flags:
1443
 
            plan = list(plan)
1444
 
            trans_id = self.tt.trans_id_file_id(file_id)
1445
 
            name = self.tt.final_name(trans_id) + '.plan'
1446
 
            contents = ('%10s|%s' % l for l in plan)
1447
 
            self.tt.new_file(name, self.tt.final_parent(trans_id), contents)
1448
 
        textmerge = PlanWeaveMerge(plan, '<<<<<<< TREE\n',
1449
 
            '>>>>>>> MERGE-SOURCE\n')
1450
 
        return textmerge.merge_lines(self.reprocess)
1451
 
 
1452
1465
 
1453
1466
class Diff3Merger(Merge3Merger):
1454
1467
    """Three-way merger using external diff3 for text merging"""
1455
1468
 
1456
1469
    def dump_file(self, temp_dir, name, tree, file_id):
1457
 
        out_path = pathjoin(temp_dir, name)
 
1470
        out_path = osutils.pathjoin(temp_dir, name)
1458
1471
        out_file = open(out_path, "wb")
1459
1472
        try:
1460
1473
            in_file = tree.get_file(file_id)
1472
1485
        import bzrlib.patch
1473
1486
        temp_dir = osutils.mkdtemp(prefix="bzr-")
1474
1487
        try:
1475
 
            new_file = pathjoin(temp_dir, "new")
 
1488
            new_file = osutils.pathjoin(temp_dir, "new")
1476
1489
            this = self.dump_file(temp_dir, "this", self.this_tree, file_id)
1477
1490
            base = self.dump_file(temp_dir, "base", self.base_tree, file_id)
1478
1491
            other = self.dump_file(temp_dir, "other", self.other_tree, file_id)
1479
1492
            status = bzrlib.patch.diff3(new_file, this, base, other)
1480
1493
            if status not in (0, 1):
1481
 
                raise BzrError("Unhandled diff3 exit code")
 
1494
                raise errors.BzrError("Unhandled diff3 exit code")
1482
1495
            f = open(new_file, 'rb')
1483
1496
            try:
1484
1497
                self.tt.create_file(f, trans_id)
1502
1515
                other_rev_id=None,
1503
1516
                interesting_files=None,
1504
1517
                this_tree=None,
1505
 
                pb=DummyProgress(),
 
1518
                pb=progress.DummyProgress(),
1506
1519
                change_reporter=None):
1507
1520
    """Primary interface for merging.
1508
1521
 
1511
1524
                     branch.get_revision_tree(base_revision))'
1512
1525
        """
1513
1526
    if this_tree is None:
1514
 
        raise BzrError("bzrlib.merge.merge_inner requires a this_tree "
1515
 
            "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.")
1516
1529
    merger = Merger(this_branch, other_tree, base_tree, this_tree=this_tree,
1517
1530
                    pb=pb, change_reporter=change_reporter)
1518
1531
    merger.backup_files = backup_files
1736
1749
        super(_PlanMerge, self).__init__(a_rev, b_rev, vf, key_prefix)
1737
1750
        self.a_key = self._key_prefix + (self.a_rev,)
1738
1751
        self.b_key = self._key_prefix + (self.b_rev,)
1739
 
        self.graph = Graph(self.vf)
 
1752
        self.graph = _mod_graph.Graph(self.vf)
1740
1753
        heads = self.graph.heads((self.a_key, self.b_key))
1741
1754
        if len(heads) == 1:
1742
1755
            # one side dominates, so we can just return its values, yay for
1747
1760
                other = b_rev
1748
1761
            else:
1749
1762
                other = a_rev
1750
 
            mutter('found dominating revision for %s\n%s > %s', self.vf,
1751
 
                   self._head_key[-1], other)
 
1763
            trace.mutter('found dominating revision for %s\n%s > %s', self.vf,
 
1764
                         self._head_key[-1], other)
1752
1765
            self._weave = None
1753
1766
        else:
1754
1767
            self._head_key = None
1768
1781
        while True:
1769
1782
            next_lcas = self.graph.find_lca(*cur_ancestors)
1770
1783
            # Map a plain NULL_REVISION to a simple no-ancestors
1771
 
            if next_lcas == set([NULL_REVISION]):
 
1784
            if next_lcas == set([_mod_revision.NULL_REVISION]):
1772
1785
                next_lcas = ()
1773
1786
            # Order the lca's based on when they were merged into the tip
1774
1787
            # While the actual merge portion of weave merge uses a set() of
1786
1799
            elif len(next_lcas) > 2:
1787
1800
                # More than 2 lca's, fall back to grabbing all nodes between
1788
1801
                # this and the unique lca.
1789
 
                mutter('More than 2 LCAs, falling back to all nodes for:'
1790
 
                       ' %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)
1791
1805
                cur_lcas = next_lcas
1792
1806
                while len(cur_lcas) > 1:
1793
1807
                    cur_lcas = self.graph.find_lca(*cur_lcas)
1796
1810
                    unique_lca = None
1797
1811
                else:
1798
1812
                    unique_lca = list(cur_lcas)[0]
1799
 
                    if unique_lca == NULL_REVISION:
 
1813
                    if unique_lca == _mod_revision.NULL_REVISION:
1800
1814
                        # find_lca will return a plain 'NULL_REVISION' rather
1801
1815
                        # than a key tuple when there is no common ancestor, we
1802
1816
                        # prefer to just use None, because it doesn't confuse
1825
1839
            # We remove NULL_REVISION because it isn't a proper tuple key, and
1826
1840
            # thus confuses things like _get_interesting_texts, and our logic
1827
1841
            # to add the texts into the memory weave.
1828
 
            if NULL_REVISION in parent_map:
1829
 
                parent_map.pop(NULL_REVISION)
 
1842
            if _mod_revision.NULL_REVISION in parent_map:
 
1843
                parent_map.pop(_mod_revision.NULL_REVISION)
1830
1844
        else:
1831
1845
            interesting = set()
1832
1846
            for tip in tip_keys:
1984
1998
        lcas = graph.find_lca(key_prefix + (a_rev,), key_prefix + (b_rev,))
1985
1999
        self.lcas = set()
1986
2000
        for lca in lcas:
1987
 
            if lca == NULL_REVISION:
 
2001
            if lca == _mod_revision.NULL_REVISION:
1988
2002
                self.lcas.add(lca)
1989
2003
            else:
1990
2004
                self.lcas.add(lca[-1])