/brz/remove-bazaar

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

« back to all changes in this revision

Viewing changes to bzrlib/merge.py

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

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/merge.py
1
 
# Copyright (C) 2005, 2006, 2008 Canonical Ltd
 
1
# Copyright (C) 2005-2010 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
14
14
# along with this program; if not, write to the Free Software
15
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
16
 
17
 
 
18
 
import errno
19
 
from itertools import chain
20
 
import os
21
17
import warnings
22
18
 
23
19
from bzrlib import (
 
20
    branch as _mod_branch,
 
21
    conflicts as _mod_conflicts,
24
22
    debug,
 
23
    decorators,
25
24
    errors,
26
25
    graph as _mod_graph,
 
26
    hooks,
 
27
    merge3,
27
28
    osutils,
28
29
    patiencediff,
29
 
    registry,
30
30
    revision as _mod_revision,
 
31
    textfile,
 
32
    trace,
 
33
    transform,
31
34
    tree as _mod_tree,
32
35
    tsort,
33
 
    )
34
 
from bzrlib.branch import Branch
35
 
from bzrlib.conflicts import ConflictList, Conflict
36
 
from bzrlib.errors import (BzrCommandError,
37
 
                           BzrError,
38
 
                           NoCommonAncestor,
39
 
                           NoCommits,
40
 
                           NoSuchRevision,
41
 
                           NoSuchFile,
42
 
                           NotBranchError,
43
 
                           NotVersionedError,
44
 
                           UnrelatedBranches,
45
 
                           UnsupportedOperation,
46
 
                           WorkingTreeNotRevision,
47
 
                           BinaryFile,
48
 
                           )
49
 
from bzrlib.graph import Graph
50
 
from bzrlib.merge3 import Merge3
51
 
from bzrlib.osutils import rename, pathjoin
52
 
from progress import DummyProgress, ProgressPhase
53
 
from bzrlib.revision import (NULL_REVISION, ensure_null)
54
 
from bzrlib.textfile import check_text_lines
55
 
from bzrlib.trace import mutter, warning, note, is_quiet
56
 
from bzrlib.transform import (TransformPreview, TreeTransform,
57
 
                              resolve_conflicts, cook_conflicts,
58
 
                              conflict_pass, FinalPaths, create_from_tree,
59
 
                              unique_add, ROOT_PARENT)
60
 
from bzrlib.versionedfile import PlanWeaveMerge
61
 
from bzrlib import ui
62
 
 
 
36
    ui,
 
37
    versionedfile
 
38
    )
 
39
from bzrlib.cleanup import OperationWithCleanups
 
40
from bzrlib.symbol_versioning import (
 
41
    deprecated_in,
 
42
    deprecated_method,
 
43
    )
63
44
# TODO: Report back as changes are merged in
64
45
 
65
46
 
66
47
def transform_tree(from_tree, to_tree, interesting_ids=None):
67
48
    from_tree.lock_tree_write()
68
 
    try:
69
 
        merge_inner(from_tree.branch, to_tree, from_tree, ignore_zero=True,
70
 
                    interesting_ids=interesting_ids, this_tree=from_tree)
71
 
    finally:
72
 
        from_tree.unlock()
 
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)
73
255
 
74
256
 
75
257
class Merger(object):
 
258
 
 
259
    hooks = MergeHooks()
 
260
 
76
261
    def __init__(self, this_branch, other_tree=None, base_tree=None,
77
262
                 this_tree=None, pb=None, change_reporter=None,
78
263
                 recurse='down', revision_graph=None):
93
278
        self.interesting_files = None
94
279
        self.show_base = False
95
280
        self.reprocess = False
96
 
        if pb is None:
97
 
            pb = DummyProgress()
98
 
        self._pb = pb
 
281
        if pb is not None:
 
282
            warnings.warn("pb parameter to Merger() is deprecated and ignored")
99
283
        self.pp = None
100
284
        self.recurse = recurse
101
285
        self.change_reporter = change_reporter
184
368
                base_revision_id, tree.branch.last_revision())):
185
369
                base_revision_id = None
186
370
            else:
187
 
                warning('Performing cherrypick')
 
371
                trace.warning('Performing cherrypick')
188
372
        merger = klass.from_revision_ids(pb, tree, other_revision_id,
189
373
                                         base_revision_id, revision_graph=
190
374
                                         revision_graph)
242
426
        if revno is None:
243
427
            tree = workingtree.WorkingTree.open_containing(location)[0]
244
428
            return tree.branch, tree
245
 
        branch = Branch.open_containing(location, possible_transports)[0]
 
429
        branch = _mod_branch.Branch.open_containing(
 
430
            location, possible_transports)[0]
246
431
        if revno == -1:
247
432
            revision_id = branch.last_revision()
248
433
        else:
249
434
            revision_id = branch.get_rev_id(revno)
250
 
        revision_id = ensure_null(revision_id)
 
435
        revision_id = _mod_revision.ensure_null(revision_id)
251
436
        return branch, self.revision_tree(revision_id, branch)
252
437
 
 
438
    @deprecated_method(deprecated_in((2, 1, 0)))
253
439
    def ensure_revision_trees(self):
254
440
        if self.this_revision_tree is None:
255
441
            self.this_basis_tree = self.revision_tree(self.this_basis)
259
445
        if self.other_rev_id is None:
260
446
            other_basis_tree = self.revision_tree(self.other_basis)
261
447
            if other_basis_tree.has_changes(self.other_tree):
262
 
                raise WorkingTreeNotRevision(self.this_tree)
 
448
                raise errors.WorkingTreeNotRevision(self.this_tree)
263
449
            other_rev_id = self.other_basis
264
450
            self.other_tree = other_basis_tree
265
451
 
 
452
    @deprecated_method(deprecated_in((2, 1, 0)))
266
453
    def file_revisions(self, file_id):
267
454
        self.ensure_revision_trees()
268
455
        def get_id(tree, file_id):
271
458
        if self.this_rev_id is None:
