← 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: 2009-04-09 20:23:07 UTC
  • mfrom: (4265.1.4 bbc-merge)
  • Revision ID: pqm@pqm.ubuntu.com-20090409202307-n0depb16qepoe21o
(jam) Change _fetch_uses_deltas = False for CHK repos until we can
        write a better fix.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/merge.py
1
 
# Copyright (C) 2005-2010 Canonical Ltd
 
1
# Copyright (C) 2005, 2006, 2008 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
17
21
import warnings
18
22
 
19
23
from bzrlib import (
20
 
    branch as _mod_branch,
21
 
    conflicts as _mod_conflicts,
22
24
    debug,
23
 
    decorators,
24
25
    errors,
25
26
    graph as _mod_graph,
26
 
    hooks,
27
 
    merge3,
28
27
    osutils,
29
28
    patiencediff,
 
29
    registry,
30
30
    revision as _mod_revision,
31
 
    textfile,
32
 
    trace,
33
 
    transform,
34
31
    tree as _mod_tree,
35
32
    tsort,
36
 
    ui,
37
 
    versionedfile
38
 
    )
39
 
from bzrlib.cleanup import OperationWithCleanups
40
 
from bzrlib.symbol_versioning import (
41
 
    deprecated_in,
42
 
    deprecated_method,
43
 
    )
 
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
 
44
63
# TODO: Report back as changes are merged in
45
64
 
46
65
 
47
66
def transform_tree(from_tree, to_tree, interesting_ids=None):
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)
 
67
    merge_inner(from_tree.branch, to_tree, from_tree, ignore_zero=True,
 
68
                interesting_ids=interesting_ids, this_tree=from_tree)
255
69
 
256
70
 
257
71
class Merger(object):
258
 
 
259
 
    hooks = MergeHooks()
260
 
 
261
72
    def __init__(self, this_branch, other_tree=None, base_tree=None,
262
73
                 this_tree=None, pb=None, change_reporter=None,
263
74
                 recurse='down', revision_graph=None):
278
89
        self.interesting_files = None
279
90
        self.show_base = False
280
91
        self.reprocess = False
281
 
        if pb is not None:
282
 
            warnings.warn("pb parameter to Merger() is deprecated and ignored")
 
92
        if pb is None:
 
93
            pb = DummyProgress()
 
94
        self._pb = pb
283
95
        self.pp = None
284
96
        self.recurse = recurse
285
97
        self.change_reporter = change_reporter
290
102
        self._is_criss_cross = None
291
103
        self._lca_trees = None
292
104
 
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
 
 
304
105
    @property
305
106
    def revision_graph(self):
306
107
        if self._revision_graph is None:
368
169
                base_revision_id, tree.branch.last_revision())):
369
170
                base_revision_id = None
370
171
            else:
371
 
                trace.warning('Performing cherrypick')
 
172
                warning('Performing cherrypick')
372
173
        merger = klass.from_revision_ids(pb, tree, other_revision_id,
373
174
                                         base_revision_id, revision_graph=
374
175
                                         revision_graph)
426
227
        if revno is None:
427
228
            tree = workingtree.WorkingTree.open_containing(location)[0]
428
229
            return tree.branch, tree
429
 
        branch = _mod_branch.Branch.open_containing(
430
 
            location, possible_transports)[0]
 
230
        branch = Branch.open_containing(location, possible_transports)[0]
431
231
        if revno == -1:
432
232
            revision_id = branch.last_revision()
433
233
        else:
434
234
            revision_id = branch.get_rev_id(revno)
435
 
        revision_id = _mod_revision.ensure_null(revision_id)
 
235
        revision_id = ensure_null(revision_id)
436
236
        return branch, self.revision_tree(revision_id, branch)
437
237
 
438
 
    @deprecated_method(deprecated_in((2, 1, 0)))
439
238
    def ensure_revision_trees(self):
440
239
        if self.this_revision_tree is None:
441
240
            self.this_basis_tree = self.revision_tree(self.this_basis)
444
243
 
445
244
        if self.other_rev_id is None:
446
245
            other_basis_tree = self.revision_tree(self.other_basis)
447
 
            if other_basis_tree.has_changes(self.other_tree):
448
 
                raise errors.WorkingTreeNotRevision(self.this_tree)
 
246
            changes = other_basis_tree.changes_from(self.other_tree)
 
247
            if changes.has_changed():
 
248
                raise WorkingTreeNotRevision(self.this_tree)
449
249
            other_rev_id = self.other_basis
450
250
            self.other_tree = other_basis_tree
451
251
 
452
 
    @deprecated_method(deprecated_in((2, 1, 0)))
453
252
    def file_revisions(self, file_id):
454
253
        self.ensure_revision_trees()
455
254
        def get_id(tree, file_id):
458
257
        if self.this_rev_id is None:
459
258
            if self.this_basis_tree.get_file_sha1(file_id) != \
460
259
                self.this_tree.get_file_sha1(file_id):
461
 
                raise errors.WorkingTreeNotRevision(self.this_tree)
 
260
                raise WorkingTreeNotRevision(self.this_tree)
462
261
 
463
262
        trees = (self.this_basis_tree, self.other_tree)
464
263
        return [get_id(tree, file_id) for tree in trees]
465
264
 
466
 
    @deprecated_method(deprecated_in((2, 1, 0)))
467
265
    def check_basis(self, check_clean, require_commits=True):
468
266
        if self.this_basis is None and require_commits is True:
469
 
            raise errors.BzrCommandError(
470
 
                "This branch has no commits."
471
 
                " (perhaps you would prefer 'bzr pull')")
 
267
            raise BzrCommandError("This branch has no commits."
 
268
                                  " (perhaps you would prefer 'bzr pull')")
472
269
        if check_clean:
473
270
            self.compare_basis()
474
271
            if self.this_basis != self.this_rev_id:
475
272
                raise errors.UncommittedChanges(self.this_tree)
476
273
 
477
 
    @deprecated_method(deprecated_in((2, 1, 0)))
478
274
    def compare_basis(self):
479
275
        try:
480
276
            basis_tree = self.revision_tree(self.this_tree.last_revision())
481
277
        except errors.NoSuchRevision:
482
278
            basis_tree = self.this_tree.basis_tree()
483
 
        if not self.this_tree.has_changes(basis_tree):
 
279
        changes = self.this_tree.changes_from(basis_tree)
 
280
        if not changes.has_changed():
484
281
            self.this_rev_id = self.this_basis
485
282
 
486
283
    def set_interesting_files(self, file_list):
487
284
        self.interesting_files = file_list
488
285
 
489
286
    def set_pending(self):
490
 
        if (not self.base_is_ancestor or not self.base_is_other_ancestor
491
 
            or self.other_rev_id is None):
 
