/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: Andrew Bennetts
  • Date: 2010-04-13 04:33:55 UTC
  • mfrom: (5147 +trunk)
  • mto: This revision was merged to the branch mainline in revision 5149.
  • Revision ID: andrew.bennetts@canonical.com-20100413043355-lg3id0uwtju0k3zs
Merge lp:bzr.

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_by_entry,
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 ConfigurableFileMerger(AbstractPerFileMerger):
 
97
    """Merge individual files when configured via a .conf file.
 
98
 
 
99
    This is a base class for concrete custom file merging logic. Concrete
 
100
    classes should implement ``merge_text``.
 
101
 
 
102
    See ``bzrlib.plugins.news_merge.news_merge`` for an example concrete class.
 
103
    
 
104
    :ivar affected_files: The configured file paths to merge.
 
105
 
 
106
    :cvar name_prefix: The prefix to use when looking up configuration
 
107
        details. <name_prefix>_merge_files describes the files targeted by the
 
108
        hook for example.
 
109
        
 
110
    :cvar default_files: The default file paths to merge when no configuration
 
111
        is present.
 
112
    """
 
113
 
 
114
    name_prefix = None
 
115
    default_files = None
 
116
 
 
117
    def __init__(self, merger):
 
118
        super(ConfigurableFileMerger, self).__init__(merger)
 
119
        self.affected_files = None
 
120
        self.default_files = self.__class__.default_files or []
 
121
        self.name_prefix = self.__class__.name_prefix
 
122
        if self.name_prefix is None:
 
123
            raise ValueError("name_prefix must be set.")
 
124
 
 
125
    def filename_matches_config(self, params):
 
126
        """Check whether the file should call the merge hook.
 
127
 
 
128
        <name_prefix>_merge_files configuration variable is a list of files
 
129
        that should use the hook.
 
130
        """
 
131
        affected_files = self.affected_files
 
132
        if affected_files is None:
 
133
            config = self.merger.this_branch.get_config()
 
134
            # Until bzr provides a better policy for caching the config, we
 
135
            # just add the part we're interested in to the params to avoid
 
136
            # reading the config files repeatedly (bazaar.conf, location.conf,
 
137
            # branch.conf).
 
138
            config_key = self.name_prefix + '_merge_files'
 
139
            affected_files = config.get_user_option_as_list(config_key)
 
140
            if affected_files is None:
 
141
                # If nothing was specified in the config, use the default.
 
142
                affected_files = self.default_files
 
143
            self.affected_files = affected_files
 
144
        if affected_files:
 
145
            filename = self.merger.this_tree.id2path(params.file_id)
 
146
            if filename in affected_files:
 
147
                return True
 
148
        return False
 
149
 
 
150
    def merge_contents(self, params):
 
151
        """Merge the contents of a single file."""
 
152
        # First, check whether this custom merge logic should be used.  We
 
153
        # expect most files should not be merged by this handler.
 
154
        if (
 
155
            # OTHER is a straight winner, rely on default merge.
 
156
            params.winner == 'other' or
 
157
            # THIS and OTHER aren't both files.
 
158
            not params.is_file_merge() or
 
159
            # The filename isn't listed in the 'NAME_merge_files' config
 
160
            # option.
 
161
            not self.filename_matches_config(params)):
 
162
            return 'not_applicable', None
 
163
        return self.merge_text(params)
 
164
 
 
165
    def merge_text(self, params):
 
166
        """Merge the byte contents of a single file.
 
167
 
 
168
        This is called after checking that the merge should be performed in
 
169
        merge_contents, and it should behave as per
 
170
        ``bzrlib.merge.AbstractPerFileMerger.merge_contents``.
 
171
        """
 
172
        raise NotImplementedError(self.merge_text)
 
173
 
 
174
 
 
175
class MergeHookParams(object):
 
176
    """Object holding parameters passed to merge_file_content hooks.
 
177
 
 
178
    There are some fields hooks can access:
 
179
 
 
180
    :ivar file_id: the file ID of the file being merged
 
181
    :ivar trans_id: the transform ID for the merge of this file
 
182
    :ivar this_kind: kind of file_id in 'this' tree
 
183
    :ivar other_kind: kind of file_id in 'other' tree
 
184
    :ivar winner: one of 'this', 'other', 'conflict'
 
185
    """
 
186
 
 
187
    def __init__(self, merger, file_id, trans_id, this_kind, other_kind,
 
188
            winner):
 
189
        self._merger = merger
 
190
        self.file_id = file_id
 
191
        self.trans_id = trans_id
 
192
        self.this_kind = this_kind
 
193
        self.other_kind = other_kind
 
194
        self.winner = winner
 
195
 
 
196
    def is_file_merge(self):
 
197
        """True if this_kind and other_kind are both 'file'."""
 
198
        return self.this_kind == 'file' and self.other_kind == 'file'
 
199
 
 
200
    @decorators.cachedproperty
 
201
    def base_lines(self):
 
202
        """The lines of the 'base' version of the file."""
 
203
        return self._merger.get_lines(self._merger.base_tree, self.file_id)
 
204
 
 
205
    @decorators.cachedproperty
 
206
    def this_lines(self):
 
207
        """The lines of the 'this' version of the file."""
 
208
        return self._merger.get_lines(self._merger.this_tree, self.file_id)
 
209
 
 
210
    @decorators.cachedproperty
 
211
    def other_lines(self):
 
212
        """The lines of the 'other' version of the file."""
 
213
        return self._merger.get_lines(self._merger.other_tree, self.file_id)
69
214
 
70
215
 
71
216
class Merger(object):
 
217
 
 
218
    hooks = MergeHooks()
 
219
 
72
220
    def __init__(self, this_branch, other_tree=None, base_tree=None,
73
 
                 this_tree=None, pb=DummyProgress(), change_reporter=None,
 
221
                 this_tree=None, pb=None, change_reporter=None,
74
222
                 recurse='down', revision_graph=None):
75
223
        object.__init__(self)
76
224
        self.this_branch = this_branch
89
237
        self.interesting_files = None
90
238
        self.show_base = False
91
239
        self.reprocess = False
92
 
        self._pb = pb
 
240
        if pb is not None:
 
241
            warnings.warn("pb parameter to Merger() is deprecated and ignored")
93
242
        self.pp = None
94
243
        self.recurse = recurse
95
244
        self.change_reporter = change_reporter
100
249
        self._is_criss_cross = None
101
250
        self._lca_trees = None
102
251
 
 
252
    def cache_trees_with_revision_ids(self, trees):
 
253
        """Cache any tree in trees if it has a revision_id."""
 
254
        for maybe_tree in trees:
 
255
            if maybe_tree is None:
 
256
                continue
 
257
            try:
 
258
                rev_id = maybe_tree.get_revision_id()
 
259
            except AttributeError:
 
260
                continue
 
261
            self._cached_trees[rev_id] = maybe_tree
 
262
 
103
263
    @property
104
264
    def revision_graph(self):
105
265
        if self._revision_graph is None:
132
292
                                      _set_base_is_other_ancestor)
133
293
 
134
294
    @staticmethod
135
 
    def from_uncommitted(tree, other_tree, pb):
 
295
    def from_uncommitted(tree, other_tree, pb=None, base_tree=None):
136
296
        """Return a Merger for uncommitted changes in other_tree.
137
297
 
138
298
        :param tree: The tree to merge into
139
299
        :param other_tree: The tree to get uncommitted changes from
140
300
        :param pb: A progress indicator
 
301
        :param base_tree: The basis to use for the merge.  If unspecified,
 
302
            other_tree.basis_tree() will be used.
141
303
        """
142
 
        merger = Merger(tree.branch, other_tree, other_tree.basis_tree(), tree,
143
 
                        pb)
 
304
        if base_tree is None:
 
305
            base_tree = other_tree.basis_tree()
 
306
        merger = Merger(tree.branch, other_tree, base_tree, tree, pb)
144
307
        merger.base_rev_id = merger.base_tree.get_revision_id()
145
308
        merger.other_rev_id = None
146
309
        merger.other_basis = merger.base_rev_id
164
327
                base_revision_id, tree.branch.last_revision())):
165
328
                base_revision_id = None
166
329
            else:
167
 
                warning('Performing cherrypick')
 
330
                trace.warning('Performing cherrypick')
168
331
        merger = klass.from_revision_ids(pb, tree, other_revision_id,
169
332
                                         base_revision_id, revision_graph=
170
333
                                         revision_graph)
176
339
                          tree_branch=None):
177
340
        """Return a Merger for revision-ids.
178
341
 
 
342
        :param pb: A progress indicator
179
343
        :param tree: The tree to merge changes into
180
344
        :param other: The revision-id to use as OTHER
181
345
        :param base: The revision-id to use as BASE.  If not specified, will
186
350
            not supplied, other_branch or tree.branch will be used.
187
351
        :param revision_graph: If you have a revision_graph precomputed, pass
188
352
            it in, otherwise it will be created for you.
189
 
        :param pb: A progress indicator
 
353
        :param tree_branch: The branch associated with tree.  If not supplied,
 
354
            tree.branch will be used.
190
355
        """