272
459
            if self.this_basis_tree.get_file_sha1(file_id) != \
273
460
                self.this_tree.get_file_sha1(file_id):
274
 
                raise WorkingTreeNotRevision(self.this_tree)
 
461
                raise errors.WorkingTreeNotRevision(self.this_tree)
275
462
 
276
463
        trees = (self.this_basis_tree, self.other_tree)
277
464
        return [get_id(tree, file_id) for tree in trees]
278
465
 
 
466
    @deprecated_method(deprecated_in((2, 1, 0)))
279
467
    def check_basis(self, check_clean, require_commits=True):
280
468
        if self.this_basis is None and require_commits is True:
281
 
            raise BzrCommandError("This branch has no commits."
282
 
                                  " (perhaps you would prefer 'bzr pull')")
 
469
            raise errors.BzrCommandError(
 
470
                "This branch has no commits."
 
471
                " (perhaps you would prefer 'bzr pull')")
283
472
        if check_clean:
284
473
            self.compare_basis()
285
474
            if self.this_basis != self.this_rev_id:
286
475
                raise errors.UncommittedChanges(self.this_tree)
287
476
 
 
477
    @deprecated_method(deprecated_in((2, 1, 0)))
288
478
    def compare_basis(self):
289
479
        try:
290
480
            basis_tree = self.revision_tree(self.this_tree.last_revision())
297
487
        self.interesting_files = file_list
298
488
 
299
489
    def set_pending(self):
300
 
        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):
301
492
            return
302
493
        self._add_parent()
303
494
 
304
495
    def _add_parent(self):
305
496
        new_parents = self.this_tree.get_parent_ids() + [self.other_rev_id]
306
497
        new_parent_trees = []
 
498
        operation = OperationWithCleanups(self.this_tree.set_parent_trees)
307
499
        for revision_id in new_parents:
308
500
            try:
309
501
                tree = self.revision_tree(revision_id)
311
503
                tree = None
312
504
            else:
313
505
                tree.lock_read()
 
506
                operation.add_cleanup(tree.unlock)
314
507
            new_parent_trees.append((revision_id, tree))
315
 
        try:
316
 
            self.this_tree.set_parent_trees(new_parent_trees,
317
 
                                            allow_leftmost_as_ghost=True)
318
 
        finally:
319
 
            for _revision_id, tree in new_parent_trees:
320
 
                if tree is not None:
321
 
                    tree.unlock()
 
508
        operation.run_simple(new_parent_trees, allow_leftmost_as_ghost=True)
322
509
 
323
510
    def set_other(self, other_revision, possible_transports=None):
324
511
        """Set the revision and tree to merge from.
333
520
            self.other_rev_id = _mod_revision.ensure_null(
334
521
                self.other_branch.last_revision())
335
522
            if _mod_revision.is_null(self.other_rev_id):
336
 
                raise NoCommits(self.other_branch)
 
523
                raise errors.NoCommits(self.other_branch)
337
524
            self.other_basis = self.other_rev_id
338
525
        elif other_revision[1] is not None:
339
526
            self.other_rev_id = self.other_branch.get_rev_id(other_revision[1])
342
529
            self.other_rev_id = None
343
530
            self.other_basis = self.other_branch.last_revision()
344
531
            if self.other_basis is None:
345
 
                raise NoCommits(self.other_branch)
 
532
                raise errors.NoCommits(self.other_branch)
346
533
        if self.other_rev_id is not None:
347
534
            self._cached_trees[self.other_rev_id] = self.other_tree
348
535
        self._maybe_fetch(self.other_branch,self.this_branch, self.other_basis)
375
562
            target.fetch(source, revision_id)
376
563
 
377
564
    def find_base(self):
378
 
        revisions = [ensure_null(self.this_basis),
379
 
                     ensure_null(self.other_basis)]
380
 
        if NULL_REVISION in revisions:
381
 
            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
382
569
            self.base_tree = self.revision_tree(self.base_rev_id)
383
570
            self._is_criss_cross = False
384
571
        else:
385
572
            lcas = self.revision_graph.find_lca(revisions[0], revisions[1])
386
573
            self._is_criss_cross = False
387
574
            if len(lcas) == 0:
388
 
                self.base_rev_id = NULL_REVISION
 
575
                self.base_rev_id = _mod_revision.NULL_REVISION
389
576
            elif len(lcas) == 1:
390
577
                self.base_rev_id = list(lcas)[0]
391
578
            else: # len(lcas) > 1
400
587
                    self.base_rev_id = self.revision_graph.find_unique_lca(
401
588
                                            *lcas)
402
589
                self._is_criss_cross = True
403
 
            if self.base_rev_id == NULL_REVISION:
404
 
                raise UnrelatedBranches()
 
590
            if self.base_rev_id == _mod_revision.NULL_REVISION:
 
591
                raise errors.UnrelatedBranches()
405
592
            if self._is_criss_cross:
406
 
                warning('Warning: criss-cross merge encountered.  See bzr'
407
 
                        ' help criss-cross.')
408
 
                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)
409
596
                interesting_revision_ids = [self.base_rev_id]
410
597
                interesting_revision_ids.extend(lcas)
411
598
                interesting_trees = dict((t.get_revision_id(), t)
421
608
                self.base_tree = self.revision_tree(self.base_rev_id)
422
609
        self.base_is_ancestor = True
423
610
        self.base_is_other_ancestor = True
424
 
        mutter('Base revid: %r' % self.base_rev_id)
 
611
        trace.mutter('Base revid: %r' % self.base_rev_id)
425
612
 
426
613
    def set_base(self, base_revision):
427
614
        """Set the base revision to use for the merge.
428
615
 
429
616
        :param base_revision: A 2-list containing a path and revision number.