287
        if not self.base_is_ancestor or not self.base_is_other_ancestor or self.other_rev_id is None:
492
288
            return
493
289
        self._add_parent()
494
290
 
495
291
    def _add_parent(self):
496
292
        new_parents = self.this_tree.get_parent_ids() + [self.other_rev_id]
497
293
        new_parent_trees = []
498
 
        operation = OperationWithCleanups(self.this_tree.set_parent_trees)
499
294
        for revision_id in new_parents:
500
295
            try:
501
296
                tree = self.revision_tree(revision_id)
503
298
                tree = None
504
299
            else:
505
300
                tree.lock_read()
506
 
                operation.add_cleanup(tree.unlock)
507
301
            new_parent_trees.append((revision_id, tree))
508
 
        operation.run_simple(new_parent_trees, allow_leftmost_as_ghost=True)
 
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()
509
309
 
510
310
    def set_other(self, other_revision, possible_transports=None):
511
311
        """Set the revision and tree to merge from.
520
320
            self.other_rev_id = _mod_revision.ensure_null(
521
321
                self.other_branch.last_revision())
522
322
            if _mod_revision.is_null(self.other_rev_id):
523
 
                raise errors.NoCommits(self.other_branch)
 
323
                raise NoCommits(self.other_branch)
524
324
            self.other_basis = self.other_rev_id
525
325
        elif other_revision[1] is not None:
526
326
            self.other_rev_id = self.other_branch.get_rev_id(other_revision[1])
529
329
            self.other_rev_id = None
530
330
            self.other_basis = self.other_branch.last_revision()
531
331
            if self.other_basis is None:
532
 
                raise errors.NoCommits(self.other_branch)
 
332
                raise NoCommits(self.other_branch)
533
333
        if self.other_rev_id is not None:
534
334
            self._cached_trees[self.other_rev_id] = self.other_tree
535
335
        self._maybe_fetch(self.other_branch,self.this_branch, self.other_basis)
562
362
            target.fetch(source, revision_id)
563
363
 
564
364
    def find_base(self):
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
 
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
569
369
            self.base_tree = self.revision_tree(self.base_rev_id)
570
370
            self._is_criss_cross = False
571
371
        else:
572
372
            lcas = self.revision_graph.find_lca(revisions[0], revisions[1])
573
373
            self._is_criss_cross = False
574
374
            if len(lcas) == 0:
575
 
                self.base_rev_id = _mod_revision.NULL_REVISION
 
375
                self.base_rev_id = NULL_REVISION
576
376
            elif len(lcas) == 1:
577
377
                self.base_rev_id = list(lcas)[0]
578
378
            else: # len(lcas) > 1
587
387
                    self.base_rev_id = self.revision_graph.find_unique_lca(
588
388
                                            *lcas)
589
389
                self._is_criss_cross = True
590
 
            if self.base_rev_id == _mod_revision.NULL_REVISION:
591
 
                raise errors.UnrelatedBranches()
 
390
            if self.base_rev_id == NULL_REVISION:
 
391
                raise UnrelatedBranches()
592
392
            if self._is_criss_cross:
593
 
                trace.warning('Warning: criss-cross merge encountered.  See bzr'
594
 
                              ' help criss-cross.')
595
 
                trace.mutter('Criss-cross lcas: %r' % lcas)
 
393
                warning('Warning: criss-cross merge encountered.  See bzr'
 
394
                        ' help criss-cross.')
 
395
                mutter('Criss-cross lcas: %r' % lcas)
596
396
                interesting_revision_ids = [self.base_rev_id]
597
397
                interesting_revision_ids.extend(lcas)
598
398
                interesting_trees = dict((t.get_revision_id(), t)
608
408
                self.base_tree = self.revision_tree(self.base_rev_id)
609
409
        self.base_is_ancestor = True
610
410
        self.base_is_other_ancestor = True
611
 
        trace.mutter('Base revid: %r' % self.base_rev_id)
 
411
        mutter('Base revid: %r' % self.base_rev_id)
612
412
 
613
413
    def set_base(self, base_revision):
614
414
        """Set the base revision to use for the merge.
615
415
 
616
416
        :param base_revision: A 2-list containing a path and revision number.
617
417
        """
618
 
        trace.mutter("doing merge() with no base_revision specified")
 
418
        mutter("doing merge() with no base_revision specified")
619
419
        if base_revision == [None, None]:
620
420
            self.find_base()
621
421
        else:
634
434
                  'other_tree': self.other_tree,
635
435
                  'interesting_ids': self.interesting_ids,
636
436
                  'interesting_files': self.interesting_files,
637
 
                  'this_branch': self.this_branch,
 
437
                  'pp': self.pp,
638
438
                  'do_merge': False}
639
439
        if self.merge_type.requires_base:
640
440
            kwargs['base_tree'] = self.base_tree
641
441
        if self.merge_type.supports_reprocess:
642
442
            kwargs['reprocess'] = self.reprocess
643
443
        elif self.reprocess:
644
 
            raise errors.BzrError(
645
 
                "Conflict reduction is not supported for merge"
646
 
                " type %s." % self.merge_type)
 
444
            raise BzrError("Conflict reduction is not supported for merge"
 
445
                                  " type %s." % self.merge_type)
647
446
        if self.merge_type.supports_show_base:
648
447
            kwargs['show_base'] = self.show_base
649
448
        elif self.show_base:
650
 
            raise errors.BzrError("Showing base is not supported for this"
651
 
                                  " merge type. %s" % self.merge_type)
 
449
            raise BzrError("Showing base is not supported for this"
 
450
                           " merge type. %s" % self.merge_type)
652
451
        if (not getattr(self.merge_type, 'supports_reverse_cherrypick', True)
653
452
            and not self.base_is_other_ancestor):
654
453
            raise errors.CannotReverseCherrypick()
658
457
        if self._is_criss_cross and getattr(self.merge_type,
659
458
                                            'supports_lca_trees', False):
660
459
            kwargs['lca_trees'] = self._lca_trees
661
 
        return self.merge_type(pb=None,
 
460
        return self.merge_type(pb=self._pb,
662
461
                               change_reporter=self.change_reporter,
663
462
                               **kwargs)
664
463
 
665
 
    def _do_merge_to(self):
666
 
        merge = self.make_merger()
667
 
        if self.other_branch is not None:
668
 
            self.other_branch.update_references(self.this_branch)
 
464
    def _do_merge_to(self, merge):
669
465
        merge.do_merge()
670
466
        if self.recurse == 'down':
671
467
            for relpath, file_id in self.this_tree.iter_references():
683
479
                    sub_tree.branch.repository.revision_tree(base_revision)
684
480
                sub_merge.base_rev_id = base_revision
685
481
                sub_merge.do_merge()
686
 
        return merge
687
482
 
688
483
    def do_merge(self):
689
 
        operation = OperationWithCleanups(self._do_merge_to)
690
484
        self.this_tree.lock_tree_write()
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()
 
485
        try:
 
486
            if self.base_tree is not None:
 
487
                self.base_tree.lock_read()
 
488
            try:
 
489
                if self.other_tree is not None:
 
490
                    self.other_tree.lock_read()
 
491
                try:
 
492
                    merge = self.make_merger()
 
493
                    self._do_merge_to(merge)
 
494
                finally:
 
495
                    if self.other_tree is not None:
 
496
                        self.other_tree.unlock()
 
497
            finally:
 
498
                if self.base_tree is not None:
 
499
                    self.base_tree.unlock()
 
500
        finally:
 
501
            self.this_tree.unlock()
699
502
        if len(merge.cooked_conflicts) == 0:
700
 
            if not self.ignore_zero and not trace.is_quiet():
701
 
                trace.note("All changes applied successfully.")
 
503
            if not self.ignore_zero and not is_quiet():
 
504
                note("All changes applied successfully.")
702
505
        else:
703
 
            trace.note("%d conflicts encountered."
704
 
                       % len(merge.cooked_conflicts))
 
506
            note("%d conflicts encountered." % len(merge.cooked_conflicts))
705
507
 
706
508
        return len(merge.cooked_conflicts)
707
509
 
736
538
 
737
539
    def __init__(self, working_tree, this_tree, base_tree, other_tree,
738
540
                 interesting_ids=None, reprocess=False, show_base=False,
739
 
                 pb=None, pp=None, change_reporter=None,
 
541
                 pb=DummyProgress(), pp=None, change_reporter=None,
740
542
                 interesting_files=None, do_merge=True,
741
 
                 cherrypick=False, lca_trees=None, this_branch=None):
 
543
                 cherrypick=False, lca_trees=None):
742
544
        """Initialize the merger object and perform the merge.