191
356
        if tree_branch is None:
192
357
            tree_branch = tree.branch
220
385
        if revno is None:
221
386
            tree = workingtree.WorkingTree.open_containing(location)[0]
222
387
            return tree.branch, tree
223
 
        branch = Branch.open_containing(location, possible_transports)[0]
 
388
        branch = _mod_branch.Branch.open_containing(
 
389
            location, possible_transports)[0]
224
390
        if revno == -1:
225
391
            revision_id = branch.last_revision()
226
392
        else:
227
393
            revision_id = branch.get_rev_id(revno)
228
 
        revision_id = ensure_null(revision_id)
 
394
        revision_id = _mod_revision.ensure_null(revision_id)
229
395
        return branch, self.revision_tree(revision_id, branch)
230
396
 
 
397
    @deprecated_method(deprecated_in((2, 1, 0)))
231
398
    def ensure_revision_trees(self):
232
399
        if self.this_revision_tree is None:
233
400
            self.this_basis_tree = self.revision_tree(self.this_basis)
236
403
 
237
404
        if self.other_rev_id is None:
238
405
            other_basis_tree = self.revision_tree(self.other_basis)
239
 
            changes = other_basis_tree.changes_from(self.other_tree)
240
 
            if changes.has_changed():
241
 
                raise WorkingTreeNotRevision(self.this_tree)
 
406
            if other_basis_tree.has_changes(self.other_tree):
 
407
                raise errors.WorkingTreeNotRevision(self.this_tree)
242
408
            other_rev_id = self.other_basis
243
409
            self.other_tree = other_basis_tree
244
410
 
 
411
    @deprecated_method(deprecated_in((2, 1, 0)))
245
412
    def file_revisions(self, file_id):
246
413
        self.ensure_revision_trees()
247
414
        def get_id(tree, file_id):
250
417
        if self.this_rev_id is None:
251
418
            if self.this_basis_tree.get_file_sha1(file_id) != \
252
419
                self.this_tree.get_file_sha1(file_id):
253
 
                raise WorkingTreeNotRevision(self.this_tree)
 
420
                raise errors.WorkingTreeNotRevision(self.this_tree)
254
421
 
255
422
        trees = (self.this_basis_tree, self.other_tree)
256
423
        return [get_id(tree, file_id) for tree in trees]
257
424
 
 
425
    @deprecated_method(deprecated_in((2, 1, 0)))
258
426
    def check_basis(self, check_clean, require_commits=True):
259
427
        if self.this_basis is None and require_commits is True:
260
 
            raise BzrCommandError("This branch has no commits."
261
 
                                  " (perhaps you would prefer 'bzr pull')")
 
428
            raise errors.BzrCommandError(
 
429
                "This branch has no commits."
 
430
                " (perhaps you would prefer 'bzr pull')")
262
431
        if check_clean:
263
432
            self.compare_basis()
264
433
            if self.this_basis != self.this_rev_id:
265
434
                raise errors.UncommittedChanges(self.this_tree)
266
435
 
 
436
    @deprecated_method(deprecated_in((2, 1, 0)))
267
437
    def compare_basis(self):
268
438
        try:
269
439
            basis_tree = self.revision_tree(self.this_tree.last_revision())
270
440
        except errors.NoSuchRevision:
271
441
            basis_tree = self.this_tree.basis_tree()
272
 
        changes = self.this_tree.changes_from(basis_tree)
273
 
        if not changes.has_changed():
 
442
        if not self.this_tree.has_changes(basis_tree):
274
443
            self.this_rev_id = self.this_basis
275
444
 
276
445
    def set_interesting_files(self, file_list):
277
446
        self.interesting_files = file_list
278
447
 
279
448
    def set_pending(self):
280
 
        if not self.base_is_ancestor or not self.base_is_other_ancestor or self.other_rev_id is None:
 
449
        if (not self.base_is_ancestor or not self.base_is_other_ancestor
 
450
            or self.other_rev_id is None):
281
451
            return
282
452
        self._add_parent()
283
453
 
284
454
    def _add_parent(self):
285
455
        new_parents = self.this_tree.get_parent_ids() + [self.other_rev_id]
286
456
        new_parent_trees = []
 
457
        operation = OperationWithCleanups(self.this_tree.set_parent_trees)
287
458
        for revision_id in new_parents:
288
459
            try:
289
460
                tree = self.revision_tree(revision_id)
291
462
                tree = None
292
463
            else:
293
464
                tree.lock_read()
 
465
                operation.add_cleanup(tree.unlock)
294
466
            new_parent_trees.append((revision_id, tree))
295
 
        try:
296
 
            self.this_tree.set_parent_trees(new_parent_trees,
297
 
                                            allow_leftmost_as_ghost=True)
298
 
        finally:
299
 
            for _revision_id, tree in new_parent_trees:
300
 
                if tree is not None:
301
 
                    tree.unlock()
 
467
        operation.run_simple(new_parent_trees, allow_leftmost_as_ghost=True)
302
468
 
303
469
    def set_other(self, other_revision, possible_transports=None):
304
470
        """Set the revision and tree to merge from.
313
479
            self.other_rev_id = _mod_revision.ensure_null(
314
480
                self.other_branch.last_revision())
315
481
            if _mod_revision.is_null(self.other_rev_id):
316
 
                raise NoCommits(self.other_branch)
 
482
                raise errors.NoCommits(self.other_branch)
317
483
            self.other_basis = self.other_rev_id
318
484
        elif other_revision[1] is not None:
319
485
            self.other_rev_id = self.other_branch.get_rev_id(other_revision[1])
322
488
            self.other_rev_id = None
323
489
            self.other_basis = self.other_branch.last_revision()
324
490
            if self.other_basis is None:
325
 
                raise NoCommits(self.other_branch)
 
491
                raise errors.NoCommits(self.other_branch)
326
492
        if self.other_rev_id is not None:
327
493
            self._cached_trees[self.other_rev_id] = self.other_tree
328
494
        self._maybe_fetch(self.other_branch,self.this_branch, self.other_basis)
355
521
            target.fetch(source, revision_id)
356
522
 
357
523
    def find_base(self):
358
 
        revisions = [ensure_null(self.this_basis),
359
 
                     ensure_null(self.other_basis)]
360
 
        if NULL_REVISION in revisions:
361
 
            self.base_rev_id = NULL_REVISION
 
524
        revisions = [_mod_revision.ensure_null(self.this_basis),
 
525
                     _mod_revision.ensure_null(self.other_basis)]
 
526
        if _mod_revision.NULL_REVISION in revisions:
 
527
            self.base_rev_id = _mod_revision.NULL_REVISION
362
528
            self.base_tree = self.revision_tree(self.base_rev_id)
363
529
            self._is_criss_cross = False
364
530
        else:
365
531
            lcas = self.revision_graph.find_lca(revisions[0], revisions[1])
366
532
            self._is_criss_cross = False
367
533
            if len(lcas) == 0:
368
 
                self.base_rev_id = NULL_REVISION
 
534
                self.base_rev_id = _mod_revision.NULL_REVISION
369
535
            elif len(lcas) == 1:
370
536
                self.base_rev_id = list(lcas)[0]
371
537
            else: # len(lcas) > 1
380
546
                    self.base_rev_id = self.revision_graph.find_unique_lca(
381
547
                                            *lcas)
382
548
                self._is_criss_cross = True
383
 
            if self.base_rev_id == NULL_REVISION:
384
 
                raise UnrelatedBranches()
 
549
            if self.base_rev_id == _mod_revision.NULL_REVISION:
 
550
                raise errors.UnrelatedBranches()
385
551
            if self._is_criss_cross:
386
 
                warning('Warning: criss-cross merge encountered.  See bzr'
387
 
                        ' help criss-cross.')
 
552
                trace.warning('Warning: criss-cross merge encountered.  See bzr'
 
553
                              ' help criss-cross.')
 
554
                trace.mutter('Criss-cross lcas: %r' % lcas)
388
555
                interesting_revision_ids = [self.base_rev_id]
389
556
                interesting_revision_ids.extend(lcas)
390
557
                interesting_trees = dict((t.get_revision_id(), t)
400
567
                self.base_tree = self.revision_tree(self.base_rev_id)
401
568
        self.base_is_ancestor = True
402
569
        self.base_is_other_ancestor = True
 
570
        trace.mutter('Base revid: %r' % self.base_rev_id)
403
571
 
404
572
    def set_base(self, base_revision):
405
573
        """Set the base revision to use for the merge.
406
574
 
407
575
        :param base_revision: A 2-list containing a path and revision number.