430
617
        """
431
 
        mutter("doing merge() with no base_revision specified")
 
618
        trace.mutter("doing merge() with no base_revision specified")
432
619
        if base_revision == [None, None]:
433
620
            self.find_base()
434
621
        else:
447
634
                  'other_tree': self.other_tree,
448
635
                  'interesting_ids': self.interesting_ids,
449
636
                  'interesting_files': self.interesting_files,
450
 
                  'pp': self.pp,
 
637
                  'this_branch': self.this_branch,
451
638
                  'do_merge': False}
452
639
        if self.merge_type.requires_base:
453
640
            kwargs['base_tree'] = self.base_tree
454
641
        if self.merge_type.supports_reprocess:
455
642
            kwargs['reprocess'] = self.reprocess
456
643
        elif self.reprocess:
457
 
            raise BzrError("Conflict reduction is not supported for merge"
458
 
                                  " type %s." % self.merge_type)
 
644
            raise errors.BzrError(
 
645
                "Conflict reduction is not supported for merge"
 
646
                " type %s." % self.merge_type)
459
647
        if self.merge_type.supports_show_base:
460
648
            kwargs['show_base'] = self.show_base
461
649
        elif self.show_base:
462
 
            raise BzrError("Showing base is not supported for this"
463
 
                           " merge type. %s" % self.merge_type)
 
650
            raise errors.BzrError("Showing base is not supported for this"
 
651
                                  " merge type. %s" % self.merge_type)
464
652
        if (not getattr(self.merge_type, 'supports_reverse_cherrypick', True)
465
653
            and not self.base_is_other_ancestor):
466
654
            raise errors.CannotReverseCherrypick()
470
658
        if self._is_criss_cross and getattr(self.merge_type,
471
659
                                            'supports_lca_trees', False):
472
660
            kwargs['lca_trees'] = self._lca_trees
473
 
        return self.merge_type(pb=self._pb,
 
661
        return self.merge_type(pb=None,
474
662
                               change_reporter=self.change_reporter,
475
663
                               **kwargs)
476
664
 
477
 
    def _do_merge_to(self, merge):
 
665
    def _do_merge_to(self):
 
666
        merge = self.make_merger()
478
667
        if self.other_branch is not None:
479
668
            self.other_branch.update_references(self.this_branch)
480
669
        merge.do_merge()
494
683
                    sub_tree.branch.repository.revision_tree(base_revision)
495
684
                sub_merge.base_rev_id = base_revision
496
685
                sub_merge.do_merge()
 
686
        return merge
497
687
 
498
688
    def do_merge(self):
 
689
        operation = OperationWithCleanups(self._do_merge_to)
499
690
        self.this_tree.lock_tree_write()
500
 
        try:
501
 
            if self.base_tree is not None:
502
 
                self.base_tree.lock_read()
503
 
            try:
504
 
                if self.other_tree is not None:
505
 
                    self.other_tree.lock_read()
506
 
                try:
507
 
                    merge = self.make_merger()
508
 
                    self._do_merge_to(merge)
509
 
                finally:
510
 
                    if self.other_tree is not None:
511
 
                        self.other_tree.unlock()
512
 
            finally:
513
 
                if self.base_tree is not None:
514
 
                    self.base_tree.unlock()
515
 
        finally:
516
 
            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()
517
699
        if len(merge.cooked_conflicts) == 0:
518
 
            if not self.ignore_zero and not is_quiet():
519
 
                note("All changes applied successfully.")
 
700
            if not self.ignore_zero and not trace.is_quiet():
 
701
                trace.note("All changes applied successfully.")
520
702
        else:
521
 
            note("%d conflicts encountered." % len(merge.cooked_conflicts))
 
703
            trace.note("%d conflicts encountered."
 
704
                       % len(merge.cooked_conflicts))
522
705
 
523
706
        return len(merge.cooked_conflicts)
524
707
 
553
736
 
554
737
    def __init__(self, working_tree, this_tree, base_tree, other_tree,
555
738
                 interesting_ids=None, reprocess=False, show_base=False,
556
 
                 pb=DummyProgress(), pp=None, change_reporter=None,
 
739
                 pb=None, pp=None, change_reporter=None,
557
740
                 interesting_files=None, do_merge=True,
558
 
                 cherrypick=False, lca_trees=None):
 
741
                 cherrypick=False, lca_trees=None, this_branch=None):
559
742
        """Initialize the merger object and perform the merge.
560
743
 
561
744
        :param working_tree: The working tree to apply the merge to
562
745
        :param this_tree: The local tree in the merge operation
563
746
        :param base_tree: The common tree in the merge operation
564
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.
565
750
        :param interesting_ids: The file_ids of files that should be
566
751
            participate in the merge.  May not be combined with
567
752
            interesting_files.
568
753
        :param: reprocess If True, perform conflict-reduction processing.
569
754
        :param show_base: If True, show the base revision in text conflicts.
570
755
            (incompatible with reprocess)
571
 
        :param pb: A Progress bar
 
756
        :param pb: ignored
572
757
        :param pp: A ProgressPhase object
573
758
        :param change_reporter: An object that should report changes made
574
759
        :param interesting_files: The tree-relative paths of files that should
585
770
        if interesting_files is not None and interesting_ids is not None:
586
771
            raise ValueError(
587
772
                'specify either interesting_ids or interesting_files')
 
773
        if this_branch is None:
 
774
            this_branch = this_tree.branch
588
775
        self.interesting_ids = interesting_ids
589
776
        self.interesting_files = interesting_files
590
777
        self.this_tree = working_tree
591
778
        self.base_tree = base_tree
592
779
        self.other_tree = other_tree
 
780
        self.this_branch = this_branch
593
781
        self._raw_conflicts = []
594
782
        self.cooked_conflicts = []
595
783
        self.reprocess = reprocess
600
788
        # making sure we haven't missed any corner cases.
601
789
        # if lca_trees is None:
602
790
        #     self._lca_trees = [self.base_tree]
603
 
        self.pb = pb
604
 
        self.pp = pp
605
791
        self.change_reporter = change_reporter
606
792
        self.cherrypick = cherrypick
607
 
        if self.pp is None:
608
 
            self.pp = ProgressPhase("Merge phase", 3, self.pb)