743
545
 
744
546
        :param working_tree: The working tree to apply the merge to
745
547
        :param this_tree: The local tree in the merge operation
746
548
        :param base_tree: The common tree in the merge operation
747
549
        :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.
750
550
        :param interesting_ids: The file_ids of files that should be
751
551
            participate in the merge.  May not be combined with
752
552
            interesting_files.
753
553
        :param: reprocess If True, perform conflict-reduction processing.
754
554
        :param show_base: If True, show the base revision in text conflicts.
755
555
            (incompatible with reprocess)
756
 
        :param pb: ignored
 
556
        :param pb: A Progress bar
757
557
        :param pp: A ProgressPhase object
758
558
        :param change_reporter: An object that should report changes made
759
559
        :param interesting_files: The tree-relative paths of files that should
770
570
        if interesting_files is not None and interesting_ids is not None:
771
571
            raise ValueError(
772
572
                'specify either interesting_ids or interesting_files')
773
 
        if this_branch is None:
774
 
            this_branch = this_tree.branch
775
573
        self.interesting_ids = interesting_ids
776
574
        self.interesting_files = interesting_files
777
575
        self.this_tree = working_tree
778
576
        self.base_tree = base_tree
779
577
        self.other_tree = other_tree
780
 
        self.this_branch = this_branch
781
578
        self._raw_conflicts = []
782
579
        self.cooked_conflicts = []
783
580
        self.reprocess = reprocess
788
585
        # making sure we haven't missed any corner cases.
789
586
        # if lca_trees is None:
790
587
        #     self._lca_trees = [self.base_tree]
 
588
        self.pb = pb
 
589
        self.pp = pp
791
590
        self.change_reporter = change_reporter
792
591
        self.cherrypick = cherrypick
 
592
        if self.pp is None:
 
593
            self.pp = ProgressPhase("Merge phase", 3, self.pb)
793
594
        if do_merge:
794
595
            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")
799
596
 
800
597
    def do_merge(self):
801
 
        operation = OperationWithCleanups(self._do_merge)
802
598
        self.this_tree.lock_tree_write()
803
 
        operation.add_cleanup(self.this_tree.unlock)
804
599
        self.base_tree.lock_read()
805
 
        operation.add_cleanup(self.base_tree.unlock)
806
600
        self.other_tree.lock_read()
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)
 
601
        self.tt = TreeTransform(self.this_tree, self.pb)
816
602
        try:
817
 
            self.this_tree.add_conflicts(self.cooked_conflicts)
818
 
        except errors.UnsupportedOperation:
819
 
            pass
 
603
            self.pp.next_phase()
 
604
            self._compute_transform()
 
605
            self.pp.next_phase()
 
606
            results = self.tt.apply(no_conflicts=True)
 
607
            self.write_modified(results)
 
608
            try:
 
609
                self.this_tree.add_conflicts(self.cooked_conflicts)
 
610
            except UnsupportedOperation:
 
611
                pass
 
612
        finally:
 
613
            self.tt.finalize()
 
614
            self.other_tree.unlock()
 
615
            self.base_tree.unlock()
 
616
            self.this_tree.unlock()
 
617
            self.pb.clear()
820
618
 
821
619
    def make_preview_transform(self):
822
 
        operation = OperationWithCleanups(self._make_preview_transform)
823
620
        self.base_tree.lock_read()
824
 
        operation.add_cleanup(self.base_tree.unlock)
825
621
        self.other_tree.lock_read()
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()
 
622
        self.tt = TransformPreview(self.this_tree)
 
623
        try:
 
624
            self.pp.next_phase()
 
625
            self._compute_transform()
 
626
            self.pp.next_phase()
 
627
        finally:
 
628
            self.other_tree.unlock()
 
629
            self.base_tree.unlock()
 
630
            self.pb.clear()
832
631
        return self.tt
833
632
 
834
633
    def _compute_transform(self):
840
639
            resolver = self._lca_multi_way
841
640
        child_pb = ui.ui_factory.nested_progress_bar()
842
641
        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]
846
642
            for num, (file_id, changed, parents3, names3,
847
643
                      executable3) in enumerate(entries):
848
644
                child_pb.update('Preparing file merge', num, len(entries))
849
645
                self._merge_names(file_id, parents3, names3, resolver=resolver)
850
646
                if changed:
851
 
                    file_status = self._do_merge_contents(file_id)
 
647
                    file_status = self.merge_contents(file_id)
852
648
                else:
853
649
                    file_status = 'unmodified'
