← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/merge.py

Merge up through 2.2.0.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/merge.py
1
 
# Copyright (C) 2005, 2006, 2008 Canonical Ltd
 
1
# Copyright (C) 2005-2010 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
14
14
# along with this program; if not, write to the Free Software
15
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
16
 
17
 
 
18
 
import errno
19
 
from itertools import chain
20
 
import os
21
17
import warnings
22
18
 
 
19
from bzrlib.lazy_import import lazy_import
 
20
lazy_import(globals(), """
23
21
from bzrlib import (
 
22
    branch as _mod_branch,
 
23
    conflicts as _mod_conflicts,
24
24
    debug,
25
 
    errors,
 
25
    generate_ids,
26
26
    graph as _mod_graph,
 
27
    merge3,
27
28
    osutils,
28
29
    patiencediff,
29
 
    registry,
30
30
    revision as _mod_revision,
 
31
    textfile,
 
32
    trace,
 
33
    transform,
31
34
    tree as _mod_tree,
32
35
    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
 
 
 
36
    ui,
 
37
    versionedfile,
 
38
    workingtree,
 
39
    )
 
40
from bzrlib.cleanup import OperationWithCleanups
 
41
""")
 
42
from bzrlib import (
 
43
    decorators,
 
44
    errors,
 
45
    hooks,
 
46
    )
 
47
from bzrlib.symbol_versioning import (
 
48
    deprecated_in,
 
49
    deprecated_method,
 
50
    )
63
51
# TODO: Report back as changes are merged in
64
52
 
65
53
 
66
54
def transform_tree(from_tree, to_tree, interesting_ids=None):
67
55
    from_tree.lock_tree_write()
68
 
    try:
69
 
        merge_inner(from_tree.branch, to_tree, from_tree, ignore_zero=True,
70
 
                    interesting_ids=interesting_ids, this_tree=from_tree)
71
 
    finally:
72
 
        from_tree.unlock()
 
56
    operation = OperationWithCleanups(merge_inner)
 
57
    operation.add_cleanup(from_tree.unlock)
 
58
    operation.run_simple(from_tree.branch, to_tree, from_tree,
 
59
        ignore_zero=True, interesting_ids=interesting_ids, this_tree=from_tree)
 
60
 
 
61
 
 
62
class MergeHooks(hooks.Hooks):
 
63
 
 
64
    def __init__(self):
 
65
        hooks.Hooks.__init__(self)
 
66
        self.create_hook(hooks.HookPoint('merge_file_content',
 
67
            "Called with a bzrlib.merge.Merger object to create a per file "
 
68
            "merge object when starting a merge. "
 
69
            "Should return either None or a subclass of "
 
70
            "``bzrlib.merge.AbstractPerFileMerger``. "
 
71
            "Such objects will then be called per file "
 
72
            "that needs to be merged (including when one "
 
73
            "side has deleted the file and the other has changed it). "
 
74
            "See the AbstractPerFileMerger API docs for details on how it is "
 
75
            "used by merge.",
 
76
            (2, 1), None))
 
77
 
 
78
 
 
79
class AbstractPerFileMerger(object):
 
80
    """PerFileMerger objects are used by plugins extending merge for bzrlib.
 
81
 
 
82
    See ``bzrlib.plugins.news_merge.news_merge`` for an example concrete class.
 
83
    
 
84
    :ivar merger: The Merge3Merger performing the merge.
 
85
    """
 
86
 
 
87
    def __init__(self, merger):
 
88
        """Create a PerFileMerger for use with merger."""
 
89
        self.merger = merger
 
90
 
 
91
    def merge_contents(self, merge_params):
 
92
        """Attempt to merge the contents of a single file.
 
93
        
 
94
        :param merge_params: A bzrlib.merge.MergeHookParams
 
95
        :return : A tuple of (status, chunks), where status is one of
 
96
            'not_applicable', 'success', 'conflicted', or 'delete'.  If status
 
97
            is 'success' or 'conflicted', then chunks should be an iterable of
 
98
            strings for the new file contents.
 
99
        """
 
100
        return ('not applicable', None)
 
101
 
 
102
 
 
103
class PerFileMerger(AbstractPerFileMerger):
 
104
    """Merge individual files when self.file_matches returns True.
 
105
 
 
106
    This class is intended to be subclassed.  The file_matches and
 
107
    merge_matching methods should be overridden with concrete implementations.
 
108
    """
 
109
 
 
110
    def file_matches(self, params):
 
111
        """Return True if merge_matching should be called on this file.
 
112
 
 
113
        Only called with merges of plain files with no clear winner.
 
114
 
 
115
        Subclasses must override this.
 
116
        """
 
117
        raise NotImplementedError(self.file_matches)
 
118
 
 
119
    def get_filename(self, params, tree):
 
120
        """Lookup the filename (i.e. basename, not path), given a Tree (e.g.
 
121
        self.merger.this_tree) and a MergeHookParams.
 
122
        """
 
123
        return osutils.basename(tree.id2path(params.file_id))
 
124
 
 
125
    def get_filepath(self, params, tree):
 
126
        """Calculate the path to the file in a tree.
 
127
 
 
128
        :param params: A MergeHookParams describing the file to merge
 
129
        :param tree: a Tree, e.g. self.merger.this_tree.
 
130
        """
 
131
        return tree.id2path(params.file_id)
 
132
 
 
133
    def merge_contents(self, params):
 
134
        """Merge the contents of a single file."""
 
135
        # Check whether this custom merge logic should be used.
 
136
        if (
 
137
            # OTHER is a straight winner, rely on default merge.
 
138
            params.winner == 'other' or
 
139
            # THIS and OTHER aren't both files.
 
140
            not params.is_file_merge() or
 
141
            # The filename doesn't match *.xml
 
142
            not self.file_matches(params)):
 
143
            return 'not_applicable', None
 
144
        return self.merge_matching(params)
 
145
 
 
146
    def merge_matching(self, params):
 
147
        """Merge the contents of a single file that has matched the criteria
 
148
        in PerFileMerger.merge_contents (is a conflict, is a file,
 
149
        self.file_matches is True).
 
150
 
 
151
        Subclasses must override this.
 
152
        """
 
153
        raise NotImplementedError(self.merge_matching)
 
154
 
 
155
 
 
156
class ConfigurableFileMerger(PerFileMerger):
 
157
    """Merge individual files when configured via a .conf file.
 
158
 
 
159
    This is a base class for concrete custom file merging logic. Concrete
 
160
    classes should implement ``merge_text``.
 
161
 
 
162
    See ``bzrlib.plugins.news_merge.news_merge`` for an example concrete class.
 
163
    
 
164
    :ivar affected_files: The configured file paths to merge.
 
165
 
 
166
    :cvar name_prefix: The prefix to use when looking up configuration
 
167
        details. <name_prefix>_merge_files describes the files targeted by the
 
168
        hook for example.
 
169
        
 
170
    :cvar default_files: The default file paths to merge when no configuration
 
171
        is present.
 
172
    """
 
173
 
 
174
    name_prefix = None
 
175
    default_files = None
 
176
 
 
177
    def __init__(self, merger):
 
178
        super(ConfigurableFileMerger, self).__init__(merger)
 
179
        self.affected_files = None
 
180
        self.default_files = self.__class__.default_files or []
 
181
        self.name_prefix = self.__class__.name_prefix
 
182
        if self.name_prefix is None:
 
183
            raise ValueError("name_prefix must be set.")
 
184
 
 
185
    def file_matches(self, params):
 
186
        """Check whether the file should call the merge hook.
 
187
 
 
188
        <name_prefix>_merge_files configuration variable is a list of files
 
189
        that should use the hook.
 
190
        """
 
191
        affected_files = self.affected_files
 
192
        if affected_files is None:
 
193
            config = self.merger.this_branch.get_config()
 
194
            # Until bzr provides a better policy for caching the config, we
 
195
            # just add the part we're interested in to the params to avoid
 
196
            # reading the config files repeatedly (bazaar.conf, location.conf,
 
197
            # branch.conf).
 
198
            config_key = self.name_prefix + '_merge_files'
 
199
            affected_files = config.get_user_option_as_list(config_key)
 
200
            if affected_files is None:
 
201
                # If nothing was specified in the config, use the default.
 
202
                affected_files = self.default_files
 
203
            self.affected_files = affected_files
 
204
        if affected_files:
 
205
            filepath = self.get_filepath(params, self.merger.this_tree)
 
206
            if filepath in affected_files:
 
207
                return True
 
208
        return False
 
209
 
 
210
    def merge_matching(self, params):
 
211
        return self.merge_text(params)
 
212
 
 
213
    def merge_text(self, params):
 
214
        """Merge the byte contents of a single file.
 
215
 
 
216
        This is called after checking that the merge should be performed in
 
217
        merge_contents, and it should behave as per
 
218
        ``bzrlib.merge.AbstractPerFileMerger.merge_contents``.
 
219
        """
 
220
        raise NotImplementedError(self.merge_text)
 
221
 
 
222
 
 
223
class MergeHookParams(object):
 
224
    """Object holding parameters passed to merge_file_content hooks.
 
225
 
 
226
    There are some fields hooks can access:
 
227
 
 
228
    :ivar file_id: the file ID of the file being merged
 
229
    :ivar trans_id: the transform ID for the merge of this file
 
230
    :ivar this_kind: kind of file_id in 'this' tree
 
231
    :ivar other_kind: kind of file_id in 'other' tree
 
232
    :ivar winner: one of 'this', 'other', 'conflict'
 
233
    """
 