609
793
        if do_merge:
610
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")
611
799
 
612
800
    def do_merge(self):
 
801
        operation = OperationWithCleanups(self._do_merge)
613
802
        self.this_tree.lock_tree_write()
 
803
        operation.add_cleanup(self.this_tree.unlock)
614
804
        self.base_tree.lock_read()
 
805
        operation.add_cleanup(self.base_tree.unlock)
615
806
        self.other_tree.lock_read()
 
807
        operation.add_cleanup(self.other_tree.unlock)
 
808
        operation.run()
 
809
 
 
810
    def _do_merge(self, operation):
 
811
        self.tt = transform.TreeTransform(self.this_tree, None)
 
812
        operation.add_cleanup(self.tt.finalize)
 
813
        self._compute_transform()
 
814
        results = self.tt.apply(no_conflicts=True)
 
815
        self.write_modified(results)
616
816
        try:
617
 
            self.tt = TreeTransform(self.this_tree, self.pb)
618
 
            try:
619
 
                self.pp.next_phase()
620
 
                self._compute_transform()
621
 
                self.pp.next_phase()
622
 
                results = self.tt.apply(no_conflicts=True)
623
 
                self.write_modified(results)
624
 
                try:
625
 
                    self.this_tree.add_conflicts(self.cooked_conflicts)
626
 
                except UnsupportedOperation:
627
 
                    pass
628
 
            finally:
629
 
                self.tt.finalize()
630
 
        finally:
631
 
            self.other_tree.unlock()
632
 
            self.base_tree.unlock()
633
 
            self.this_tree.unlock()
634
 
            self.pb.clear()
 
817
            self.this_tree.add_conflicts(self.cooked_conflicts)
 
818
        except errors.UnsupportedOperation:
 
819
            pass
635
820
 
636
821
    def make_preview_transform(self):
 
822
        operation = OperationWithCleanups(self._make_preview_transform)
637
823
        self.base_tree.lock_read()
 
824
        operation.add_cleanup(self.base_tree.unlock)
638
825
        self.other_tree.lock_read()
639
 
        self.tt = TransformPreview(self.this_tree)
640
 
        try:
641
 
            self.pp.next_phase()
642
 
            self._compute_transform()
643
 
            self.pp.next_phase()
644
 
        finally:
645
 
            self.other_tree.unlock()
646
 
            self.base_tree.unlock()
647
 
            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()
648
832
        return self.tt
649
833
 
650
834
    def _compute_transform(self):
656
840
            resolver = self._lca_multi_way
657
841
        child_pb = ui.ui_factory.nested_progress_bar()
658
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]
659
846
            for num, (file_id, changed, parents3, names3,
660
847
                      executable3) in enumerate(entries):
661
848
                child_pb.update('Preparing file merge', num, len(entries))
662
849
                self._merge_names(file_id, parents3, names3, resolver=resolver)
663
850
                if changed:
664
 
                    file_status = self.merge_contents(file_id)
 
851
                    file_status = self._do_merge_contents(file_id)
665
852
                else:
666
853
                    file_status = 'unmodified'
667
854
                self._merge_executable(file_id,
669
856
        finally:
670
857
            child_pb.finished()
671
858
        self.fix_root()
672
 
        self.pp.next_phase()
673
859
        child_pb = ui.ui_factory.nested_progress_bar()
674
860
        try:
675
 
            fs_conflicts = resolve_conflicts(self.tt, child_pb,
676
 
                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))
677
863
        finally:
678
864
            child_pb.finished()
679
865
        if self.change_reporter is not None:
682
868
                self.tt.iter_changes(), self.change_reporter)
683
869
        self.cook_conflicts(fs_conflicts)
684
870
        for conflict in self.cooked_conflicts:
685
 
            warning(conflict)
 
871
            trace.warning(conflict)
686
872
 
687
873
    def _entries3(self):
688
874
        """Gather data about files modified between three trees.
873
1059
                        continue
874
1060
                else:
875
1061
                    raise AssertionError('unhandled kind: %s' % other_ie.kind)
876
 
                # XXX: We need to handle kind == 'symlink'
877
1062
 
878
1063
            # If we have gotten this far, that means something has changed
879
1064
            result.append((file_id, content_changed,
890
1075
    def fix_root(self):
891
1076
        try:
892
1077
            self.tt.final_kind(self.tt.root)
893
 
        except NoSuchFile:
 
1078
        except errors.NoSuchFile:
894
1079
            self.tt.cancel_deletion(self.tt.root)
895
1080
        if self.tt.final_file_id(self.tt.root) is None:
896
1081
            self.tt.version_file(self.tt.tree_file_id(self.tt.root),
901
1086
        other_root = self.tt.trans_id_file_id(other_root_file_id)
902
1087
        if other_root == self.tt.root:
903
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
904
1093
        try:
905
1094
            self.tt.final_kind(other_root)
906
 
        except NoSuchFile:
907
 
            return
908
 
        if self.other_tree.inventory.root.file_id in self.this_tree.inventory:
909
 
            # the other tree's root is a non-root in the current tree
910
 
            return
911
 
        self.reparent_children(self.other_tree.inventory.root, self.tt.root)
912
 
        self.tt.cancel_creation(other_root)
913
 
        self.tt.cancel_versioning(other_root)
914
 
 
915
 
    def reparent_children(self, ie, target):
916
 
        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():
917
1104
            trans_id = self.tt.trans_id_file_id(child.file_id)
918
 
            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)
919
1121
 
920
1122
    def write_modified(self, results):
921
1123
        modified_hashes = {}
953
1155
    @staticmethod
954
1156
    def executable(tree, file_id):
955
1157
        """Determine the executability of a file-id (used as a key method)."""
956
 
        if file_id not in tree:
 
1158
        if not tree.has_id(file_id):
957
1159
            return None
958
1160
        if tree.kind(file_id) != "file":
959
1161
            return False
962
1164
    @staticmethod
963
1165
    def kind(tree, file_id):
964
1166
        """Determine the kind of a file-id (used as a key method)."""
965
 
        if file_id not in tree:
 
1167
        if not tree.has_id(file_id):
966
1168
            return None
967
1169
        return tree.kind(file_id)
968
1170
 
969
1171
    @staticmethod
970
1172
    def _three_way(base, other, this):
971
 
        #if base == other, either they all agree, or only THIS has changed.
972
1173
        if base == other:
 
1174
            # if 'base == other', either they all agree, or only 'this' has
 
1175
            # changed.
973
1176
            return 'this'
974
1177
        elif this not in (base, other):
 
1178
            # 'this' is neither 'base' nor 'other', so both sides changed
975
1179
            return 'conflict'
976
 
        # "Ambiguous clean merge" -- both sides have made the same change.
977
1180
        elif this == other:
 
1181
            # "Ambiguous clean merge" -- both sides have made the same change.
978
1182
            return "this"
979
 
        # this == base: only other has changed.
980
1183
        else:
 
1184
            # this == base: only other has changed.
981
1185
            return "other"
982
1186
 
983
1187
    @staticmethod
1027
1231
                # only has an lca value
1028
1232
                return 'other'
1029
1233
 
1030
 
        # At this point, the lcas disagree, and the tips disagree
 
1234
        # At this point, the lcas disagree, and the tip disagree
1031
1235
        return 'conflict'
1032
1236
 
1033
1237
    @staticmethod
 
1238
    @deprecated_method(deprecated_in((2, 2, 0)))
1034
1239
    def scalar_three_way(this_tree, base_tree, other_tree, file_id, key):
1035
1240
        """Do a three-way test on a scalar.
