/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: Robert Collins
  • Date: 2010-05-06 11:08:10 UTC
  • mto: This revision was merged to the branch mainline in revision 5223.
  • Revision ID: robertc@robertcollins.net-20100506110810-h3j07fh5gmw54s25
Cleaner matcher matching revised unlocking protocol.

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
12
12
#
13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
 
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
 
 
17
 
 
18
 
import errno
19
 
from itertools import chain
20
 
import os
 
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
16
 
21
17
import warnings
22
18
 
23
19
from bzrlib import (
 
20
    branch as _mod_branch,
 
21
    conflicts as _mod_conflicts,
24
22
    debug,
 
23
    decorators,
25
24
    errors,
26
25
    graph as _mod_graph,
 
26
    hooks,
 
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
    )
 
39
from bzrlib.cleanup import OperationWithCleanups
 
40
from bzrlib.symbol_versioning import (
 
41
    deprecated_in,
 
42
    deprecated_method,
 
43
    )
63
44
# TODO: Report back as changes are merged in
64
45
 
65
46
 
66
47
def transform_tree(from_tree, to_tree, interesting_ids=None):
67
 
    merge_inner(from_tree.branch, to_tree, from_tree, ignore_zero=True,
68
 
                interesting_ids=interesting_ids, this_tree=from_tree)
 
48
    from_tree.lock_tree_write()
 
49
    operation = OperationWithCleanups(merge_inner)
 
50
    operation.add_cleanup(from_tree.unlock)
 
51
    operation.run_simple(from_tree.branch, to_tree, from_tree,
 
52
        ignore_zero=True, interesting_ids=interesting_ids, this_tree=from_tree)
 
53
 
 
54
 
 
55
class MergeHooks(hooks.Hooks):
 
56
 
 
57
    def __init__(self):
 
58
        hooks.Hooks.__init__(self)
 
59
        self.create_hook(hooks.HookPoint('merge_file_content',
 
60
            "Called with a bzrlib.merge.Merger object to create a per file "
 
61
            "merge object when starting a merge. "
 
62
            "Should return either None or a subclass of "
 
63
            "``bzrlib.merge.AbstractPerFileMerger``. "
 
64
            "Such objects will then be called per file "
 
65
            "that needs to be merged (including when one "
 
66
            "side has deleted the file and the other has changed it). "
 
67
            "See the AbstractPerFileMerger API docs for details on how it is "
 
68
            "used by merge.",
 
69
            (2, 1), None))
 
70
 
 
71
 
 
72
class AbstractPerFileMerger(object):
 
73
    """PerFileMerger objects are used by plugins extending merge for bzrlib.
 
74
 
 
75
    See ``bzrlib.plugins.news_merge.news_merge`` for an example concrete class.
 
76
    
 
77
    :ivar merger: The Merge3Merger performing the merge.
 
78
    """
 
79
 
 
80
    def __init__(self, merger):
 
81
        """Create a PerFileMerger for use with merger."""
 
82
        self.merger = merger
 
83
 
 
84
    def merge_contents(self, merge_params):
 
85
        """Attempt to merge the contents of a single file.
 
86
        
 
87
        :param merge_params: A bzrlib.merge.MergeHookParams
 
88
        :return : A tuple of (status, chunks), where status is one of
 
89
            'not_applicable', 'success', 'conflicted', or 'delete'.  If status
 
90
            is 'success' or 'conflicted', then chunks should be an iterable of
 
91
            strings for the new file contents.
 
92
        """
 
93
        return ('not applicable', None)
 
94
 
 
95
 
 
96
class PerFileMerger(AbstractPerFileMerger):
 
97
    """Merge individual files when self.file_matches returns True.
 
98
 
 
99
    This class is intended to be subclassed.  The file_matches and
 
100
    merge_matching methods should be overridden with concrete implementations.
 
101
    """
 
102
 
 
103
    def file_matches(self, params):
 
104
        """Return True if merge_matching should be called on this file.
 
105
 
 
106
        Only called with merges of plain files with no clear winner.
 
107
 
 
108
        Subclasses must override this.
 
109
        """
 
110
        raise NotImplementedError(self.file_matches)
 
111
 
 
112
    def get_filename(self, params, tree):
 
113
        """Lookup the filename (i.e. basename, not path), given a Tree (e.g.
 
114
        self.merger.this_tree) and a MergeHookParams.
 
115
        """
 
116
        return osutils.basename(tree.id2path(params.file_id))
 
117
 
 
118
    def get_filepath(self, params, tree):
 
119
        """Calculate the path to the file in a tree.
 
120
 
 
121
        :param params: A MergeHookParams describing the file to merge
 
122
        :param tree: a Tree, e.g. self.merger.this_tree.
 
123
        """
 
124
        return tree.id2path(params.file_id)
 
125
 
 
126
    def merge_contents(self, params):
 
127
        """Merge the contents of a single file."""
 
128
        # Check whether this custom merge logic should be used.
 
129
        if (
 
130
            # OTHER is a straight winner, rely on default merge.
 
131
            params.winner == 'other' or
 
132
            # THIS and OTHER aren't both files.
 
133
            not params.is_file_merge() or
 
134
            # The filename doesn't match *.xml
 
135
            not self.file_matches(params)):
 
136
            return 'not_applicable', None
 
137
        return self.merge_matching(params)
 
138
 
 
139
    def merge_matching(self, params):
 
140
        """Merge the contents of a single file that has matched the criteria
 
141
        in PerFileMerger.merge_contents (is a conflict, is a file,
 
142
        self.file_matches is True).
 
143
 
 
144
        Subclasses must override this.
 
145
        """
 
146
        raise NotImplementedError(self.merge_matching)
 
147
 
 
148
 
 
149
class ConfigurableFileMerger(PerFileMerger):
 
150
    """Merge individual files when configured via a .conf file.
 
151
 
 
152
    This is a base class for concrete custom file merging logic. Concrete
 
153
    classes should implement ``merge_text``.
 
154
 
 
155
    See ``bzrlib.plugins.news_merge.news_merge`` for an example concrete class.
 
156
    
 
157
    :ivar affected_files: The configured file paths to merge.
 
158
 
 
159
    :cvar name_prefix: The prefix to use when looking up configuration
 
160
        details. <name_prefix>_merge_files describes the files targeted by the
 
161
        hook for example.
 
162
        
 
163
    :cvar default_files: The default file paths to merge when no configuration
 
164
        is present.
 
165
    """
 
166
 
 
167
    name_prefix = None
 
168
    default_files = None
 
169
 
 
170
    def __init__(self, merger):
 
171
        super(ConfigurableFileMerger, self).__init__(merger)
 
172
        self.affected_files = None
 
173
        self.default_files = self.__class__.default_files or []
 
174
        self.name_prefix = self.__class__.name_prefix
 
175
        if self.name_prefix is None:
 
176
            raise ValueError("name_prefix must be set.")
 
177
 
 
178
    def file_matches(self, params):
 
179
        """Check whether the file should call the merge hook.
 
180
 
 
181
        <name_prefix>_merge_files configuration variable is a list of files
 
182
        that should use the hook.
 
183
        """
 
184
        affected_files = self.affected_files
 
185
        if affected_files is None:
 
186
            config = self.merger.this_branch.get_config()
 
187
            # Until bzr provides a better policy for caching the config, we
 
188
            # just add the part we're interested in to the params to avoid
 
189
            # reading the config files repeatedly (bazaar.conf, location.conf,
 
190
            # branch.conf).
 
191
            config_key = self.name_prefix + '_merge_files'
 
192
            affected_files = config.get_user_option_as_list(config_key)
 
193
            if affected_files is None:
 
194
                # If nothing was specified in the config, use the default.
 
195
                affected_files = self.default_files
 
196
            self.affected_files = affected_files
 
197
        if affected_files:
 
198
            filepath = self.get_filepath(params, self.merger.this_tree)
 
199
            if filepath in affected_files:
 
200
                return True
 
201
        return False
 
202
 
 
203
    def merge_matching(self, params):
 
204
        return self.merge_text(params)
 
205
 
 
206
    def merge_text(self, params):
 
207
        """Merge the byte contents of a single file.
 
208
 
 
209
        This is called after checking that the merge should be performed in
 
210
        merge_contents, and it should behave as per
 
211
        ``bzrlib.merge.AbstractPerFileMerger.merge_contents``.
 
212
        """
 
213
        raise NotImplementedError(self.merge_text)
 
214
 
 
215
 
 
216
class MergeHookParams(object):
 
217
    """Object holding parameters passed to merge_file_content hooks.
 
218
 
 
219
    There are some fields hooks can access:
 
220
 
 
221
    :ivar file_id: the file ID of the file being merged
 
222
    :ivar trans_id: the transform ID for the merge of this file
 
223
    :ivar this_kind: kind of file_id in 'this' tree
 
224
    :ivar other_kind: kind of file_id in 'other' tree
 
225
    :ivar winner: one of 'this', 'other', 'conflict'
 
226
    """
 
227
 
 
228
    def __init__(self, merger, file_id, trans_id, this_kind, other_kind,
 
229
            winner):
 
230
        self._merger = merger
 
231
        self.file_id = file_id
 
232
        self.trans_id = trans_id
 
233
        self.this_kind = this_kind
 
234
        self.other_kind = other_kind
 
235
        self.winner = winner
 
236
 
 
237
    def is_file_merge(self):
 
238
        """True if this_kind and other_kind are both 'file'."""
 
239
        return self.this_kind == 'file' and self.other_kind == 'file'
 