234
 
 
235
    def __init__(self, merger, file_id, trans_id, this_kind, other_kind,
 
236
            winner):
 
237
        self._merger = merger
 
238
        self.file_id = file_id
 
239
        self.trans_id = trans_id
 
240
        self.this_kind = this_kind
 
241
        self.other_kind = other_kind
 
242
        self.winner = winner
 
243
 
 
244
    def is_file_merge(self):
 
245
        """True if this_kind and other_kind are both 'file'."""
 
246
        return self.this_kind == 'file' and self.other_kind == 'file'
 
247
 
 
248
    @decorators.cachedproperty
 
249
    def base_lines(self):
 
250
        """The lines of the 'base' version of the file."""
 
251
        return self._merger.get_lines(self._merger.base_tree, self.file_id)
 
252
 
 
253
    @decorators.cachedproperty
 
254
    def this_lines(self):
 
255
        """The lines of the 'this' version of the file."""
 
256
        return self._merger.get_lines(self._merger.this_tree, self.file_id)
 
257
 
 
258
    @decorators.cachedproperty
 
259
    def other_lines(self):
 
260
        """The lines of the 'other' version of the file."""
 
261
        return self._merger.get_lines(self._merger.other_tree, self.file_id)
73
262
 
74
263
 
75
264
class Merger(object):
 
265
 
 
266
    hooks = MergeHooks()
 
267
 
76
268
    def __init__(self, this_branch, other_tree=None, base_tree=None,
77
269
                 this_tree=None, pb=None, change_reporter=None,
78
270
                 recurse='down', revision_graph=None):
93
285
        self.interesting_files = None
94
286
        self.show_base = False
95
287
        self.reprocess = False
96
 
        if pb is None:
97
 
            pb = DummyProgress()
98
 
        self._pb = pb
 
288
        if pb is not None:
 
289
            warnings.warn("pb parameter to Merger() is deprecated and ignored")
99
290
        self.pp = None
100
291
        self.recurse = recurse
101
292
        self.change_reporter = change_reporter
184
375
                base_revision_id, tree.branch.last_revision())):
185
376
                base_revision_id = None
186
377
            else:
187
 
                warning('Performing cherrypick')
 
378
                trace.warning('Performing cherrypick')
188
379
        merger = klass.from_revision_ids(pb, tree, other_revision_id,
189
380
                                         base_revision_id, revision_graph=
190
381
                                         revision_graph)
237
428
        return self._cached_trees[revision_id]
238
429
 
239
430
    def _get_tree(self, treespec, possible_transports=None):
240
 
        from bzrlib import workingtree
241
431
        location, revno = treespec
242
432
        if revno is None:
243
433
            tree = workingtree.WorkingTree.open_containing(location)[0]
244
434
            return tree.branch, tree
245
 
        branch = Branch.open_containing(location, possible_transports)[0]
 
435
        branch = _mod_branch.Branch.open_containing(
 
436
            location, possible_transports)[0]
246
437
        if revno == -1:
247
438
            revision_id = branch.last_revision()
248
439
        else:
249
440
            revision_id = branch.get_rev_id(revno)
250
 
        revision_id = ensure_null(revision_id)
 
441
        revision_id = _mod_revision.ensure_null(revision_id)
251
442
        return branch, self.revision_tree(revision_id, branch)
252
443
 
 
444
    @deprecated_method(deprecated_in((2, 1, 0)))
253
445
    def ensure_revision_trees(self):
254
446
        if self.this_revision_tree is None:
255
447
            self.this_basis_tree = self.revision_tree(self.this_basis)
259
451
        if self.other_rev_id is None:
260
452
            other_basis_tree = self.revision_tree(self.other_basis)
261
453
            if other_basis_tree.has_changes(self.other_tree):
262
 
                raise WorkingTreeNotRevision(self.this_tree)
 
454
                raise errors.WorkingTreeNotRevision(self.this_tree)
263
455
            other_rev_id = self.other_basis
264
456
            self.other_tree = other_basis_tree
265
457
 
 
458
    @deprecated_method(deprecated_in((2, 1, 0)))
266
459
    def file_revisions(self, file_id):
267
460
        self.ensure_revision_trees()
268
461
        def get_id(tree, file_id):
271
464
        if self.this_rev_id is None:
272
465
            if self.this_basis_tree.get_file_sha1(file_id) != \
273
466
                self.this_tree.get_file_sha1(file_id):
274
 
                raise WorkingTreeNotRevision(self.this_tree)
 
467
                raise errors.WorkingTreeNotRevision(self.this_tree)
275
468
 
276
469
        trees = (self.this_basis_tree, self.other_tree)
277
470
        return [get_id(tree, file_id) for tree in trees]
278
471
 
 
472
    @deprecated_method(deprecated_in((2, 1, 0)))
279
473
    def check_basis(self, check_clean, require_commits=True):
280
474
        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')")
 
475
            raise errors.BzrCommandError(
 
476
                "This branch has no commits."
 
477
                " (perhaps you would prefer 'bzr pull')")
283
478
        if check_clean:
284
479
            self.compare_basis()
285
480
            if self.this_basis != self.this_rev_id:
286
481
                raise errors.UncommittedChanges(self.this_tree)
287
482
 
 
483
    @deprecated_method(deprecated_in((2, 1, 0)))
288
484
    def compare_basis(self):
289
485
        try:
290
486
            basis_tree = self.revision_tree(self.this_tree.last_revision())
297
493
        self.interesting_files = file_list
298
494
 
299
495
    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:
 
496
        if (not self.base_is_ancestor or not self.base_is_other_ancestor
 
497
            or self.other_rev_id is None):
301
498
            return
302
499
        self._add_parent()
303
500
 
304
501
    def _add_parent(self):
305
502
        new_parents = self.this_tree.get_parent_ids() + [self.other_rev_id]
306
503
        new_parent_trees = []
 
504
        operation = OperationWithCleanups(self.this_tree.set_parent_trees)
307
505
        for revision_id in new_parents:
308
506
            try:
309
507
                tree = self.revision_tree(revision_id)
311
509
                tree = None
312
510
            else:
313
511
                tree.lock_read()
 
512
                operation.add_cleanup(tree.unlock)
314
513
            new_parent_trees.append((revision_id, tree))
315
 
        try:
316
 
            self.this_tree.set_parent_trees(new_parent_trees,
317
 
                                            allow_leftmost_as_ghost=True)
318
 
        finally:
319
 
            for _revision_id, tree in new_parent_trees:
320
 
                if tree is not None:
321
 
                    tree.unlock()
 
514
        operation.run_simple(new_parent_trees, allow_leftmost_as_ghost=True)
322
515
 
323
516
    def set_other(self, other_revision, possible_transports=None):
324
517
        """Set the revision and tree to merge from.
333
526
            self.other_rev_id = _mod_revision.ensure_null(
334
527
                self.other_branch.last_revision())
335
528
            if _mod_revision.is_null(self.other_rev_id):
336
 
                raise NoCommits(self.other_branch)
 
529
                raise errors.NoCommits(self.other_branch)
337
530
            self.other_basis = self.other_rev_id
338
531
        elif other_revision[1] is not None:
339
532
            self.other_rev_id = self.other_branch.get_rev_id(other_revision[1])
342
535
            self.other_rev_id = None
343
536
            self.other_basis = self.other_branch.last_revision()
344
537
            if self.other_basis is None:
345
 
                raise NoCommits(self.other_branch)
 
538
                raise errors.NoCommits(self.other_branch)
346
539
        if self.other_rev_id is not None:
347
540
            self._cached_trees[self.other_rev_id] = self.other_tree
348
541
        self._maybe_fetch(self.other_branch,self.this_branch, self.other_basis)
375
568
            target.fetch(source, revision_id)
376
569
 
377
570
    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
 
571
        revisions = [_mod_revision.ensure_null(self.this_basis),
 
572
                     _mod_revision.ensure_null(self.other_basis)]
 
573
        if _mod_revision.NULL_REVISION in revisions:
 
574
            self.base_rev_id = _mod_revision.NULL_REVISION
382
575
            self.base_tree = self.revision_tree(self.base_rev_id)
383
576
            self._is_criss_cross = False
384
577
        else:
385
578
            lcas = self.revision_graph.find_lca(revisions[0], revisions[1])
386
579
            self._is_criss_cross = False
387
580
            if len(lcas) == 0:
388
 
                self.base_rev_id = NULL_REVISION
 
581
                self.base_rev_id = _mod_revision.NULL_REVISION
389
582
            elif len(lcas) == 1:
390
583
                self.base_rev_id = list(lcas)[0]
391
584
            else: # len(lcas) > 1
400
593
                    self.base_rev_id = self.revision_graph.find_unique_lca(
401
594
                                            *lcas)
402
595
                self._is_criss_cross = True
403
 
            if self.base_rev_id == NULL_REVISION:
404
 
                raise UnrelatedBranches()
 
596
            if self.base_rev_id == _mod_revision.NULL_REVISION:
 
597
                raise errors.UnrelatedBranches()
405
598
            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)
 
599
                trace.warning('Warning: criss-cross merge encountered.  See bzr'
 
600
                              ' help criss-cross.')
 
601
                trace.mutter('Criss-cross lcas: %r' % lcas)
409
602
                interesting_revision_ids = [self.base_rev_id]
410
603
                interesting_revision_ids.extend(lcas)
411
604
                interesting_trees = dict((t.get_revision_id(), t)
421
614
                self.base_tree = self.revision_tree(self.base_rev_id)
422
615
        self.base_is_ancestor = True
423
616
        self.base_is_other_ancestor = True
424
 
        mutter('Base revid: %r' % self.base_rev_id)
 
617
        trace.mutter('Base revid: %r' % self.base_rev_id)
425
618
 
426
619
    def set_base(self, base_revision):
427
620
        """Set the base revision to use for the merge.