1036
1241
        Return "this", "other" or "conflict", depending whether a value wins.
1051
1256
 
1052
1257
    def merge_names(self, file_id):
1053
1258
        def get_entry(tree):
1054
 
            if file_id in tree.inventory:
 
1259
            if tree.has_id(file_id):
1055
1260
                return tree.inventory[file_id]
1056
1261
            else:
1057
1262
                return None
1086
1291
                parent_id_winner = "other"
1087
1292
        if name_winner == "this" and parent_id_winner == "this":
1088
1293
            return
1089
 
        if name_winner == "conflict":
1090
 
            trans_id = self.tt.trans_id_file_id(file_id)
1091
 
            self._raw_conflicts.append(('name conflict', trans_id,
1092
 
                                        this_name, other_name))
1093
 
        if parent_id_winner == "conflict":
1094
 
            trans_id = self.tt.trans_id_file_id(file_id)
1095
 
            self._raw_conflicts.append(('parent conflict', trans_id,
1096
 
                                        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))
1097
1302
        if other_name is None:
1098
1303
            # it doesn't matter whether the result was 'other' or
1099
1304
            # 'conflict'-- if there's no 'other', we leave it alone.
1100
1305
            return
1101
 
        # if we get here, name_winner and parent_winner are set to safe values.
1102
 
        trans_id = self.tt.trans_id_file_id(file_id)
1103
1306
        parent_id = parents[self.winner_idx[parent_id_winner]]
1104
1307
        if parent_id is not None:
1105
 
            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.
1106
1310
            self.tt.adjust_path(names[self.winner_idx[name_winner]],
1107
 
                                parent_trans_id, trans_id)
 
1311
                                self.tt.trans_id_file_id(parent_id),
 
1312
                                self.tt.trans_id_file_id(file_id))
1108
1313
 
1109
 
    def merge_contents(self, file_id):
 
1314
    def _do_merge_contents(self, file_id):
1110
1315
        """Performs a merge on file_id contents."""
1111
1316
        def contents_pair(tree):
1112
1317
            if file_id not in tree:
1120
1325
                contents = None
1121
1326
            return kind, contents
1122
1327
 
1123
 
        def contents_conflict():
1124
 
            trans_id = self.tt.trans_id_file_id(file_id)
1125
 
            name = self.tt.final_name(trans_id)
1126
 
            parent_id = self.tt.final_parent(trans_id)
1127
 
            if file_id in self.this_tree.inventory:
1128
 
                self.tt.unversion_file(trans_id)
1129
 
                if file_id in self.this_tree:
1130
 
                    self.tt.delete_contents(trans_id)
1131
 
            file_group = self._dump_conflicts(name, parent_id, file_id,
1132
 
                                              set_version=True)
1133
 
            self._raw_conflicts.append(('contents conflict', file_group))
1134
 
 
1135
1328
        # See SPOT run.  run, SPOT, run.
1136
1329
        # So we're not QUITE repeating ourselves; we do tricky things with
1137
1330
        # file kind...
1153
1346
        if winner == 'this':
1154
1347
            # No interesting changes introduced by OTHER
1155
1348
            return "unmodified"
 
1349
        # We have a hypothetical conflict, but if we have files, then we
 
1350
        # can try to merge the content
1156
1351
        trans_id = self.tt.trans_id_file_id(file_id)
1157
 
        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':
1158
1440
            # OTHER is a straight winner, so replace this contents with other
1159
 
            file_in_this = file_id in self.this_tree
1160
 
            if file_in_this:
1161
 
                # Remove any existing contents
1162
 
                self.tt.delete_contents(trans_id)
1163
 
            if file_id in self.other_tree:
1164
 
                # OTHER changed the file
1165
 
                wt = self.this_tree
1166
 
                if wt.supports_content_filtering():
1167
 
                    # We get the path from the working tree if it exists.
1168
 
                    # That fails though when OTHER is adding a file, so
1169
 
                    # we fall back to the other tree to find the path if
1170
 
                    # it doesn't exist locally.
1171
 
                    try:
1172
 
                        filter_tree_path = wt.id2path(file_id)
1173
 
                    except errors.NoSuchId:
1174
 
                        filter_tree_path = self.other_tree.id2path(file_id)
1175
 
                else:
1176
 
                    # Skip the id2path lookup for older formats
1177
 
                    filter_tree_path = None