240
 
 
241
    @decorators.cachedproperty
 
242
    def base_lines(self):
 
243
        """The lines of the 'base' version of the file."""
 
244
        return self._merger.get_lines(self._merger.base_tree, self.file_id)
 
245
 
 
246
    @decorators.cachedproperty
 
247
    def this_lines(self):
 
248
        """The lines of the 'this' version of the file."""
 
249
        return self._merger.get_lines(self._merger.this_tree, self.file_id)
 
250
 
 
251
    @decorators.cachedproperty
 
252
    def other_lines(self):
 
253
        """The lines of the 'other' version of the file."""
 
254
        return self._merger.get_lines(self._merger.other_tree, self.file_id)
69
255
 
70
256
 
71
257
class Merger(object):
 
258
 
 
259
    hooks = MergeHooks()
 
260
 
72
261
    def __init__(self, this_branch, other_tree=None, base_tree=None,
73
 
                 this_tree=None, pb=DummyProgress(), change_reporter=None,
 
262
                 this_tree=None, pb=None, change_reporter=None,
74
263
                 recurse='down', revision_graph=None):
75
264
        object.__init__(self)
76
265
        self.this_branch = this_branch
89
278
        self.interesting_files = None
90
279
        self.show_base = False
91
280
        self.reprocess = False
92
 
        self._pb = pb
 
281
        if pb is not None:
 
282
            warnings.warn("pb parameter to Merger() is deprecated and ignored")
93
283
        self.pp = None
94
284
        self.recurse = recurse
95
285
        self.change_reporter = change_reporter
100
290
        self._is_criss_cross = None
101
291
        self._lca_trees = None
102
292
 
 
293
    def cache_trees_with_revision_ids(self, trees):
 
294
        """Cache any tree in trees if it has a revision_id."""
 
295
        for maybe_tree in trees:
 
296
            if maybe_tree is None:
 
297
                continue
 
298
            try:
 
299
                rev_id = maybe_tree.get_revision_id()
 
300
            except AttributeError:
 
301
                continue
 
302
            self._cached_trees[rev_id] = maybe_tree
 
303
 
103
304
    @property
104
305
    def revision_graph(self):
105
306
        if self._revision_graph is None:
132
333
                                      _set_base_is_other_ancestor)
133
334
 
134
335
    @staticmethod
135
 
    def from_uncommitted(tree, other_tree, pb, base_tree=None):
 
336
    def from_uncommitted(tree, other_tree, pb=None, base_tree=None):
136
337
        """Return a Merger for uncommitted changes in other_tree.
137
338
 
138
339
        :param tree: The tree to merge into
167
368
                base_revision_id, tree.branch.last_revision())):
168
369
                base_revision_id = None
169
370
            else:
170
 
                warning('Performing cherrypick')
 
371
                trace.warning('Performing cherrypick')
171
372
        merger = klass.from_revision_ids(pb, tree, other_revision_id,
172
373
                                         base_revision_id, revision_graph=
173
374
                                         revision_graph)
225
426
        if revno is None:
226
427
            tree = workingtree.WorkingTree.open_containing(location)[0]
227
428
            return tree.branch, tree
228
 
        branch = Branch.open_containing(location, possible_transports)[0]
 
429
        branch = _mod_branch.Branch.open_containing(
 
430
            location, possible_transports)[0]
229
431
        if revno == -1:
230
432
            revision_id = branch.last_revision()
231
433
        else:
232
434
            revision_id = branch.get_rev_id(revno)
233
 
        revision_id = ensure_null(revision_id)
 
435
        revision_id = _mod_revision.ensure_null(revision_id)
234
436
        return branch, self.revision_tree(revision_id, branch)
235
437
 
 
438
    @deprecated_method(deprecated_in((2, 1, 0)))
236
439
    def ensure_revision_trees(self):
237
440
        if self.this_revision_tree is None:
238
441
            self.this_basis_tree = self.revision_tree(self.this_basis)
241
444
 
242
445
        if self.other_rev_id is None:
243
446
            other_basis_tree = self.revision_tree(self.other_basis)
244
 
            changes = other_basis_tree.changes_from(self.other_tree)
245
 
            if changes.has_changed():
246
 
                raise WorkingTreeNotRevision(self.this_tree)
 
447
            if other_basis_tree.has_changes(self.other_tree):
 
448
                raise errors.WorkingTreeNotRevision(self.this_tree)
247
449
            other_rev_id = self.other_basis
248
450
            self.other_tree = other_basis_tree
249
451
 
 
452
    @deprecated_method(deprecated_in((2, 1, 0)))
250
453
    def file_revisions(self, file_id):
251
454
        self.ensure_revision_trees()
252
455
        def get_id(tree, file_id):
255
458
        if self.this_rev_id is None:
256
459
            if self.this_basis_tree.get_file_sha1(file_id) != \
257
460
                self.this_tree.get_file_sha1(file_id):
258
 
                raise WorkingTreeNotRevision(self.this_tree)
 
461
                raise errors.WorkingTreeNotRevision(self.this_tree)
259
462
 
260
463
        trees = (self.this_basis_tree, self.other_tree)
261
464
        return [get_id(tree, file_id) for tree in trees]
262
465
 
 
466
    @deprecated_method(deprecated_in((2, 1, 0)))
263
467
    def check_basis(self, check_clean, require_commits=True):
264
468
        if self.this_basis is None and require_commits is True:
265
 
            raise BzrCommandError("This branch has no commits."
266
 
                                  " (perhaps you would prefer 'bzr pull')")
 
469
            raise errors.BzrCommandError(
 
470
                "This branch has no commits."
 
471
                " (perhaps you would prefer 'bzr pull')")
267
472
        if check_clean:
268
473
            self.compare_basis()
269
474
            if self.this_basis != self.this_rev_id:
270
475
                raise errors.UncommittedChanges(self.this_tree)
271
476
 
 
477
    @deprecated_method(deprecated_in((2, 1, 0)))
272
478
    def compare_basis(self):
273
479
        try:
274
480
            basis_tree = self.revision_tree(self.this_tree.last_revision())
275
481
        except errors.NoSuchRevision:
276
482
            basis_tree = self.this_tree.basis_tree()
277
 
        changes = self.this_tree.changes_from(basis_tree)
278
 
        if not changes.has_changed():
 
483
        if not self.this_tree.has_changes(basis_tree):
279
484
            self.this_rev_id = self.this_basis
280
485
 
281
486
    def set_interesting_files(self, file_list):
282
487
        self.interesting_files = file_list
283
488
 
284
489
    def set_pending(self):
285
 
        if not self.base_is_ancestor or not self.base_is_other_ancestor or self.other_rev_id is None:
 
490
        if (not self.base_is_ancestor or not self.base_is_other_ancestor
 
491
            or self.other_rev_id is None):
286
492
            return
287
493
        self._add_parent()
288
494
 
289
495
    def _add_parent(self):
290
496
        new_parents = self.this_tree.get_parent_ids() + [self.other_rev_id]
291
497
        new_parent_trees = []
 
498
        operation = OperationWithCleanups(self.this_tree.set_parent_trees)
292
499
        for revision_id in new_parents:
293
500
            try:
294
501
                tree = self.revision_tree(revision_id)
296
503
                tree = None
297
504
            else:
298
505
                tree.lock_read()
 
506
                operation.add_cleanup(tree.unlock)
299
507
            new_parent_trees.append((revision_id, tree))
300
 
        try:
301
 
            self.this_tree.set_parent_trees(new_parent_trees,
302
 
                                            allow_leftmost_as_ghost=True)
303
 
        finally:
304
 
            for _revision_id, tree in new_parent_trees:
305
 
                if tree is not None:
306
 
                    tree.unlock()
 
508
        operation.run_simple(new_parent_trees, allow_leftmost_as_ghost=True)
307
509
 
308
510
    def set_other(self, other_revision, possible_transports=None):
309
511
        """Set the revision and tree to merge from.
318
520
            self.other_rev_id = _mod_revision.ensure_null(
319
521
                self.other_branch.last_revision())
320
522
            if _mod_revision.is_null(self.other_rev_id):
321
 
                raise NoCommits(self.other_branch)
 
523
                raise errors.NoCommits(self.other_branch)
322
524
            self.other_basis = self.other_rev_id
323
525
        elif other_revision[1] is not None:
324
526
            self.other_rev_id = self.other_branch.get_rev_id(other_revision[1])
327
529
            self.other_rev_id = None
328
530
            self.other_basis = self.other_branch.last_revision()
329
531
            if self.other_basis is None:
330
 
                raise NoCommits(self.other_branch)
 
532
                raise errors.NoCommits(self.other_branch)
331
533
        if self.other_rev_id is not None:
332
534
            self._cached_trees[self.other_rev_id] = self.other_tree
333
535
        self._maybe_fetch(self.other_branch,self.this_branch, self.other_basis)
360
562
            target.fetch(source, revision_id)
361
563
 
362
564
    def find_base(self):
363
 
        revisions = [ensure_null(self.this_basis),
364
 
                     ensure_null(self.other_basis)]
365
 
        if NULL_REVISION in revisions:
366
 
            self.base_rev_id = NULL_REVISION
 
565
        revisions = [_mod_revision.ensure_null(self.this_basis),
 
566
                     _mod_revision.ensure_null(self.other_basis)]
 
567
        if _mod_revision.NULL_REVISION in revisions:
 
568
            self.base_rev_id = _mod_revision.NULL_REVISION
367
569
            self.base_tree = self.revision_tree(self.base_rev_id)
368
570
            self._is_criss_cross = False