428
621
 
429
622
        :param base_revision: A 2-list containing a path and revision number.
430
623
        """
431
 
        mutter("doing merge() with no base_revision specified")
 
624
        trace.mutter("doing merge() with no base_revision specified")
432
625
        if base_revision == [None, None]:
433
626
            self.find_base()
434
627
        else:
447
640
                  'other_tree': self.other_tree,
448
641
                  'interesting_ids': self.interesting_ids,
449
642
                  'interesting_files': self.interesting_files,
450
 
                  'pp': self.pp,
 
643
                  'this_branch': self.this_branch,
451
644
                  'do_merge': False}
452
645
        if self.merge_type.requires_base:
453
646
            kwargs['base_tree'] = self.base_tree
454
647
        if self.merge_type.supports_reprocess:
455
648
            kwargs['reprocess'] = self.reprocess
456
649
        elif self.reprocess:
457
 
            raise BzrError("Conflict reduction is not supported for merge"
458
 
                                  " type %s." % self.merge_type)
 
650
            raise errors.BzrError(
 
651
                "Conflict reduction is not supported for merge"
 
652
                " type %s." % self.merge_type)
459
653
        if self.merge_type.supports_show_base:
460
654
            kwargs['show_base'] = self.show_base
461
655
        elif self.show_base:
462
 
            raise BzrError("Showing base is not supported for this"
463
 
                           " merge type. %s" % self.merge_type)
 
656
            raise errors.BzrError("Showing base is not supported for this"
 
657
                                  " merge type. %s" % self.merge_type)
464
658
        if (not getattr(self.merge_type, 'supports_reverse_cherrypick', True)
465
659
            and not self.base_is_other_ancestor):
466
660
            raise errors.CannotReverseCherrypick()
470
664
        if self._is_criss_cross and getattr(self.merge_type,
471
665
                                            'supports_lca_trees', False):
472
666
            kwargs['lca_trees'] = self._lca_trees
473
 
        return self.merge_type(pb=self._pb,
 
667
        return self.merge_type(pb=None,
474
668
                               change_reporter=self.change_reporter,
475
669
                               **kwargs)
476
670
 
477
 
    def _do_merge_to(self, merge):
 
671
    def _do_merge_to(self):
 
672
        merge = self.make_merger()
478
673
        if self.other_branch is not None:
479
674
            self.other_branch.update_references(self.this_branch)
480
675
        merge.do_merge()
494
689
                    sub_tree.branch.repository.revision_tree(base_revision)
495
690
                sub_merge.base_rev_id = base_revision
496
691
                sub_merge.do_merge()
 
692
        return merge
497
693
 
498
694
    def do_merge(self):
 
695
        operation = OperationWithCleanups(self._do_merge_to)
499
696
        self.this_tree.lock_tree_write()
500
 
        try:
501
 
            if self.base_tree is not None:
502
 
                self.base_tree.lock_read()
503
 
            try:
504
 
                if self.other_tree is not None:
505
 
                    self.other_tree.lock_read()
506
 
                try:
507
 
                    merge = self.make_merger()
508
 
                    self._do_merge_to(merge)
509
 
                finally:
510
 
                    if self.other_tree is not None:
511
 
                        self.other_tree.unlock()
512
 
            finally:
513
 
                if self.base_tree is not None:
514
 
                    self.base_tree.unlock()
515
 
        finally:
516
 
            self.this_tree.unlock()
 
697
        operation.add_cleanup(self.this_tree.unlock)
 
698
        if self.base_tree is not None:
 
699
            self.base_tree.lock_read()
 
700
            operation.add_cleanup(self.base_tree.unlock)
 
701
        if self.other_tree is not None:
 
702
            self.other_tree.lock_read()
 
703
            operation.add_cleanup(self.other_tree.unlock)
 
704
        merge = operation.run_simple()
517
705
        if len(merge.cooked_conflicts) == 0:
518
 
            if not self.ignore_zero and not is_quiet():
519
 
                note("All changes applied successfully.")
 
706
            if not self.ignore_zero and not trace.is_quiet():
 
707
                trace.note("All changes applied successfully.")
520
708
        else:
521
 
            note("%d conflicts encountered." % len(merge.cooked_conflicts))
 
709
            trace.note("%d conflicts encountered."
 
710
                       % len(merge.cooked_conflicts))
522
711
 
523
712
        return len(merge.cooked_conflicts)
524
713
 
553
742
 
554
743
    def __init__(self, working_tree, this_tree, base_tree, other_tree,
555
744
                 interesting_ids=None, reprocess=False, show_base=False,
556
 
                 pb=DummyProgress(), pp=None, change_reporter=None,
 
745
                 pb=None, pp=None, change_reporter=None,
557
746
                 interesting_files=None, do_merge=True,
558
 
                 cherrypick=False, lca_trees=None):
 
747
                 cherrypick=False, lca_trees=None, this_branch=None):
559
748
        """Initialize the merger object and perform the merge.
560
749
 
561
750
        :param working_tree: The working tree to apply the merge to
562
751
        :param this_tree: The local tree in the merge operation
563
752
        :param base_tree: The common tree in the merge operation
564
753
        :param other_tree: The other tree to merge changes from
 
754
        :param this_branch: The branch associated with this_tree.  Defaults to
 
755
            this_tree.branch if not supplied.
565
756
        :param interesting_ids: The file_ids of files that should be
566
757
            participate in the merge.  May not be combined with
567
758
            interesting_files.
568
759
        :param: reprocess If True, perform conflict-reduction processing.
569
760
        :param show_base: If True, show the base revision in text conflicts.
570
761
            (incompatible with reprocess)
571
 
        :param pb: A Progress bar
 
762
        :param pb: ignored
572
763
        :param pp: A ProgressPhase object
573
764
        :param change_reporter: An object that should report changes made
574
765
        :param interesting_files: The tree-relative paths of files that should
585
776
        if interesting_files is not None and interesting_ids is not None:
586
777
            raise ValueError(
587
778
                'specify either interesting_ids or interesting_files')
 
779
        if this_branch is None:
 
780
            this_branch = this_tree.branch
588
781
        self.interesting_ids = interesting_ids
589
782
        self.interesting_files = interesting_files
590
783
        self.this_tree = working_tree
591
784
        self.base_tree = base_tree
592
785
        self.other_tree = other_tree
 
786
        self.this_branch = this_branch
593
787
        self._raw_conflicts = []
594
788
        self.cooked_conflicts = []
595
789
        self.reprocess = reprocess
600
794
        # making sure we haven't missed any corner cases.
601
795
        # if lca_trees is None:
602
796
        #     self._lca_trees = [self.base_tree]
603
 
        self.pb = pb
604
 
        self.pp = pp
605
797
        self.change_reporter = change_reporter
606
798
        self.cherrypick = cherrypick
607
 
        if self.pp is None:
608
 
            self.pp = ProgressPhase("Merge phase", 3, self.pb)
609
799
        if do_merge:
610
800
            self.do_merge()
 
801
        if pp is not None:
 
802
            warnings.warn("pp argument to Merge3Merger is deprecated")
 
803
        if pb is not None:
 
804
            warnings.warn("pb argument to Merge3Merger is deprecated")
611
805
 
612
806
    def do_merge(self):
 
807
        operation = OperationWithCleanups(self._do_merge)
613
808
        self.this_tree.lock_tree_write()
 
809
        operation.add_cleanup(self.this_tree.unlock)
614
810
        self.base_tree.lock_read()
 
811
        operation.add_cleanup(self.base_tree.unlock)
615
812
        self.other_tree.lock_read()
616
 
        self.tt = TreeTransform(self.this_tree, self.pb)
 
813
        operation.add_cleanup(self.other_tree.unlock)
 
814
        operation.run()
 
815
 
 
816
    def _do_merge(self, operation):
 
817
        self.tt = transform.TreeTransform(self.this_tree, None)
 
818
        operation.add_cleanup(self.tt.finalize)
 
819
        self._compute_transform()
 
820
        results = self.tt.apply(no_conflicts=True)
 
821
        self.write_modified(results)
617
822
        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)
623
 
            try:
624
 
                self.this_tree.add_conflicts(self.cooked_conflicts)
625
 
            except UnsupportedOperation:
626
 
                pass
627
 
        finally:
628
 
            self.tt.finalize()
629
 
            self.other_tree.unlock()
630
 
            self.base_tree.unlock()
631
 
            self.this_tree.unlock()
632
 
            self.pb.clear()
 
823
            self.this_tree.add_conflicts(self.cooked_conflicts)
 
824
        except errors.UnsupportedOperation:
 
825
            pass