1178
 
                create_from_tree(self.tt, trans_id,
1179
 
                                 self.other_tree, file_id,
1180
 
                                 filter_tree_path=filter_tree_path)
1181
 
                if not file_in_this:
1182
 
                    self.tt.version_file(file_id, trans_id)
1183
 
                return "modified"
1184
 
            elif file_in_this:
1185
 
                # OTHER deleted the file
1186
 
                self.tt.unversion_file(trans_id)
1187
 
                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
1188
1452
        else:
1189
 
            # We have a hypothetical conflict, but if we have files, then we
1190
 
            # can try to merge the content
1191
 
            if this_pair[0] == 'file' and other_pair[0] == 'file':
1192
 
                # THIS and OTHER are both files, so text merge.  Either
1193
 
                # BASE is a file, or both converted to files, so at least we
1194
 
                # have agreement that output should be a file.
1195
 
                try:
1196
 
                    self.text_merge(file_id, trans_id)
1197
 
                except BinaryFile:
1198
 
                    return contents_conflict()
1199
 
                if file_id not in self.this_tree:
1200
 
                    self.tt.version_file(file_id, trans_id)
1201
 
                try:
1202
 
                    self.tt.tree_kind(trans_id)
1203
 
                    self.tt.delete_contents(trans_id)
1204
 
                except NoSuchFile:
1205
 
                    pass
1206
 
                return "modified"
1207
 
            else:
1208
 
                return contents_conflict()
 
1453
            return 'not_applicable', None
1209
1454
 
1210
1455
    def get_lines(self, tree, file_id):
1211
1456
        """Return the lines in a file, or an empty list."""
1212
 
        if file_id in tree:
 
1457
        if tree.has_id(file_id):
1213
1458
            return tree.get_file(file_id).readlines()
1214
1459
        else:
1215
1460
            return []
1218
1463
        """Perform a three-way text merge on a file_id"""
1219
1464
        # it's possible that we got here with base as a different type.
1220
1465
        # if so, we just want two-way text conflicts.
1221
 
        if file_id in self.base_tree and \
 
1466
        if self.base_tree.has_id(file_id) and \
1222
1467
            self.base_tree.kind(file_id) == "file":
1223
1468
            base_lines = self.get_lines(self.base_tree, file_id)
1224
1469
        else:
1225
1470
            base_lines = []
1226
1471
        other_lines = self.get_lines(self.other_tree, file_id)
1227
1472
        this_lines = self.get_lines(self.this_tree, file_id)
1228
 
        m3 = Merge3(base_lines, this_lines, other_lines,
1229
 
                    is_cherrypick=self.cherrypick)
 
1473
        m3 = merge3.Merge3(base_lines, this_lines, other_lines,
 
1474
                           is_cherrypick=self.cherrypick)
1230
1475
        start_marker = "!START OF MERGE CONFLICT!" + "I HOPE THIS IS UNIQUE"
1231
1476
        if self.show_base is True:
1232
1477
            base_marker = '|' * 7
1287
1532
        versioned = False
1288
1533
        file_group = []
1289
1534
        for suffix, tree, lines in data:
1290
 
            if file_id in tree:
 
1535
            if tree.has_id(file_id):
1291
1536
                trans_id = self._conflict_file(name, parent_id, tree, file_id,
1292
1537
                                               suffix, lines, filter_tree_path)
1293
1538
                file_group.append(trans_id)
1301
1546
        """Emit a single conflict file."""
1302
1547
        name = name + '.' + suffix
1303
1548
        trans_id = self.tt.create_path(name, parent_id)
