/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: Ian Clatworthy
  • Date: 2009-07-13 06:58:49 UTC
  • mto: (4527.1.1 integration)
  • mto: This revision was merged to the branch mainline in revision 4529.
  • Revision ID: ian.clatworthy@canonical.com-20090713065849-n7g2rsjyl6dt1mgv
Apply review feedback

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