408
576
        """
409
 
        mutter("doing merge() with no base_revision specified")
 
577
        trace.mutter("doing merge() with no base_revision specified")
410
578
        if base_revision == [None, None]:
411
579
            self.find_base()
412
580
        else:
425
593
                  'other_tree': self.other_tree,
426
594
                  'interesting_ids': self.interesting_ids,
427
595
                  'interesting_files': self.interesting_files,
428
 
                  'pp': self.pp,
 
596
                  'this_branch': self.this_branch,
429
597
                  'do_merge': False}
430
598
        if self.merge_type.requires_base:
431
599
            kwargs['base_tree'] = self.base_tree
432
600
        if self.merge_type.supports_reprocess:
433
601
            kwargs['reprocess'] = self.reprocess
434
602
        elif self.reprocess:
435
 
            raise BzrError("Conflict reduction is not supported for merge"
436
 
                                  " type %s." % self.merge_type)
 
603
            raise errors.BzrError(
 
604
                "Conflict reduction is not supported for merge"
 
605
                " type %s." % self.merge_type)
437
606
        if self.merge_type.supports_show_base:
438
607
            kwargs['show_base'] = self.show_base
439
608
        elif self.show_base:
440
 
            raise BzrError("Showing base is not supported for this"
441
 
                           " merge type. %s" % self.merge_type)
 
609
            raise errors.BzrError("Showing base is not supported for this"
 
610
                                  " merge type. %s" % self.merge_type)
442
611
        if (not getattr(self.merge_type, 'supports_reverse_cherrypick', True)
443
612
            and not self.base_is_other_ancestor):
444
613
            raise errors.CannotReverseCherrypick()
448
617
        if self._is_criss_cross and getattr(self.merge_type,
449
618
                                            'supports_lca_trees', False):
450
619
            kwargs['lca_trees'] = self._lca_trees
451
 
        return self.merge_type(pb=self._pb,
 
620
        return self.merge_type(pb=None,
452
621
                               change_reporter=self.change_reporter,
453
622
                               **kwargs)
454
623
 
455
 
    def _do_merge_to(self, merge):
 
624
    def _do_merge_to(self):
 
625
        merge = self.make_merger()
 
626
        if self.other_branch is not None:
 
627
            self.other_branch.update_references(self.this_branch)
456
628
        merge.do_merge()
457
629
        if self.recurse == 'down':
458
630
            for relpath, file_id in self.this_tree.iter_references():
470
642
                    sub_tree.branch.repository.revision_tree(base_revision)
471
643
                sub_merge.base_rev_id = base_revision
472
644
                sub_merge.do_merge()
473
 
        
 
645
        return merge
 
646
 
474
647
    def do_merge(self):
 
648
        operation = OperationWithCleanups(self._do_merge_to)
475
649
        self.this_tree.lock_tree_write()
476
 
        try:
477
 
            if self.base_tree is not None:
478
 
                self.base_tree.lock_read()
479
 
            try:
480
 
                if self.other_tree is not None:
481
 
                    self.other_tree.lock_read()
482
 
                try:
483
 
                    merge = self.make_merger()
484
 
                    self._do_merge_to(merge)
485
 
                finally:
486
 
                    if self.other_tree is not None:
487
 
                        self.other_tree.unlock()
488
 
            finally:
489
 
                if self.base_tree is not None:
490
 
                    self.base_tree.unlock()
491
 
        finally:
492
 
            self.this_tree.unlock()
 
650
        operation.add_cleanup(self.this_tree.unlock)
 
651
        if self.base_tree is not None:
 
652
            self.base_tree.lock_read()
 
653
            operation.add_cleanup(self.base_tree.unlock)
 
654
        if self.other_tree is not None:
 
655
            self.other_tree.lock_read()
 
656
            operation.add_cleanup(self.other_tree.unlock)
 
657
        merge = operation.run_simple()
493
658
        if len(merge.cooked_conflicts) == 0:
494
 
            if not self.ignore_zero and not is_quiet():
495
 
                note("All changes applied successfully.")
 
659
            if not self.ignore_zero and not trace.is_quiet():
 
660
                trace.note("All changes applied successfully.")
496
661
        else:
497
 
            note("%d conflicts encountered." % len(merge.cooked_conflicts))
 
662
            trace.note("%d conflicts encountered."
 
663
                       % len(merge.cooked_conflicts))
498
664
 
499
665
        return len(merge.cooked_conflicts)
500
666
 
527
693
    winner_idx = {"this": 2, "other": 1, "conflict": 1}
528
694
    supports_lca_trees = True
529
695
 
530
 
    def __init__(self, working_tree, this_tree, base_tree, other_tree, 
 
696
    def __init__(self, working_tree, this_tree, base_tree, other_tree,
531
697
                 interesting_ids=None, reprocess=False, show_base=False,
532
 
                 pb=DummyProgress(), pp=None, change_reporter=None,
 
698
                 pb=None, pp=None, change_reporter=None,
533
699
                 interesting_files=None, do_merge=True,
534
 
                 cherrypick=False, lca_trees=None):
 
700
                 cherrypick=False, lca_trees=None, this_branch=None):
535
701
        """Initialize the merger object and perform the merge.
536
702
 
537
703
        :param working_tree: The working tree to apply the merge to
538
704
        :param this_tree: The local tree in the merge operation
539
705
        :param base_tree: The common tree in the merge operation
540
 
        :param other_tree: The other other tree to merge changes from
 
706
        :param other_tree: The other tree to merge changes from
 
707
        :param this_branch: The branch associated with this_tree
541
708
        :param interesting_ids: The file_ids of files that should be
542
709
            participate in the merge.  May not be combined with
543
710
            interesting_files.
544
711
        :param: reprocess If True, perform conflict-reduction processing.
545
712
        :param show_base: If True, show the base revision in text conflicts.
546
713
            (incompatible with reprocess)
547
 
        :param pb: A Progress bar
 
714
        :param pb: ignored
548
715
        :param pp: A ProgressPhase object
549
716
        :param change_reporter: An object that should report changes made
550
717
        :param interesting_files: The tree-relative paths of files that should
566
733
        self.this_tree = working_tree
567
734
        self.base_tree = base_tree
568
735
        self.other_tree = other_tree
 
736
        self.this_branch = this_branch
569
737
        self._raw_conflicts = []
570
738
        self.cooked_conflicts = []
571
739
        self.reprocess = reprocess
576
744
        # making sure we haven't missed any corner cases.
577
745
        # if lca_trees is None:
578
746
        #     self._lca_trees = [self.base_tree]
579
 
        self.pb = pb
580
 
        self.pp = pp
581
747
        self.change_reporter = change_reporter
582
748
        self.cherrypick = cherrypick
583
 
        if self.pp is None:
584
 
            self.pp = ProgressPhase("Merge phase", 3, self.pb)
585
749
        if do_merge:
586
750
            self.do_merge()
 
751
        if pp is not None:
 
752
            warnings.warn("pp argument to Merge3Merger is deprecated")
 
753
        if pb is not None:
 
754
            warnings.warn("pb argument to Merge3Merger is deprecated")
587
755
 
588
756
    def do_merge(self):
 
757
        operation = OperationWithCleanups(self._do_merge)
589
758
        self.this_tree.lock_tree_write()
 
759
        operation.add_cleanup(self.this_tree.unlock)
590
760
        self.base_tree.lock_read()
 
761
        operation.add_cleanup(self.base_tree.unlock)
591
762
        self.other_tree.lock_read()
592
 
        self.tt = TreeTransform(self.this_tree, self.pb)
 
763
        operation.add_cleanup(self.other_tree.unlock)
 
764
        operation.run()
 
765
 
 
766
    def _do_merge(self, operation):
 
767
        self.tt = transform.TreeTransform(self.this_tree, None)
 
768
        operation.add_cleanup(self.tt.finalize)
 
769
        self._compute_transform()
 
770
        results = self.tt.apply(no_conflicts=True)
 
771
        self.write_modified(results)
593
772
        try:
594
 
            self.pp.next_phase()
595
 
            self._compute_transform()
596
 
            self.pp.next_phase()
597
 
            results = self.tt.apply(no_conflicts=True)
598
 
            self.write_modified(results)
599
 
            try:
600
 
                self.this_tree.add_conflicts(self.cooked_conflicts)
601
 
            except UnsupportedOperation:
602
 
                pass
603
 
        finally:
604
 
            self.tt.finalize()
605
 
            self.other_tree.unlock()
606
 
            self.base_tree.unlock()
607
 
            self.this_tree.unlock()
608
 
            self.pb.clear()
 
773
            self.this_tree.add_conflicts(self.cooked_conflicts)
 
774
        except errors.UnsupportedOperation:
 
775
            pass
609
776
 
610
777
    def make_preview_transform(self):
 
778
        operation = OperationWithCleanups(self._make_preview_transform)
611
779
        self.base_tree.lock_read()
 
780
        operation.add_cleanup(self.base_tree.unlock)
612
781
        self.other_tree.lock_read()
613
 
        self.tt = TransformPreview(self.this_tree)
614
 
        try:
615
 
            self.pp.next_phase()
616
 
            self._compute_transform()
617
 
            self.pp.next_phase()
618
 
        finally:
619
 
            self.other_tree.unlock()
620
 
            self.base_tree.unlock()