1304
 
        create_from_tree(self.tt, trans_id, tree, file_id, lines,
 
1549
        transform.create_from_tree(self.tt, trans_id, tree, file_id, lines,
1305
1550
            filter_tree_path)
1306
1551
        return trans_id
1307
1552
 
1332
1577
        try:
1333
1578
            if self.tt.final_kind(trans_id) != "file":
1334
1579
                return
1335
 
        except NoSuchFile:
 
1580
        except errors.NoSuchFile:
1336
1581
            return
1337
1582
        if winner == "this":
1338
1583
            executability = this_executable
1339
1584
        else:
1340
 
            if file_id in self.other_tree:
 
1585
            if self.other_tree.has_id(file_id):
1341
1586
                executability = other_executable
1342
 
            elif file_id in self.this_tree:
 
1587
            elif self.this_tree.has_id(file_id):
1343
1588
                executability = this_executable
1344
 
            elif file_id in self.base_tree:
 
1589
            elif self.base_tree_has_id(file_id):
1345
1590
                executability = base_executable
1346
1591
        if executability is not None:
1347
1592
            trans_id = self.tt.trans_id_file_id(file_id)
1349
1594
 
1350
1595
    def cook_conflicts(self, fs_conflicts):
1351
1596
        """Convert all conflicts into a form that doesn't depend on trans_id"""
1352
 
        from conflicts import Conflict
1353
 
        name_conflicts = {}
1354
 
        self.cooked_conflicts.extend(cook_conflicts(fs_conflicts, self.tt))
1355
 
        fp = FinalPaths(self.tt)
 
1597
        self.cooked_conflicts.extend(transform.cook_conflicts(
 
1598
                fs_conflicts, self.tt))
 
1599
        fp = transform.FinalPaths(self.tt)
1356
1600
        for conflict in self._raw_conflicts:
1357
1601
            conflict_type = conflict[0]
1358
 
            if conflict_type in ('name conflict', 'parent conflict'):
1359
 
                trans_id = conflict[1]
1360
 
                conflict_args = conflict[2:]
1361
 
                if trans_id not in name_conflicts:
1362
 
                    name_conflicts[trans_id] = {}
1363
 
                unique_add(name_conflicts[trans_id], conflict_type,
1364
 
                           conflict_args)
1365
 
            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':
1366
1623
                for trans_id in conflict[1]:
1367
1624
                    file_id = self.tt.final_file_id(trans_id)
1368
1625
                    if file_id is not None:
1372
1629
                    if path.endswith(suffix):
1373
1630
                        path = path[:-len(suffix)]
1374
1631
                        break
1375
 
                c = Conflict.factory(conflict_type, path=path, file_id=file_id)
1376
 
                self.cooked_conflicts.append(c)
1377
 
            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':
1378
1635
                trans_id = conflict[1]
1379
1636
                path = fp.get_path(trans_id)
1380
1637
                file_id = self.tt.final_file_id(trans_id)
1381
 
                c = Conflict.factory(conflict_type, path=path, file_id=file_id)
1382
 
                self.cooked_conflicts.append(c)
1383
 
 
1384
 
        for trans_id, conflicts in name_conflicts.iteritems():
1385
 
            try:
1386
 
                this_parent, other_parent = conflicts['parent conflict']
1387
 
                if this_parent == other_parent:
1388
 
                    raise AssertionError()
1389
 
            except KeyError:
1390
 
                this_parent = other_parent = \
1391
 
                    self.tt.final_file_id(self.tt.final_parent(trans_id))
1392
 
            try:
1393
 
                this_name, other_name = conflicts['name conflict']
1394
 
                if this_name == other_name:
1395
 
                    raise AssertionError()
1396
 
            except KeyError:
1397
 
                this_name = other_name = self.tt.final_name(trans_id)
1398
 
            other_path = fp.get_path(trans_id)
1399
 
            if this_parent is not None and this_name is not None:
1400
 
                this_parent_path = \
1401
 
                    fp.get_path(self.tt.trans_id_file_id(this_parent))
1402
 
                this_path = pathjoin(this_parent_path, this_name)
 
1638
                c = _mod_conflicts.Conflict.factory(conflict_type,
 
1639
                                                    path=path, file_id=file_id)
1403
1640
            else:
1404
 
                this_path = "<deleted>"
1405
 
            file_id = self.tt.final_file_id(trans_id)
1406
 
            c = Conflict.factory('path conflict', path=this_path,
1407
 
                                 conflict_path=other_path, file_id=file_id)
 
1641
                raise AssertionError('bad conflict type: %r' % (conflict,))
1408
1642
            self.cooked_conflicts.append(c)
1409
 
        self.cooked_conflicts.sort(key=Conflict.sort_key)
 
1643
        self.cooked_conflicts.sort(key=_mod_conflicts.Conflict.sort_key)
1410
1644
 
1411
1645
 
1412
1646
class WeaveMerger(Merge3Merger):
1416
1650
    supports_reverse_cherrypick = False
1417
1651
    history_based = True
1418
1652
 
1419
 
    def _merged_lines(self, file_id):
1420
 
        """Generate the merged lines.
1421
 
        There is no distinction between lines that are meant to contain <<<<<<<
1422
 
        and conflicts.
1423
 
        """
1424
 
        if self.cherrypick:
1425
 
            base = self.base_tree
1426
 
        else:
1427
 
            base = None
1428
 
        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,
1429
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)
1430
1667
        if 'merge' in debug.debug_flags:
1431
1668
            plan = list(plan)
1432
1669
            trans_id = self.tt.trans_id_file_id(file_id)
1433
1670
            name = self.tt.final_name(trans_id) + '.plan'
1434
 
            contents = ('%10s|%s' % l for l in plan)
 
1671
            contents = ('%11s|%s' % l for l in plan)
1435
1672
            self.tt.new_file(name, self.tt.final_parent(trans_id), contents)
1436
 
        textmerge = PlanWeaveMerge(plan, '<<<<<<< TREE\n',
1437
 
            '>>>>>>> MERGE-SOURCE\n')
1438
 
        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
1439
1681
 
1440
1682
    def text_merge(self, file_id, trans_id):
1441
1683
        """Perform a (weave) text merge for a given file and file-id.
1442
1684
        If conflicts are encountered, .THIS and .OTHER files will be emitted,
1443
1685
        and a conflict will be noted.
1444
1686
        """
1445
 
        lines, conflicts = self._merged_lines(file_id)
 
1687
        lines, base_lines = self._merged_lines(file_id)
1446
1688
        lines = list(lines)
1447
1689
        # Note we're checking whether the OUTPUT is binary in this case,
1448
1690
        # because we don't want to get into weave merge guts.
1449
 
        check_text_lines(lines)
 
1691
        textfile.check_text_lines(lines)
1450
1692
        self.tt.create_file(lines, trans_id)
1451
 
        if conflicts:
 
1693
        if base_lines is not None:
 
1694
            # Conflict
1452
1695
            self._raw_conflicts.append(('text conflict', trans_id))
1453
1696
            name = self.tt.final_name(trans_id)
1454
1697
            parent_id = self.tt.final_parent(trans_id)
1455
1698
            file_group = self._dump_conflicts(name, parent_id, file_id,
1456
 
                                              no_base=True)
 
1699
                                              no_base=False,
 
1700
                                              base_lines=base_lines)
1457
1701
            file_group.append(trans_id)
1458
1702
 
1459
1703
 
1460
1704
class LCAMerger(WeaveMerger):
1461
1705
 
1462
 
    def _merged_lines(self, file_id):
1463
 
        """Generate the merged lines.
1464
 
        There is no distinction between lines that are meant to contain <<<<<<<
1465
 
        and conflicts.
1466
 
        """
1467
 
        if self.cherrypick:
1468
 
            base = self.base_tree
1469
 
        else:
1470
 
            base = None
1471
 
        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,
1472
1708
                                                  base=base)
1473
 
        if 'merge' in debug.debug_flags:
1474
 
            plan = list(plan)
1475
 
            trans_id = self.tt.trans_id_file_id(file_id)
1476
 
            name = self.tt.final_name(trans_id) + '.plan'
1477
 
            contents = ('%10s|%s' % l for l in plan)
1478
 
            self.tt.new_file(name, self.tt.final_parent(trans_id), contents)