633
826
 
634
827
    def make_preview_transform(self):
 
828
        operation = OperationWithCleanups(self._make_preview_transform)
635
829
        self.base_tree.lock_read()
 
830
        operation.add_cleanup(self.base_tree.unlock)
636
831
        self.other_tree.lock_read()
637
 
        self.tt = TransformPreview(self.this_tree)
638
 
        try:
639
 
            self.pp.next_phase()
640
 
            self._compute_transform()
641
 
            self.pp.next_phase()
642
 
        finally:
643
 
            self.other_tree.unlock()
644
 
            self.base_tree.unlock()
645
 
            self.pb.clear()
 
832
        operation.add_cleanup(self.other_tree.unlock)
 
833
        return operation.run_simple()
 
834
 
 
835
    def _make_preview_transform(self):
 
836
        self.tt = transform.TransformPreview(self.this_tree)
 
837
        self._compute_transform()
646
838
        return self.tt
647
839
 
648
840
    def _compute_transform(self):
654
846
            resolver = self._lca_multi_way
655
847
        child_pb = ui.ui_factory.nested_progress_bar()
656
848
        try:
 
849
            factories = Merger.hooks['merge_file_content']
 
850
            hooks = [factory(self) for factory in factories] + [self]
 
851
            self.active_hooks = [hook for hook in hooks if hook is not None]
657
852
            for num, (file_id, changed, parents3, names3,
658
853
                      executable3) in enumerate(entries):
659
854
                child_pb.update('Preparing file merge', num, len(entries))
660
855
                self._merge_names(file_id, parents3, names3, resolver=resolver)
661
856
                if changed:
662
 
                    file_status = self.merge_contents(file_id)
 
857
                    file_status = self._do_merge_contents(file_id)
663
858
                else:
664
859
                    file_status = 'unmodified'
665
860
                self._merge_executable(file_id,
667
862
        finally:
668
863
            child_pb.finished()
669
864
        self.fix_root()
670
 
        self.pp.next_phase()
 
865
        self._finish_computing_transform()
 
866
 
 
867
    def _finish_computing_transform(self):
 
868
        """Finalize the transform and report the changes.
 
869
 
 
870
        This is the second half of _compute_transform.
 
871
        """
671
872
        child_pb = ui.ui_factory.nested_progress_bar()
672
873
        try:
673
 
            fs_conflicts = resolve_conflicts(self.tt, child_pb,
674
 
                lambda t, c: conflict_pass(t, c, self.other_tree))
 
874
            fs_conflicts = transform.resolve_conflicts(self.tt, child_pb,
 
875
                lambda t, c: transform.conflict_pass(t, c, self.other_tree))
675
876
        finally:
676
877
            child_pb.finished()
677
878
        if self.change_reporter is not None:
680
881
                self.tt.iter_changes(), self.change_reporter)
681
882
        self.cook_conflicts(fs_conflicts)
682
883
        for conflict in self.cooked_conflicts:
683
 
            warning(conflict)
 
884
            trace.warning(conflict)
684
885
 
685
886
    def _entries3(self):
686
887
        """Gather data about files modified between three trees.
871
1072
                        continue
872
1073
                else:
873
1074
                    raise AssertionError('unhandled kind: %s' % other_ie.kind)
874
 
                # XXX: We need to handle kind == 'symlink'
875
1075
 
876
1076
            # If we have gotten this far, that means something has changed
877
1077
            result.append((file_id, content_changed,
884
1084
                          ))
885
1085
        return result
886
1086
 
887
 
 
888
1087
    def fix_root(self):
889
1088
        try:
890
1089
            self.tt.final_kind(self.tt.root)
891
 
        except NoSuchFile:
 
1090
        except errors.NoSuchFile:
892
1091
            self.tt.cancel_deletion(self.tt.root)
893
1092
        if self.tt.final_file_id(self.tt.root) is None:
894
1093
            self.tt.version_file(self.tt.tree_file_id(self.tt.root),
899
1098
        other_root = self.tt.trans_id_file_id(other_root_file_id)
900
1099
        if other_root == self.tt.root:
901
1100
            return
 
1101
        if self.other_tree.inventory.root.file_id in self.this_tree.inventory:
 
1102
            # the other tree's root is a non-root in the current tree (as when
 
1103
            # a previously unrelated branch is merged into another)
 
1104
            return
902
1105
        try:
903
1106
            self.tt.final_kind(other_root)
904
 
        except NoSuchFile:
905
 
            return
906
 
        if self.other_tree.inventory.root.file_id in self.this_tree.inventory:
907
 
            # the other tree's root is a non-root in the current tree
908
 
            return
909
 
        self.reparent_children(self.other_tree.inventory.root, self.tt.root)
910
 
        self.tt.cancel_creation(other_root)
911
 
        self.tt.cancel_versioning(other_root)
912
 
 
913
 
    def reparent_children(self, ie, target):
914
 
        for thing, child in ie.children.iteritems():
 
1107
            other_root_is_present = True
 
1108
        except errors.NoSuchFile:
 
1109
            # other_root doesn't have a physical representation. We still need
 
1110
            # to move any references to the actual root of the tree.
 
1111
            other_root_is_present = False
 
1112
        # 'other_tree.inventory.root' is not present in this tree. We are
 
1113
        # calling adjust_path for children which *want* to be present with a
 
1114
        # correct place to go.
 
1115
        for thing, child in self.other_tree.inventory.root.children.iteritems():
915
1116
            trans_id = self.tt.trans_id_file_id(child.file_id)
916
 
            self.tt.adjust_path(self.tt.final_name(trans_id), target, trans_id)
 
1117
            if not other_root_is_present:
 
1118
                # FIXME: Make final_kind returns None instead of raising
 
1119
                # NoSuchFile to avoid the ugly construct below -- vila 20100402
 
1120
                try:
 
1121
                    self.tt.final_kind(trans_id)
 
1122
                    # The item exist in the final tree and has a defined place
 
1123
                    # to go already.
 
1124
                    continue
 
1125
                except errors.NoSuchFile, e:
 
1126
                    pass
 
1127
            # Move the item into the root
 
1128
            self.tt.adjust_path(self.tt.final_name(trans_id),
 
1129
                                self.tt.root, trans_id)
 
1130
        if other_root_is_present:
 
1131
            self.tt.cancel_creation(other_root)
 
1132
            self.tt.cancel_versioning(other_root)
917
1133
 
918
1134
    def write_modified(self, results):
919
1135
        modified_hashes = {}
951
1167
    @staticmethod
952
1168
    def executable(tree, file_id):
953
1169
        """Determine the executability of a file-id (used as a key method)."""
954
 
        if file_id not in tree:
 
1170
        if not tree.has_id(file_id):
955
1171
            return None
956
1172
        if tree.kind(file_id) != "file":
957
1173
            return False
960
1176
    @staticmethod
961
1177
    def kind(tree, file_id):
962
1178
        """Determine the kind of a file-id (used as a key method)."""
963
 
        if file_id not in tree:
 
1179
        if not tree.has_id(file_id):
964
1180
            return None
965
1181
        return tree.kind(file_id)
966
1182
 
967
1183
    @staticmethod
968
1184
    def _three_way(base, other, this):
969
 
        #if base == other, either they all agree, or only THIS has changed.
970
1185
        if base == other:
 
1186
            # if 'base == other', either they all agree, or only 'this' has
 
1187
            # changed.
971
1188
            return 'this'
972
1189
        elif this not in (base, other):
 
1190
            # 'this' is neither 'base' nor 'other', so both sides changed
973
1191
            return 'conflict'
974
 
        # "Ambiguous clean merge" -- both sides have made the same change.
975
1192
        elif this == other:
 
1193
            # "Ambiguous clean merge" -- both sides have made the same change.
976
1194
            return "this"
977
 
        # this == base: only other has changed.
978
1195
        else:
 
1196
            # this == base: only other has changed.
979
1197
            return "other"
980
1198
 
981
1199
    @staticmethod
1025
1243
                # only has an lca value
1026
1244
                return 'other'
1027
1245
 
1028
 
        # At this point, the lcas disagree, and the tips disagree
 
1246
        # At this point, the lcas disagree, and the tip disagree
1029
1247
        return 'conflict'
1030
1248
 
1031
1249
    @staticmethod
 
1250
    @deprecated_method(deprecated_in((2, 2, 0)))
1032
1251
    def scalar_three_way(this_tree, base_tree, other_tree, file_id, key):
1033
1252
        """Do a three-way test on a scalar.
1034
1253
        Return "this", "other" or "conflict", depending whether a value wins.
1049
1268
 
1050
1269
    def merge_names(self, file_id):
1051
1270
        def get_entry(tree):
1052
 
            if file_id in tree.inventory:
 
1271
            if tree.has_id(file_id):
1053
1272
                return tree.inventory[file_id]
1054
1273
            else:
1055
1274
                return None
1084
1303
                parent_id_winner = "other"
1085
1304
        if name_winner == "this" and parent_id_winner == "this":
1086
1305
            return
1087
 
        if name_winner == "conflict":
1088
 
            trans_id = self.tt.trans_id_file_id(file_id)
1089
 
            self._raw_conflicts.append(('name conflict', trans_id,
1090
 
                                        this_name, other_name))
1091
 
        if parent_id_winner == "conflict":