621
 
            self.pb.clear()
 
782
        operation.add_cleanup(self.other_tree.unlock)
 
783
        return operation.run_simple()
 
784
 
 
785
    def _make_preview_transform(self):
 
786
        self.tt = transform.TransformPreview(self.this_tree)
 
787
        self._compute_transform()
622
788
        return self.tt
623
789
 
624
790
    def _compute_transform(self):
630
796
            resolver = self._lca_multi_way
631
797
        child_pb = ui.ui_factory.nested_progress_bar()
632
798
        try:
 
799
            factories = Merger.hooks['merge_file_content']
 
800
            hooks = [factory(self) for factory in factories] + [self]
 
801
            self.active_hooks = [hook for hook in hooks if hook is not None]
633
802
            for num, (file_id, changed, parents3, names3,
634
803
                      executable3) in enumerate(entries):
635
804
                child_pb.update('Preparing file merge', num, len(entries))
636
805
                self._merge_names(file_id, parents3, names3, resolver=resolver)
637
806
                if changed:
638
 
                    file_status = self.merge_contents(file_id)
 
807
                    file_status = self._do_merge_contents(file_id)
639
808
                else:
640
809
                    file_status = 'unmodified'
641
810
                self._merge_executable(file_id,
643
812
        finally:
644
813
            child_pb.finished()
645
814
        self.fix_root()
646
 
        self.pp.next_phase()
647
815
        child_pb = ui.ui_factory.nested_progress_bar()
648
816
        try:
649
 
            fs_conflicts = resolve_conflicts(self.tt, child_pb,
650
 
                lambda t, c: conflict_pass(t, c, self.other_tree))
 
817
            fs_conflicts = transform.resolve_conflicts(self.tt, child_pb,
 
818
                lambda t, c: transform.conflict_pass(t, c, self.other_tree))
651
819
        finally:
652
820
            child_pb.finished()
653
821
        if self.change_reporter is not None:
656
824
                self.tt.iter_changes(), self.change_reporter)
657
825
        self.cook_conflicts(fs_conflicts)
658
826
        for conflict in self.cooked_conflicts:
659
 
            warning(conflict)
 
827
            trace.warning(conflict)
660
828
 
661
829
    def _entries3(self):
662
830
        """Gather data about files modified between three trees.
789
957
            content_changed = True
790
958
            if kind_winner == 'this':
791
959
                # No kind change in OTHER, see if there are *any* changes
792
 
                if other_ie.kind == None:
793
 
                    # No content and 'this' wins the kind, so skip this?
794
 
                    # continue
795
 
                    pass
796
 
                elif other_ie.kind == 'directory':
 
960
                if other_ie.kind == 'directory':
797
961
                    if parent_id_winner == 'this' and name_winner == 'this':
798
962
                        # No change for this directory in OTHER, skip
799
963
                        continue
800
964
                    content_changed = False
801
 
                elif other_ie.kind == 'file':
 
965
                elif other_ie.kind is None or other_ie.kind == 'file':
802
966
                    def get_sha1(ie, tree):
803
967
                        if ie.kind != 'file':
804
968
                            return None
851
1015
                        continue
852
1016
                else:
853
1017
                    raise AssertionError('unhandled kind: %s' % other_ie.kind)
854
 
                # XXX: We need to handle kind == 'symlink'
855
1018
 
856
1019
            # If we have gotten this far, that means something has changed
857
1020
            result.append((file_id, content_changed,
868
1031
    def fix_root(self):
869
1032
        try:
870
1033
            self.tt.final_kind(self.tt.root)
871
 
        except NoSuchFile:
 
1034
        except errors.NoSuchFile:
872
1035
            self.tt.cancel_deletion(self.tt.root)
873
1036
        if self.tt.final_file_id(self.tt.root) is None:
874
 
            self.tt.version_file(self.tt.tree_file_id(self.tt.root), 
 
1037
            self.tt.version_file(self.tt.tree_file_id(self.tt.root),
875
1038
                                 self.tt.root)
876
 
        if self.other_tree.inventory.root is None:
877
 
            return
878
1039
        other_root_file_id = self.other_tree.get_root_id()
 
1040
        if other_root_file_id is None:
 
1041
            return
879
1042
        other_root = self.tt.trans_id_file_id(other_root_file_id)
880
1043
        if other_root == self.tt.root:
881
1044
            return
882
1045
        try:
883
1046
            self.tt.final_kind(other_root)
884
 
        except NoSuchFile:
 
1047
        except errors.NoSuchFile:
885
1048
            return
886
 
        if self.other_tree.inventory.root.file_id in self.this_tree.inventory:
 
1049
        if self.this_tree.has_id(self.other_tree.inventory.root.file_id):
887
1050
            # the other tree's root is a non-root in the current tree
888
1051
            return
889
1052
        self.reparent_children(self.other_tree.inventory.root, self.tt.root)
920
1083
        if entry is None:
921
1084
            return None
922
1085
        return entry.name
923
 
    
 
1086
 
924
1087
    @staticmethod
925
1088
    def contents_sha1(tree, file_id):
926
1089
        """Determine the sha1 of the file contents (used as a key method)."""
931
1094
    @staticmethod
932
1095
    def executable(tree, file_id):
933
1096
        """Determine the executability of a file-id (used as a key method)."""
934
 
        if file_id not in tree:
 
1097
        if not tree.has_id(file_id):
935
1098
            return None
936
1099
        if tree.kind(file_id) != "file":
937
1100
            return False
940
1103
    @staticmethod
941
1104
    def kind(tree, file_id):
942
1105
        """Determine the kind of a file-id (used as a key method)."""
943
 
        if file_id not in tree:
 
1106
        if not tree.has_id(file_id):
944
1107
            return None
945
1108
        return tree.kind(file_id)
946
1109
 
947
1110
    @staticmethod
948
1111
    def _three_way(base, other, this):
949
 
        #if base == other, either they all agree, or only THIS has changed.
950
1112
        if base == other:
 
1113
            # if 'base == other', either they all agree, or only 'this' has
 
1114
            # changed.
951
1115
            return 'this'
952
1116
        elif this not in (base, other):
 
1117
            # 'this' is neither 'base' nor 'other', so both sides changed
953
1118
            return 'conflict'
954
 
        # "Ambiguous clean merge" -- both sides have made the same change.
955
1119
        elif this == other:
 
1120
            # "Ambiguous clean merge" -- both sides have made the same change.
956
1121
            return "this"
957
 
        # this == base: only other has changed.
958
1122
        else:
 
1123
            # this == base: only other has changed.
959
1124
            return "other"
960
1125
 
961
1126
    @staticmethod
974
1139
        :return: 'this', 'other', or 'conflict' depending on whether an entry
975
1140
            changed or not.
976
1141
        """
977
 
        # See doc/developers/lca_merge_resolution.txt for details about this
 
1142
        # See doc/developers/lca_tree_merging.txt for details about this
978
1143
        # algorithm.
979
1144
        if other == this:
980
1145
            # Either Ambiguously clean, or nothing was actually changed. We
1005
1170
                # only has an lca value
1006
1171
                return 'other'
1007
1172
 
1008
 
        # At this point, the lcas disagree, and the tips disagree
 
1173
        # At this point, the lcas disagree, and the tip disagree
1009
1174
        return 'conflict'
1010
1175
 
1011
1176
    @staticmethod
 
1177
    @deprecated_method(deprecated_in((2, 2, 0)))
1012
1178
    def scalar_three_way(this_tree, base_tree, other_tree, file_id, key):