1479
 
        textmerge = PlanWeaveMerge(plan, '<<<<<<< TREE\n',
1480
 
            '>>>>>>> MERGE-SOURCE\n')
1481
 
        return textmerge.merge_lines(self.reprocess)
1482
 
 
1483
1709
 
1484
1710
class Diff3Merger(Merge3Merger):
1485
1711
    """Three-way merger using external diff3 for text merging"""
1486
1712
 
1487
1713
    def dump_file(self, temp_dir, name, tree, file_id):
1488
 
        out_path = pathjoin(temp_dir, name)
 
1714
        out_path = osutils.pathjoin(temp_dir, name)
1489
1715
        out_file = open(out_path, "wb")
1490
1716
        try:
1491
1717
            in_file = tree.get_file(file_id)
1503
1729
        import bzrlib.patch
1504
1730
        temp_dir = osutils.mkdtemp(prefix="bzr-")
1505
1731
        try:
1506
 
            new_file = pathjoin(temp_dir, "new")
 
1732
            new_file = osutils.pathjoin(temp_dir, "new")
1507
1733
            this = self.dump_file(temp_dir, "this", self.this_tree, file_id)
1508
1734
            base = self.dump_file(temp_dir, "base", self.base_tree, file_id)
1509
1735
            other = self.dump_file(temp_dir, "other", self.other_tree, file_id)
1510
1736
            status = bzrlib.patch.diff3(new_file, this, base, other)
1511
1737
            if status not in (0, 1):
1512
 
                raise BzrError("Unhandled diff3 exit code")
 
1738
                raise errors.BzrError("Unhandled diff3 exit code")
1513
1739
            f = open(new_file, 'rb')
1514
1740
            try:
1515
1741
                self.tt.create_file(f, trans_id)
1533
1759
                other_rev_id=None,
1534
1760
                interesting_files=None,
1535
1761
                this_tree=None,
1536
 
                pb=DummyProgress(),
 
1762
                pb=None,
1537
1763
                change_reporter=None):
1538
1764
    """Primary interface for merging.
1539
1765
 
1542
1768
                     branch.get_revision_tree(base_revision))'
1543
1769
        """
1544
1770
    if this_tree is None:
1545
 
        raise BzrError("bzrlib.merge.merge_inner requires a this_tree "
1546
 
            "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.")
1547
1773
    merger = Merger(this_branch, other_tree, base_tree, this_tree=this_tree,
1548
1774
                    pb=pb, change_reporter=change_reporter)
1549
1775
    merger.backup_files = backup_files
1767
1993
        super(_PlanMerge, self).__init__(a_rev, b_rev, vf, key_prefix)
1768
1994
        self.a_key = self._key_prefix + (self.a_rev,)
1769
1995
        self.b_key = self._key_prefix + (self.b_rev,)
1770
 
        self.graph = Graph(self.vf)
 
1996
        self.graph = _mod_graph.Graph(self.vf)
1771
1997
        heads = self.graph.heads((self.a_key, self.b_key))
1772
1998
        if len(heads) == 1:
1773
1999
            # one side dominates, so we can just return its values, yay for
1778
2004
                other = b_rev
1779
2005
            else:
1780
2006
                other = a_rev
1781
 
            mutter('found dominating revision for %s\n%s > %s', self.vf,
1782
 
                   self._head_key[-1], other)
 
2007
            trace.mutter('found dominating revision for %s\n%s > %s', self.vf,
 
2008
                         self._head_key[-1], other)
1783
2009
            self._weave = None
1784
2010
        else:
1785
2011
            self._head_key = None
1799
2025
        while True:
1800
2026
            next_lcas = self.graph.find_lca(*cur_ancestors)
1801
2027
            # Map a plain NULL_REVISION to a simple no-ancestors
1802
 
            if next_lcas == set([NULL_REVISION]):
 
2028
            if next_lcas == set([_mod_revision.NULL_REVISION]):
1803
2029
                next_lcas = ()
1804
2030
            # Order the lca's based on when they were merged into the tip
1805
2031
            # While the actual merge portion of weave merge uses a set() of
1817
2043
            elif len(next_lcas) > 2:
1818
2044
                # More than 2 lca's, fall back to grabbing all nodes between
1819
2045
                # this and the unique lca.
1820
 
                mutter('More than 2 LCAs, falling back to all nodes for:'
1821
 
                       ' %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)
1822
2049
                cur_lcas = next_lcas
1823
2050
                while len(cur_lcas) > 1:
1824
2051
                    cur_lcas = self.graph.find_lca(*cur_lcas)
1827
2054
                    unique_lca = None
1828
2055
                else:
1829
2056
                    unique_lca = list(cur_lcas)[0]
1830
 
                    if unique_lca == NULL_REVISION:
 
2057
                    if unique_lca == _mod_revision.NULL_REVISION:
1831
2058
                        # find_lca will return a plain 'NULL_REVISION' rather
1832
2059
                        # than a key tuple when there is no common ancestor, we
1833
2060
                        # prefer to just use None, because it doesn't confuse
1856
2083
            # We remove NULL_REVISION because it isn't a proper tuple key, and
1857
2084
            # thus confuses things like _get_interesting_texts, and our logic
1858
2085
            # to add the texts into the memory weave.
1859
 
            if NULL_REVISION in parent_map:
1860
 
                parent_map.pop(NULL_REVISION)
 
2086
            if _mod_revision.NULL_REVISION in parent_map:
 
2087
                parent_map.pop(_mod_revision.NULL_REVISION)
1861
2088
        else:
1862
2089
            interesting = set()
1863
2090
            for tip in tip_keys:
2015
2242
        lcas = graph.find_lca(key_prefix + (a_rev,), key_prefix + (b_rev,))
2016
2243
        self.lcas = set()
2017
2244
        for lca in lcas:
2018
 
            if lca == NULL_REVISION:
 
2245
            if lca == _mod_revision.NULL_REVISION:
2019
2246
                self.lcas.add(lca)
2020
2247
            else:
2021
2248
                self.lcas.add(lca[-1])