← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/merge.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2010-09-29 22:03:03 UTC
  • mfrom: (5416.2.6 jam-integration)
  • Revision ID: pqm@pqm.ubuntu.com-20100929220303-cr95h8iwtggco721
(mbp) Add 'break-lock --force'

Show diffs side-by-side

added added

removed removed

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