1013
1179
        """Do a three-way test on a scalar.
1014
1180
        Return "this", "other" or "conflict", depending whether a value wins.
1029
1195
 
1030
1196
    def merge_names(self, file_id):
1031
1197
        def get_entry(tree):
1032
 
            if file_id in tree.inventory:
 
1198
            if tree.has_id(file_id):
1033
1199
                return tree.inventory[file_id]
1034
1200
            else:
1035
1201
                return None
1064
1230
                parent_id_winner = "other"
1065
1231
        if name_winner == "this" and parent_id_winner == "this":
1066
1232
            return
1067
 
        if name_winner == "conflict":
1068
 
            trans_id = self.tt.trans_id_file_id(file_id)
1069
 
            self._raw_conflicts.append(('name conflict', trans_id, 
1070
 
                                        this_name, other_name))
1071
 
        if parent_id_winner == "conflict":
1072
 
            trans_id = self.tt.trans_id_file_id(file_id)
1073
 
            self._raw_conflicts.append(('parent conflict', trans_id, 
1074
 
                                        this_parent, other_parent))
 
1233
        if name_winner == 'conflict' or parent_id_winner == 'conflict':
 
1234
            # Creating helpers (.OTHER or .THIS) here cause problems down the
 
1235
            # road if a ContentConflict needs to be created so we should not do
 
1236
            # that
 
1237
            trans_id = self.tt.trans_id_file_id(file_id)
 
1238
            self._raw_conflicts.append(('path conflict', trans_id, file_id,
 
1239
                                        this_parent, this_name,
 
1240
                                        other_parent, other_name))
1075
1241
        if other_name is None:
1076
 
            # it doesn't matter whether the result was 'other' or 
 
1242
            # it doesn't matter whether the result was 'other' or
1077
1243
            # 'conflict'-- if there's no 'other', we leave it alone.
1078
1244
            return
1079
 
        # if we get here, name_winner and parent_winner are set to safe values.
1080
 
        trans_id = self.tt.trans_id_file_id(file_id)
1081
1245
        parent_id = parents[self.winner_idx[parent_id_winner]]
1082
1246
        if parent_id is not None:
1083
 
            parent_trans_id = self.tt.trans_id_file_id(parent_id)
 
1247
            # if we get here, name_winner and parent_winner are set to safe
 
1248
            # values.
1084
1249
            self.tt.adjust_path(names[self.winner_idx[name_winner]],
1085
 
                                parent_trans_id, trans_id)
 
1250
                                self.tt.trans_id_file_id(parent_id),
 
1251
                                self.tt.trans_id_file_id(file_id))
1086
1252
 
1087
 
    def merge_contents(self, file_id):
1088
 
        """Performa a merge on file_id contents."""
 
1253
    def _do_merge_contents(self, file_id):
 
1254
        """Performs a merge on file_id contents."""
1089
1255
        def contents_pair(tree):
1090
1256
            if file_id not in tree:
1091
1257
                return (None, None)
1098
1264
                contents = None
1099
1265
            return kind, contents
1100
1266
 
1101
 
        def contents_conflict():
1102
 
            trans_id = self.tt.trans_id_file_id(file_id)
1103
 
            name = self.tt.final_name(trans_id)
1104
 
            parent_id = self.tt.final_parent(trans_id)
1105
 
            if file_id in self.this_tree.inventory:
1106
 
                self.tt.unversion_file(trans_id)
1107
 
                if file_id in self.this_tree:
1108
 
                    self.tt.delete_contents(trans_id)
1109
 
            file_group = self._dump_conflicts(name, parent_id, file_id, 
1110
 
                                              set_version=True)
1111
 
            self._raw_conflicts.append(('contents conflict', file_group))
1112
 
 
1113
1267
        # See SPOT run.  run, SPOT, run.
1114
1268
        # So we're not QUITE repeating ourselves; we do tricky things with
1115
1269
        # file kind...
1116
1270
        base_pair = contents_pair(self.base_tree)
1117
1271
        other_pair = contents_pair(self.other_tree)
1118
 
        if base_pair == other_pair:
1119
 
            # OTHER introduced no changes
1120
 
            return "unmodified"
1121
 
        this_pair = contents_pair(self.this_tree)
1122
 
        if this_pair == other_pair:
1123
 
            # THIS and OTHER introduced the same changes
1124
 
            return "unmodified"
1125
 
        else:
1126
 
            trans_id = self.tt.trans_id_file_id(file_id)
1127
 
            if this_pair == base_pair:
1128
 
                # only OTHER introduced changes
1129
 
                if file_id in self.this_tree:
1130
 
                    # Remove any existing contents
1131
 
                    self.tt.delete_contents(trans_id)
1132
 
                if file_id in self.other_tree:
1133
 
                    # OTHER changed the file
1134
 
                    create_by_entry(self.tt,
1135
 
                                    self.other_tree.inventory[file_id],
1136
 
                                    self.other_tree, trans_id)
1137
 
                    if file_id not in self.this_tree:
1138
 
                        self.tt.version_file(file_id, trans_id)
1139
 
                    return "modified"
1140
 
                elif file_id in self.this_tree.inventory:
1141
 
                    # OTHER deleted the file
1142
 
                    self.tt.unversion_file(trans_id)
1143
 
                    return "deleted"
1144
 
            #BOTH THIS and OTHER introduced changes; scalar conflict
1145
 
            elif this_pair[0] == "file" and other_pair[0] == "file":
1146
 
                # THIS and OTHER are both files, so text merge.  Either
1147
 
                # BASE is a file, or both converted to files, so at least we
1148
 
                # have agreement that output should be a file.
1149
 
                try:
1150
 
                    self.text_merge(file_id, trans_id)
1151
 
                except BinaryFile:
1152
 
                    return contents_conflict()
1153
 
                if file_id not in self.this_tree:
1154
 
                    self.tt.version_file(file_id, trans_id)
1155
 
                try:
1156
 
                    self.tt.tree_kind(trans_id)
1157
 
                    self.tt.delete_contents(trans_id)
1158
 
                except NoSuchFile:
1159
 
                    pass
1160
 
                return "modified"
1161
 
            else:
1162
 
                # Scalar conflict, can't text merge.  Dump conflicts
1163
 
                return contents_conflict()
 
1272
        if self._lca_trees:
 
1273
            this_pair = contents_pair(self.this_tree)
 
1274
            lca_pairs = [contents_pair(tree) for tree in self._lca_trees]
 
1275
            winner = self._lca_multi_way((base_pair, lca_pairs), other_pair,
 
1276
                                         this_pair, allow_overriding_lca=False)
 
1277
        else:
 
1278
            if base_pair == other_pair:
 
1279
                winner = 'this'
 
1280
            else:
 
1281
                # We delayed evaluating this_pair as long as we can to avoid
 
1282
                # unnecessary sha1 calculation
 
1283
                this_pair = contents_pair(self.this_tree)
 
1284
                winner = self._three_way(base_pair, other_pair, this_pair)
 
1285
        if winner == 'this':
 
1286
            # No interesting changes introduced by OTHER
 
1287
            return "unmodified"
 
1288
        # We have a hypothetical conflict, but if we have files, then we
 
1289
        # can try to merge the content
 
1290
        trans_id = self.tt.trans_id_file_id(file_id)
 
1291
        params = MergeHookParams(self, file_id, trans_id, this_pair[0],
 
1292
            other_pair[0], winner)
 
1293
        hooks = self.active_hooks
 
1294
        hook_status = 'not_applicable'
 
1295
        for hook in hooks:
 
1296
            hook_status, lines = hook.merge_contents(params)
 
1297
            if hook_status != 'not_applicable':
 
1298
                # Don't try any more hooks, this one applies.
 
1299
                break
 
1300
        result = "modified"
 
1301
        if hook_status == 'not_applicable':
 
1302
            # This is a contents conflict, because none of the available
 
1303
            # functions could merge it.
 
1304
            result = None
 
1305
            name = self.tt.final_name(trans_id)
 
1306
            parent_id = self.tt.final_parent(trans_id)
 
1307
            if self.this_tree.has_id(file_id):
 
1308
                self.tt.unversion_file(trans_id)
 
1309
            file_group = self._dump_conflicts(name, parent_id, file_id,
 
1310
                                              set_version=True)
 
1311
            self._raw_conflicts.append(('contents conflict', file_group))
 
1312
        elif hook_status == 'success':
 
1313
            self.tt.create_file(lines, trans_id)
 
1314
        elif hook_status == 'conflicted':
 
1315
            # XXX: perhaps the hook should be able to provide
 
1316
            # the BASE/THIS/OTHER files?
 
1317
            self.tt.create_file(lines, trans_id)
 
1318
            self._raw_conflicts.append(('text conflict', trans_id))
 
1319
            name = self.tt.final_name(trans_id)
 
1320
            parent_id = self.tt.final_parent(trans_id)
 
1321
            self._dump_conflicts(name, parent_id, file_id)
 
1322
        elif hook_status == 'delete':
 
1323
            self.tt.unversion_file(trans_id)
 
1324
            result = "deleted"
 
1325
        elif hook_status == 'done':
 
1326
            # The hook function did whatever it needs to do directly, no
 
1327
            # further action needed here.
 
1328
            pass
 
1329
        else:
 
1330
            raise AssertionError('unknown hook_status: %r' % (hook_status,))
 
1331
        if not self.this_tree.has_id(file_id) and result == "modified":
 
1332
            self.tt.version_file(file_id, trans_id)
 
1333
        # The merge has been performed, so the old contents should not be
 
1334
        # retained.
 
1335
        try:
 
1336
            self.tt.delete_contents(trans_id)
 
1337
        except errors.NoSuchFile:
 
1338
            pass
 
1339
        return result
 
1340
 
 
1341
    def _default_other_winner_merge(self, merge_hook_params):
 
1342
        """Replace this contents with other."""
 
1343
        file_id = merge_hook_params.file_id
 
1344
        trans_id = merge_hook_params.trans_id
 
1345
        file_in_this = self.this_tree.has_id(file_id)
 
1346
        if self.other_tree.has_id(file_id):
 
1347
            # OTHER changed the file
 
1348
            wt = self.this_tree
 
1349
            if wt.supports_content_filtering():
 
1350
                # We get the path from the working tree if it exists.
 
1351
                # That fails though when OTHER is adding a file, so
 
1352
                # we fall back to the other tree to find the path if
 
1353
                # it doesn't exist locally.
 
1354
                try:
 
1355
                    filter_tree_path = wt.id2path(file_id)
 
1356
                except errors.NoSuchId:
 
1357
                    filter_tree_path = self.other_tree.id2path(file_id)
 
1358
            else:
 
1359
                # Skip the id2path lookup for older formats
 
1360
                filter_tree_path = None
 
1361
            transform.create_from_tree(self.tt, trans_id,
 
1362
                             self.other_tree, file_id,
 
1363
                             filter_tree_path=filter_tree_path)
 
1364
            return 'done', None
 
1365
        elif file_in_this:
 
1366
            # OTHER deleted the file
 
1367
            return 'delete', None
 
1368
        else:
 
1369
            raise AssertionError(
 
1370
                'winner is OTHER, but file_id %r not in THIS or OTHER tree'
 
1371
                % (file_id,))
 
1372
 
 
1373
    def merge_contents(self, merge_hook_params):
 
1374
        """Fallback merge logic after user installed hooks."""
 
1375
        # This function is used in merge hooks as the fallback instance.
 
1376
        # Perhaps making this function and the functions it calls be a 
 
1377
        # a separate class would be better.
 
1378
        if merge_hook_params.winner == 'other':
 
1379
            # OTHER is a straight winner, so replace this contents with other
 
1380
            return self._default_other_winner_merge(merge_hook_params)
 
1381
        elif merge_hook_params.is_file_merge():
 
1382
            # THIS and OTHER are both files, so text merge.  Either
 
1383
            # BASE is a file, or both converted to files, so at least we
 
1384
            # have agreement that output should be a file.
 
1385
            try:
 
1386
                self.text_merge(merge_hook_params.file_id,
 
1387
                    merge_hook_params.trans_id)
 
1388
            except errors.BinaryFile:
 
1389
                return 'not_applicable', None
 
1390
            return 'done', None
 
1391
        else:
 
1392
            return 'not_applicable', None
1164
1393
 
1165
1394
    def get_lines(self, tree, file_id):
1166
1395
        """Return the lines in a file, or an empty list."""
1167
 
        if file_id in tree:
 
1396
        if tree.has_id(file_id):
1168
1397
            return tree.get_file(file_id).readlines()
1169
1398
        else:
1170
1399
            return []
1173
1402
        """Perform a three-way text merge on a file_id"""
1174
1403
        # it's possible that we got here with base as a different type.
1175
1404
        # if so, we just want two-way text conflicts.
1176
 
        if file_id in self.base_tree and \
 
1405
        if self.base_tree.has_id(file_id) and \
1177
1406
            self.base_tree.kind(file_id) == "file":
1178
1407
            base_lines = self.get_lines(self.base_tree, file_id)
1179
1408
        else:
1180
1409
            base_lines = []
1181
1410
        other_lines = self.get_lines(self.other_tree, file_id)
1182
1411
        this_lines = self.get_lines(self.this_tree, file_id)
1183
 
        m3 = Merge3(base_lines, this_lines, other_lines,
1184
 
                    is_cherrypick=self.cherrypick)
 
1412
        m3 = merge3.Merge3(base_lines, this_lines, other_lines,
 
1413
                           is_cherrypick=self.cherrypick)
1185
1414
        start_marker = "!START OF MERGE CONFLICT!" + "I HOPE THIS IS UNIQUE"
1186
1415
        if self.show_base is True:
1187
1416
            base_marker = '|' * 7
1190
1419
 
1191
1420
        def iter_merge3(retval):
1192
1421
            retval["text_conflicts"] = False
1193
 
            for line in m3.merge_lines(name_a = "TREE", 
1194
 
                                       name_b = "MERGE-SOURCE", 
 
1422
            for line in m3.merge_lines(name_a = "TREE",
 
1423
                                       name_b = "MERGE-SOURCE",
1195
1424
                                       name_base = "BASE-REVISION",
1196
 
                                       start_marker=start_marker, 
 
1425
                                       start_marker=start_marker,
1197
1426
                                       base_marker=base_marker,
1198
1427
                                       reprocess=self.reprocess):
1199
1428
                if line.startswith(start_marker):
1208
1437
            self._raw_conflicts.append(('text conflict', trans_id))
1209
1438
            name = self.tt.final_name(trans_id)
1210
1439
            parent_id = self.tt.final_parent(trans_id)
1211
 
            file_group = self._dump_conflicts(name, parent_id, file_id, 
 
1440
            file_group = self._dump_conflicts(name, parent_id, file_id,
1212
1441
                                              this_lines, base_lines,
1213
1442
                                              other_lines)
1214
1443
            file_group.append(trans_id)
1215
1444
 
1216
 
    def _dump_conflicts(self, name, parent_id, file_id, this_lines=None, 
 
1445
    def _dump_conflicts(self, name, parent_id, file_id, this_lines=None,
1217
1446
                        base_lines=None, other_lines=None, set_version=False,
1218
1447
                        no_base=False):
1219
1448
        """Emit conflict files.