1092
 
            trans_id = self.tt.trans_id_file_id(file_id)
1093
 
            self._raw_conflicts.append(('parent conflict', trans_id,
1094
 
                                        this_parent, other_parent))
 
1306
        if name_winner == 'conflict' or parent_id_winner == 'conflict':
 
1307
            # Creating helpers (.OTHER or .THIS) here cause problems down the
 
1308
            # road if a ContentConflict needs to be created so we should not do
 
1309
            # that
 
1310
            trans_id = self.tt.trans_id_file_id(file_id)
 
1311
            self._raw_conflicts.append(('path conflict', trans_id, file_id,
 
1312
                                        this_parent, this_name,
 
1313
                                        other_parent, other_name))
1095
1314
        if other_name is None:
1096
1315
            # it doesn't matter whether the result was 'other' or
1097
1316
            # 'conflict'-- if there's no 'other', we leave it alone.
1098
1317
            return
1099
 
        # if we get here, name_winner and parent_winner are set to safe values.
1100
 
        trans_id = self.tt.trans_id_file_id(file_id)
1101
1318
        parent_id = parents[self.winner_idx[parent_id_winner]]
1102
1319
        if parent_id is not None:
1103
 
            parent_trans_id = self.tt.trans_id_file_id(parent_id)
 
1320
            # if we get here, name_winner and parent_winner are set to safe
 
1321
            # values.
1104
1322
            self.tt.adjust_path(names[self.winner_idx[name_winner]],
1105
 
                                parent_trans_id, trans_id)
 
1323
                                self.tt.trans_id_file_id(parent_id),
 
1324
                                self.tt.trans_id_file_id(file_id))
1106
1325
 
1107
 
    def merge_contents(self, file_id):
 
1326
    def _do_merge_contents(self, file_id):
1108
1327
        """Performs a merge on file_id contents."""
1109
1328
        def contents_pair(tree):
1110
1329
            if file_id not in tree:
1118
1337
                contents = None
1119
1338
            return kind, contents
1120
1339
 
1121
 
        def contents_conflict():
1122
 
            trans_id = self.tt.trans_id_file_id(file_id)
1123
 
            name = self.tt.final_name(trans_id)
1124
 
            parent_id = self.tt.final_parent(trans_id)
1125
 
            if file_id in self.this_tree.inventory:
1126
 
                self.tt.unversion_file(trans_id)
1127
 
                if file_id in self.this_tree:
1128
 
                    self.tt.delete_contents(trans_id)
1129
 
            file_group = self._dump_conflicts(name, parent_id, file_id,
1130
 
                                              set_version=True)
1131
 
            self._raw_conflicts.append(('contents conflict', file_group))
1132
 
 
1133
1340
        # See SPOT run.  run, SPOT, run.
1134
1341
        # So we're not QUITE repeating ourselves; we do tricky things with
1135
1342
        # file kind...
1151
1358
        if winner == 'this':
1152
1359
            # No interesting changes introduced by OTHER
1153
1360
            return "unmodified"
 
1361
        # We have a hypothetical conflict, but if we have files, then we
 
1362
        # can try to merge the content
1154
1363
        trans_id = self.tt.trans_id_file_id(file_id)
1155
 
        if winner == 'other':
 
1364
        params = MergeHookParams(self, file_id, trans_id, this_pair[0],
 
1365
            other_pair[0], winner)
 
1366
        hooks = self.active_hooks
 
1367
        hook_status = 'not_applicable'
 
1368
        for hook in hooks:
 
1369
            hook_status, lines = hook.merge_contents(params)
 
1370
            if hook_status != 'not_applicable':
 
1371
                # Don't try any more hooks, this one applies.
 
1372
                break
 
1373
        result = "modified"
 
1374
        if hook_status == 'not_applicable':
 
1375
            # This is a contents conflict, because none of the available
 
1376
            # functions could merge it.
 
1377
            result = None
 
1378
            name = self.tt.final_name(trans_id)
 
1379
            parent_id = self.tt.final_parent(trans_id)
 
1380
            if self.this_tree.has_id(file_id):
 
1381
                self.tt.unversion_file(trans_id)
 
1382
            file_group = self._dump_conflicts(name, parent_id, file_id,
 
1383
                                              set_version=True)
 
1384
            self._raw_conflicts.append(('contents conflict', file_group))
 
1385
        elif hook_status == 'success':
 
1386
            self.tt.create_file(lines, trans_id)
 
1387
        elif hook_status == 'conflicted':
 
1388
            # XXX: perhaps the hook should be able to provide
 
1389
            # the BASE/THIS/OTHER files?
 
1390
            self.tt.create_file(lines, trans_id)
 
1391
            self._raw_conflicts.append(('text conflict', trans_id))
 
1392
            name = self.tt.final_name(trans_id)
 
1393
            parent_id = self.tt.final_parent(trans_id)
 
1394
            self._dump_conflicts(name, parent_id, file_id)
 
1395
        elif hook_status == 'delete':
 
1396
            self.tt.unversion_file(trans_id)
 
1397
            result = "deleted"
 
1398
        elif hook_status == 'done':
 
1399
            # The hook function did whatever it needs to do directly, no
 
1400
            # further action needed here.
 
1401
            pass
 
1402
        else:
 
1403
            raise AssertionError('unknown hook_status: %r' % (hook_status,))
 
1404
        if not self.this_tree.has_id(file_id) and result == "modified":
 
1405
            self.tt.version_file(file_id, trans_id)
 
1406
        # The merge has been performed, so the old contents should not be
 
1407
        # retained.
 
1408
        try:
 
1409
            self.tt.delete_contents(trans_id)
 
1410
        except errors.NoSuchFile:
 
1411
            pass
 
1412
        return result
 
1413
 
 
1414
    def _default_other_winner_merge(self, merge_hook_params):
 
1415
        """Replace this contents with other."""
 
1416
        file_id = merge_hook_params.file_id
 
1417
        trans_id = merge_hook_params.trans_id
 
1418
        file_in_this = self.this_tree.has_id(file_id)
 
1419
        if self.other_tree.has_id(file_id):
 
1420
            # OTHER changed the file
 
1421
            wt = self.this_tree
 
1422
            if wt.supports_content_filtering():
 
1423
                # We get the path from the working tree if it exists.
 
1424
                # That fails though when OTHER is adding a file, so
 
1425
                # we fall back to the other tree to find the path if
 
1426
                # it doesn't exist locally.
 
1427
                try:
 
1428
                    filter_tree_path = wt.id2path(file_id)
 
1429
                except errors.NoSuchId:
 
1430
                    filter_tree_path = self.other_tree.id2path(file_id)
 
1431
            else:
 
1432
                # Skip the id2path lookup for older formats
 
1433
                filter_tree_path = None
 
1434
            transform.create_from_tree(self.tt, trans_id,
 
1435
                             self.other_tree, file_id,
 
1436
                             filter_tree_path=filter_tree_path)
 
1437
            return 'done', None
 
1438
        elif file_in_this:
 
1439
            # OTHER deleted the file
 
1440
            return 'delete', None
 
1441
        else:
 
1442
            raise AssertionError(
 
1443
                'winner is OTHER, but file_id %r not in THIS or OTHER tree'
 
1444
                % (file_id,))
 
1445
 
 
1446
    def merge_contents(self, merge_hook_params):
 
1447
        """Fallback merge logic after user installed hooks."""
 
1448
        # This function is used in merge hooks as the fallback instance.
 
1449
        # Perhaps making this function and the functions it calls be a 
 
1450
        # a separate class would be better.
 
1451
        if merge_hook_params.winner == 'other':
1156
1452
            # OTHER is a straight winner, so replace this contents with other
1157
 
            file_in_this = file_id in self.this_tree
1158
 
            if file_in_this:
1159
 
                # Remove any existing contents
1160
 
                self.tt.delete_contents(trans_id)
1161
 
            if file_id in self.other_tree:
1162
 
                # OTHER changed the file
1163
 
                create_from_tree(self.tt, trans_id,
1164
 
                                 self.other_tree, file_id)
1165
 
                if not file_in_this:
1166
 
                    self.tt.version_file(file_id, trans_id)
1167
 
                return "modified"
1168
 
            elif file_in_this:
1169
 
                # OTHER deleted the file
1170
 
                self.tt.unversion_file(trans_id)
1171
 
                return "deleted"
 
1453
            return self._default_other_winner_merge(merge_hook_params)
 
1454
        elif merge_hook_params.is_file_merge():
 
1455
            # THIS and OTHER are both files, so text merge.  Either
 
1456
            # BASE is a file, or both converted to files, so at least we
 
1457
            # have agreement that output should be a file.
 
1458
            try:
 
1459
                self.text_merge(merge_hook_params.file_id,
 
1460
                    merge_hook_params.trans_id)
 
1461
            except errors.BinaryFile:
 
1462
                return 'not_applicable', None
 
1463
            return 'done', None
1172
1464
        else:
1173
 
            # We have a hypothetical conflict, but if we have files, then we
1174
 
            # can try to merge the content
1175
 
            if this_pair[0] == 'file' and other_pair[0] == 'file':
1176
 
                # THIS and OTHER are both files, so text merge.  Either
1177
 
                # BASE is a file, or both converted to files, so at least we
1178
 
                # have agreement that output should be a file.
1179
 
                try:
1180
 
                    self.text_merge(file_id, trans_id)