854
650
                self._merge_executable(file_id,
856
652
        finally:
857
653
            child_pb.finished()
858
654
        self.fix_root()
 
655
        self.pp.next_phase()
859
656
        child_pb = ui.ui_factory.nested_progress_bar()
860
657
        try:
861
 
            fs_conflicts = transform.resolve_conflicts(self.tt, child_pb,
862
 
                lambda t, c: transform.conflict_pass(t, c, self.other_tree))
 
658
            fs_conflicts = resolve_conflicts(self.tt, child_pb,
 
659
                lambda t, c: conflict_pass(t, c, self.other_tree))
863
660
        finally:
864
661
            child_pb.finished()
865
662
        if self.change_reporter is not None:
868
665
                self.tt.iter_changes(), self.change_reporter)
869
666
        self.cook_conflicts(fs_conflicts)
870
667
        for conflict in self.cooked_conflicts:
871
 
            trace.warning(conflict)
 
668
            warning(conflict)
872
669
 
873
670
    def _entries3(self):
874
671
        """Gather data about files modified between three trees.
1059
856
                        continue
1060
857
                else:
1061
858
                    raise AssertionError('unhandled kind: %s' % other_ie.kind)
 
859
                # XXX: We need to handle kind == 'symlink'
1062
860
 
1063
861
            # If we have gotten this far, that means something has changed
1064
862
            result.append((file_id, content_changed,
1075
873
    def fix_root(self):
1076
874
        try:
1077
875
            self.tt.final_kind(self.tt.root)
1078
 
        except errors.NoSuchFile:
 
876
        except NoSuchFile:
1079
877
            self.tt.cancel_deletion(self.tt.root)
1080
878
        if self.tt.final_file_id(self.tt.root) is None:
1081
879
            self.tt.version_file(self.tt.tree_file_id(self.tt.root),
1086
884
        other_root = self.tt.trans_id_file_id(other_root_file_id)
1087
885
        if other_root == self.tt.root:
1088
886
            return
 
887
        try:
 
888
            self.tt.final_kind(other_root)
 
889
        except NoSuchFile:
 
890
            return
1089
891
        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)
 
892
            # the other tree's root is a non-root in the current tree
1092
893
            return
1093
 
        try:
1094
 
            self.tt.final_kind(other_root)
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():
 
894
        self.reparent_children(self.other_tree.inventory.root, self.tt.root)
 
895
        self.tt.cancel_creation(other_root)
 
896
        self.tt.cancel_versioning(other_root)
 
897
 
 
898
    def reparent_children(self, ie, target):
 
899
        for thing, child in ie.children.iteritems():
1104
900
            trans_id = self.tt.trans_id_file_id(child.file_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)
 
901
            self.tt.adjust_path(self.tt.final_name(trans_id), target, trans_id)
1121
902
 
1122
903
    def write_modified(self, results):
1123
904
        modified_hashes = {}
1155
936
    @staticmethod
1156
937
    def executable(tree, file_id):
1157
938
        """Determine the executability of a file-id (used as a key method)."""
1158
 
        if not tree.has_id(file_id):
 
939
        if file_id not in tree:
1159
940
            return None
1160
941
        if tree.kind(file_id) != "file":
1161
942
            return False
1164
945
    @staticmethod
1165
946
    def kind(tree, file_id):
1166
947
        """Determine the kind of a file-id (used as a key method)."""
1167
 
        if not tree.has_id(file_id):
 
948
        if file_id not in tree:
1168
949
            return None
1169
950
        return tree.kind(file_id)
1170
951
 
1171
952
    @staticmethod
1172
953
    def _three_way(base, other, this):
 
954
        #if base == other, either they all agree, or only THIS has changed.
1173
955
        if base == other:
1174
 
            # if 'base == other', either they all agree, or only 'this' has
1175
 
            # changed.
1176
956
            return 'this'
1177
957
        elif this not in (base, other):
1178
 
            # 'this' is neither 'base' nor 'other', so both sides changed
1179
958
            return 'conflict'
 
959
        # "Ambiguous clean merge" -- both sides have made the same change.
1180
960
        elif this == other:
1181
 
            # "Ambiguous clean merge" -- both sides have made the same change.
1182
961
            return "this"
 
962
        # this == base: only other has changed.
1183
963
        else:
1184
 
            # this == base: only other has changed.
1185
964
            return "other"
1186
965
 
1187
966
    @staticmethod
1231
1010
                # only has an lca value
1232
1011
                return 'other'
1233
1012
 
1234
 
        # At this point, the lcas disagree, and the tip disagree
 
1013
        # At this point, the lcas disagree, and the tips disagree
1235
1014
        return 'conflict'
1236
1015
 
1237
1016
    @staticmethod
1238
 
    @deprecated_method(deprecated_in((2, 2, 0)))
1239
1017
    def scalar_three_way(this_tree, base_tree, other_tree, file_id, key):
1240
1018
        """Do a three-way test on a scalar.
1241
1019
        Return "this", "other" or "conflict", depending whether a value wins.
1256
1034
 
1257
1035
    def merge_names(self, file_id):
1258
1036
        def get_entry(tree):
1259
 
            if tree.has_id(file_id):
 
1037
            if file_id in tree.inventory:
1260
1038
                return tree.inventory[file_id]
1261
1039
            else:
1262
1040
                return None
1291
1069
                parent_id_winner = "other"
1292
1070
        if name_winner == "this" and parent_id_winner == "this":
1293
1071
            return
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))
 
1072
        if name_winner == "conflict":
 
1073
            trans_id = self.tt.trans_id_file_id(file_id)
 
1074
            self._raw_conflicts.append(('name conflict', trans_id,
 
1075
                                        this_name, other_name))
 
1076
        if parent_id_winner == "conflict":
 
1077
            trans_id = self.tt.trans_id_file_id(file_id)
 
1078
            self._raw_conflicts.append(('parent conflict', trans_id,
 
1079
                                        this_parent, other_parent))
1302
1080
        if other_name is None:
1303
1081
            # it doesn't matter whether the result was 'other' or
1304
1082
            # 'conflict'-- if there's no 'other', we leave it alone.
1305
1083
            return
 
1084
        # if we get here, name_winner and parent_winner are set to safe values.
 
1085
        trans_id = self.tt.trans_id_file_id(file_id)
1306
1086
        parent_id = parents[self.winner_idx[parent_id_winner]]
1307
1087
        if parent_id is not None:
1308
 
            # if we get here, name_winner and parent_winner are set to safe
1309
 
            # values.
 
1088
            parent_trans_id = self.tt.trans_id_file_id(parent_id)
1310
1089
            self.tt.adjust_path(names[self.winner_idx[name_winner]],
1311
 
                                self.tt.trans_id_file_id(parent_id),
1312
 
                                self.tt.trans_id_file_id(file_id))
 
1090
                                parent_trans_id, trans_id)
1313
1091
 