1221
1450
        determined automatically.  If set_version is true, the .OTHER, .THIS
1222
1451
        or .BASE (in that order) will be created as versioned files.
1223
1452
        """
1224
 
        data = [('OTHER', self.other_tree, other_lines), 
 
1453
        data = [('OTHER', self.other_tree, other_lines),
1225
1454
                ('THIS', self.this_tree, this_lines)]
1226
1455
        if not no_base:
1227
1456
            data.append(('BASE', self.base_tree, base_lines))
 
1457
 
 
1458
        # We need to use the actual path in the working tree of the file here,
 
1459
        # ignoring the conflict suffixes
 
1460
        wt = self.this_tree
 
1461
        if wt.supports_content_filtering():
 
1462
            try:
 
1463
                filter_tree_path = wt.id2path(file_id)
 
1464
            except errors.NoSuchId:
 
1465
                # file has been deleted
 
1466
                filter_tree_path = None
 
1467
        else:
 
1468
            # Skip the id2path lookup for older formats
 
1469
            filter_tree_path = None
 
1470
 
1228
1471
        versioned = False
1229
1472
        file_group = []
1230
1473
        for suffix, tree, lines in data:
1231
 
            if file_id in tree:
 
1474
            if tree.has_id(file_id):
1232
1475
                trans_id = self._conflict_file(name, parent_id, tree, file_id,
1233
 
                                               suffix, lines)
 
1476
                                               suffix, lines, filter_tree_path)
1234
1477
                file_group.append(trans_id)
1235
1478
                if set_version and not versioned:
1236
1479
                    self.tt.version_file(file_id, trans_id)
1237
1480
                    versioned = True
1238
1481
        return file_group
1239
 
           
1240
 
    def _conflict_file(self, name, parent_id, tree, file_id, suffix, 
1241
 
                       lines=None):
 
1482
 
 
1483
    def _conflict_file(self, name, parent_id, tree, file_id, suffix,
 
1484
                       lines=None, filter_tree_path=None):
1242
1485
        """Emit a single conflict file."""
1243
1486
        name = name + '.' + suffix
1244
1487
        trans_id = self.tt.create_path(name, parent_id)
1245
 
        entry = tree.inventory[file_id]
1246
 
        create_by_entry(self.tt, entry, tree, trans_id, lines)
 
1488
        transform.create_from_tree(self.tt, trans_id, tree, file_id, lines,
 
1489
            filter_tree_path)
1247
1490
        return trans_id
1248
1491
 
1249
1492
    def merge_executable(self, file_id, file_status):
1273
1516
        try:
1274
1517
            if self.tt.final_kind(trans_id) != "file":
1275
1518
                return
1276
 
        except NoSuchFile:
 
1519
        except errors.NoSuchFile:
1277
1520
            return
1278
1521
        if winner == "this":
1279
1522
            executability = this_executable
1280
1523
        else:
1281
 
            if file_id in self.other_tree:
 
1524
            if self.other_tree.has_id(file_id):
1282
1525
                executability = other_executable
1283
 
            elif file_id in self.this_tree:
 
1526
            elif self.this_tree.has_id(file_id):
1284
1527
                executability = this_executable
1285
 
            elif file_id in self.base_tree:
 
1528
            elif self.base_tree_has_id(file_id):
1286
1529
                executability = base_executable
1287
1530
        if executability is not None:
1288
1531
            trans_id = self.tt.trans_id_file_id(file_id)
1290
1533
 
1291
1534
    def cook_conflicts(self, fs_conflicts):
1292
1535
        """Convert all conflicts into a form that doesn't depend on trans_id"""
1293
 
        from conflicts import Conflict
1294
 
        name_conflicts = {}
1295
 
        self.cooked_conflicts.extend(cook_conflicts(fs_conflicts, self.tt))
1296
 
        fp = FinalPaths(self.tt)
 
1536
        self.cooked_conflicts.extend(transform.cook_conflicts(
 
1537
                fs_conflicts, self.tt))
 
1538
        fp = transform.FinalPaths(self.tt)
1297
1539
        for conflict in self._raw_conflicts:
1298
1540
            conflict_type = conflict[0]