369
571
        else:
370
572
            lcas = self.revision_graph.find_lca(revisions[0], revisions[1])
371
573
            self._is_criss_cross = False
372
574
            if len(lcas) == 0:
373
 
                self.base_rev_id = NULL_REVISION
 
575
                self.base_rev_id = _mod_revision.NULL_REVISION
374
576
            elif len(lcas) == 1:
375
577
                self.base_rev_id = list(lcas)[0]
376
578
            else: # len(lcas) > 1
385
587
                    self.base_rev_id = self.revision_graph.find_unique_lca(
386
588
                                            *lcas)
387
589
                self._is_criss_cross = True
388
 
            if self.base_rev_id == NULL_REVISION:
389
 
                raise UnrelatedBranches()
 
590
            if self.base_rev_id == _mod_revision.NULL_REVISION:
 
591
                raise errors.UnrelatedBranches()
390
592
            if self._is_criss_cross:
391
 
                warning('Warning: criss-cross merge encountered.  See bzr'
392
 
                        ' help criss-cross.')
 
593
                trace.warning('Warning: criss-cross merge encountered.  See bzr'
 
594
                              ' help criss-cross.')
 
595
                trace.mutter('Criss-cross lcas: %r' % lcas)
393
596
                interesting_revision_ids = [self.base_rev_id]
394
597
                interesting_revision_ids.extend(lcas)
395
598
                interesting_trees = dict((t.get_revision_id(), t)
405
608
                self.base_tree = self.revision_tree(self.base_rev_id)
406
609
        self.base_is_ancestor = True
407
610
        self.base_is_other_ancestor = True
 
611
        trace.mutter('Base revid: %r' % self.base_rev_id)
408
612
 
409
613
    def set_base(self, base_revision):
410
614
        """Set the base revision to use for the merge.
411
615
 
412
616
        :param base_revision: A 2-list containing a path and revision number.
413
617
        """
414
 
        mutter("doing merge() with no base_revision specified")
 
618
        trace.mutter("doing merge() with no base_revision specified")
415
619
        if base_revision == [None, None]:
416
620
            self.find_base()
417
621
        else:
430
634
                  'other_tree': self.other_tree,
431
635
                  'interesting_ids': self.interesting_ids,
432
636
                  'interesting_files': self.interesting_files,
433
 
                  'pp': self.pp,
 
637
                  'this_branch': self.this_branch,
434
638
                  'do_merge': False}
435
639
        if self.merge_type.requires_base:
436
640
            kwargs['base_tree'] = self.base_tree
437
641
        if self.merge_type.supports_reprocess:
438
642
            kwargs['reprocess'] = self.reprocess
439
643
        elif self.reprocess:
440
 
            raise BzrError("Conflict reduction is not supported for merge"
441
 
                                  " type %s." % self.merge_type)
 
644
            raise errors.BzrError(
 
645
                "Conflict reduction is not supported for merge"
 
646
                " type %s." % self.merge_type)
442
647
        if self.merge_type.supports_show_base:
443
648
            kwargs['show_base'] = self.show_base
444
649
        elif self.show_base:
445
 
            raise BzrError("Showing base is not supported for this"
446
 
                           " merge type. %s" % self.merge_type)
 
650
            raise errors.BzrError("Showing base is not supported for this"
 
651
                                  " merge type. %s" % self.merge_type)
447
652
        if (not getattr(self.merge_type, 'supports_reverse_cherrypick', True)
448
653
            and not self.base_is_other_ancestor):
449
654
            raise errors.CannotReverseCherrypick()
453
658
        if self._is_criss_cross and getattr(self.merge_type,
454
659
                                            'supports_lca_trees', False):
455
660
            kwargs['lca_trees'] = self._lca_trees