1314
 
    def _do_merge_contents(self, file_id):
 
1092
    def merge_contents(self, file_id):
1315
1093
        """Performs a merge on file_id contents."""
1316
1094
        def contents_pair(tree):
1317
1095
            if file_id not in tree:
1325
1103
                contents = None
1326
1104
            return kind, contents
1327
1105
 
 
1106
        def contents_conflict():
 
1107
            trans_id = self.tt.trans_id_file_id(file_id)
 
1108
            name = self.tt.final_name(trans_id)
 
1109
            parent_id = self.tt.final_parent(trans_id)
 
1110
            if file_id in self.this_tree.inventory:
 
1111
                self.tt.unversion_file(trans_id)
 
1112
                if file_id in self.this_tree:
 
1113
                    self.tt.delete_contents(trans_id)
 
1114
            file_group = self._dump_conflicts(name, parent_id, file_id,
 
1115
                                              set_version=True)
 
1116
            self._raw_conflicts.append(('contents conflict', file_group))
 
1117
 
1328
1118
        # See SPOT run.  run, SPOT, run.
1329
1119
        # So we're not QUITE repeating ourselves; we do tricky things with
1330
1120
        # file kind...
1346
1136
        if winner == 'this':
1347
1137
            # No interesting changes introduced by OTHER
1348
1138
            return "unmodified"
1349
 
        # We have a hypothetical conflict, but if we have files, then we
1350
 
        # can try to merge the content
1351
1139
        trans_id = self.tt.trans_id_file_id(file_id)
1352
 
        params = MergeHookParams(self, file_id, trans_id, this_pair[0],
1353
 
            other_pair[0], winner)
1354
 
        hooks = self.active_hooks
1355
 
        hook_status = 'not_applicable'
1356
 
        for hook in hooks:
1357
 
            hook_status, lines = hook.merge_contents(params)
1358
 
            if hook_status != 'not_applicable':
1359
 
                # Don't try any more hooks, this one applies.
1360
 
                break
1361
 
        result = "modified"
1362
 
        if hook_status == 'not_applicable':
1363
 
            # This is a contents conflict, because none of the available
1364
 
            # functions could merge it.
1365
 
            result = None
1366
 
            name = self.tt.final_name(trans_id)
1367
 
            parent_id = self.tt.final_parent(trans_id)
1368
 
            if self.this_tree.has_id(file_id):
1369
 
                self.tt.unversion_file(trans_id)
1370
 
            file_group = self._dump_conflicts(name, parent_id, file_id,
1371
 
                                              set_version=True)
1372
 
            self._raw_conflicts.append(('contents conflict', file_group))
1373
 
        elif hook_status == 'success':
1374
 
            self.tt.create_file(lines, trans_id)
1375
 
        elif hook_status == 'conflicted':
1376
 
            # XXX: perhaps the hook should be able to provide
1377
 
            # the BASE/THIS/OTHER files?
1378
 
            self.tt.create_file(lines, trans_id)
1379
 
            self._raw_conflicts.append(('text conflict', trans_id))
1380
 
            name = self.tt.final_name(trans_id)
1381
 
            parent_id = self.tt.final_parent(trans_id)
1382
 
            self._dump_conflicts(name, parent_id, file_id)
1383
 
        elif hook_status == 'delete':
1384
 
            self.tt.unversion_file(trans_id)
1385
 
            result = "deleted"
1386
 
        elif hook_status == 'done':
1387
 
            # The hook function did whatever it needs to do directly, no
1388
 
            # further action needed here.
1389
 
            pass
1390
 
        else:
1391
 
            raise AssertionError('unknown hook_status: %r' % (hook_status,))
1392
 
        if not self.this_tree.has_id(file_id) and result == "modified":
1393
 
            self.tt.version_file(file_id, trans_id)
1394
 
        # The merge has been performed, so the old contents should not be
1395
 
        # retained.
1396
 
        try:
1397
 
            self.tt.delete_contents(trans_id)
1398
 
        except errors.NoSuchFile:
1399
 
            pass
1400
 
        return result
1401
 
 
1402
 
    def _default_other_winner_merge(self, merge_hook_params):
1403
 
        """Replace this contents with other."""
1404
 
        file_id = merge_hook_params.file_id
1405
 
        trans_id = merge_hook_params.trans_id
1406
 
        file_in_this = self.this_tree.has_id(file_id)
1407
 
        if self.other_tree.has_id(file_id):
1408
 
            # OTHER changed the file
1409
 
            wt = self.this_tree
1410
 
            if wt.supports_content_filtering():
1411
 
                # We get the path from the working tree if it exists.
1412
 
                # That fails though when OTHER is adding a file, so
1413
 
                # we fall back to the other tree to find the path if
1414
 
                # it doesn't exist locally.
1415
 
                try:
1416
 
                    filter_tree_path = wt.id2path(file_id)
1417
 
                except errors.NoSuchId:
1418
 
                    filter_tree_path = self.other_tree.id2path(file_id)
1419
 
            else:
1420
 
                # Skip the id2path lookup for older formats
1421
 
                filter_tree_path = None
1422
 
            transform.create_from_tree(self.tt, trans_id,
1423
 
                             self.other_tree, file_id,
1424
 
                             filter_tree_path=filter_tree_path)
1425
 
            return 'done', None
1426
 
        elif file_in_this:
1427
 
            # OTHER deleted the file
1428
 
            return 'delete', None
1429
 
        else:
1430
 
            raise AssertionError(
1431
 
                'winner is OTHER, but file_id %r not in THIS or OTHER tree'
1432
 
                % (file_id,))
1433
 
 
1434
 
    def merge_contents(self, merge_hook_params):
1435
 
        """Fallback merge logic after user installed hooks."""
1436
 
        # This function is used in merge hooks as the fallback instance.
1437
 
        # Perhaps making this function and the functions it calls be a 
1438
 
        # a separate class would be better.
1439
 
        if merge_hook_params.winner == 'other':
 
1140
        if winner == 'other':
1440
1141
            # OTHER is a straight winner, so replace this contents with other
1441
 
            return self._default_other_winner_merge(merge_hook_params)
1442
 
        elif merge_hook_params.is_file_merge():
1443
 
            # THIS and OTHER are both files, so text merge.  Either
1444
 
            # BASE is a file, or both converted to files, so at least we
1445
 
            # have agreement that output should be a file.
1446
 
            try:
1447
 
                self.text_merge(merge_hook_params.file_id,
1448
 
                    merge_hook_params.trans_id)
1449
 
            except errors.BinaryFile:
1450
 
                return 'not_applicable', None
1451
 
            return 'done', None
 
1142
            file_in_this = file_id in self.this_tree
 