1299
 
            if conflict_type in ('name conflict', 'parent conflict'):
1300
 
                trans_id = conflict[1]
1301
 
                conflict_args = conflict[2:]
1302
 
                if trans_id not in name_conflicts:
1303
 
                    name_conflicts[trans_id] = {}
1304
 
                unique_add(name_conflicts[trans_id], conflict_type, 
1305
 
                           conflict_args)
1306
 
            if conflict_type == 'contents conflict':
 
1541
            if conflict_type == 'path conflict':
 
1542
                (trans_id, file_id,
 
1543
                this_parent, this_name,
 
1544
                other_parent, other_name) = conflict[1:]
 
1545
                if this_parent is None or this_name is None:
 
1546
                    this_path = '<deleted>'
 
1547
                else:
 
1548
                    parent_path =  fp.get_path(
 
1549
                        self.tt.trans_id_file_id(this_parent))
 
1550
                    this_path = osutils.pathjoin(parent_path, this_name)
 
1551
                if other_parent is None or other_name is None:
 
1552
                    other_path = '<deleted>'
 
1553
                else:
 
1554
                    parent_path =  fp.get_path(
 
1555
                        self.tt.trans_id_file_id(other_parent))
 
1556
                    other_path = osutils.pathjoin(parent_path, other_name)
 
1557
                c = _mod_conflicts.Conflict.factory(
 
1558
                    'path conflict', path=this_path,
 
1559
                    conflict_path=other_path,
 
1560
                    file_id=file_id)
 
1561
            elif conflict_type == 'contents conflict':
1307
1562
                for trans_id in conflict[1]:
1308
1563
                    file_id = self.tt.final_file_id(trans_id)
1309
1564
                    if file_id is not None:
1313
1568
                    if path.endswith(suffix):
1314
1569
                        path = path[:-len(suffix)]
1315
1570
                        break
1316
 
                c = Conflict.factory(conflict_type, path=path, file_id=file_id)
1317
 
                self.cooked_conflicts.append(c)
1318
 
            if conflict_type == 'text conflict':
 
1571
                c = _mod_conflicts.Conflict.factory(conflict_type,
 
1572
                                                    path=path, file_id=file_id)
 
1573
            elif conflict_type == 'text conflict':
1319
1574
                trans_id = conflict[1]
1320
1575
                path = fp.get_path(trans_id)
1321
1576
                file_id = self.tt.final_file_id(trans_id)
1322
 
                c = Conflict.factory(conflict_type, path=path, file_id=file_id)
1323
 
                self.cooked_conflicts.append(c)
1324
 
 
1325
 
        for trans_id, conflicts in name_conflicts.iteritems():
1326
 
            try:
1327
 
                this_parent, other_parent = conflicts['parent conflict']
1328
 
                if this_parent == other_parent:
1329
 
                    raise AssertionError()
1330
 
            except KeyError:
1331
 
                this_parent = other_parent = \
1332
 
                    self.tt.final_file_id(self.tt.final_parent(trans_id))
1333
 
            try:
1334
 
                this_name, other_name = conflicts['name conflict']
1335
 
                if this_name == other_name:
1336
 
                    raise AssertionError()
1337
 
            except KeyError:
1338
 
                this_name = other_name = self.tt.final_name(trans_id)
1339
 
            other_path = fp.get_path(trans_id)
1340
 
            if this_parent is not None and this_name is not None:
1341
 
                this_parent_path = \
1342
 
                    fp.get_path(self.tt.trans_id_file_id(this_parent))
1343
 
                this_path = pathjoin(this_parent_path, this_name)
 
1577
                c = _mod_conflicts.Conflict.factory(conflict_type,
 
1578
                                                    path=path, file_id=file_id)
1344
1579
            else:
1345
 
                this_path = "<deleted>"
1346
 
            file_id = self.tt.final_file_id(trans_id)
1347
 
            c = Conflict.factory('path conflict', path=this_path,
1348
 
                                 conflict_path=other_path, file_id=file_id)
 
1580
                raise AssertionError('bad conflict type: %r' % (conflict,))
1349
1581
            self.cooked_conflicts.append(c)
1350
 
        self.cooked_conflicts.sort(key=Conflict.sort_key)
 
1582
        self.cooked_conflicts.sort(key=_mod_conflicts.Conflict.sort_key)
1351
1583
 
1352
1584
 
1353
1585
class WeaveMerger(Merge3Merger):
1357
1589
    supports_reverse_cherrypick = False
1358
1590
    history_based = True
1359
1591
 
1360
 
    def _merged_lines(self, file_id):
1361
 
        """Generate the merged lines.
1362
 
        There is no distinction between lines that are meant to contain <<<<<<<
1363
 
        and conflicts.
1364
 
        """
1365
 
        if self.cherrypick:
1366
 
            base = self.base_tree
1367
 
        else:
1368
 
            base = None
1369
 
        plan = self.this_tree.plan_file_merge(file_id, self.other_tree,
 
1592
    def _generate_merge_plan(self, file_id, base):
 
1593
        return self.this_tree.plan_file_merge(file_id, self.other_tree,
1370
1594
                                              base=base)
 
1595
 
 
1596
    def _merged_lines(self, file_id):
 
1597
        """Generate the merged lines.
 
1598
        There is no distinction between lines that are meant to contain <<<<<<<
 
1599
        and conflicts.
 
1600
        """
 
1601
        if self.cherrypick:
 
1602
            base = self.base_tree
 
1603
        else:
 
1604
            base = None
 
1605
        plan = self._generate_merge_plan(file_id, base)
1371
1606
        if 'merge' in debug.debug_flags:
1372
1607
            plan = list(plan)
1373
1608
            trans_id = self.tt.trans_id_file_id(file_id)
1374
1609
            name = self.tt.final_name(trans_id) + '.plan'
1375
 
            contents = ('%10s|%s' % l for l in plan)
 
1610
            contents = ('%11s|%s' % l for l in plan)
1376
1611
            self.tt.new_file(name, self.tt.final_parent(trans_id), contents)
1377
 
        textmerge = PlanWeaveMerge(plan, '<<<<<<< TREE\n',
1378
 
            '>>>>>>> MERGE-SOURCE\n')
1379
 
        return textmerge.merge_lines(self.reprocess)
 
1612
        textmerge = versionedfile.PlanWeaveMerge(plan, '<<<<<<< TREE\n',
 
1613
                                                 '>>>>>>> MERGE-SOURCE\n')
 
1614
        lines, conflicts = textmerge.merge_lines(self.reprocess)
 
1615
        if conflicts:
 
1616
            base_lines = textmerge.base_from_plan()
 
1617
        else:
 
1618
            base_lines = None
 
1619
        return lines, base_lines
1380
1620
 
1381
1621
    def text_merge(self, file_id, trans_id):
1382
1622
        """Perform a (weave) text merge for a given file and file-id.
1383
1623
        If conflicts are encountered, .THIS and .OTHER files will be emitted,
1384
1624
        and a conflict will be noted.
1385
1625
        """
1386
 
        lines, conflicts = self._merged_lines(file_id)
 
1626
        lines, base_lines = self._merged_lines(file_id)
1387
1627
        lines = list(lines)
1388
 
        # Note we're checking whether the OUTPUT is binary in this case, 
 
1628
        # Note we're checking whether the OUTPUT is binary in this case,
1389
1629
        # because we don't want to get into weave merge guts.
1390
 
        check_text_lines(lines)
 
1630
        textfile.check_text_lines(lines)
1391
1631
        self.tt.create_file(lines, trans_id)
1392
 
        if conflicts:
 
1632
        if base_lines is not None:
 
1633
            # Conflict
1393
1634
            self._raw_conflicts.append(('text conflict', trans_id))
1394
1635
            name = self.tt.final_name(trans_id)
1395
1636
            parent_id = self.tt.final_parent(trans_id)
1396
 
            file_group = self._dump_conflicts(name, parent_id, file_id, 
1397
 
                                              no_base=True)
 
1637
            file_group = self._dump_conflicts(name, parent_id, file_id,
 
1638
                                              no_base=False,
 
1639
                                              base_lines=base_lines)
1398
1640
            file_group.append(trans_id)
1399
1641
 
1400
1642
 
1401
1643
class LCAMerger(WeaveMerger):
1402
1644
 
1403
 
    def _merged_lines(self, file_id):
1404
 
        """Generate the merged lines.
1405
 
        There is no distinction between lines that are meant to contain <<<<<<<
1406
 
        and conflicts.
1407
 
        """
1408
 
        if self.cherrypick:
1409
 
            base = self.base_tree
1410
 
        else:
1411
 
            base = None
1412
 
        plan = self.this_tree.plan_file_lca_merge(file_id, self.other_tree,
 
1645
    def _generate_merge_plan(self, file_id, base):
 
1646
        return self.this_tree.plan_file_lca_merge(file_id, self.other_tree,
1413
1647
                                                  base=base)
1414
 
        if 'merge' in debug.debug_flags:
1415
 
            plan = list(plan)
1416
 
            trans_id = self.tt.trans_id_file_id(file_id)
1417
 
            name = self.tt.final_name(trans_id) + '.plan'
1418
 
            contents = ('%10s|%s' % l for l in plan)
1419
 
            self.tt.new_file(name, self.tt.final_parent(trans_id), contents)
1420
 
        textmerge = PlanWeaveMerge(plan, '<<<<<<< TREE\n',
1421
 
            '>>>>>>> MERGE-SOURCE\n')
1422
 
        return textmerge.merge_lines(self.reprocess)
1423
 
 
1424
1648
 
1425
1649
class Diff3Merger(Merge3Merger):
1426
1650
    """Three-way merger using external diff3 for text merging"""
1427
1651
 
1428
1652
    def dump_file(self, temp_dir, name, tree, file_id):
1429
 
        out_path = pathjoin(temp_dir, name)
 
1653
        out_path = osutils.pathjoin(temp_dir, name)
1430
1654
        out_file = open(out_path, "wb")
1431
1655
        try:
1432
1656
            in_file = tree.get_file(file_id)
1444
1668
        import bzrlib.patch
1445
1669
        temp_dir = osutils.mkdtemp(prefix="bzr-")
1446
1670
        try:
1447
 
            new_file = pathjoin(temp_dir, "new")
 
1671
            new_file = osutils.pathjoin(temp_dir, "new")
1448
1672
            this = self.dump_file(temp_dir, "this", self.this_tree, file_id)
1449
1673
            base = self.dump_file(temp_dir, "base", self.base_tree, file_id)
1450
1674
            other = self.dump_file(temp_dir, "other", self.other_tree, file_id)
1451
1675
            status = bzrlib.patch.diff3(new_file, this, base, other)
1452
1676
            if status not in (0, 1):
1453
 
                raise BzrError("Unhandled diff3 exit code")
 
1677
                raise errors.BzrError("Unhandled diff3 exit code")
1454
1678
            f = open(new_file, 'rb')
1455
1679
            try:
1456
1680
                self.tt.create_file(f, trans_id)
1474
1698
                other_rev_id=None,
1475
1699
                interesting_files=None,
1476
1700
                this_tree=None,
1477
 
                pb=DummyProgress(),
 
1701
                pb=None,
1478
1702
                change_reporter=None):
1479
 
    """Primary interface for merging. 
 
1703
    """Primary interface for merging.
1480
1704
 
1481
 
        typical use is probably 
 
1705
        typical use is probably
1482
1706
        'merge_inner(branch, branch.get_revision_tree(other_revision),
1483
1707
                     branch.get_revision_tree(base_revision))'