1181
 
                except BinaryFile:
1182
 
                    return contents_conflict()
1183
 
                if file_id not in self.this_tree:
1184
 
                    self.tt.version_file(file_id, trans_id)
1185
 
                try:
1186
 
                    self.tt.tree_kind(trans_id)
1187
 
                    self.tt.delete_contents(trans_id)
1188
 
                except NoSuchFile:
1189
 
                    pass
1190
 
                return "modified"
1191
 
            else:
1192
 
                return contents_conflict()
 
1465
            return 'not_applicable', None
1193
1466
 
1194
1467
    def get_lines(self, tree, file_id):
1195
1468
        """Return the lines in a file, or an empty list."""
1196
 
        if file_id in tree:
1197
 
            return tree.get_file(file_id).readlines()
 
1469
        if tree.has_id(file_id):
 
1470
            return tree.get_file_lines(file_id)
1198
1471
        else:
1199
1472
            return []
1200
1473
 
1202
1475
        """Perform a three-way text merge on a file_id"""
1203
1476
        # it's possible that we got here with base as a different type.
1204
1477
        # if so, we just want two-way text conflicts.
1205
 
        if file_id in self.base_tree and \
 
1478
        if self.base_tree.has_id(file_id) and \
1206
1479
            self.base_tree.kind(file_id) == "file":
1207
1480
            base_lines = self.get_lines(self.base_tree, file_id)
1208
1481
        else:
1209
1482
            base_lines = []
1210
1483
        other_lines = self.get_lines(self.other_tree, file_id)
1211
1484
        this_lines = self.get_lines(self.this_tree, file_id)
1212
 
        m3 = Merge3(base_lines, this_lines, other_lines,
1213
 
                    is_cherrypick=self.cherrypick)
 
1485
        m3 = merge3.Merge3(base_lines, this_lines, other_lines,
 
1486
                           is_cherrypick=self.cherrypick)
1214
1487
        start_marker = "!START OF MERGE CONFLICT!" + "I HOPE THIS IS UNIQUE"
1215
1488
        if self.show_base is True:
1216
1489
            base_marker = '|' * 7
1254
1527
                ('THIS', self.this_tree, this_lines)]
1255
1528
        if not no_base:
1256
1529
            data.append(('BASE', self.base_tree, base_lines))
 
1530
 
 
1531
        # We need to use the actual path in the working tree of the file here,
 
1532
        # ignoring the conflict suffixes
 
1533
        wt = self.this_tree
 
1534
        if wt.supports_content_filtering():
 
1535
            try:
 
1536
                filter_tree_path = wt.id2path(file_id)
 
1537
            except errors.NoSuchId:
 
1538
                # file has been deleted
 
1539
                filter_tree_path = None
 
1540
        else:
 
1541
            # Skip the id2path lookup for older formats
 
1542
            filter_tree_path = None
 
1543
 
1257
1544
        versioned = False
1258
1545
        file_group = []
1259
1546
        for suffix, tree, lines in data:
1260
 
            if file_id in tree:
 
1547
            if tree.has_id(file_id):
1261
1548
                trans_id = self._conflict_file(name, parent_id, tree, file_id,
1262
 
                                               suffix, lines)
 
1549
                                               suffix, lines, filter_tree_path)
1263
1550
                file_group.append(trans_id)
1264
1551
                if set_version and not versioned:
1265
1552
                    self.tt.version_file(file_id, trans_id)
1267
1554
        return file_group
1268
1555
 
1269
1556
    def _conflict_file(self, name, parent_id, tree, file_id, suffix,
1270
 
                       lines=None):
 
1557
                       lines=None, filter_tree_path=None):
1271
1558
        """Emit a single conflict file."""
1272
1559
        name = name + '.' + suffix
1273
1560
        trans_id = self.tt.create_path(name, parent_id)
1274
 
        create_from_tree(self.tt, trans_id, tree, file_id, lines)
 
1561
        transform.create_from_tree(self.tt, trans_id, tree, file_id, lines,
 
1562
            filter_tree_path)
1275
1563
        return trans_id
1276
1564
 
1277
1565
    def merge_executable(self, file_id, file_status):
1301
1589
        try:
1302
1590
            if self.tt.final_kind(trans_id) != "file":
1303
1591
                return
1304
 
        except NoSuchFile:
 
1592
        except errors.NoSuchFile:
1305
1593
            return
1306
1594
        if winner == "this":
1307
1595
            executability = this_executable
1308
1596
        else:
1309
 
            if file_id in self.other_tree:
 
1597
            if self.other_tree.has_id(file_id):
1310
1598
                executability = other_executable
1311
 
            elif file_id in self.this_tree:
 
1599
            elif self.this_tree.has_id(file_id):
1312
1600
                executability = this_executable
1313
 
            elif file_id in self.base_tree:
 
1601
            elif self.base_tree_has_id(file_id):
1314
1602
                executability = base_executable
1315
1603
        if executability is not None:
1316
1604
            trans_id = self.tt.trans_id_file_id(file_id)
1318
1606
 
1319
1607
    def cook_conflicts(self, fs_conflicts):
1320
1608
        """Convert all conflicts into a form that doesn't depend on trans_id"""
1321
 
        from conflicts import Conflict
1322
 
        name_conflicts = {}
1323
 
        self.cooked_conflicts.extend(cook_conflicts(fs_conflicts, self.tt))
1324
 
        fp = FinalPaths(self.tt)
 
1609
        self.cooked_conflicts.extend(transform.cook_conflicts(
 
1610
                fs_conflicts, self.tt))
 
1611
        fp = transform.FinalPaths(self.tt)
1325
1612
        for conflict in self._raw_conflicts:
1326
1613
            conflict_type = conflict[0]
1327
 
            if conflict_type in ('name conflict', 'parent conflict'):
1328
 
                trans_id = conflict[1]
1329
 
                conflict_args = conflict[2:]
1330
 
                if trans_id not in name_conflicts:
1331
 
                    name_conflicts[trans_id] = {}
1332
 
                unique_add(name_conflicts[trans_id], conflict_type,
1333
 
                           conflict_args)
1334
 
            if conflict_type == 'contents conflict':
 
1614
            if conflict_type == 'path conflict':
 
1615
                (trans_id, file_id,
 
1616
                this_parent, this_name,
 
1617
                other_parent, other_name) = conflict[1:]
 
1618
                if this_parent is None or this_name is None:
 
1619
                    this_path = '<deleted>'
 
1620
                else:
 
1621
                    parent_path =  fp.get_path(
 
1622
                        self.tt.trans_id_file_id(this_parent))
 
1623
                    this_path = osutils.pathjoin(parent_path, this_name)
 
1624
                if other_parent is None or other_name is None:
 
1625
                    other_path = '<deleted>'
 
1626
                else:
 
1627
                    parent_path =  fp.get_path(
 
1628
                        self.tt.trans_id_file_id(other_parent))
 
1629
                    other_path = osutils.pathjoin(parent_path, other_name)
 
1630
                c = _mod_conflicts.Conflict.factory(
 
1631
                    'path conflict', path=this_path,
 
1632
                    conflict_path=other_path,
 
1633
                    file_id=file_id)
 
1634
            elif conflict_type == 'contents conflict':
1335
1635
                for trans_id in conflict[1]:
1336
1636
                    file_id = self.tt.final_file_id(trans_id)
1337
1637
                    if file_id is not None:
1341
1641
                    if path.endswith(suffix):
1342
1642
                        path = path[:-len(suffix)]
1343
1643
                        break
1344
 
                c = Conflict.factory(conflict_type, path=path, file_id=file_id)
1345
 
                self.cooked_conflicts.append(c)
1346
 
            if conflict_type == 'text conflict':
 
1644
                c = _mod_conflicts.Conflict.factory(conflict_type,
 
1645
                                                    path=path, file_id=file_id)
 
1646
            elif conflict_type == 'text conflict':
1347
1647
                trans_id = conflict[1]
1348
1648
                path = fp.get_path(trans_id)
1349
1649
                file_id = self.tt.final_file_id(trans_id)
1350
 
                c = Conflict.factory(conflict_type, path=path, file_id=file_id)
1351
 
                self.cooked_conflicts.append(c)
1352
 
 
1353
 
        for trans_id, conflicts in name_conflicts.iteritems():
1354
 
            try:
1355
 
                this_parent, other_parent = conflicts['parent conflict']
1356
 
                if this_parent == other_parent:
1357
 
                    raise AssertionError()
1358
 
            except KeyError:
1359
 
                this_parent = other_parent = \
1360
 
                    self.tt.final_file_id(self.tt.final_parent(trans_id))
1361
 
            try:
1362
 
                this_name, other_name = conflicts['name conflict']
1363
 
                if this_name == other_name:
1364
 
                    raise AssertionError()
1365
 
            except KeyError:
1366
 
                this_name = other_name = self.tt.final_name(trans_id)
1367
 
            other_path = fp.get_path(trans_id)
1368
 
            if this_parent is not None and this_name is not None:
1369
 
                this_parent_path = \
1370
 
                    fp.get_path(self.tt.trans_id_file_id(this_parent))
1371
 
                this_path = pathjoin(this_parent_path, this_name)
 
1650
                c = _mod_conflicts.Conflict.factory(conflict_type,
 
1651
                                                    path=path, file_id=file_id)