1143
            if file_in_this:
 
1144
                # Remove any existing contents
 
1145
                self.tt.delete_contents(trans_id)
 
1146
            if file_id in self.other_tree:
 
1147
                # OTHER changed the file
 
1148
                create_from_tree(self.tt, trans_id,
 
1149
                                 self.other_tree, file_id)
 
1150
                if not file_in_this:
 
1151
                    self.tt.version_file(file_id, trans_id)
 
1152
                return "modified"
 
1153
            elif file_in_this:
 
1154
                # OTHER deleted the file
 
1155
                self.tt.unversion_file(trans_id)
 
1156
                return "deleted"
1452
1157
        else:
1453
 
            return 'not_applicable', None
 
1158
            # We have a hypothetical conflict, but if we have files, then we
 
1159
            # can try to merge the content
 
1160
            if this_pair[0] == 'file' and other_pair[0] == 'file':
 
1161
                # THIS and OTHER are both files, so text merge.  Either
 
1162
                # BASE is a file, or both converted to files, so at least we
 
1163
                # have agreement that output should be a file.
 
1164
                try:
 
1165
                    self.text_merge(file_id, trans_id)
 
1166
                except BinaryFile:
 
1167
                    return contents_conflict()
 
1168
                if file_id not in self.this_tree:
 
1169
                    self.tt.version_file(file_id, trans_id)
 
1170
                try:
 
1171
                    self.tt.tree_kind(trans_id)
 
1172
                    self.tt.delete_contents(trans_id)
 
1173
                except NoSuchFile:
 
1174
                    pass
 
1175
                return "modified"
 
1176
            else:
 
1177
                return contents_conflict()
1454
1178
 
1455
1179
    def get_lines(self, tree, file_id):
1456
1180
        """Return the lines in a file, or an empty list."""
1457
 
        if tree.has_id(file_id):
 
1181
        if file_id in tree:
1458
1182
            return tree.get_file(file_id).readlines()
1459
1183
        else:
1460
1184
            return []
1463
1187
        """Perform a three-way text merge on a file_id"""
1464
1188
        # it's possible that we got here with base as a different type.
1465
1189
        # if so, we just want two-way text conflicts.
1466
 
        if self.base_tree.has_id(file_id) and \
 
1190
        if file_id in self.base_tree and \
1467
1191
            self.base_tree.kind(file_id) == "file":
1468
1192
            base_lines = self.get_lines(self.base_tree, file_id)
1469
1193
        else:
1470
1194
            base_lines = []
1471
1195
        other_lines = self.get_lines(self.other_tree, file_id)
1472
1196
        this_lines = self.get_lines(self.this_tree, file_id)
1473
 
        m3 = merge3.Merge3(base_lines, this_lines, other_lines,
1474
 
                           is_cherrypick=self.cherrypick)
 
1197
        m3 = Merge3(base_lines, this_lines, other_lines,
 
1198
                    is_cherrypick=self.cherrypick)
1475
1199
        start_marker = "!START OF MERGE CONFLICT!" + "I HOPE THIS IS UNIQUE"
1476
1200
        if self.show_base is True:
1477
1201
            base_marker = '|' * 7
1515
1239
                ('THIS', self.this_tree, this_lines)]
1516
1240
        if not no_base:
1517
1241
            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
 
 
1532
1242
        versioned = False
1533
1243
        file_group = []
1534
1244
        for suffix, tree, lines in data:
1535
 
            if tree.has_id(file_id):
 
1245
            if file_id in tree:
1536
1246
                trans_id = self._conflict_file(name, parent_id, tree, file_id,
1537
 
                                               suffix, lines, filter_tree_path)
 
1247
                                               suffix, lines)
1538
1248
                file_group.append(trans_id)
1539
1249
                if set_version and not versioned:
1540
1250
                    self.tt.version_file(file_id, trans_id)
1542
1252
        return file_group
1543
1253
 
1544
1254
    def _conflict_file(self, name, parent_id, tree, file_id, suffix,
1545
 
                       lines=None, filter_tree_path=None):
 
1255
                       lines=None):
1546
1256
        """Emit a single conflict file."""
1547
1257
        name = name + '.' + suffix
1548
1258
        trans_id = self.tt.create_path(name, parent_id)
1549
 
        transform.create_from_tree(self.tt, trans_id, tree, file_id, lines,
1550
 
            filter_tree_path)
 
1259
        create_from_tree(self.tt, trans_id, tree, file_id, lines)
1551
1260
        return trans_id
1552
1261
 
1553
1262
    def merge_executable(self, file_id, file_status):
1577
1286
        try:
1578
1287
            if self.tt.final_kind(trans_id) != "file":
1579
1288
                return
1580
 
        except errors.NoSuchFile:
 
1289
        except NoSuchFile:
1581
1290
            return
1582
1291
        if winner == "this":
1583
1292
            executability = this_executable
1584
1293
        else:
1585
 
            if self.other_tree.has_id(file_id):
 
1294
            if file_id in self.other_tree:
1586
1295
                executability = other_executable
1587
 
            elif self.this_tree.has_id(file_id):
 
1296
            elif file_id in self.this_tree:
1588
1297
                executability = this_executable
1589
 
            elif self.base_tree_has_id(file_id):
 
1298
            elif file_id in self.base_tree:
1590
1299
                executability = base_executable
1591
1300
        if executability is not None:
1592
1301
            trans_id = self.tt.trans_id_file_id(file_id)
1594
1303
 
1595
1304
    def cook_conflicts(self, fs_conflicts):
1596
1305
        """Convert all conflicts into a form that doesn't depend on trans_id"""
1597
 
        self.cooked_conflicts.extend(transform.cook_conflicts(
1598
 
                fs_conflicts, self.tt))
1599
 
        fp = transform.FinalPaths(self.tt)
 
1306
        from conflicts import Conflict
 
1307
        name_conflicts = {}
 
1308
        self.cooked_conflicts.extend(cook_conflicts(fs_conflicts, self.tt))
 
1309
        fp = FinalPaths(self.tt)
1600
1310
        for conflict in self._raw_conflicts:
1601
1311
            conflict_type = conflict[0]
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':
 
1312
            if conflict_type in ('name conflict', 'parent conflict'):
 
1313
                trans_id = conflict[1]
 
1314
                conflict_args = conflict[2:]
 
1315
                if trans_id not in name_conflicts:
 
1316
                    name_conflicts[trans_id] = {}
 
1317
                unique_add(name_conflicts[trans_id], conflict_type,
 
1318
                           conflict_args)
 
1319
            if conflict_type == 'contents conflict':
1623
1320
                for trans_id in conflict[1]:
1624
1321
                    file_id = self.tt.final_file_id(trans_id)