1484
1708
        """
1485
1709
    if this_tree is None:
1486
 
        raise BzrError("bzrlib.merge.merge_inner requires a this_tree "
1487
 
            "parameter as of bzrlib version 0.8.")
 
1710
        raise errors.BzrError("bzrlib.merge.merge_inner requires a this_tree "
 
1711
                              "parameter as of bzrlib version 0.8.")
1488
1712
    merger = Merger(this_branch, other_tree, base_tree, this_tree=this_tree,
1489
1713
                    pb=pb, change_reporter=change_reporter)
1490
1714
    merger.backup_files = backup_files
1503
1727
    get_revision_id = getattr(base_tree, 'get_revision_id', None)
1504
1728
    if get_revision_id is None:
1505
1729
        get_revision_id = base_tree.last_revision
 
1730
    merger.cache_trees_with_revision_ids([other_tree, base_tree, this_tree])
1506
1731
    merger.set_base_revision(get_revision_id(), this_branch)
1507
1732
    return merger.do_merge()
1508
1733
 
1576
1801
 
1577
1802
    def get_lines(self, revisions):
1578
1803
        """Get lines for revisions from the backing VersionedFiles.
1579
 
        
 
1804
 
1580
1805
        :raises RevisionNotPresent: on absent texts.
1581
1806
        """
1582
1807
        keys = [(self._key_prefix + (rev,)) for rev in revisions]
1584
1809
        for record in self.vf.get_record_stream(keys, 'unordered', True):
1585
1810
            if record.storage_kind == 'absent':
1586
1811
                raise errors.RevisionNotPresent(record.key, self.vf)
1587
 
            result[record.key[-1]] = osutils.split_lines(
1588
 
                record.get_bytes_as('fulltext'))
 
1812
            result[record.key[-1]] = osutils.chunks_to_lines(
 
1813
                record.get_bytes_as('chunked'))
1589
1814
        return result
1590
1815
 
1591
1816
    def plan_merge(self):
1707
1932
        super(_PlanMerge, self).__init__(a_rev, b_rev, vf, key_prefix)
1708
1933
        self.a_key = self._key_prefix + (self.a_rev,)
1709
1934
        self.b_key = self._key_prefix + (self.b_rev,)
1710
 
        self.graph = Graph(self.vf)
 
1935
        self.graph = _mod_graph.Graph(self.vf)
1711
1936
        heads = self.graph.heads((self.a_key, self.b_key))
1712
1937
        if len(heads) == 1:
1713
1938
            # one side dominates, so we can just return its values, yay for
1718
1943
                other = b_rev
1719
1944
            else:
1720
1945
                other = a_rev
1721
 
            mutter('found dominating revision for %s\n%s > %s', self.vf,
1722
 
                   self._head_key[-1], other)
 
1946
            trace.mutter('found dominating revision for %s\n%s > %s', self.vf,
 
1947
                         self._head_key[-1], other)
1723
1948
            self._weave = None
1724
1949
        else:
1725
1950
            self._head_key = None
1739
1964
        while True:
1740
1965
            next_lcas = self.graph.find_lca(*cur_ancestors)
1741
1966
            # Map a plain NULL_REVISION to a simple no-ancestors
1742
 
            if next_lcas == set([NULL_REVISION]):
 
1967
            if next_lcas == set([_mod_revision.NULL_REVISION]):
1743
1968
                next_lcas = ()
1744
1969
            # Order the lca's based on when they were merged into the tip
1745
1970
            # While the actual merge portion of weave merge uses a set() of
1757
1982
            elif len(next_lcas) > 2:
1758
1983
                # More than 2 lca's, fall back to grabbing all nodes between
1759
1984
                # this and the unique lca.
1760
 
                mutter('More than 2 LCAs, falling back to all nodes for:'
1761
 
                       ' %s, %s\n=> %s', self.a_key, self.b_key, cur_ancestors)
 
1985
                trace.mutter('More than 2 LCAs, falling back to all nodes for:'
 
1986
                             ' %s, %s\n=> %s',
 
1987
                             self.a_key, self.b_key, cur_ancestors)
1762
1988
                cur_lcas = next_lcas
1763
1989
                while len(cur_lcas) > 1:
1764
1990
                    cur_lcas = self.graph.find_lca(*cur_lcas)
1767
1993
                    unique_lca = None
1768
1994
                else:
1769
1995
                    unique_lca = list(cur_lcas)[0]
1770
 
                    if unique_lca == NULL_REVISION:
 
1996
                    if unique_lca == _mod_revision.NULL_REVISION:
1771
1997
                        # find_lca will return a plain 'NULL_REVISION' rather
1772
1998
                        # than a key tuple when there is no common ancestor, we
1773
1999
                        # prefer to just use None, because it doesn't confuse
1781
2007
 
1782
2008
    def _find_unique_parents(self, tip_keys, base_key):
1783
2009
        """Find ancestors of tip that aren't ancestors of base.
1784
 
        
 
2010
 
1785
2011
        :param tip_keys: Nodes that are interesting
1786
2012
        :param base_key: Cull all ancestors of this node
1787
2013
        :return: The parent map for all revisions between tip_keys and
1796
2022
            # We remove NULL_REVISION because it isn't a proper tuple key, and
1797
2023
            # thus confuses things like _get_interesting_texts, and our logic
1798
2024
            # to add the texts into the memory weave.
1799
 
            if NULL_REVISION in parent_map:
1800
 
                parent_map.pop(NULL_REVISION)
 
2025
            if _mod_revision.NULL_REVISION in parent_map:
 
2026
                parent_map.pop(_mod_revision.NULL_REVISION)
1801
2027
        else:
1802
2028
            interesting = set()
1803
2029
            for tip in tip_keys:
1847
2073
    @staticmethod
1848
2074
    def _prune_tails(parent_map, child_map, tails_to_remove):
1849
2075
        """Remove tails from the parent map.
1850
 
        
 
2076
 
1851
2077
        This will remove the supplied revisions until no more children have 0
1852
2078
        parents.
1853
2079
 
1955
2181
        lcas = graph.find_lca(key_prefix + (a_rev,), key_prefix + (b_rev,))
1956
2182
        self.lcas = set()
1957
2183
        for lca in lcas:
1958
 
            if lca == NULL_REVISION:
 
2184
            if lca == _mod_revision.NULL_REVISION:
1959
2185
                self.lcas.add(lca)
1960
2186
            else:
1961
2187
                self.lcas.add(lca[-1])