456
 
        return self.merge_type(pb=self._pb,
 
661
        return self.merge_type(pb=None,
457
662
                               change_reporter=self.change_reporter,
458
663
                               **kwargs)
459
664
 
460
 
    def _do_merge_to(self, merge):
 
665
    def _do_merge_to(self):
 
666
        merge = self.make_merger()
 
667
        if self.other_branch is not None:
 
668
            self.other_branch.update_references(self.this_branch)
461
669
        merge.do_merge()
462
670
        if self.recurse == 'down':
463
671
            for relpath, file_id in self.this_tree.iter_references():
475
683
                    sub_tree.branch.repository.revision_tree(base_revision)
476
684
                sub_merge.base_rev_id = base_revision
477
685
                sub_merge.do_merge()
478
 
        
 
686
        return merge
 
687
 
479
688
    def do_merge(self):
 
689
        operation = OperationWithCleanups(self._do_merge_to)
480
690
        self.this_tree.lock_tree_write()
481
 
        try:
482
 
            if self.base_tree is not None:
483
 
                self.base_tree.lock_read()
484
 
            try:
485
 
                if self.other_tree is not None:
486
 
                    self.other_tree.lock_read()
487
 
                try:
488
 
                    merge = self.make_merger()
489
 
                    self._do_merge_to(merge)
490
 
                finally:
491
 
                    if self.other_tree is not None:
492
 
                        self.other_tree.unlock()
493
 
            finally:
494
 
                if self.base_tree is not None:
495
 
                    self.base_tree.unlock()
496
 
        finally:
497
 
            self.this_tree.unlock()
 
691
        operation.add_cleanup(self.this_tree.unlock)
 
692
        if self.base_tree is not None:
 
693
            self.base_tree.lock_read()
 
694
            operation.add_cleanup(self.base_tree.unlock)
 
695
        if self.other_tree is not None:
 
696
            self.other_tree.lock_read()
 
697
            operation.add_cleanup(self.other_tree.unlock)
 
698
        merge = operation.run_simple()
498
699
        if len(merge.cooked_conflicts) == 0:
499
 
            if not self.ignore_zero and not is_quiet():
500
 
                note("All changes applied successfully.")
 
700
            if not self.ignore_zero and not trace.is_quiet():
 
701
                trace.note("All changes applied successfully.")
501
702
        else:
502
 
            note("%d conflicts encountered." % len(merge.cooked_conflicts))
 
703
            trace.note("%d conflicts encountered."
 
704
                       % len(merge.cooked_conflicts))
503
705
 
504
706
        return len(merge.cooked_conflicts)
505
707
 
532
734
    winner_idx = {"this": 2, "other": 1, "conflict": 1}
533
735
    supports_lca_trees = True
534
736
 
535
 
    def __init__(self, working_tree, this_tree, base_tree, other_tree, 
 
737
    def __init__(self, working_tree, this_tree, base_tree, other_tree,
536
738
                 interesting_ids=None, reprocess=False, show_base=False,
537
 
                 pb=DummyProgress(), pp=None, change_reporter=None,
 
739
                 pb=None, pp=None, change_reporter=None,
538
740
                 interesting_files=None, do_merge=True,
539
 
                 cherrypick=False, lca_trees=None):
 
741
                 cherrypick=False, lca_trees=None, this_branch=None):
540
742
        """Initialize the merger object and perform the merge.
541
743
 
542
744
        :param working_tree: The working tree to apply the merge to
543
745
        :param this_tree: The local tree in the merge operation
544
746
        :param base_tree: The common tree in the merge operation
545
 
        :param other_tree: The other other tree to merge changes from
 
747
        :param other_tree: The other tree to merge changes from
 
748
        :param this_branch: The branch associated with this_tree.  Defaults to
 
749
            this_tree.branch if not supplied.
546
750
        :param interesting_ids: The file_ids of files that should be
547
751
            participate in the merge.  May not be combined with
548
752
            interesting_files.
549
753
        :param: reprocess If True, perform conflict-reduction processing.
550
754
        :param show_base: If True, show the base revision in text conflicts.
551
755
            (incompatible with reprocess)
552
 
        :param pb: A Progress bar
 
756
        :param pb: ignored
553
757
        :param pp: A ProgressPhase object
554
758
        :param change_reporter: An object that should report changes made
555
759
        :param interesting_files: The tree-relative paths of files that should
566
770
        if interesting_files is not None and interesting_ids is not None:
567
771
            raise ValueError(
568
772
                'specify either interesting_ids or interesting_files')
 
773
        if this_branch is None:
 
774
            this_branch = this_tree.branch
569
775
        self.interesting_ids = interesting_ids
570
776
        self.interesting_files = interesting_files
571
777
        self.this_tree = working_tree
572
778
        self.base_tree = base_tree
573
779
        self.other_tree = other_tree
 
780
        self.this_branch = this_branch
574
781
        self._raw_conflicts = []
575
782
        self.cooked_conflicts = []
576
783
        self.reprocess = reprocess
581
788
        # making sure we haven't missed any corner cases.
582
789
        # if lca_trees is None:
583
790
        #     self._lca_trees = [self.base_tree]
584
 
        self.pb = pb
585
 
        self.pp = pp
586
791
        self.change_reporter = change_reporter
587
792
        self.cherrypick = cherrypick
588
 
        if self.pp is None:
589
 
            self.pp = ProgressPhase("Merge phase", 3, self.pb)
590
793
        if do_merge:
591
794
            self.do_merge()
 
795
        if pp is not None:
 
796
            warnings.warn("pp argument to Merge3Merger is deprecated")
 
797
        if pb is not None:
 
798
            warnings.warn("pb argument to Merge3Merger is deprecated")
592
799
 
593
800
    def do_merge(self):
 
801
        operation = OperationWithCleanups(self._do_merge)
594
802
        self.this_tree.lock_tree_write()
 
803
        operation.add_cleanup(self.this_tree.unlock)
595
804
        self.base_tree.lock_read()
 
805
        operation.add_cleanup(self.base_tree.unlock)
596
806
        self.other_tree.lock_read()
597
 
        self.tt = TreeTransform(self.this_tree, self.pb)
 
807
        operation.add_cleanup(self.other_tree.unlock)
 
808
        operation.run()
 
809
 
 
810
    def _do_merge(self, operation):
 
811
        self.tt = transform.TreeTransform(self.this_tree, None)
 
812
        operation.add_cleanup(self.tt.finalize)
 
813
        self._compute_transform()
 
814
        results = self.tt.apply(no_conflicts=True)
 
815
        self.write_modified(results)
598
816
        try:
599
 
            self.pp.next_phase()
600
 
            self._compute_transform()
601
 
            self.pp.next_phase()
602
 
            results = self.tt.apply(no_conflicts=True)
603
 
            self.write_modified(results)
604
 
            try:
605
 
                self.this_tree.add_conflicts(self.cooked_conflicts)
606
 
            except UnsupportedOperation:
607
 
                pass
608
 
        finally:
609
 
            self.tt.finalize()
610
 
            self.other_tree.unlock()
611
 
            self.base_tree.unlock()
612
 
            self.this_tree.unlock()
613
 
            self.pb.clear()
 
817
            self.this_tree.add_conflicts(self.cooked_conflicts)
 
818
        except errors.UnsupportedOperation:
 
819
            pass
614
820
 
615
821
    def make_preview_transform(self):
 
822
        operation = OperationWithCleanups(self._make_preview_transform)
616
823
        self.base_tree.lock_read()
 
824
        operation.add_cleanup(self.base_tree.unlock)
617
825
        self.other_tree.lock_read()
618
 
        self.tt = TransformPreview(self.this_tree)
619
 
        try:
620
 
            self.pp.next_phase()
621
 
            self._compute_transform()
622
 
            self.pp.next_phase()
623
 
        finally:
624
 
            self.other_tree.unlock()
625
 
            self.base_tree.unlock()
626
 
            self.pb.clear()
 
826
        operation.add_cleanup(self.other_tree.unlock)
 
827
        return operation.run_simple()
 
828
 
 
829
    def _make_preview_transform(self):
 
830
        self.tt = transform.TransformPreview(self.this_tree)
 
831
        self._compute_transform()
627
832
        return self.tt
628
833
 
629
834
    def _compute_transform(self):
635
840
            resolver = self._lca_multi_way
636
841
        child_pb = ui.ui_factory.nested_progress_bar()
637
842
        try:
 
843
            factories = Merger.hooks['merge_file_content']
 
844
            hooks = [factory(self) for factory in factories] + [self]
 
845
            self.active_hooks = [hook for hook in hooks if hook is not None]
638
846
            for num, (file_id, changed, parents3, names3,
639
847
                      executable3) in enumerate(entries):
640
848
                child_pb.update('Preparing file merge', num, len(entries))
641
849
                self._merge_names(file_id, parents3, names3, resolver=resolver)
642
850
                if changed:
643
 
                    file_status = self.merge_contents(file_id)
 
851
                    file_status = self._do_merge_contents(file_id)
644
852
                else:
645
853
                    file_status = 'unmodified'
646
854
                self._merge_executable(file_id,
648
856
        finally:
649
857
            child_pb.finished()
650
858
        self.fix_root()
651
 
        self.pp.next_phase()
652
859
        child_pb = ui.ui_factory.nested_progress_bar()
653
860
        try:
654
 
            fs_conflicts = resolve_conflicts(self.tt, child_pb,
655
 
                lambda t, c: conflict_pass(t, c, self.other_tree))
 
861
            fs_conflicts = transform.resolve_conflicts(self.tt, child_pb,
 
862
                lambda t, c: transform.conflict_pass(t, c, self.other_tree))
656
863
        finally:
657
864
            child_pb.finished()
658
865
        if self.change_reporter is not None:
661
868
                self.tt.iter_changes(), self.change_reporter)
662
869
        self.cook_conflicts(fs_conflicts)
663
870
        for conflict in self.cooked_conflicts:
664
 
            warning(conflict)
 
871
            trace.warning(conflict)
665
872
 
666
873
    def _entries3(self):
667
874
        """Gather data about files modified between three trees.
794
1001
            content_changed = True
795
1002
            if kind_winner == 'this':
796
1003
                # No kind change in OTHER, see if there are *any* changes
797
 
                if other_ie.kind == None:
798
 
                    # No content and 'this' wins the kind, so skip this?
799
 
                    # continue
800
 
                    pass
801
 
                elif other_ie.kind == 'directory':
 
1004
                if other_ie.kind == 'directory':
802
1005
                    if parent_id_winner == 'this' and name_winner == 'this':
803
1006
                        # No change for this directory in OTHER, skip
804
1007
                        continue
805
1008
                    content_changed = False
806
 
                elif other_ie.kind == 'file':
 
1009
                elif other_ie.kind is None or other_ie.kind == 'file':
807
1010
                    def get_sha1(ie, tree):
808
1011
                        if ie.kind != 'file':
809
1012
                            return None
856
1059
                        continue
857
1060
                else:
858
1061
                    raise AssertionError('unhandled kind: %s' % other_ie.kind)
859
 
                # XXX: We need to handle kind == 'symlink'
860
1062
 
861
1063
            # If we have gotten this far, that means something has changed
862
1064
            result.append((file_id, content_changed,
873
1075
    def fix_root(self):
874
1076
        try:
875
1077
            self.tt.final_kind(self.tt.root)
876
 
        except NoSuchFile:
 
1078
        except errors.NoSuchFile:
877
1079
            self.tt.cancel_deletion(self.tt.root)
878
1080
        if self.tt.final_file_id(self.tt.root) is None:
879
 
            self.tt.version_file(self.tt.tree_file_id(self.tt.root), 
 
1081
            self.tt.version_file(self.tt.tree_file_id(self.tt.root),
880
1082
                                 self.tt.root)
881
1083
        other_root_file_id = self.other_tree.get_root_id()
882
1084
        if other_root_file_id is None:
884
1086
        other_root = self.tt.trans_id_file_id(other_root_file_id)
885
1087
        if other_root == self.tt.root:
886
1088
            return
 
1089
        if self.other_tree.inventory.root.file_id in self.this_tree.inventory:
 
1090
            # the other tree's root is a non-root in the current tree (as when
 
1091
            # a previously unrelated branch is merged into another)
 
1092
            return
887
1093
        try:
888
1094
            self.tt.final_kind(other_root)
889
 
        except NoSuchFile:
890
 
            return
891
 
        if self.other_tree.inventory.root.file_id in self.this_tree.inventory:
892
 
            # the other tree's root is a non-root in the current tree
893
 
            return
894
 
        self.reparent_children(self.other_tree.inventory.root, self.tt.root)
895
 
        self.tt.cancel_creation(other_root)
896
 
        self.tt.cancel_versioning(other_root)
897
 
 
898
 
    def reparent_children(self, ie, target):
899
 
        for thing, child in ie.children.iteritems():
 
1095
            other_root_is_present = True
 
1096
        except errors.NoSuchFile:
 
1097
            # other_root doesn't have a physical representation. We still need
 
1098
            # to move any references to the actual root of the tree.
 
1099
            other_root_is_present = False
 
1100
        # 'other_tree.inventory.root' is not present in this tree. We are
 
1101
        # calling adjust_path for children which *want* to be present with a
 
1102
        # correct place to go.
 
1103
        for thing, child in self.other_tree.inventory.root.children.iteritems():
900
1104
            trans_id = self.tt.trans_id_file_id(child.file_id)
901
 
            self.tt.adjust_path(self.tt.final_name(trans_id), target, trans_id)
 
1105
            if not other_root_is_present:
 
1106
                # FIXME: Make final_kind returns None instead of raising
 
1107
                # NoSuchFile to avoid the ugly construct below -- vila 20100402
 
1108
                try:
 
1109
                    self.tt.final_kind(trans_id)
 
1110
                    # The item exist in the final tree and has a defined place
 
1111
                    # to go already.
 
1112
                    continue
 
1113
                except errors.NoSuchFile, e:
 
1114
                    pass
 
1115
            # Move the item into the root
 
1116
            self.tt.adjust_path(self.tt.final_name(trans_id),
 
1117
                                self.tt.root, trans_id)
 
1118
        if other_root_is_present:
 
1119
            self.tt.cancel_creation(other_root)
 
1120
            self.tt.cancel_versioning(other_root)
902
1121
 
903
1122
    def write_modified(self, results):
904
1123
        modified_hashes = {}
925
1144
        if entry is None:
926
1145
            return None
927
1146
        return entry.name
928
 
    
 
1147
 
929
1148
    @staticmethod
930
1149
    def contents_sha1(tree, file_id):
931
1150
        """Determine the sha1 of the file contents (used as a key method)."""
936
1155
    @staticmethod
937
1156
    def executable(tree, file_id):
938
1157
        """Determine the executability of a file-id (used as a key method)."""
939
 
        if file_id not in tree:
 
1158
        if not tree.has_id(file_id):
940
1159
            return None
941
1160
        if tree.kind(file_id) != "file":
942
1161
            return False
945
1164
    @staticmethod
946
1165
    def kind(tree, file_id):
947
1166
        """Determine the kind of a file-id (used as a key method)."""
948
 
        if file_id not in tree:
 
1167
        if not tree.has_id(file_id):
949
1168
            return None
950
1169
        return tree.kind(file_id)
951
1170
 
952
1171
    @staticmethod
953
1172
    def _three_way(base, other, this):
954
 
        #if base == other, either they all agree, or only THIS has changed.
955
1173
        if base == other:
 
1174
            # if 'base == other', either they all agree, or only 'this' has
 
1175
            # changed.
956
1176
            return 'this'
957
1177
        elif this not in (base, other):
 
1178
            # 'this' is neither 'base' nor 'other', so both sides changed
958
1179
            return 'conflict'
959
 
        # "Ambiguous clean merge" -- both sides have made the same change.
960
1180
        elif this == other:
 
1181
            # "Ambiguous clean merge" -- both sides have made the same change.
961
1182
            return "this"
962
 
        # this == base: only other has changed.
963
1183
        else:
 
1184
            # this == base: only other has changed.
964
1185
            return "other"
965
1186
 
966
1187
    @staticmethod
979
1200
        :return: 'this', 'other', or 'conflict' depending on whether an entry
980
1201
            changed or not.
981
1202
        """
982
 
        # See doc/developers/lca_merge_resolution.txt for details about this
 
1203
        # See doc/developers/lca_tree_merging.txt for details about this
983
1204
        # algorithm.
984
1205
        if other == this:
985
1206
            # Either Ambiguously clean, or nothing was actually changed. We
1010
1231
                # only has an lca value
1011
1232
                return 'other'
1012
1233
 
1013
 
        # At this point, the lcas disagree, and the tips disagree
 
1234
        # At this point, the lcas disagree, and the tip disagree
1014
1235
        return 'conflict'
1015
1236
 
1016
1237
    @staticmethod
 
1238
    @deprecated_method(deprecated_in((2, 2, 0)))
1017
1239
    def scalar_three_way(this_tree, base_tree, other_tree, file_id, key):
1018
1240
        """Do a three-way test on a scalar.
1019
1241
        Return "this", "other" or "conflict", depending whether a value wins.
1034
1256
 
1035
1257
    def merge_names(self, file_id):
1036
1258
        def get_entry(tree):
1037
 
            if file_id in tree.inventory:
 
1259
            if tree.has_id(file_id):
1038
1260
                return tree.inventory[file_id]
1039
1261
            else:
1040
1262
                return None
1069
1291
                parent_id_winner = "other"
1070
1292
        if name_winner == "this" and parent_id_winner == "this":
1071
1293
            return
1072
 
        if name_winner == "conflict":
1073
 
            trans_id = self.tt.trans_id_file_id(file_id)
1074
 
            self._raw_conflicts.append(('name conflict', trans_id, 
1075
 
                                        this_name, other_name))
1076
 
        if parent_id_winner == "conflict":
1077
 
            trans_id = self.tt.trans_id_file_id(file_id)
1078
 
            self._raw_conflicts.append(('parent conflict', trans_id, 
1079
 
                                        this_parent, other_parent))
 
1294
        if name_winner == 'conflict' or parent_id_winner == 'conflict':
 
1295
            # Creating helpers (.OTHER or .THIS) here cause problems down the
 
1296
            # road if a ContentConflict needs to be created so we should not do
 
1297
            # that
 
1298
            trans_id = self.tt.trans_id_file_id(file_id)
 
1299
            self._raw_conflicts.append(('path conflict', trans_id, file_id,
 
1300
                                        this_parent, this_name,
 
1301
                                        other_parent, other_name))
1080
1302
        if other_name is None:
1081
 
            # it doesn't matter whether the result was 'other' or 
 
1303
            # it doesn't matter whether the result was 'other' or
1082
1304
            # 'conflict'-- if there's no 'other', we leave it alone.
1083
1305
            return
1084
 
        # if we get here, name_winner and parent_winner are set to safe values.
1085
 
        trans_id = self.tt.trans_id_file_id(file_id)
1086
1306
        parent_id = parents[self.winner_idx[parent_id_winner]]
1087
1307
        if parent_id is not None:
1088
 
            parent_trans_id = self.tt.trans_id_file_id(parent_id)
 
1308
            # if we get here, name_winner and parent_winner are set to safe
 
1309
            # values.
1089
1310
            self.tt.adjust_path(names[self.winner_idx[name_winner]],
1090
 
                                parent_trans_id, trans_id)
 
1311
                                self.tt.trans_id_file_id(parent_id),
 
1312
                                self.tt.trans_id_file_id(file_id))
1091
1313
 
1092
 
    def merge_contents(self, file_id):
1093
 
        """Performa a merge on file_id contents."""
 
1314
    def _do_merge_contents(self, file_id):
 
1315
        """Performs a merge on file_id contents."""
1094
1316
        def contents_pair(tree):
1095
1317
            if file_id not in tree:
1096
1318
                return (None, None)
1103
1325
                contents = None
1104
1326
            return kind, contents
1105
1327
 
1106
 
        def contents_conflict():
1107
 
            trans_id = self.tt.trans_id_file_id(file_id)
1108
 
            name = self.tt.final_name(trans_id)
1109
 
            parent_id = self.tt.final_parent(trans_id)
1110
 
            if file_id in self.this_tree.inventory:
1111
 
                self.tt.unversion_file(trans_id)
1112
 
                if file_id in self.this_tree:
1113
 
                    self.tt.delete_contents(trans_id)
1114
 
            file_group = self._dump_conflicts(name, parent_id, file_id, 
1115
 
                                              set_version=True)
1116
 
            self._raw_conflicts.append(('contents conflict', file_group))
1117
 
 
1118
1328
        # See SPOT run.  run, SPOT, run.
1119
1329
        # So we're not QUITE repeating ourselves; we do tricky things with
1120
1330
        # file kind...
1121
1331
        base_pair = contents_pair(self.base_tree)
1122
1332
        other_pair = contents_pair(self.other_tree)
1123
 
        if base_pair == other_pair:
1124
 
            # OTHER introduced no changes
1125
 
            return "unmodified"
1126
 
        this_pair = contents_pair(self.this_tree)
1127
 
        if this_pair == other_pair:
1128
 
            # THIS and OTHER introduced the same changes
1129
 
            return "unmodified"
1130
 
        else:
1131
 
            trans_id = self.tt.trans_id_file_id(file_id)
1132
 
            if this_pair == base_pair:
1133
 
                # only OTHER introduced changes
1134
 
                if file_id in self.this_tree:
1135
 
                    # Remove any existing contents
1136
 
                    self.tt.delete_contents(trans_id)
1137
 
                if file_id in self.other_tree:
1138
 
                    # OTHER changed the file
1139
 
                    create_from_tree(self.tt, trans_id,
1140
 
                                     self.other_tree, file_id)
1141
 
                    if file_id not in self.this_tree:
1142
 
                        self.tt.version_file(file_id, trans_id)
1143
 
                    return "modified"
1144
 
                elif file_id in self.this_tree.inventory:
1145
 
                    # OTHER deleted the file
1146
 
                    self.tt.unversion_file(trans_id)
1147
 
                    return "deleted"
1148
 
            #BOTH THIS and OTHER introduced changes; scalar conflict
1149
 
            elif this_pair[0] == "file" and other_pair[0] == "file":
1150
 
                # THIS and OTHER are both files, so text merge.  Either
1151
 
                # BASE is a file, or both converted to files, so at least we
1152
 
                # have agreement that output should be a file.
1153
 
                try:
1154
 
                    self.text_merge(file_id, trans_id)
1155
 
                except BinaryFile:
1156
 
                    return contents_conflict()
1157
 
                if file_id not in self.this_tree:
1158
 
                    self.tt.version_file(file_id, trans_id)
1159
 
                try:
1160
 
                    self.tt.tree_kind(trans_id)
1161
 
                    self.tt.delete_contents(trans_id)
1162
 
                except NoSuchFile:
1163
 
                    pass
1164
 
                return "modified"
1165
 
            else:
1166
 
                # Scalar conflict, can't text merge.  Dump conflicts
1167
 
                return contents_conflict()
 
1333
        if self._lca_trees:
 
1334
            this_pair = contents_pair(self.this_tree)
 
1335
            lca_pairs = [contents_pair(tree) for tree in self._lca_trees]
 
1336
            winner = self._lca_multi_way((base_pair, lca_pairs), other_pair,
 
1337
                                         this_pair, allow_overriding_lca=False)
 
1338
        else:
 
1339
            if base_pair == other_pair:
 
1340
                winner = 'this'
 
1341
            else:
 
1342
                # We delayed evaluating this_pair as long as we can to avoid
 
1343
                # unnecessary sha1 calculation
 
1344
                this_pair = contents_pair(self.this_tree)
 
1345
                winner = self._three_way(base_pair, other_pair, this_pair)
 
1346
        if winner == 'this':
 
1347
            # No interesting changes introduced by OTHER
 
1348
            return "unmodified"
 
1349
        # We have a hypothetical conflict, but if we have files, then we
 
1350
        # can try to merge the content
 
1351
        trans_id = self.tt.trans_id_file_id(file_id)
 
1352
        params = MergeHookParams(self, file_id, trans_id, this_pair[0],
 
1353
            other_pair[0], winner)
 
1354
        hooks = self.active_hooks
 
1355
        hook_status = 'not_applicable'
 
1356
        for hook in hooks:
 
1357
            hook_status, lines = hook.merge_contents(params)
 
1358
            if hook_status != 'not_applicable':
 
1359
                # Don't try any more hooks, this one applies.
 
1360
                break
 
1361
        result = "modified"
 
1362
        if hook_status == 'not_applicable':
 
1363
            # This is a contents conflict, because none of the available
 
1364
            # functions could merge it.
 
1365
            result = None
 
1366
            name = self.tt.final_name(trans_id)
 
1367
            parent_id = self.tt.final_parent(trans_id)
 
1368
            if self.this_tree.has_id(file_id):
 
1369
                self.tt.unversion_file(trans_id)
 
1370
            file_group = self._dump_conflicts(name, parent_id, file_id,
 
1371
                                              set_version=True)
 
1372
            self._raw_conflicts.append(('contents conflict', file_group))
 
1373
        elif hook_status == 'success':
 
1374
            self.tt.create_file(lines, trans_id)
 
1375
        elif hook_status == 'conflicted':
 
1376
            # XXX: perhaps the hook should be able to provide
 
1377
            # the BASE/THIS/OTHER files?
 
1378
            self.tt.create_file(lines, trans_id)
 
1379
            self._raw_conflicts.append(('text conflict', trans_id))
 
1380
            name = self.tt.final_name(trans_id)
 
1381
            parent_id = self.tt.final_parent(trans_id)
 
1382
            self._dump_conflicts(name, parent_id, file_id)
 
1383
        elif hook_status == 'delete':
 
1384
            self.tt.unversion_file(trans_id)
 
1385
            result = "deleted"
 
1386
        elif hook_status == 'done':
 
1387
            # The hook function did whatever it needs to do directly, no
 
1388
            # further action needed here.
 
1389
            pass
 
1390
        else:
 
1391
            raise AssertionError('unknown hook_status: %r' % (hook_status,))
 
1392
        if not self.this_tree.has_id(file_id) and result == "modified":
 
1393
            self.tt.version_file(file_id, trans_id)
 
1394
        # The merge has been performed, so the old contents should not be
 
1395
        # retained.
 
1396
        try:
 
1397
            self.tt.delete_contents(trans_id)
 
1398
        except errors.NoSuchFile:
 
1399
            pass
 
1400
        return result
 
1401
 
 
1402
    def _default_other_winner_merge(self, merge_hook_params):
 
1403
        """Replace this contents with other."""
 
1404
        file_id = merge_hook_params.file_id
 
1405
        trans_id = merge_hook_params.trans_id
 
1406
        file_in_this = self.this_tree.has_id(file_id)
 
1407
        if self.other_tree.has_id(file_id):
 
1408
            # OTHER changed the file
 
1409
            wt = self.this_tree
 
1410
            if wt.supports_content_filtering():
 
1411
                # We get the path from the working tree if it exists.
 
1412
                # That fails though when OTHER is adding a file, so
 
1413
                # we fall back to the other tree to find the path if
 
1414
                # it doesn't exist locally.
 
1415
                try:
 
1416
                    filter_tree_path = wt.id2path(file_id)
 
1417
                except errors.NoSuchId:
 
1418
                    filter_tree_path = self.other_tree.id2path(file_id)
 
1419
            else:
 
1420
                # Skip the id2path lookup for older formats
 
1421
                filter_tree_path = None
 
1422
            transform.create_from_tree(self.tt, trans_id,
 
1423
                             self.other_tree, file_id,
 
1424
                             filter_tree_path=filter_tree_path)
 
1425
            return 'done', None
 
1426
        elif file_in_this:
 
1427
            # OTHER deleted the file
 
1428
            return 'delete', None
 
1429
        else:
 
1430
            raise AssertionError(
 
1431
                'winner is OTHER, but file_id %r not in THIS or OTHER tree'
 
1432
                % (file_id,))
 
1433
 
 
1434
    def merge_contents(self, merge_hook_params):
 
1435
        """Fallback merge logic after user installed hooks."""
 
1436
        # This function is used in merge hooks as the fallback instance.
 
1437
        # Perhaps making this function and the functions it calls be a 
 
1438
        # a separate class would be better.
 
1439
        if merge_hook_params.winner == 'other':
 
1440
            # OTHER is a straight winner, so replace this contents with other
 
1441
            return self._default_other_winner_merge(merge_hook_params)
 
1442
        elif merge_hook_params.is_file_merge():
 
1443
            # THIS and OTHER are both files, so text merge.  Either
 
1444
            # BASE is a file, or both converted to files, so at least we
 
1445
            # have agreement that output should be a file.
 
1446
            try:
 
1447
                self.text_merge(merge_hook_params.file_id,
 
1448
                    merge_hook_params.trans_id)
 
1449
            except errors.BinaryFile:
 
1450
                return 'not_applicable', None
 
1451
            return 'done', None
 
1452
        else:
 
1453
            return 'not_applicable', None
1168
1454
 
1169
1455
    def get_lines(self, tree, file_id):
1170
1456
        """Return the lines in a file, or an empty list."""
1171
 
        if file_id in tree:
 
1457
        if tree.has_id(file_id):
1172
1458
            return tree.get_file(file_id).readlines()
1173
1459
        else:
1174
1460
            return []
1177
1463
        """Perform a three-way text merge on a file_id"""
1178
1464
        # it's possible that we got here with base as a different type.
1179
1465
        # if so, we just want two-way text conflicts.
1180
 
        if file_id in self.base_tree and \
 
1466
        if self.base_tree.has_id(file_id) and \
1181
1467
            self.base_tree.kind(file_id) == "file":
1182
1468
            base_lines = self.get_lines(self.base_tree, file_id)
1183
1469
        else:
1184
1470
            base_lines = []
1185
1471
        other_lines = self.get_lines(self.other_tree, file_id)
1186
1472
        this_lines = self.get_lines(self.this_tree, file_id)
1187
 
        m3 = Merge3(base_lines, this_lines, other_lines,
1188
 
                    is_cherrypick=self.cherrypick)
 
1473
        m3 = merge3.Merge3(base_lines, this_lines, other_lines,
 
1474
                           is_cherrypick=self.cherrypick)
1189
1475
        start_marker = "!START OF MERGE CONFLICT!" + "I HOPE THIS IS UNIQUE"
1190
1476
        if self.show_base is True:
1191
1477
            base_marker = '|' * 7
1194
1480
 
1195
1481
        def iter_merge3(retval):
1196
1482
            retval["text_conflicts"] = False
1197
 
            for line in m3.merge_lines(name_a = "TREE", 
1198
 
                                       name_b = "MERGE-SOURCE", 
 
1483
            for line in m3.merge_lines(name_a = "TREE",
 
1484
                                       name_b = "MERGE-SOURCE",
1199
1485
                                       name_base = "BASE-REVISION",
1200
 
                                       start_marker=start_marker, 
 
1486
                                       start_marker=start_marker,
1201
1487
                                       base_marker=base_marker,
1202
1488
                                       reprocess=self.reprocess):
1203
1489
                if line.startswith(start_marker):
1212
1498
            self._raw_conflicts.append(('text conflict', trans_id))
1213
1499
            name = self.tt.final_name(trans_id)
1214
1500
            parent_id = self.tt.final_parent(trans_id)
1215
 
            file_group = self._dump_conflicts(name, parent_id, file_id, 
 
1501
            file_group = self._dump_conflicts(name, parent_id, file_id,
1216
1502
                                              this_lines, base_lines,
1217
1503
                                              other_lines)
1218
1504
            file_group.append(trans_id)
1219
1505
 
1220
 
    def _dump_conflicts(self, name, parent_id, file_id, this_lines=None, 
 
1506
    def _dump_conflicts(self, name, parent_id, file_id, this_lines=None,
1221
1507
                        base_lines=None, other_lines=None, set_version=False,
1222
1508
                        no_base=False):
1223
1509
        """Emit conflict files.
1225
1511
        determined automatically.  If set_version is true, the .OTHER, .THIS
1226
1512
        or .BASE (in that order) will be created as versioned files.
1227
1513
        """
1228
 
        data = [('OTHER', self.other_tree, other_lines), 
 
1514
        data = [('OTHER', self.other_tree, other_lines),
1229
1515
                ('THIS', self.this_tree, this_lines)]
1230
1516
        if not no_base:
1231
1517
            data.append(('BASE', self.base_tree, base_lines))
 
1518
 
 
1519
        # We need to use the actual path in the working tree of the file here,
 
1520
        # ignoring the conflict suffixes
 
1521
        wt = self.this_tree
 
1522
        if wt.supports_content_filtering():
 
1523
            try:
 
1524
                filter_tree_path = wt.id2path(file_id)
 
1525
            except errors.NoSuchId:
 
1526
                # file has been deleted
 
1527
                filter_tree_path = None
 
1528
        else:
 
1529
            # Skip the id2path lookup for older formats
 
1530
            filter_tree_path = None
 
1531
 
1232
1532
        versioned = False
1233
1533
        file_group = []
1234
1534
        for suffix, tree, lines in data:
1235
 
            if file_id in tree:
 
1535
            if tree.has_id(file_id):
1236
1536
                trans_id = self._conflict_file(name, parent_id, tree, file_id,
1237
 
                                               suffix, lines)
 
1537
                                               suffix, lines, filter_tree_path)
1238
1538
                file_group.append(trans_id)
1239
1539
                if set_version and not versioned:
1240
1540
                    self.tt.version_file(file_id, trans_id)
1241
1541
                    versioned = True
1242
1542
        return file_group
1243
 
           
 
1543
 
1244
1544
    def _conflict_file(self, name, parent_id, tree, file_id, suffix,
1245
 
                       lines=None):
 
1545
                       lines=None, filter_tree_path=None):
1246
1546
        """Emit a single conflict file."""
1247
1547
        name = name + '.' + suffix
1248
1548
        trans_id = self.tt.create_path(name, parent_id)
1249
 
        create_from_tree(self.tt, trans_id, tree, file_id, lines)
 
1549
        transform.create_from_tree(self.tt, trans_id, tree, file_id, lines,
 
1550
            filter_tree_path)
1250
1551
        return trans_id
1251
1552
 
1252
1553
    def merge_executable(self, file_id, file_status):
1276
1577
        try:
1277
1578
            if self.tt.final_kind(trans_id) != "file":
1278
1579
                return
1279
 
        except NoSuchFile:
 
1580
        except errors.NoSuchFile:
1280
1581
            return
1281
1582
        if winner == "this":
1282
1583
            executability = this_executable
1283
1584
        else:
1284
 
            if file_id in self.other_tree:
 
1585
            if self.other_tree.has_id(file_id):
1285
1586
                executability = other_executable
1286
 
            elif file_id in self.this_tree:
 
1587
            elif self.this_tree.has_id(file_id):
1287
1588
                executability = this_executable
1288
 
            elif file_id in self.base_tree:
 
1589
            elif self.base_tree_has_id(file_id):
1289
1590
                executability = base_executable
1290
1591
        if executability is not None:
1291
1592
            trans_id = self.tt.trans_id_file_id(file_id)
1293
1594
 
1294
1595
    def cook_conflicts(self, fs_conflicts):
1295
1596
        """Convert all conflicts into a form that doesn't depend on trans_id"""
1296
 
        from conflicts import Conflict
1297
 
        name_conflicts = {}
1298
 
        self.cooked_conflicts.extend(cook_conflicts(fs_conflicts, self.tt))
1299
 
        fp = FinalPaths(self.tt)
 
1597
        self.cooked_conflicts.extend(transform.cook_conflicts(
 
1598
                fs_conflicts, self.tt))
 
1599
        fp = transform.FinalPaths(self.tt)
1300
1600
        for conflict in self._raw_conflicts:
1301
1601
            conflict_type = conflict[0]
1302
 
            if conflict_type in ('name conflict', 'parent conflict'):
1303
 
                trans_id = conflict[1]
1304
 
                conflict_args = conflict[2:]
1305
 
                if trans_id not in name_conflicts:
1306
 
                    name_conflicts[trans_id] = {}
1307
 
                unique_add(name_conflicts[trans_id], conflict_type, 
1308
 
                           conflict_args)
1309
 
            if conflict_type == 'contents conflict':
 
1602
            if conflict_type == 'path conflict':
 
1603
                (trans_id, file_id,
 
1604
                this_parent, this_name,
 
1605
                other_parent, other_name) = conflict[1:]
 
1606
                if this_parent is None or this_name is None:
 
1607
                    this_path = '<deleted>'
 
1608
                else:
 
1609
                    parent_path =  fp.get_path(
 
1610
                        self.tt.trans_id_file_id(this_parent))
 
1611
                    this_path = osutils.pathjoin(parent_path, this_name)
 
1612
                if other_parent is None or other_name is None:
 
1613
                    other_path = '<deleted>'
 
1614
                else:
 
1615
                    parent_path =  fp.get_path(
 
1616
                        self.tt.trans_id_file_id(other_parent))
 
1617
                    other_path = osutils.pathjoin(parent_path, other_name)
 
1618
                c = _mod_conflicts.Conflict.factory(
 
1619
                    'path conflict', path=this_path,
 
1620
                    conflict_path=other_path,
 
1621
                    file_id=file_id)
 
1622
            elif conflict_type == 'contents conflict':
1310
1623
                for trans_id in conflict[1]:
1311
1624
                    file_id = self.tt.final_file_id(trans_id)
1312
1625
                    if file_id is not None:
1316
1629
                    if path.endswith(suffix):
1317
1630
                        path = path[:-len(suffix)]
1318
1631
                        break
1319
 
                c = Conflict.factory(conflict_type, path=path, file_id=file_id)
1320
 
                self.cooked_conflicts.append(c)
1321
 
            if conflict_type == 'text conflict':
 
1632
                c = _mod_conflicts.Conflict.factory(conflict_type,
 
1633
                                                    path=path, file_id=file_id)
 
1634
            elif conflict_type == 'text conflict':
1322
1635
                trans_id = conflict[1]
1323
1636
                path = fp.get_path(trans_id)
1324
1637
                file_id = self.tt.final_file_id(trans_id)
1325
 
                c = Conflict.factory(conflict_type, path=path, file_id=file_id)
1326
 
                self.cooked_conflicts.append(c)
1327
 
 
1328
 
        for trans_id, conflicts in name_conflicts.iteritems():
1329
 
            try:
1330
 
                this_parent, other_parent = conflicts['parent conflict']
1331
 
                if this_parent == other_parent:
1332
 
                    raise AssertionError()
1333
 
            except KeyError:
1334
 
                this_parent = other_parent = \
1335
 
                    self.tt.final_file_id(self.tt.final_parent(trans_id))
1336
 
            try:
1337
 
                this_name, other_name = conflicts['name conflict']
1338
 
                if this_name == other_name:
1339
 
                    raise AssertionError()
1340
 
            except KeyError:
1341
 
                this_name = other_name = self.tt.final_name(trans_id)
1342
 
            other_path = fp.get_path(trans_id)
1343
 
            if this_parent is not None and this_name is not None:
1344
 
                this_parent_path = \
1345
 
                    fp.get_path(self.tt.trans_id_file_id(this_parent))
1346
 
                this_path = pathjoin(this_parent_path, this_name)
 
1638
                c = _mod_conflicts.Conflict.factory(conflict_type,
 
1639
                                                    path=path, file_id=file_id)
1347
1640
            else:
1348
 
                this_path = "<deleted>"
1349
 
            file_id = self.tt.final_file_id(trans_id)
1350
 
            c = Conflict.factory('path conflict', path=this_path,
1351
 
                                 conflict_path=other_path, file_id=file_id)
 
1641
                raise AssertionError('bad conflict type: %r' % (conflict,))
1352
1642
            self.cooked_conflicts.append(c)
1353
 
        self.cooked_conflicts.sort(key=Conflict.sort_key)
 
1643
        self.cooked_conflicts.sort(key=_mod_conflicts.Conflict.sort_key)
1354
1644
 
1355
1645
 
1356
1646
class WeaveMerger(Merge3Merger):
1360
1650
    supports_reverse_cherrypick = False
1361
1651
    history_based = True
1362
1652
 
1363
 
    def _merged_lines(self, file_id):
1364
 
        """Generate the merged lines.
1365
 
        There is no distinction between lines that are meant to contain <<<<<<<
1366
 
        and conflicts.
1367
 
        """
1368
 
        if self.cherrypick:
1369
 
            base = self.base_tree
1370
 
        else:
1371
 
            base = None
1372
 
        plan = self.this_tree.plan_file_merge(file_id, self.other_tree,
 
1653
    def _generate_merge_plan(self, file_id, base):
 
1654
        return self.this_tree.plan_file_merge(file_id, self.other_tree,
1373
1655
                                              base=base)
 
1656
 
 
1657
    def _merged_lines(self, file_id):
 
1658
        """Generate the merged lines.
 
1659
        There is no distinction between lines that are meant to contain <<<<<<<
 
1660
        and conflicts.
 
1661
        """
 
1662
        if self.cherrypick:
 
1663
            base = self.base_tree
 
1664
        else:
 
1665
            base = None
 
1666
        plan = self._generate_merge_plan(file_id, base)
1374
1667
        if 'merge' in debug.debug_flags:
1375
1668
            plan = list(plan)
1376
1669
            trans_id = self.tt.trans_id_file_id(file_id)
1377
1670
            name = self.tt.final_name(trans_id) + '.plan'
1378
 
            contents = ('%10s|%s' % l for l in plan)
 
1671
            contents = ('%11s|%s' % l for l in plan)
1379
1672
            self.tt.new_file(name, self.tt.final_parent(trans_id), contents)
1380
 
        textmerge = PlanWeaveMerge(plan, '<<<<<<< TREE\n',
1381
 
            '>>>>>>> MERGE-SOURCE\n')
1382
 
        return textmerge.merge_lines(self.reprocess)
 
1673
        textmerge = versionedfile.PlanWeaveMerge(plan, '<<<<<<< TREE\n',
 
1674
                                                 '>>>>>>> MERGE-SOURCE\n')
 
1675
        lines, conflicts = textmerge.merge_lines(self.reprocess)
 
1676
        if conflicts:
 
1677
            base_lines = textmerge.base_from_plan()
 
1678
        else:
 
1679
            base_lines = None
 
1680
        return lines, base_lines
1383
1681
 
1384
1682
    def text_merge(self, file_id, trans_id):
1385
1683
        """Perform a (weave) text merge for a given file and file-id.
1386
1684
        If conflicts are encountered, .THIS and .OTHER files will be emitted,
1387
1685
        and a conflict will be noted.
1388
1686
        """
1389
 
        lines, conflicts = self._merged_lines(file_id)
 
1687
        lines, base_lines = self._merged_lines(file_id)
1390
1688
        lines = list(lines)
1391
 
        # Note we're checking whether the OUTPUT is binary in this case, 
 
1689
        # Note we're checking whether the OUTPUT is binary in this case,
1392
1690
        # because we don't want to get into weave merge guts.
1393
 
        check_text_lines(lines)
 
1691
        textfile.check_text_lines(lines)
1394
1692
        self.tt.create_file(lines, trans_id)
1395
 
        if conflicts:
 
1693
        if base_lines is not None:
 
1694
            # Conflict
1396
1695
            self._raw_conflicts.append(('text conflict', trans_id))
1397
1696
            name = self.tt.final_name(trans_id)
1398
1697
            parent_id = self.tt.final_parent(trans_id)
1399
 
            file_group = self._dump_conflicts(name, parent_id, file_id, 
1400
 
                                              no_base=True)
 
1698
            file_group = self._dump_conflicts(name, parent_id, file_id,
 
1699
                                              no_base=False,
 
1700
                                              base_lines=base_lines)
1401
1701
            file_group.append(trans_id)
1402
1702
 
1403
1703
 
1404
1704
class LCAMerger(WeaveMerger):
1405
1705
 
1406
 
    def _merged_lines(self, file_id):
1407
 
        """Generate the merged lines.
1408
 
        There is no distinction between lines that are meant to contain <<<<<<<
1409
 
        and conflicts.
1410
 
        """
1411
 
        if self.cherrypick:
1412
 
            base = self.base_tree
1413
 
        else:
1414
 
            base = None
1415
 
        plan = self.this_tree.plan_file_lca_merge(file_id, self.other_tree,
 
1706
    def _generate_merge_plan(self, file_id, base):
 
1707
        return self.this_tree.plan_file_lca_merge(file_id, self.other_tree,
1416
1708
                                                  base=base)
1417
 
        if 'merge' in debug.debug_flags:
1418
 
            plan = list(plan)
1419
 
            trans_id = self.tt.trans_id_file_id(file_id)
1420
 
            name = self.tt.final_name(trans_id) + '.plan'
1421
 
            contents = ('%10s|%s' % l for l in plan)
1422
 
            self.tt.new_file(name, self.tt.final_parent(trans_id), contents)
1423
 
        textmerge = PlanWeaveMerge(plan, '<<<<<<< TREE\n',
1424
 
            '>>>>>>> MERGE-SOURCE\n')
1425
 
        return textmerge.merge_lines(self.reprocess)
1426
 
 
1427
1709
 
1428
1710
class Diff3Merger(Merge3Merger):
1429
1711
    """Three-way merger using external diff3 for text merging"""
1430
1712
 
1431
1713
    def dump_file(self, temp_dir, name, tree, file_id):
1432
 
        out_path = pathjoin(temp_dir, name)
 
1714
        out_path = osutils.pathjoin(temp_dir, name)
1433
1715
        out_file = open(out_path, "wb")
1434
1716
        try:
1435
1717
            in_file = tree.get_file(file_id)
1447
1729
        import bzrlib.patch
1448
1730
        temp_dir = osutils.mkdtemp(prefix="bzr-")
1449
1731
        try:
1450
 
            new_file = pathjoin(temp_dir, "new")
 
1732
            new_file = osutils.pathjoin(temp_dir, "new")
1451
1733
            this = self.dump_file(temp_dir, "this", self.this_tree, file_id)
1452
1734
            base = self.dump_file(temp_dir, "base", self.base_tree, file_id)
1453
1735
            other = self.dump_file(temp_dir, "other", self.other_tree, file_id)
1454
1736
            status = bzrlib.patch.diff3(new_file, this, base, other)
1455
1737
            if status not in (0, 1):
1456
 
                raise BzrError("Unhandled diff3 exit code")
 
1738
                raise errors.BzrError("Unhandled diff3 exit code")
1457
1739
            f = open(new_file, 'rb')
1458
1740
            try:
1459
1741
                self.tt.create_file(f, trans_id)
1477
1759
                other_rev_id=None,
1478
1760
                interesting_files=None,
1479
1761
                this_tree=None,
1480
 
                pb=DummyProgress(),
 
1762
                pb=None,
1481
1763
                change_reporter=None):
1482
 
    """Primary interface for merging. 
 
1764
    """Primary interface for merging.
1483
1765
 
1484
 
        typical use is probably 
 
1766
        typical use is probably
1485
1767
        'merge_inner(branch, branch.get_revision_tree(other_revision),
1486
1768
                     branch.get_revision_tree(base_revision))'
1487
1769
        """
1488
1770
    if this_tree is None:
1489
 
        raise BzrError("bzrlib.merge.merge_inner requires a this_tree "
1490
 
            "parameter as of bzrlib version 0.8.")
 
1771
        raise errors.BzrError("bzrlib.merge.merge_inner requires a this_tree "
 
1772
                              "parameter as of bzrlib version 0.8.")
1491
1773
    merger = Merger(this_branch, other_tree, base_tree, this_tree=this_tree,
1492
1774
                    pb=pb, change_reporter=change_reporter)
1493
1775
    merger.backup_files = backup_files
1506
1788
    get_revision_id = getattr(base_tree, 'get_revision_id', None)
1507
1789
    if get_revision_id is None:
1508
1790
        get_revision_id = base_tree.last_revision
 
1791
    merger.cache_trees_with_revision_ids([other_tree, base_tree, this_tree])
1509
1792
    merger.set_base_revision(get_revision_id(), this_branch)
1510
1793
    return merger.do_merge()
1511
1794
 
1710
1993
        super(_PlanMerge, self).__init__(a_rev, b_rev, vf, key_prefix)
1711
1994
        self.a_key = self._key_prefix + (self.a_rev,)
1712
1995
        self.b_key = self._key_prefix + (self.b_rev,)
1713
 
        self.graph = Graph(self.vf)
 
1996
        self.graph = _mod_graph.Graph(self.vf)
1714
1997
        heads = self.graph.heads((self.a_key, self.b_key))
1715
1998
        if len(heads) == 1:
1716
1999
            # one side dominates, so we can just return its values, yay for
1721
2004
                other = b_rev
1722
2005
            else:
1723
2006
                other = a_rev
1724
 
            mutter('found dominating revision for %s\n%s > %s', self.vf,
1725
 
                   self._head_key[-1], other)
 
2007
            trace.mutter('found dominating revision for %s\n%s > %s', self.vf,
 
2008
                         self._head_key[-1], other)
1726
2009
            self._weave = None
1727
2010
        else:
1728
2011
            self._head_key = None
1742
2025
        while True:
1743
2026
            next_lcas = self.graph.find_lca(*cur_ancestors)
1744
2027
            # Map a plain NULL_REVISION to a simple no-ancestors
1745
 
            if next_lcas == set([NULL_REVISION]):
 
2028
            if next_lcas == set([_mod_revision.NULL_REVISION]):
1746
2029
                next_lcas = ()
1747
2030
            # Order the lca's based on when they were merged into the tip
1748
2031
            # While the actual merge portion of weave merge uses a set() of
1760
2043
            elif len(next_lcas) > 2:
1761
2044
                # More than 2 lca's, fall back to grabbing all nodes between
1762
2045
                # this and the unique lca.
1763
 
                mutter('More than 2 LCAs, falling back to all nodes for:'
1764
 
                       ' %s, %s\n=> %s', self.a_key, self.b_key, cur_ancestors)
 
2046
                trace.mutter('More than 2 LCAs, falling back to all nodes for:'
 
2047
                             ' %s, %s\n=> %s',
 
2048
                             self.a_key, self.b_key, cur_ancestors)
1765
2049
                cur_lcas = next_lcas
1766
2050
                while len(cur_lcas) > 1:
1767
2051
                    cur_lcas = self.graph.find_lca(*cur_lcas)
1770
2054
                    unique_lca = None
1771
2055
                else:
1772
2056
                    unique_lca = list(cur_lcas)[0]
1773
 
                    if unique_lca == NULL_REVISION:
 
2057
                    if unique_lca == _mod_revision.NULL_REVISION:
1774
2058
                        # find_lca will return a plain 'NULL_REVISION' rather
1775
2059
                        # than a key tuple when there is no common ancestor, we
1776
2060
                        # prefer to just use None, because it doesn't confuse
1784
2068
 
1785
2069
    def _find_unique_parents(self, tip_keys, base_key):
1786
2070
        """Find ancestors of tip that aren't ancestors of base.
1787
 
        
 
2071
 
1788
2072
        :param tip_keys: Nodes that are interesting
1789
2073
        :param base_key: Cull all ancestors of this node
1790
2074
        :return: The parent map for all revisions between tip_keys and
1799
2083
            # We remove NULL_REVISION because it isn't a proper tuple key, and
1800
2084
            # thus confuses things like _get_interesting_texts, and our logic
1801
2085
            # to add the texts into the memory weave.
1802
 
            if NULL_REVISION in parent_map:
1803
 
                parent_map.pop(NULL_REVISION)
 
2086
            if _mod_revision.NULL_REVISION in parent_map:
 
2087
                parent_map.pop(_mod_revision.NULL_REVISION)
1804
2088
        else:
1805
2089
            interesting = set()
1806
2090
            for tip in tip_keys:
1850
2134
    @staticmethod
1851
2135
    def _prune_tails(parent_map, child_map, tails_to_remove):
1852
2136
        """Remove tails from the parent map.
1853
 
        
 
2137
 
1854
2138
        This will remove the supplied revisions until no more children have 0
1855
2139
        parents.
1856
2140
 
1958
2242
        lcas = graph.find_lca(key_prefix + (a_rev,), key_prefix + (b_rev,))
1959
2243
        self.lcas = set()
1960
2244
        for lca in lcas:
1961
 
            if lca == NULL_REVISION:
 
2245
            if lca == _mod_revision.NULL_REVISION:
1962
2246
                self.lcas.add(lca)
1963
2247
            else:
1964
2248
                self.lcas.add(lca[-1])