← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/merge.py

  • Committer: Martin
  • Date: 2010-05-16 15:18:43 UTC
  • mfrom: (5235 +trunk)
  • mto: This revision was merged to the branch mainline in revision 5239.
  • Revision ID: gzlist@googlemail.com-20100516151843-lu53u7caehm3ie3i
Merge bzr.dev to resolve conflicts in NEWS and _chk_map_pyx

Show diffs side-by-side

added added

removed removed

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