1372
1652
            else:
1373
 
                this_path = "<deleted>"
1374
 
            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)
 
1653
                raise AssertionError('bad conflict type: %r' % (conflict,))
1377
1654
            self.cooked_conflicts.append(c)
1378
 
        self.cooked_conflicts.sort(key=Conflict.sort_key)
 
1655
        self.cooked_conflicts.sort(key=_mod_conflicts.Conflict.sort_key)
1379
1656
 
1380
1657
 
1381
1658
class WeaveMerger(Merge3Merger):
1385
1662
    supports_reverse_cherrypick = False
1386
1663
    history_based = True
1387
1664
 
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,
 
1665
    def _generate_merge_plan(self, file_id, base):
 
1666
        return self.this_tree.plan_file_merge(file_id, self.other_tree,
1398
1667
                                              base=base)
 
1668
 
 
1669
    def _merged_lines(self, file_id):
 
1670
        """Generate the merged lines.
 
1671
        There is no distinction between lines that are meant to contain <<<<<<<
 
1672
        and conflicts.
 
1673
        """
 
1674
        if self.cherrypick:
 
1675
            base = self.base_tree
 
1676
        else:
 
1677
            base = None
 
1678
        plan = self._generate_merge_plan(file_id, base)
1399
1679
        if 'merge' in debug.debug_flags:
1400
1680
            plan = list(plan)
1401
1681
            trans_id = self.tt.trans_id_file_id(file_id)
1402
1682
            name = self.tt.final_name(trans_id) + '.plan'
1403
 
            contents = ('%10s|%s' % l for l in plan)
 
1683
            contents = ('%11s|%s' % l for l in plan)
1404
1684
            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)
 
1685
        textmerge = versionedfile.PlanWeaveMerge(plan, '<<<<<<< TREE\n',
 
1686
                                                 '>>>>>>> MERGE-SOURCE\n')
 
1687
        lines, conflicts = textmerge.merge_lines(self.reprocess)
 
1688
        if conflicts:
 
1689
            base_lines = textmerge.base_from_plan()
 
1690
        else:
 
1691
            base_lines = None
 
1692
        return lines, base_lines
1408
1693
 
1409
1694
    def text_merge(self, file_id, trans_id):
1410
1695
        """Perform a (weave) text merge for a given file and file-id.
1411
1696
        If conflicts are encountered, .THIS and .OTHER files will be emitted,
1412
1697
        and a conflict will be noted.
1413
1698
        """
1414
 
        lines, conflicts = self._merged_lines(file_id)
 
1699
        lines, base_lines = self._merged_lines(file_id)
1415
1700
        lines = list(lines)
1416
1701
        # Note we're checking whether the OUTPUT is binary in this case,
1417
1702
        # because we don't want to get into weave merge guts.
1418
 
        check_text_lines(lines)
 
1703
        textfile.check_text_lines(lines)
1419
1704
        self.tt.create_file(lines, trans_id)
1420
 
        if conflicts:
 
1705
        if base_lines is not None:
 
1706
            # Conflict
1421
1707
            self._raw_conflicts.append(('text conflict', trans_id))
1422
1708
            name = self.tt.final_name(trans_id)
1423
1709
            parent_id = self.tt.final_parent(trans_id)
1424
1710
            file_group = self._dump_conflicts(name, parent_id, file_id,
1425
 
                                              no_base=True)
 
1711
                                              no_base=False,
 
1712
                                              base_lines=base_lines)
1426
1713
            file_group.append(trans_id)
1427
1714
 
1428
1715
 
1429
1716
class LCAMerger(WeaveMerger):
1430
1717
 
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,
 
1718
    def _generate_merge_plan(self, file_id, base):
 