1625
1322
                    if file_id is not None:
1629
1326
                    if path.endswith(suffix):
1630
1327
                        path = path[:-len(suffix)]
1631
1328
                        break
1632
 
                c = _mod_conflicts.Conflict.factory(conflict_type,
1633
 
                                                    path=path, file_id=file_id)
1634
 
            elif conflict_type == 'text conflict':
 
1329
                c = Conflict.factory(conflict_type, path=path, file_id=file_id)
 
1330
                self.cooked_conflicts.append(c)
 
1331
            if conflict_type == 'text conflict':
1635
1332
                trans_id = conflict[1]
1636
1333
                path = fp.get_path(trans_id)
1637
1334
                file_id = self.tt.final_file_id(trans_id)
1638
 
                c = _mod_conflicts.Conflict.factory(conflict_type,
1639
 
                                                    path=path, file_id=file_id)
 
1335
                c = Conflict.factory(conflict_type, path=path, file_id=file_id)
 
1336
                self.cooked_conflicts.append(c)
 
1337
 
 
1338
        for trans_id, conflicts in name_conflicts.iteritems():
 
1339
            try:
 
1340
                this_parent, other_parent = conflicts['parent conflict']
 
1341
                if this_parent == other_parent:
 
1342
                    raise AssertionError()
 
1343
            except KeyError:
 
1344
                this_parent = other_parent = \
 
1345
                    self.tt.final_file_id(self.tt.final_parent(trans_id))
 
1346
            try:
 
1347
                this_name, other_name = conflicts['name conflict']
 
1348
                if this_name == other_name:
 
1349
                    raise AssertionError()
 
1350
            except KeyError:
 
1351
                this_name = other_name = self.tt.final_name(trans_id)
 
1352
            other_path = fp.get_path(trans_id)
 
1353
            if this_parent is not None and this_name is not None:
 
1354
                this_parent_path = \
 
1355
                    fp.get_path(self.tt.trans_id_file_id(this_parent))
 
1356
                this_path = pathjoin(this_parent_path, this_name)
1640
1357
            else:
1641
 
                raise AssertionError('bad conflict type: %r' % (conflict,))
 
1358
                this_path = "<deleted>"
 
1359
            file_id = self.tt.final_file_id(trans_id)
 
1360
            c = Conflict.factory('path conflict', path=this_path,
 
1361
                                 conflict_path=other_path, file_id=file_id)
1642
1362
            self.cooked_conflicts.append(c)
1643
 
        self.cooked_conflicts.sort(key=_mod_conflicts.Conflict.sort_key)
 
1363
        self.cooked_conflicts.sort(key=Conflict.sort_key)
1644
1364
 
1645
1365
 
1646
1366
class WeaveMerger(Merge3Merger):
1650
1370
    supports_reverse_cherrypick = False
1651
1371
    history_based = True
1652
1372
 
1653
 
    def _generate_merge_plan(self, file_id, base):
1654
 
        return self.this_tree.plan_file_merge(file_id, self.other_tree,
 
1373
    def _merged_lines(self, file_id):
 
1374
        """Generate the merged lines.
 
1375
        There is no distinction between lines that are meant to contain <<<<<<<
 
1376
        and conflicts.
 
1377
        """
 
1378
        if self.cherrypick:
 
1379
            base = self.base_tree
 
1380
        else:
 
1381
            base = None
 
1382
        plan = self.this_tree.plan_file_merge(file_id, self.other_tree,
1655
1383
                                              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)
1667
1384
        if 'merge' in debug.debug_flags:
1668
1385
            plan = list(plan)
1669
1386
            trans_id = self.tt.trans_id_file_id(file_id)
1670
1387
            name = self.tt.final_name(trans_id) + '.plan'
1671
 
            contents = ('%11s|%s' % l for l in plan)
 
1388
            contents = ('%10s|%s' % l for l in plan)
1672
1389
            self.tt.new_file(name, self.tt.final_parent(trans_id), contents)
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
 
1390
        textmerge = PlanWeaveMerge(plan, '<<<<<<< TREE\n',
 
1391
            '>>>>>>> MERGE-SOURCE\n')
 
1392
        return textmerge.merge_lines(self.reprocess)
1681
1393
 
1682
1394
    def text_merge(self, file_id, trans_id):
1683
1395
        """Perform a (weave) text merge for a given file and file-id.
1684
1396
        If conflicts are encountered, .THIS and .OTHER files will be emitted,
1685
1397
        and a conflict will be noted.
1686
1398
        """
1687
 
        lines, base_lines = self._merged_lines(file_id)
 
1399
        lines, conflicts = self._merged_lines(file_id)
1688
1400
        lines = list(lines)
1689
1401
        # Note we're checking whether the OUTPUT is binary in this case,
1690
1402
        # because we don't want to get into weave merge guts.
1691
 
        textfile.check_text_lines(lines)
 
1403
        check_text_lines(lines)
1692
1404
        self.tt.create_file(lines, trans_id)
1693
 
        if base_lines is not None:
1694
 
            # Conflict
 
1405
        if conflicts:
1695
1406
            self._raw_conflicts.append(('text conflict', trans_id))
1696
1407
            name = self.tt.final_name(trans_id)
1697
1408
            parent_id = self.tt.final_parent(trans_id)
1698
1409
            file_group = self._dump_conflicts(name, parent_id, file_id,
1699
 
                                              no_base=False,
1700
 
                                              base_lines=base_lines)
 
1410
                                              no_base=True)
1701
1411
            file_group.append(trans_id)
1702
1412
 
1703
1413
 
1704
1414
class LCAMerger(WeaveMerger):
1705
1415
 
1706
 
    def _generate_merge_plan(self, file_id, base):
