/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/merge.py

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

Show diffs side-by-side

added added

removed removed

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