1719
        return self.this_tree.plan_file_lca_merge(file_id, self.other_tree,
1441
1720
                                                  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
1721
 
1453
1722
class Diff3Merger(Merge3Merger):
1454
1723
    """Three-way merger using external diff3 for text merging"""
1455
1724
 
1456
1725
    def dump_file(self, temp_dir, name, tree, file_id):
1457
 
        out_path = pathjoin(temp_dir, name)
 
1726
        out_path = osutils.pathjoin(temp_dir, name)
1458
1727
        out_file = open(out_path, "wb")
1459
1728
        try:
1460
1729
            in_file = tree.get_file(file_id)
1472
1741
        import bzrlib.patch
1473
1742
        temp_dir = osutils.mkdtemp(prefix="bzr-")
1474
1743
        try:
1475
 
            new_file = pathjoin(temp_dir, "new")
 
1744
            new_file = osutils.pathjoin(temp_dir, "new")
1476
1745
            this = self.dump_file(temp_dir, "this", self.this_tree, file_id)
1477
1746
            base = self.dump_file(temp_dir, "base", self.base_tree, file_id)
1478
1747
            other = self.dump_file(temp_dir, "other", self.other_tree, file_id)
1479
1748
            status = bzrlib.patch.diff3(new_file, this, base, other)
1480
1749
            if status not in (0, 1):
1481
 
                raise BzrError("Unhandled diff3 exit code")
 
1750
                raise errors.BzrError("Unhandled diff3 exit code")
1482
1751
            f = open(new_file, 'rb')
1483
1752
            try:
1484
1753
                self.tt.create_file(f, trans_id)
1493
1762
            osutils.rmtree(temp_dir)
1494
1763
 
1495
1764
 
 
1765
class PathNotInTree(errors.BzrError):
 
1766
 
 
1767
    _fmt = """Merge-into failed because %(tree)s does not contain %(path)s."""
 
1768
 
 
1769
    def __init__(self, path, tree):
 
1770
        errors.BzrError.__init__(self, path=path, tree=tree)
 
1771
 
 
1772
 
 
1773
class MergeIntoMerger(Merger):
 
1774
    """Merger that understands other_tree will be merged into a subdir.
 
1775
 
 
1776
    This also changes the Merger api so that it uses real Branch, revision_id,
 
1777
    and RevisonTree objects, rather than using revision specs.
 
1778
    """
 
1779
 
 
1780
    def __init__(self, this_tree, other_branch, other_tree, target_subdir,
 
1781
            source_subpath, other_rev_id=None):
 
1782
        """Create a new MergeIntoMerger object.
 
1783
 
 
1784
        source_subpath in other_tree will be effectively copied to
 
1785
        target_subdir in this_tree.
 
1786
 
 
1787
        :param this_tree: The tree that we will be merging into.
 
1788
        :param other_branch: The Branch we will be merging from.
 
1789
        :param other_tree: The RevisionTree object we want to merge.
 
1790
        :param target_subdir: The relative path where we want to merge
 
1791
            other_tree into this_tree
 
1792
        :param source_subpath: The relative path specifying the subtree of
 
1793
            other_tree to merge into this_tree.
 
1794
        """
 
1795
        # It is assumed that we are merging a tree that is not in our current
 
1796
        # ancestry, which means we are using the "EmptyTree" as our basis.
 
1797
        null_ancestor_tree = this_tree.branch.repository.revision_tree(
 
1798
                                _mod_revision.NULL_REVISION)
 
1799
        super(MergeIntoMerger, self).__init__(
 
1800
            this_branch=this_tree.branch,
 
1801
            this_tree=this_tree,
 
1802
            other_tree=other_tree,
 
1803
            base_tree=null_ancestor_tree,
 
1804
            )
 
1805
        self._target_subdir = target_subdir
 
1806
        self._source_subpath = source_subpath
 
1807
        self.other_branch = other_branch
 
1808
        if other_rev_id is None:
 
1809
            other_rev_id = other_tree.get_revision_id()
 
1810
        self.other_rev_id = self.other_basis = other_rev_id
 
1811
        self.base_is_ancestor = True
 
1812
        self.backup_files = True
 
1813
        self.merge_type = Merge3Merger
 
1814
        self.show_base = False
 
1815
        self.reprocess = False
 
1816
        self.interesting_ids = None
 
1817
        self.merge_type = _MergeTypeParameterizer(MergeIntoMergeType,
 
1818
              target_subdir=self._target_subdir,
 
1819
              source_subpath=self._source_subpath)
 
1820
        if self._source_subpath != '':
 
1821
            # If this isn't a partial merge make sure the revisions will be
 
1822
            # present.
 
1823
            self._maybe_fetch(self.other_branch, self.this_branch,
 
1824
                self.other_basis)
 
1825
 
 
1826
    def set_pending(self):
 
1827
        if self._source_subpath != '':
 
1828
            return
 
1829
        Merger.set_pending(self)
 
1830
 
 
1831
 
 
1832
class _MergeTypeParameterizer(object):
 
1833
    """Wrap a merge-type class to provide extra parameters.
 
1834
    
 
1835
    This is hack used by MergeIntoMerger to pass some extra parameters to its
 
1836
    merge_type.  Merger.do_merge() sets up its own set of parameters to pass to
 
1837
    the 'merge_type' member.  It is difficult override do_merge without
 
1838
    re-writing the whole thing, so instead we create a wrapper which will pass
 
1839
    the extra parameters.
 
1840
    """
 
1841
 
 
1842
    def __init__(self, merge_type, **kwargs):
 
1843
        self._extra_kwargs = kwargs
 
1844
        self._merge_type = merge_type
 
1845
 
 
1846
    def __call__(self, *args, **kwargs):
 
1847
        kwargs.update(self._extra_kwargs)
 
1848
        return self._merge_type(*args, **kwargs)
 
1849
 
 
1850
    def __getattr__(self, name):
 
1851
        return getattr(self._merge_type, name)
 
1852
 
 
1853
 
 
1854
class MergeIntoMergeType(Merge3Merger):
 
1855
    """Merger that incorporates a tree (or part of a tree) into another."""
 
1856
 
 
1857
    def __init__(self, *args, **kwargs):
 
1858
        """Initialize the merger object.
 
1859
 
 
1860
        :param args: See Merge3Merger.__init__'s args.
 
1861
        :param kwargs: See Merge3Merger.__init__'s keyword args, except for
 
1862
            source_subpath and target_subdir.
 
1863
        :keyword source_subpath: The relative path specifying the subtree of
 
1864
            other_tree to merge into this_tree.
 
1865
        :keyword target_subdir: The relative path where we want to merge
 
1866
            other_tree into this_tree
 
1867
        """
 
1868
        # All of the interesting work happens during Merge3Merger.__init__(),
 
1869
        # so we have have to hack in to get our extra parameters set.
 
1870
        self._source_subpath = kwargs.pop('source_subpath')
 
1871
        self._target_subdir = kwargs.pop('target_subdir')
 
1872
        super(MergeIntoMergeType, self).__init__(*args, **kwargs)
 
1873
 
 
1874
    def _compute_transform(self):
 
1875
        child_pb = ui.ui_factory.nested_progress_bar()
 
1876
        try:
 
1877
            entries = self._entries_to_incorporate()
 
1878
            entries = list(entries)
 
1879
            for num, (entry, parent_id) in enumerate(entries):
 
1880
                child_pb.update('Preparing file merge', num, len(entries))
 
1881
                parent_trans_id = self.tt.trans_id_file_id(parent_id)
 
1882
                trans_id = transform.new_by_entry(self.tt, entry,
 
1883
                    parent_trans_id, self.other_tree)
 
1884
        finally:
 
1885
            child_pb.finished()
 
1886
        self._finish_computing_transform()
 
1887
 
 
1888
    def _entries_to_incorporate(self):
 
1889
        """Yields pairs of (inventory_entry, new_parent)."""
 
1890
        other_inv = self.other_tree.inventory
 
1891
        subdir_id = other_inv.path2id(self._source_subpath)
 
1892
        if subdir_id is None:
 
1893
            # XXX: The error would be clearer if it gave the URL of the source
 
1894
            # branch, but we don't have a reference to that here.
 
1895
            raise PathNotInTree(self._source_subpath, "Source tree")
 
1896
        subdir = other_inv[subdir_id]
 
1897
        parent_in_target = osutils.dirname(self._target_subdir)
 
1898
        target_id = self.this_tree.inventory.path2id(parent_in_target)
 
1899
        if target_id is None:
 
1900
            raise PathNotInTree(self._target_subdir, "Target tree")
 
1901
        name_in_target = osutils.basename(self._target_subdir)
 
1902
        merge_into_root = subdir.copy()
 
1903
        merge_into_root.name = name_in_target
 
1904
        if merge_into_root.file_id in self.this_tree.inventory:
 
1905
            # Give the root a new file-id.
 
1906
            # This can happen fairly easily if the directory we are
 
1907
            # incorporating is the root, and both trees have 'TREE_ROOT' as
 
1908
            # their root_id.  Users will expect this to Just Work, so we
 
1909
            # change the file-id here.
 
1910
            # Non-root file-ids could potentially conflict too.  That's really
 
1911
            # an edge case, so we don't do anything special for those.  We let
 
1912
            # them cause conflicts.
 
1913
            merge_into_root.file_id = generate_ids.gen_file_id(name_in_target)
 
1914
        yield (merge_into_root, target_id)
 
1915
        if subdir.kind != 'directory':
 
1916
            # No children, so we are done.
 
1917
            return
 
1918
        for ignored_path, entry in other_inv.iter_entries_by_dir(subdir_id):
 
1919
            parent_id = entry.parent_id
 
1920
            if parent_id == subdir.file_id:
 
1921
                # The root's parent ID has changed, so make sure children of
 
1922
                # the root refer to the new ID.
 
1923
                parent_id = merge_into_root.file_id
 
1924
            yield (entry, parent_id)
 
1925
 
 
1926
 
1496
1927
def merge_inner(this_branch, other_tree, base_tree, ignore_zero=False,
1497
1928
                backup_files=False,
1498
1929
                merge_type=Merge3Merger,
1502
1933
                other_rev_id=None,
1503
1934
                interesting_files=None,
1504
1935
                this_tree=None,
1505
 
                pb=DummyProgress(),
 
1936
                pb=None,
1506
1937
                change_reporter=None):
1507
1938
    """Primary interface for merging.
1508
1939
 
1509
 
        typical use is probably
1510
 
        'merge_inner(branch, branch.get_revision_tree(other_revision),
1511
 
                     branch.get_revision_tree(base_revision))'
1512
 
        """
 
1940
    Typical use is probably::
 
1941
 
 
1942
        merge_inner(branch, branch.get_revision_tree(other_revision),
 
1943
                    branch.get_revision_tree(base_revision))
 
1944
    """
1513
1945
    if this_tree is None:
1514
 
        raise BzrError("bzrlib.merge.merge_inner requires a this_tree "
1515
 
            "parameter as of bzrlib version 0.8.")
 
1946
        raise errors.BzrError("bzrlib.merge.merge_inner requires a this_tree "
 
1947
                              "parameter as of bzrlib version 0.8.")
1516
1948
    merger = Merger(this_branch, other_tree, base_tree, this_tree=this_tree,
1517
1949
                    pb=pb, change_reporter=change_reporter)
1518
1950
    merger.backup_files = backup_files
1736
2168
        super(_PlanMerge, self).__init__(a_rev, b_rev, vf, key_prefix)
1737
2169
        self.a_key = self._key_prefix + (self.a_rev,)
1738
2170
        self.b_key = self._key_prefix + (self.b_rev,)
1739
 
        self.graph = Graph(self.vf)
 
2171
        self.graph = _mod_graph.Graph(self.vf)
1740
2172
        heads = self.graph.heads((self.a_key, self.b_key))
1741
2173
        if len(heads) == 1:
1742
2174
            # one side dominates, so we can just return its values, yay for
1747
2179
                other = b_rev
1748
2180
            else:
1749
2181
                other = a_rev
1750
 
            mutter('found dominating revision for %s\n%s > %s', self.vf,
1751
 
                   self._head_key[-1], other)
 
2182
            trace.mutter('found dominating revision for %s\n%s > %s', self.vf,
 
2183
                         self._head_key[-1], other)
1752
2184
            self._weave = None
1753
2185
        else:
1754
2186
            self._head_key = None
1768
2200
        while True:
1769
2201
            next_lcas = self.graph.find_lca(*cur_ancestors)
1770
2202
            # Map a plain NULL_REVISION to a simple no-ancestors
1771
 
            if next_lcas == set([NULL_REVISION]):
 
2203
            if next_lcas == set([_mod_revision.NULL_REVISION]):
1772
2204
                next_lcas = ()
1773
2205
            # Order the lca's based on when they were merged into the tip
1774
2206
            # While the actual merge portion of weave merge uses a set() of
1786
2218
            elif len(next_lcas) > 2:
1787
2219
                # More than 2 lca's, fall back to grabbing all nodes between
1788
2220
                # 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)
 
2221
                trace.mutter('More than 2 LCAs, falling back to all nodes for:'
 
2222
                             ' %s, %s\n=> %s',
 
2223
                             self.a_key, self.b_key, cur_ancestors)
1791
2224
                cur_lcas = next_lcas
1792
2225
                while len(cur_lcas) > 1:
1793
2226
                    cur_lcas = self.graph.find_lca(*cur_lcas)
1796
2229
                    unique_lca = None
1797
2230
                else:
1798
2231
                    unique_lca = list(cur_lcas)[0]
1799
 
                    if unique_lca == NULL_REVISION:
 
2232
                    if unique_lca == _mod_revision.NULL_REVISION:
1800
2233
                        # find_lca will return a plain 'NULL_REVISION' rather
1801
2234
                        # than a key tuple when there is no common ancestor, we
1802
2235
                        # prefer to just use None, because it doesn't confuse
1825
2258
            # We remove NULL_REVISION because it isn't a proper tuple key, and
1826
2259
            # thus confuses things like _get_interesting_texts, and our logic
1827
2260
            # to add the texts into the memory weave.
1828
 
            if NULL_REVISION in parent_map:
1829
 
                parent_map.pop(NULL_REVISION)
 
2261
            if _mod_revision.NULL_REVISION in parent_map:
 
2262
                parent_map.pop(_mod_revision.NULL_REVISION)
1830
2263
        else:
1831
2264
            interesting = set()
1832
2265
            for tip in tip_keys:
1984
2417
        lcas = graph.find_lca(key_prefix + (a_rev,), key_prefix + (b_rev,))
1985
2418
        self.lcas = set()
1986
2419
        for lca in lcas:
1987
 
            if lca == NULL_REVISION:
 
2420
            if lca == _mod_revision.NULL_REVISION:
1988
2421
                self.lcas.add(lca)
1989
2422
            else:
1990
2423
                self.lcas.add(lca[-1])