1707
 
        return self.this_tree.plan_file_lca_merge(file_id, self.other_tree,
 
1416
    def _merged_lines(self, file_id):
 
1417
        """Generate the merged lines.
 
1418
        There is no distinction between lines that are meant to contain <<<<<<<
 
1419
        and conflicts.
 
1420
        """
 
1421
        if self.cherrypick:
 
1422
            base = self.base_tree
 
1423
        else:
 
1424
            base = None
 
1425
        plan = self.this_tree.plan_file_lca_merge(file_id, self.other_tree,
1708
1426
                                                  base=base)
 
1427
        if 'merge' in debug.debug_flags:
 
1428
            plan = list(plan)
 
1429
            trans_id = self.tt.trans_id_file_id(file_id)
 
1430
            name = self.tt.final_name(trans_id) + '.plan'
 
1431
            contents = ('%10s|%s' % l for l in plan)
 
1432
            self.tt.new_file(name, self.tt.final_parent(trans_id), contents)
 
1433
        textmerge = PlanWeaveMerge(plan, '<<<<<<< TREE\n',
 
1434
            '>>>>>>> MERGE-SOURCE\n')
 
1435
        return textmerge.merge_lines(self.reprocess)
 
1436
 
1709
1437
 
1710
1438
class Diff3Merger(Merge3Merger):
1711
1439
    """Three-way merger using external diff3 for text merging"""
1712
1440
 
1713
1441
    def dump_file(self, temp_dir, name, tree, file_id):
1714
 
        out_path = osutils.pathjoin(temp_dir, name)
 
1442
        out_path = pathjoin(temp_dir, name)
1715
1443
        out_file = open(out_path, "wb")
1716
1444
        try:
1717
1445
            in_file = tree.get_file(file_id)
1729
1457
        import bzrlib.patch
1730
1458
        temp_dir = osutils.mkdtemp(prefix="bzr-")
1731
1459
        try:
1732
 
            new_file = osutils.pathjoin(temp_dir, "new")
 
1460
            new_file = pathjoin(temp_dir, "new")
1733
1461
            this = self.dump_file(temp_dir, "this", self.this_tree, file_id)
1734
1462
            base = self.dump_file(temp_dir, "base", self.base_tree, file_id)
1735
1463
            other = self.dump_file(temp_dir, "other", self.other_tree, file_id)
1736
1464
            status = bzrlib.patch.diff3(new_file, this, base, other)
1737
1465
            if status not in (0, 1):
1738
 
                raise errors.BzrError("Unhandled diff3 exit code")
 
1466
                raise BzrError("Unhandled diff3 exit code")
1739
1467
            f = open(new_file, 'rb')
1740
1468
            try:
1741
1469
                self.tt.create_file(f, trans_id)
1759
1487
                other_rev_id=None,
1760
1488
                interesting_files=None,
1761
1489
                this_tree=None,
1762
 
                pb=None,
 
1490
                pb=DummyProgress(),
1763
1491
                change_reporter=None):
1764
1492
    """Primary interface for merging.
1765
1493
 
1768
1496
                     branch.get_revision_tree(base_revision))'
1769
1497
        """
1770
1498
    if this_tree is None:
1771
 
        raise errors.BzrError("bzrlib.merge.merge_inner requires a this_tree "
1772
 
                              "parameter as of bzrlib version 0.8.")
 
1499
        raise BzrError("bzrlib.merge.merge_inner requires a this_tree "
 
1500
            "parameter as of bzrlib version 0.8.")
1773
1501
    merger = Merger(this_branch, other_tree, base_tree, this_tree=this_tree,
1774
1502
                    pb=pb, change_reporter=change_reporter)
1775
1503
    merger.backup_files = backup_files
1788
1516
    get_revision_id = getattr(base_tree, 'get_revision_id', None)
1789
1517
    if get_revision_id is None:
1790
1518
        get_revision_id = base_tree.last_revision
1791
 
    merger.cache_trees_with_revision_ids([other_tree, base_tree, this_tree])
1792
1519
    merger.set_base_revision(get_revision_id(), this_branch)
1793
1520
    return merger.do_merge()
1794
1521
 
1993
1720
        super(_PlanMerge, self).__init__(a_rev, b_rev, vf, key_prefix)
1994
1721
        self.a_key = self._key_prefix + (self.a_rev,)
1995
1722
        self.b_key = self._key_prefix + (self.b_rev,)
1996
 
        self.graph = _mod_graph.Graph(self.vf)
 
1723
        self.graph = Graph(self.vf)
1997
1724
        heads = self.graph.heads((self.a_key, self.b_key))
1998
1725
        if len(heads) == 1:
1999
1726
            # one side dominates, so we can just return its values, yay for
2004
1731
                other = b_rev
2005
1732
            else:
2006
1733
                other = a_rev
2007
 
            trace.mutter('found dominating revision for %s\n%s > %s', self.vf,
2008
 
                         self._head_key[-1], other)
 
1734
            mutter('found dominating revision for %s\n%s > %s', self.vf,
 
1735
                   self._head_key[-1], other)
2009
1736
            self._weave = None
2010
1737
        else:
2011
1738
            self._head_key = None
2025
1752
        while True:
2026
1753
            next_lcas = self.graph.find_lca(*cur_ancestors)
2027
1754
            # Map a plain NULL_REVISION to a simple no-ancestors
2028
 
            if next_lcas == set([_mod_revision.NULL_REVISION]):
 
1755
            if next_lcas == set([NULL_REVISION]):
2029
1756
                next_lcas = ()
2030
1757
            # Order the lca's based on when they were merged into the tip
2031
1758
            # While the actual merge portion of weave merge uses a set() of
2043
1770
            elif len(next_lcas) > 2:
2044
1771
                # More than 2 lca's, fall back to grabbing all nodes between
2045
1772
                # this and the unique lca.
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)
 
1773
                mutter('More than 2 LCAs, falling back to all nodes for:'
 
1774
                       ' %s, %s\n=> %s', self.a_key, self.b_key, cur_ancestors)
2049
1775
                cur_lcas = next_lcas
2050
1776
                while len(cur_lcas) > 1:
2051
1777
                    cur_lcas = self.graph.find_lca(*cur_lcas)
2054
1780
                    unique_lca = None
2055
1781
                else:
2056
1782
                    unique_lca = list(cur_lcas)[0]
2057
 
                    if unique_lca == _mod_revision.NULL_REVISION:
 
1783
                    if unique_lca == NULL_REVISION:
2058
1784
                        # find_lca will return a plain 'NULL_REVISION' rather
2059
1785
                        # than a key tuple when there is no common ancestor, we
2060
1786
                        # prefer to just use None, because it doesn't confuse
2083
1809
            # We remove NULL_REVISION because it isn't a proper tuple key, and
2084
1810
            # thus confuses things like _get_interesting_texts, and our logic
2085
1811
            # to add the texts into the memory weave.
2086
 
            if _mod_revision.NULL_REVISION in parent_map:
2087
 
                parent_map.pop(_mod_revision.NULL_REVISION)
 
1812
            if NULL_REVISION in parent_map:
 
1813
                parent_map.pop(NULL_REVISION)
2088
1814
        else:
2089
1815
            interesting = set()
2090
1816
            for tip in tip_keys:
2242
1968
        lcas = graph.find_lca(key_prefix + (a_rev,), key_prefix + (b_rev,))
2243
1969
        self.lcas = set()
2244
1970
        for lca in lcas:
2245
 
            if lca == _mod_revision.NULL_REVISION:
 
1971
            if lca == NULL_REVISION:
2246
1972
                self.lcas.add(lca)
2247
1973
            else:
2248
1974
                self.lcas.add(lca[-1])