/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 breezy/merge.py

  • Committer: Jelmer Vernooij
  • Date: 2018-07-08 14:45:27 UTC
  • mto: This revision was merged to the branch mainline in revision 7036.
  • Revision ID: jelmer@jelmer.uk-20180708144527-codhlvdcdg9y0nji
Fix a bunch of merge tests.

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
# Copyright (C) 2005-2010 Canonical Ltd
 
1
# Copyright (C) 2005-2011 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
from __future__ import absolute_import
 
18
 
17
19
import warnings
18
20
 
19
 
from bzrlib import (
 
21
from .lazy_import import lazy_import
 
22
lazy_import(globals(), """
 
23
from breezy import (
20
24
    branch as _mod_branch,
 
25
    cleanup,
21
26
    conflicts as _mod_conflicts,
22
27
    debug,
23
 
    decorators,
24
 
    errors,
 
28
    generate_ids,
25
29
    graph as _mod_graph,
26
 
    hooks,
27
30
    merge3,
28
31
    osutils,
29
32
    patiencediff,
34
37
    tree as _mod_tree,
35
38
    tsort,
36
39
    ui,
37
 
    versionedfile
38
 
    )
39
 
from bzrlib.cleanup import OperationWithCleanups
40
 
from bzrlib.symbol_versioning import (
41
 
    deprecated_in,
42
 
    deprecated_method,
 
40
    workingtree,
 
41
    )
 
42
from breezy.bzr import (
 
43
    versionedfile,
 
44
    )
 
45
from breezy.i18n import gettext
 
46
""")
 
47
from . import (
 
48
    decorators,
 
49
    errors,
 
50
    hooks,
 
51
    registry,
 
52
    )
 
53
from .sixish import (
 
54
    text_type,
 
55
    viewitems,
43
56
    )
44
57
# TODO: Report back as changes are merged in
45
58
 
46
59
 
47
 
def transform_tree(from_tree, to_tree, interesting_ids=None):
 
60
def transform_tree(from_tree, to_tree, interesting_files=None):
48
61
    from_tree.lock_tree_write()
49
 
    operation = OperationWithCleanups(merge_inner)
 
62
    operation = cleanup.OperationWithCleanups(merge_inner)
50
63
    operation.add_cleanup(from_tree.unlock)
51
64
    operation.run_simple(from_tree.branch, to_tree, from_tree,
52
 
        ignore_zero=True, interesting_ids=interesting_ids, this_tree=from_tree)
 
65
        ignore_zero=True, this_tree=from_tree,
 
66
        interesting_files=interesting_files)
53
67
 
54
68
 
55
69
class MergeHooks(hooks.Hooks):
56
70
 
57
71
    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 "
 
72
        hooks.Hooks.__init__(self, "breezy.merge", "Merger.hooks")
 
73
        self.add_hook('merge_file_content',
 
74
            "Called with a breezy.merge.Merger object to create a per file "
61
75
            "merge object when starting a merge. "
62
76
            "Should return either None or a subclass of "
63
 
            "``bzrlib.merge.AbstractPerFileMerger``. "
 
77
            "``breezy.merge.AbstractPerFileMerger``. "
64
78
            "Such objects will then be called per file "
65
79
            "that needs to be merged (including when one "
66
80
            "side has deleted the file and the other has changed it). "
67
81
            "See the AbstractPerFileMerger API docs for details on how it is "
68
82
            "used by merge.",
69
 
            (2, 1), None))
 
83
            (2, 1))
 
84
        self.add_hook('pre_merge',
 
85
            'Called before a merge. '
 
86
            'Receives a Merger object as the single argument.',
 
87
            (2, 5))
 
88
        self.add_hook('post_merge',
 
89
            'Called after a merge. '
 
90
            'Receives a Merger object as the single argument. '
 
91
            'The return value is ignored.',
 
92
            (2, 5))
70
93
 
71
94
 
72
95
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
 
    
 
96
    """PerFileMerger objects are used by plugins extending merge for breezy.
 
97
 
 
98
    See ``breezy.plugins.news_merge.news_merge`` for an example concrete class.
 
99
 
77
100
    :ivar merger: The Merge3Merger performing the merge.
78
101
    """
79
102
 
83
106
 
84
107
    def merge_contents(self, merge_params):
85
108
        """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
 
109
 
 
110
        :param merge_params: A breezy.merge.MergeFileHookParams
 
111
        :return: A tuple of (status, chunks), where status is one of
89
112
            'not_applicable', 'success', 'conflicted', or 'delete'.  If status
90
113
            is 'success' or 'conflicted', then chunks should be an iterable of
91
114
            strings for the new file contents.
109
132
        """
110
133
        raise NotImplementedError(self.file_matches)
111
134
 
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
135
    def merge_contents(self, params):
127
136
        """Merge the contents of a single file."""
128
137
        # Check whether this custom merge logic should be used.
131
140
            params.winner == 'other' or
132
141
            # THIS and OTHER aren't both files.
133
142
            not params.is_file_merge() or
134
 
            # The filename doesn't match *.xml
 
143
            # The filename doesn't match
135
144
            not self.file_matches(params)):
136
145
            return 'not_applicable', None
137
146
        return self.merge_matching(params)
152
161
    This is a base class for concrete custom file merging logic. Concrete
153
162
    classes should implement ``merge_text``.
154
163
 
155
 
    See ``bzrlib.plugins.news_merge.news_merge`` for an example concrete class.
156
 
    
 
164
    See ``breezy.plugins.news_merge.news_merge`` for an example concrete class.
 
165
 
157
166
    :ivar affected_files: The configured file paths to merge.
158
167
 
159
168
    :cvar name_prefix: The prefix to use when looking up configuration
160
169
        details. <name_prefix>_merge_files describes the files targeted by the
161
170
        hook for example.
162
 
        
 
171
 
163
172
    :cvar default_files: The default file paths to merge when no configuration
164
173
        is present.
165
174
    """
186
195
            config = self.merger.this_branch.get_config()
187
196
            # Until bzr provides a better policy for caching the config, we
188
197
            # just add the part we're interested in to the params to avoid
189
 
            # reading the config files repeatedly (bazaar.conf, location.conf,
 
198
            # reading the config files repeatedly (breezy.conf, location.conf,
190
199
            # branch.conf).
191
200
            config_key = self.name_prefix + '_merge_files'
192
201
            affected_files = config.get_user_option_as_list(config_key)
195
204
                affected_files = self.default_files
196
205
            self.affected_files = affected_files
197
206
        if affected_files:
198
 
            filepath = self.get_filepath(params, self.merger.this_tree)
 
207
            filepath = params.this_path
199
208
            if filepath in affected_files:
200
209
                return True
201
210
        return False
208
217
 
209
218
        This is called after checking that the merge should be performed in
210
219
        merge_contents, and it should behave as per
211
 
        ``bzrlib.merge.AbstractPerFileMerger.merge_contents``.
 
220
        ``breezy.merge.AbstractPerFileMerger.merge_contents``.
212
221
        """
213
222
        raise NotImplementedError(self.merge_text)
214
223
 
215
224
 
216
 
class MergeHookParams(object):
 
225
class MergeFileHookParams(object):
217
226
    """Object holding parameters passed to merge_file_content hooks.
218
227
 
219
228
    There are some fields hooks can access:
220
229
 
221
230
    :ivar file_id: the file ID of the file being merged
 
231
    :ivar base_path: Path in base tree
 
232
    :ivar other_path: Path in other tree
 
233
    :ivar this_path: Path in this tree
222
234
    :ivar trans_id: the transform ID for the merge of this file
223
235
    :ivar this_kind: kind of file_id in 'this' tree
224
236
    :ivar other_kind: kind of file_id in 'other' tree
225
237
    :ivar winner: one of 'this', 'other', 'conflict'
226
238
    """
227
239
 
228
 
    def __init__(self, merger, file_id, trans_id, this_kind, other_kind,
 
240
    def __init__(self, merger, file_id, paths, trans_id, this_kind, other_kind,
229
241
            winner):
230
242
        self._merger = merger
231
243
        self.file_id = file_id
 
244
        self.paths = paths
 
245
        self.base_path, self.other_path, self.this_path = paths
232
246
        self.trans_id = trans_id
233
247
        self.this_kind = this_kind
234
248
        self.other_kind = other_kind
241
255
    @decorators.cachedproperty
242
256
    def base_lines(self):
243
257
        """The lines of the 'base' version of the file."""
244
 
        return self._merger.get_lines(self._merger.base_tree, self.file_id)
 
258
        return self._merger.get_lines(self._merger.base_tree, self.base_path, self.file_id)
245
259
 
246
260
    @decorators.cachedproperty
247
261
    def this_lines(self):
248
262
        """The lines of the 'this' version of the file."""
249
 
        return self._merger.get_lines(self._merger.this_tree, self.file_id)
 
263
        return self._merger.get_lines(self._merger.this_tree, self.this_path, self.file_id)
250
264
 
251
265
    @decorators.cachedproperty
252
266
    def other_lines(self):
253
267
        """The lines of the 'other' version of the file."""
254
 
        return self._merger.get_lines(self._merger.other_tree, self.file_id)
 
268
        return self._merger.get_lines(self._merger.other_tree, self.other_path, self.file_id)
255
269
 
256
270
 
257
271
class Merger(object):
259
273
    hooks = MergeHooks()
260
274
 
261
275
    def __init__(self, this_branch, other_tree=None, base_tree=None,
262
 
                 this_tree=None, pb=None, change_reporter=None,
 
276
                 this_tree=None, change_reporter=None,
263
277
                 recurse='down', revision_graph=None):
264
278
        object.__init__(self)
265
279
        self.this_branch = this_branch
274
288
        self.base_tree = base_tree
275
289
        self.ignore_zero = False
276
290
        self.backup_files = False
277
 
        self.interesting_ids = None
278
291
        self.interesting_files = None
279
292
        self.show_base = False
280
293
        self.reprocess = False
281
 
        if pb is not None:
282
 
            warnings.warn("pb parameter to Merger() is deprecated and ignored")
283
294
        self.pp = None
284
295
        self.recurse = recurse
285
296
        self.change_reporter = change_reporter
333
344
                                      _set_base_is_other_ancestor)
334
345
 
335
346
    @staticmethod
336
 
    def from_uncommitted(tree, other_tree, pb=None, base_tree=None):
 
347
    def from_uncommitted(tree, other_tree, base_tree=None):
337
348
        """Return a Merger for uncommitted changes in other_tree.
338
349
 
339
350
        :param tree: The tree to merge into
340
351
        :param other_tree: The tree to get uncommitted changes from
341
 
        :param pb: A progress indicator
342
352
        :param base_tree: The basis to use for the merge.  If unspecified,
343
353
            other_tree.basis_tree() will be used.
344
354
        """
345
355
        if base_tree is None:
346
356
            base_tree = other_tree.basis_tree()
347
 
        merger = Merger(tree.branch, other_tree, base_tree, tree, pb)
 
357
        merger = Merger(tree.branch, other_tree, base_tree, tree)
348
358
        merger.base_rev_id = merger.base_tree.get_revision_id()
349
359
        merger.other_rev_id = None
350
360
        merger.other_basis = merger.base_rev_id
351
361
        return merger
352
362
 
353
363
    @classmethod
354
 
    def from_mergeable(klass, tree, mergeable, pb):
 
364
    def from_mergeable(klass, tree, mergeable):
355
365
        """Return a Merger for a bundle or merge directive.
356
366
 
357
367
        :param tree: The tree to merge changes into
358
368
        :param mergeable: A merge directive or bundle
359
 
        :param pb: A progress indicator
360
369
        """
361
370
        mergeable.install_revisions(tree.branch.repository)
362
371
        base_revision_id, other_revision_id, verified =\
369
378
                base_revision_id = None
370
379
            else:
371
380
                trace.warning('Performing cherrypick')
372
 
        merger = klass.from_revision_ids(pb, tree, other_revision_id,
 
381
        merger = klass.from_revision_ids(tree, other_revision_id,
373
382
                                         base_revision_id, revision_graph=
374
383
                                         revision_graph)
375
384
        return merger, verified
376
385
 
377
386
    @staticmethod
378
 
    def from_revision_ids(pb, tree, other, base=None, other_branch=None,
 
387
    def from_revision_ids(tree, other, base=None, other_branch=None,
379
388
                          base_branch=None, revision_graph=None,
380
389
                          tree_branch=None):
381
390
        """Return a Merger for revision-ids.
382
391
 
383
 
        :param pb: A progress indicator
384
392
        :param tree: The tree to merge changes into
385
393
        :param other: The revision-id to use as OTHER
386
394
        :param base: The revision-id to use as BASE.  If not specified, will
396
404
        """
397
405
        if tree_branch is None:
398
406
            tree_branch = tree.branch
399
 
        merger = Merger(tree_branch, this_tree=tree, pb=pb,
 
407
        merger = Merger(tree_branch, this_tree=tree,
400
408
                        revision_graph=revision_graph)
401
409
        if other_branch is None:
402
410
            other_branch = tree.branch
421
429
        return self._cached_trees[revision_id]
422
430
 
423
431
    def _get_tree(self, treespec, possible_transports=None):
424
 
        from bzrlib import workingtree
425
432
        location, revno = treespec
426
433
        if revno is None:
427
434
            tree = workingtree.WorkingTree.open_containing(location)[0]
435
442
        revision_id = _mod_revision.ensure_null(revision_id)
436
443
        return branch, self.revision_tree(revision_id, branch)
437
444
 
438
 
    @deprecated_method(deprecated_in((2, 1, 0)))
439
 
    def ensure_revision_trees(self):
440
 
        if self.this_revision_tree is None:
441
 
            self.this_basis_tree = self.revision_tree(self.this_basis)
442
 
            if self.this_basis == self.this_rev_id:
443
 
                self.this_revision_tree = self.this_basis_tree
444
 
 
445
 
        if self.other_rev_id is None:
446
 
            other_basis_tree = self.revision_tree(self.other_basis)
447
 
            if other_basis_tree.has_changes(self.other_tree):
448
 
                raise errors.WorkingTreeNotRevision(self.this_tree)
449
 
            other_rev_id = self.other_basis
450
 
            self.other_tree = other_basis_tree
451
 
 
452
 
    @deprecated_method(deprecated_in((2, 1, 0)))
453
 
    def file_revisions(self, file_id):
454
 
        self.ensure_revision_trees()
455
 
        def get_id(tree, file_id):
456
 
            revision_id = tree.inventory[file_id].revision
457
 
            return revision_id
458
 
        if self.this_rev_id is None:
459
 
            if self.this_basis_tree.get_file_sha1(file_id) != \
460
 
                self.this_tree.get_file_sha1(file_id):
461
 
                raise errors.WorkingTreeNotRevision(self.this_tree)
462
 
 
463
 
        trees = (self.this_basis_tree, self.other_tree)
464
 
        return [get_id(tree, file_id) for tree in trees]
465
 
 
466
 
    @deprecated_method(deprecated_in((2, 1, 0)))
467
 
    def check_basis(self, check_clean, require_commits=True):
468
 
        if self.this_basis is None and require_commits is True:
469
 
            raise errors.BzrCommandError(
470
 
                "This branch has no commits."
471
 
                " (perhaps you would prefer 'bzr pull')")
472
 
        if check_clean:
473
 
            self.compare_basis()
474
 
            if self.this_basis != self.this_rev_id:
475
 
                raise errors.UncommittedChanges(self.this_tree)
476
 
 
477
 
    @deprecated_method(deprecated_in((2, 1, 0)))
478
 
    def compare_basis(self):
479
 
        try:
480
 
            basis_tree = self.revision_tree(self.this_tree.last_revision())
481
 
        except errors.NoSuchRevision:
482
 
            basis_tree = self.this_tree.basis_tree()
483
 
        if not self.this_tree.has_changes(basis_tree):
484
 
            self.this_rev_id = self.this_basis
485
 
 
486
445
    def set_interesting_files(self, file_list):
487
446
        self.interesting_files = file_list
488
447
 
495
454
    def _add_parent(self):
496
455
        new_parents = self.this_tree.get_parent_ids() + [self.other_rev_id]
497
456
        new_parent_trees = []
498
 
        operation = OperationWithCleanups(self.this_tree.set_parent_trees)
 
457
        operation = cleanup.OperationWithCleanups(
 
458
            self.this_tree.set_parent_trees)
499
459
        for revision_id in new_parents:
500
460
            try:
501
461
                tree = self.revision_tree(revision_id)
532
492
                raise errors.NoCommits(self.other_branch)
533
493
        if self.other_rev_id is not None:
534
494
            self._cached_trees[self.other_rev_id] = self.other_tree
535
 
        self._maybe_fetch(self.other_branch,self.this_branch, self.other_basis)
 
495
        self._maybe_fetch(self.other_branch, self.this_branch, self.other_basis)
536
496
 
537
497
    def set_other_revision(self, revision_id, other_branch):
538
498
        """Set 'other' based on a branch and revision id
576
536
            elif len(lcas) == 1:
577
537
                self.base_rev_id = list(lcas)[0]
578
538
            else: # len(lcas) > 1
 
539
                self._is_criss_cross = True
579
540
                if len(lcas) > 2:
580
541
                    # find_unique_lca can only handle 2 nodes, so we have to
581
542
                    # start back at the beginning. It is a shame to traverse
586
547
                else:
587
548
                    self.base_rev_id = self.revision_graph.find_unique_lca(
588
549
                                            *lcas)
589
 
                self._is_criss_cross = True
 
550
                sorted_lca_keys = self.revision_graph.find_merge_order(
 
551
                    revisions[0], lcas)
 
552
                if self.base_rev_id == _mod_revision.NULL_REVISION:
 
553
                    self.base_rev_id = sorted_lca_keys[0]
 
554
 
590
555
            if self.base_rev_id == _mod_revision.NULL_REVISION:
591
556
                raise errors.UnrelatedBranches()
592
557
            if self._is_criss_cross:
593
558
                trace.warning('Warning: criss-cross merge encountered.  See bzr'
594
559
                              ' help criss-cross.')
595
560
                trace.mutter('Criss-cross lcas: %r' % lcas)
596
 
                interesting_revision_ids = [self.base_rev_id]
597
 
                interesting_revision_ids.extend(lcas)
 
561
                if self.base_rev_id in lcas:
 
562
                    trace.mutter('Unable to find unique lca. '
 
563
                                 'Fallback %r as best option.'
 
564
                                 % self.base_rev_id)
 
565
                interesting_revision_ids = set(lcas)
 
566
                interesting_revision_ids.add(self.base_rev_id)
598
567
                interesting_trees = dict((t.get_revision_id(), t)
599
568
                    for t in self.this_branch.repository.revision_trees(
600
569
                        interesting_revision_ids))
601
570
                self._cached_trees.update(interesting_trees)
602
 
                self.base_tree = interesting_trees.pop(self.base_rev_id)
603
 
                sorted_lca_keys = self.revision_graph.find_merge_order(
604
 
                    revisions[0], lcas)
 
571
                if self.base_rev_id in lcas:
 
572
                    self.base_tree = interesting_trees[self.base_rev_id]
 
573
                else:
 
574
                    self.base_tree = interesting_trees.pop(self.base_rev_id)
605
575
                self._lca_trees = [interesting_trees[key]
606
576
                                   for key in sorted_lca_keys]
607
577
            else:
630
600
            self._maybe_fetch(base_branch, self.this_branch, self.base_rev_id)
631
601
 
632
602
    def make_merger(self):
633
 
        kwargs = {'working_tree':self.this_tree, 'this_tree': self.this_tree,
 
603
        kwargs = {'working_tree': self.this_tree, 'this_tree': self.this_tree,
634
604
                  'other_tree': self.other_tree,
635
 
                  'interesting_ids': self.interesting_ids,
636
605
                  'interesting_files': self.interesting_files,
637
606
                  'this_branch': self.this_branch,
 
607
                  'other_branch': self.other_branch,
638
608
                  'do_merge': False}
639
609
        if self.merge_type.requires_base:
640
610
            kwargs['base_tree'] = self.base_tree
658
628
        if self._is_criss_cross and getattr(self.merge_type,
659
629
                                            'supports_lca_trees', False):
660
630
            kwargs['lca_trees'] = self._lca_trees
661
 
        return self.merge_type(pb=None,
662
 
                               change_reporter=self.change_reporter,
 
631
        return self.merge_type(change_reporter=self.change_reporter,
663
632
                               **kwargs)
664
633
 
665
634
    def _do_merge_to(self):
666
635
        merge = self.make_merger()
667
636
        if self.other_branch is not None:
668
637
            self.other_branch.update_references(self.this_branch)
 
638
        for hook in Merger.hooks['pre_merge']:
 
639
            hook(merge)
669
640
        merge.do_merge()
 
641
        for hook in Merger.hooks['post_merge']:
 
642
            hook(merge)
670
643
        if self.recurse == 'down':
671
644
            for relpath, file_id in self.this_tree.iter_references():
672
 
                sub_tree = self.this_tree.get_nested_tree(file_id, relpath)
 
645
                sub_tree = self.this_tree.get_nested_tree(relpath, file_id)
673
646
                other_revision = self.other_tree.get_reference_revision(
674
 
                    file_id, relpath)
 
647
                    relpath, file_id)
675
648
                if  other_revision == sub_tree.last_revision():
676
649
                    continue
677
650
                sub_merge = Merger(sub_tree.branch, this_tree=sub_tree)
678
651
                sub_merge.merge_type = self.merge_type
679
 
                other_branch = self.other_branch.reference_parent(file_id, relpath)
 
652
                other_branch = self.other_branch.reference_parent(
 
653
                    relpath, file_id)
680
654
                sub_merge.set_other_revision(other_revision, other_branch)
681
 
                base_revision = self.base_tree.get_reference_revision(file_id)
 
655
                base_tree_path = _mod_tree.find_previous_path(
 
656
                    self.this_tree, self.base_tree, relpath)
 
657
                base_revision = self.base_tree.get_reference_revision(
 
658
                    base_tree_path, file_id)
682
659
                sub_merge.base_tree = \
683
660
                    sub_tree.branch.repository.revision_tree(base_revision)
684
661
                sub_merge.base_rev_id = base_revision
686
663
        return merge
687
664
 
688
665
    def do_merge(self):
689
 
        operation = OperationWithCleanups(self._do_merge_to)
 
666
        operation = cleanup.OperationWithCleanups(self._do_merge_to)
690
667
        self.this_tree.lock_tree_write()
691
668
        operation.add_cleanup(self.this_tree.unlock)
692
669
        if self.base_tree is not None:
698
675
        merge = operation.run_simple()
699
676
        if len(merge.cooked_conflicts) == 0:
700
677
            if not self.ignore_zero and not trace.is_quiet():
701
 
                trace.note("All changes applied successfully.")
 
678
                trace.note(gettext("All changes applied successfully."))
702
679
        else:
703
 
            trace.note("%d conflicts encountered."
 
680
            trace.note(gettext("%d conflicts encountered.")
704
681
                       % len(merge.cooked_conflicts))
705
682
 
706
683
        return len(merge.cooked_conflicts)
733
710
    supports_reverse_cherrypick = True
734
711
    winner_idx = {"this": 2, "other": 1, "conflict": 1}
735
712
    supports_lca_trees = True
 
713
    requires_file_merge_plan = False
736
714
 
737
715
    def __init__(self, working_tree, this_tree, base_tree, other_tree,
738
 
                 interesting_ids=None, reprocess=False, show_base=False,
739
 
                 pb=None, pp=None, change_reporter=None,
740
 
                 interesting_files=None, do_merge=True,
741
 
                 cherrypick=False, lca_trees=None, this_branch=None):
 
716
                 reprocess=False, show_base=False,
 
717
                 change_reporter=None, interesting_files=None, do_merge=True,
 
718
                 cherrypick=False, lca_trees=None, this_branch=None,
 
719
                 other_branch=None):
742
720
        """Initialize the merger object and perform the merge.
743
721
 
744
722
        :param working_tree: The working tree to apply the merge to
747
725
        :param other_tree: The other tree to merge changes from
748
726
        :param this_branch: The branch associated with this_tree.  Defaults to
749
727
            this_tree.branch if not supplied.
750
 
        :param interesting_ids: The file_ids of files that should be
751
 
            participate in the merge.  May not be combined with
752
 
            interesting_files.
 
728
        :param other_branch: The branch associated with other_tree, if any.
753
729
        :param: reprocess If True, perform conflict-reduction processing.
754
730
        :param show_base: If True, show the base revision in text conflicts.
755
731
            (incompatible with reprocess)
756
 
        :param pb: ignored
757
 
        :param pp: A ProgressPhase object
758
732
        :param change_reporter: An object that should report changes made
759
733
        :param interesting_files: The tree-relative paths of files that should
760
734
            participate in the merge.  If these paths refer to directories,
761
 
            the contents of those directories will also be included.  May not
762
 
            be combined with interesting_ids.  If neither interesting_files nor
763
 
            interesting_ids is specified, all files may participate in the
 
735
            the contents of those directories will also be included.  If not
 
736
            specified, all files may participate in the
764
737
            merge.
765
738
        :param lca_trees: Can be set to a dictionary of {revision_id:rev_tree}
766
739
            if the ancestry was found to include a criss-cross merge.
767
740
            Otherwise should be None.
768
741
        """
769
742
        object.__init__(self)
770
 
        if interesting_files is not None and interesting_ids is not None:
771
 
            raise ValueError(
772
 
                'specify either interesting_ids or interesting_files')
773
743
        if this_branch is None:
774
744
            this_branch = this_tree.branch
775
 
        self.interesting_ids = interesting_ids
776
745
        self.interesting_files = interesting_files
777
 
        self.this_tree = working_tree
 
746
        self.working_tree = working_tree
 
747
        self.this_tree = this_tree
778
748
        self.base_tree = base_tree
779
749
        self.other_tree = other_tree
780
750
        self.this_branch = this_branch
 
751
        self.other_branch = other_branch
781
752
        self._raw_conflicts = []
782
753
        self.cooked_conflicts = []
783
754
        self.reprocess = reprocess
792
763
        self.cherrypick = cherrypick
793
764
        if do_merge:
794
765
            self.do_merge()
795
 
        if pp is not None:
796
 
            warnings.warn("pp argument to Merge3Merger is deprecated")
797
 
        if pb is not None:
798
 
            warnings.warn("pb argument to Merge3Merger is deprecated")
799
766
 
800
767
    def do_merge(self):
801
 
        operation = OperationWithCleanups(self._do_merge)
802
 
        self.this_tree.lock_tree_write()
 
768
        operation = cleanup.OperationWithCleanups(self._do_merge)
 
769
        self.working_tree.lock_tree_write()
 
770
        operation.add_cleanup(self.working_tree.unlock)
 
771
        self.this_tree.lock_read()
803
772
        operation.add_cleanup(self.this_tree.unlock)
804
773
        self.base_tree.lock_read()
805
774
        operation.add_cleanup(self.base_tree.unlock)
808
777
        operation.run()
809
778
 
810
779
    def _do_merge(self, operation):
811
 
        self.tt = transform.TreeTransform(self.this_tree, None)
 
780
        self.tt = transform.TreeTransform(self.working_tree, None)
812
781
        operation.add_cleanup(self.tt.finalize)
813
782
        self._compute_transform()
814
783
        results = self.tt.apply(no_conflicts=True)
815
784
        self.write_modified(results)
816
785
        try:
817
 
            self.this_tree.add_conflicts(self.cooked_conflicts)
 
786
            self.working_tree.add_conflicts(self.cooked_conflicts)
818
787
        except errors.UnsupportedOperation:
819
788
            pass
820
789
 
821
790
    def make_preview_transform(self):
822
 
        operation = OperationWithCleanups(self._make_preview_transform)
 
791
        operation = cleanup.OperationWithCleanups(self._make_preview_transform)
823
792
        self.base_tree.lock_read()
824
793
        operation.add_cleanup(self.base_tree.unlock)
825
794
        self.other_tree.lock_read()
827
796
        return operation.run_simple()
828
797
 
829
798
    def _make_preview_transform(self):
830
 
        self.tt = transform.TransformPreview(self.this_tree)
 
799
        self.tt = transform.TransformPreview(self.working_tree)
831
800
        self._compute_transform()
832
801
        return self.tt
833
802
 
838
807
        else:
839
808
            entries = self._entries_lca()
840
809
            resolver = self._lca_multi_way
841
 
        child_pb = ui.ui_factory.nested_progress_bar()
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]
846
 
            for num, (file_id, changed, parents3, names3,
 
810
        # Prepare merge hooks
 
811
        factories = Merger.hooks['merge_file_content']
 
812
        # One hook for each registered one plus our default merger
 
813
        hooks = [factory(self) for factory in factories] + [self]
 
814
        self.active_hooks = [hook for hook in hooks if hook is not None]
 
815
        with ui.ui_factory.nested_progress_bar() as child_pb:
 
816
            for num, (file_id, changed, paths3, parents3, names3,
847
817
                      executable3) in enumerate(entries):
848
 
                child_pb.update('Preparing file merge', num, len(entries))
849
 
                self._merge_names(file_id, parents3, names3, resolver=resolver)
 
818
                # Try merging each entry
 
819
                child_pb.update(gettext('Preparing file merge'),
 
820
                                num, len(entries))
 
821
                self._merge_names(file_id, paths3, parents3, names3, resolver=resolver)
850
822
                if changed:
851
 
                    file_status = self._do_merge_contents(file_id)
 
823
                    file_status = self._do_merge_contents(paths3, file_id)
852
824
                else:
853
825
                    file_status = 'unmodified'
854
 
                self._merge_executable(file_id,
855
 
                    executable3, file_status, resolver=resolver)
856
 
        finally:
857
 
            child_pb.finished()
858
 
        self.fix_root()
859
 
        child_pb = ui.ui_factory.nested_progress_bar()
860
 
        try:
 
826
                self._merge_executable(paths3, file_id, executable3,
 
827
                        file_status, resolver=resolver)
 
828
        self.tt.fixup_new_roots()
 
829
        self._finish_computing_transform()
 
830
 
 
831
    def _finish_computing_transform(self):
 
832
        """Finalize the transform and report the changes.
 
833
 
 
834
        This is the second half of _compute_transform.
 
835
        """
 
836
        with ui.ui_factory.nested_progress_bar() as child_pb:
861
837
            fs_conflicts = transform.resolve_conflicts(self.tt, child_pb,
862
838
                lambda t, c: transform.conflict_pass(t, c, self.other_tree))
863
 
        finally:
864
 
            child_pb.finished()
865
839
        if self.change_reporter is not None:
866
 
            from bzrlib import delta
 
840
            from breezy import delta
867
841
            delta.report_changes(
868
842
                self.tt.iter_changes(), self.change_reporter)
869
843
        self.cook_conflicts(fs_conflicts)
870
844
        for conflict in self.cooked_conflicts:
871
 
            trace.warning(conflict)
 
845
            trace.warning('%s', conflict.describe())
872
846
 
873
847
    def _entries3(self):
874
848
        """Gather data about files modified between three trees.
881
855
        """
882
856
        result = []
883
857
        iterator = self.other_tree.iter_changes(self.base_tree,
884
 
                include_unchanged=True, specific_files=self.interesting_files,
 
858
                specific_files=self.interesting_files,
885
859
                extra_trees=[self.this_tree])
886
 
        this_entries = dict((e.file_id, e) for p, e in
887
 
                            self.this_tree.iter_entries_by_dir(
888
 
                            self.interesting_ids))
 
860
        this_interesting_files = self.this_tree.find_related_paths_across_trees(
 
861
                self.interesting_files, trees=[self.other_tree])
 
862
        this_entries = dict(self.this_tree.iter_entries_by_dir(
 
863
                            specific_files=this_interesting_files))
889
864
        for (file_id, paths, changed, versioned, parents, names, kind,
890
865
             executable) in iterator:
891
 
            if (self.interesting_ids is not None and
892
 
                file_id not in self.interesting_ids):
893
 
                continue
894
 
            entry = this_entries.get(file_id)
895
 
            if entry is not None:
896
 
                this_name = entry.name
897
 
                this_parent = entry.parent_id
898
 
                this_executable = entry.executable
 
866
            if paths[0] is not None:
 
867
                this_path = _mod_tree.find_previous_path(
 
868
                        self.base_tree, self.this_tree, paths[0])
 
869
            else:
 
870
                this_path = _mod_tree.find_previous_path(
 
871
                        self.other_tree, self.this_tree, paths[1])
 
872
            this_entry = this_entries.get(this_path)
 
873
            if this_entry is not None:
 
874
                this_name = this_entry.name
 
875
                this_parent = this_entry.parent_id
 
876
                this_executable = this_entry.executable
899
877
            else:
900
878
                this_name = None
901
879
                this_parent = None
902
880
                this_executable = None
903
881
            parents3 = parents + (this_parent,)
904
882
            names3 = names + (this_name,)
 
883
            paths3 = paths + (this_path, )
905
884
            executable3 = executable + (this_executable,)
906
 
            result.append((file_id, changed, parents3, names3, executable3))
 
885
            result.append((file_id, changed, paths3, parents3, names3, executable3))
907
886
        return result
908
887
 
909
888
    def _entries_lca(self):
913
892
        it then compares with THIS and BASE.
914
893
 
915
894
        For the multi-valued entries, the format will be (BASE, [lca1, lca2])
916
 
        :return: [(file_id, changed, parents, names, executable)]
917
 
            file_id     Simple file_id of the entry
918
 
            changed     Boolean, True if the kind or contents changed
919
 
                        else False
920
 
            parents     ((base, [parent_id, in, lcas]), parent_id_other,
921
 
                         parent_id_this)
922
 
            names       ((base, [name, in, lcas]), name_in_other, name_in_this)
923
 
            executable  ((base, [exec, in, lcas]), exec_in_other, exec_in_this)
 
895
 
 
896
        :return: [(file_id, changed, paths, parents, names, executable)], where:
 
897
 
 
898
            * file_id: Simple file_id of the entry
 
899
            * changed: Boolean, True if the kind or contents changed else False
 
900
            * paths: ((base, [path, in, lcas]), path_other, path_this)
 
901
            * parents: ((base, [parent_id, in, lcas]), parent_id_other,
 
902
                        parent_id_this)
 
903
            * names:   ((base, [name, in, lcas]), name_in_other, name_in_this)
 
904
            * executable: ((base, [exec, in, lcas]), exec_in_other,
 
905
                        exec_in_this)
924
906
        """
925
907
        if self.interesting_files is not None:
926
908
            lookup_trees = [self.this_tree, self.base_tree]
927
909
            lookup_trees.extend(self._lca_trees)
928
910
            # I think we should include the lca trees as well
929
 
            interesting_ids = self.other_tree.paths2ids(self.interesting_files,
930
 
                                                        lookup_trees)
 
911
            interesting_files = self.other_tree.find_related_paths_across_trees(
 
912
                    self.interesting_files, lookup_trees)
931
913
        else:
932
 
            interesting_ids = self.interesting_ids
 
914
            interesting_files = None
933
915
        result = []
934
916
        walker = _mod_tree.MultiWalker(self.other_tree, self._lca_trees)
935
917
 
936
 
        base_inventory = self.base_tree.inventory
937
 
        this_inventory = self.this_tree.inventory
 
918
        base_inventory = self.base_tree.root_inventory
 
919
        this_inventory = self.this_tree.root_inventory
938
920
        for path, file_id, other_ie, lca_values in walker.iter_all():
939
921
            # Is this modified at all from any of the other trees?
940
922
            if other_ie is None:
941
923
                other_ie = _none_entry
942
 
            if interesting_ids is not None and file_id not in interesting_ids:
 
924
                other_path = None
 
925
            else:
 
926
                other_path = self.other_tree.id2path(file_id)
 
927
            if interesting_files is not None and other_path not in interesting_files:
943
928
                continue
944
929
 
945
930
            # If other_revision is found in any of the lcas, that means this
962
947
                    continue
963
948
 
964
949
            lca_entries = []
 
950
            lca_paths = []
965
951
            for lca_path, lca_ie in lca_values:
966
952
                if lca_ie is None:
967
953
                    lca_entries.append(_none_entry)
 
954
                    lca_paths.append(None)
968
955
                else:
969
956
                    lca_entries.append(lca_ie)
 
957
                    lca_paths.append(lca_path)
970
958
 
971
 
            if file_id in base_inventory:
972
 
                base_ie = base_inventory[file_id]
973
 
            else:
 
959
            try:
 
960
                base_ie = base_inventory.get_entry(file_id)
 
961
            except errors.NoSuchId:
974
962
                base_ie = _none_entry
 
963
                base_path = None
 
964
            else:
 
965
                base_path = self.base_tree.id2path(file_id)
975
966
 
976
 
            if file_id in this_inventory:
977
 
                this_ie = this_inventory[file_id]
978
 
            else:
 
967
            try:
 
968
                this_ie = this_inventory.get_entry(file_id)
 
969
            except errors.NoSuchId:
979
970
                this_ie = _none_entry
 
971
                this_path = None
 
972
            else:
 
973
                this_path = self.this_tree.id2path(file_id)
980
974
 
981
975
            lca_kinds = []
982
976
            lca_parent_ids = []
1007
1001
                        continue
1008
1002
                    content_changed = False
1009
1003
                elif other_ie.kind is None or other_ie.kind == 'file':
1010
 
                    def get_sha1(ie, tree):
1011
 
                        if ie.kind != 'file':
1012
 
                            return None
1013
 
                        return tree.get_file_sha1(file_id)
1014
 
                    base_sha1 = get_sha1(base_ie, self.base_tree)
1015
 
                    lca_sha1s = [get_sha1(ie, tree) for ie, tree
1016
 
                                 in zip(lca_entries, self._lca_trees)]
1017
 
                    this_sha1 = get_sha1(this_ie, self.this_tree)
1018
 
                    other_sha1 = get_sha1(other_ie, self.other_tree)
 
1004
                    def get_sha1(tree, path):
 
1005
                        if path is None:
 
1006
                            return None
 
1007
                        try:
 
1008
                            return tree.get_file_sha1(path, file_id)
 
1009
                        except errors.NoSuchFile:
 
1010
                            return None
 
1011
                    base_sha1 = get_sha1(self.base_tree, base_path)
 
1012
                    lca_sha1s = [get_sha1(tree, lca_path)
 
1013
                                 for tree, lca_path
 
1014
                                 in zip(self._lca_trees, lca_paths)]
 
1015
                    this_sha1 = get_sha1(self.this_tree, this_path)
 
1016
                    other_sha1 = get_sha1(self.other_tree, other_path)
1019
1017
                    sha1_winner = self._lca_multi_way(
1020
1018
                        (base_sha1, lca_sha1s), other_sha1, this_sha1,
1021
1019
                        allow_overriding_lca=False)
1030
1028
                    if sha1_winner == 'this':
1031
1029
                        content_changed = False
1032
1030
                elif other_ie.kind == 'symlink':
1033
 
                    def get_target(ie, tree):
 
1031
                    def get_target(ie, tree, path):
1034
1032
                        if ie.kind != 'symlink':
1035
1033
                            return None
1036
 
                        return tree.get_symlink_target(file_id)
1037
 
                    base_target = get_target(base_ie, self.base_tree)
1038
 
                    lca_targets = [get_target(ie, tree) for ie, tree
1039
 
                                   in zip(lca_entries, self._lca_trees)]
1040
 
                    this_target = get_target(this_ie, self.this_tree)
1041
 
                    other_target = get_target(other_ie, self.other_tree)
 
1034
                        return tree.get_symlink_target(path, file_id)
 
1035
                    base_target = get_target(base_ie, self.base_tree, base_path)
 
1036
                    lca_targets = [get_target(ie, tree, lca_path) for ie, tree, lca_path
 
1037
                                   in zip(lca_entries, self._lca_trees, lca_paths)]
 
1038
                    this_target = get_target(this_ie, self.this_tree, this_path)
 
1039
                    other_target = get_target(other_ie, self.other_tree, other_path)
1042
1040
                    target_winner = self._lca_multi_way(
1043
1041
                        (base_target, lca_targets),
1044
1042
                        other_target, this_target)
1062
1060
 
1063
1061
            # If we have gotten this far, that means something has changed
1064
1062
            result.append((file_id, content_changed,
 
1063
                           ((base_path, lca_paths),
 
1064
                            other_path, this_path),
1065
1065
                           ((base_ie.parent_id, lca_parent_ids),
1066
1066
                            other_ie.parent_id, this_ie.parent_id),
1067
1067
                           ((base_ie.name, lca_names),
1071
1071
                          ))
1072
1072
        return result
1073
1073
 
1074
 
 
1075
 
    def fix_root(self):
1076
 
        try:
1077
 
            self.tt.final_kind(self.tt.root)
1078
 
        except errors.NoSuchFile:
1079
 
            self.tt.cancel_deletion(self.tt.root)
1080
 
        if self.tt.final_file_id(self.tt.root) is None:
1081
 
            self.tt.version_file(self.tt.tree_file_id(self.tt.root),
1082
 
                                 self.tt.root)
1083
 
        other_root_file_id = self.other_tree.get_root_id()
1084
 
        if other_root_file_id is None:
1085
 
            return
1086
 
        other_root = self.tt.trans_id_file_id(other_root_file_id)
1087
 
        if other_root == self.tt.root:
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
1093
 
        try:
1094
 
            self.tt.final_kind(other_root)
1095
 
            other_root_is_present = True
1096
 
        except errors.NoSuchFile:
1097
 
            # other_root doesn't have a physical representation. We still need
1098
 
            # to move any references to the actual root of the tree.
1099
 
            other_root_is_present = False
1100
 
        # 'other_tree.inventory.root' is not present in this tree. We are
1101
 
        # calling adjust_path for children which *want* to be present with a
1102
 
        # correct place to go.
1103
 
        for thing, child in self.other_tree.inventory.root.children.iteritems():
1104
 
            trans_id = self.tt.trans_id_file_id(child.file_id)
1105
 
            if not other_root_is_present:
1106
 
                # FIXME: Make final_kind returns None instead of raising
1107
 
                # NoSuchFile to avoid the ugly construct below -- vila 20100402
1108
 
                try:
1109
 
                    self.tt.final_kind(trans_id)
1110
 
                    # The item exist in the final tree and has a defined place
1111
 
                    # to go already.
1112
 
                    continue
1113
 
                except errors.NoSuchFile, e:
1114
 
                    pass
1115
 
            # Move the item into the root
1116
 
            self.tt.adjust_path(self.tt.final_name(trans_id),
1117
 
                                self.tt.root, trans_id)
1118
 
        if other_root_is_present:
1119
 
            self.tt.cancel_creation(other_root)
1120
 
            self.tt.cancel_versioning(other_root)
1121
 
 
1122
1074
    def write_modified(self, results):
 
1075
        if not self.working_tree.supports_merge_modified():
 
1076
            return
1123
1077
        modified_hashes = {}
1124
1078
        for path in results.modified_paths:
1125
 
            file_id = self.this_tree.path2id(self.this_tree.relpath(path))
 
1079
            wt_relpath = self.working_tree.relpath(path)
 
1080
            file_id = self.working_tree.path2id(wt_relpath)
1126
1081
            if file_id is None:
1127
1082
                continue
1128
 
            hash = self.this_tree.get_file_sha1(file_id)
 
1083
            hash = self.working_tree.get_file_sha1(wt_relpath, file_id)
1129
1084
            if hash is None:
1130
1085
                continue
1131
1086
            modified_hashes[file_id] = hash
1132
 
        self.this_tree.set_merge_modified(modified_hashes)
 
1087
        self.working_tree.set_merge_modified(modified_hashes)
1133
1088
 
1134
1089
    @staticmethod
1135
1090
    def parent(entry, file_id):
1146
1101
        return entry.name
1147
1102
 
1148
1103
    @staticmethod
1149
 
    def contents_sha1(tree, file_id):
 
1104
    def contents_sha1(tree, path, file_id=None):
1150
1105
        """Determine the sha1 of the file contents (used as a key method)."""
1151
 
        if file_id not in tree:
 
1106
        try:
 
1107
            return tree.get_file_sha1(path, file_id)
 
1108
        except errors.NoSuchFile:
1152
1109
            return None
1153
 
        return tree.get_file_sha1(file_id)
1154
1110
 
1155
1111
    @staticmethod
1156
 
    def executable(tree, file_id):
 
1112
    def executable(tree, path, file_id=None):
1157
1113
        """Determine the executability of a file-id (used as a key method)."""
1158
 
        if not tree.has_id(file_id):
 
1114
        try:
 
1115
            if tree.kind(path, file_id) != "file":
 
1116
                return False
 
1117
        except errors.NoSuchFile:
1159
1118
            return None
1160
 
        if tree.kind(file_id) != "file":
1161
 
            return False
1162
 
        return tree.is_executable(file_id)
 
1119
        return tree.is_executable(path, file_id)
1163
1120
 
1164
1121
    @staticmethod
1165
 
    def kind(tree, file_id):
 
1122
    def kind(tree, path, file_id=None):
1166
1123
        """Determine the kind of a file-id (used as a key method)."""
1167
 
        if not tree.has_id(file_id):
 
1124
        try:
 
1125
            return tree.kind(path, file_id)
 
1126
        except errors.NoSuchFile:
1168
1127
            return None
1169
 
        return tree.kind(file_id)
1170
1128
 
1171
1129
    @staticmethod
1172
1130
    def _three_way(base, other, this):
1234
1192
        # At this point, the lcas disagree, and the tip disagree
1235
1193
        return 'conflict'
1236
1194
 
1237
 
    @staticmethod
1238
 
    @deprecated_method(deprecated_in((2, 2, 0)))
1239
 
    def scalar_three_way(this_tree, base_tree, other_tree, file_id, key):
1240
 
        """Do a three-way test on a scalar.
1241
 
        Return "this", "other" or "conflict", depending whether a value wins.
1242
 
        """
1243
 
        key_base = key(base_tree, file_id)
1244
 
        key_other = key(other_tree, file_id)
1245
 
        #if base == other, either they all agree, or only THIS has changed.
1246
 
        if key_base == key_other:
1247
 
            return "this"
1248
 
        key_this = key(this_tree, file_id)
1249
 
        # "Ambiguous clean merge"
1250
 
        if key_this == key_other:
1251
 
            return "this"
1252
 
        elif key_this == key_base:
1253
 
            return "other"
1254
 
        else:
1255
 
            return "conflict"
1256
 
 
1257
 
    def merge_names(self, file_id):
1258
 
        def get_entry(tree):
1259
 
            if tree.has_id(file_id):
1260
 
                return tree.inventory[file_id]
1261
 
            else:
 
1195
    def merge_names(self, paths):
 
1196
        def get_entry(tree, path):
 
1197
            try:
 
1198
                return next(tree.iter_entries_by_dir(specific_files=[path]))[1]
 
1199
            except StopIteration:
1262
1200
                return None
1263
 
        this_entry = get_entry(self.this_tree)
1264
 
        other_entry = get_entry(self.other_tree)
1265
 
        base_entry = get_entry(self.base_tree)
 
1201
        used_base_path, other_path, this_path = paths
 
1202
        this_entry = get_entry(self.this_tree, this_path)
 
1203
        other_entry = get_entry(self.other_tree, other_path)
 
1204
        base_entry = get_entry(self.base_tree, base_path)
1266
1205
        entries = (base_entry, other_entry, this_entry)
1267
1206
        names = []
1268
1207
        parents = []
1273
1212
            else:
1274
1213
                names.append(entry.name)
1275
1214
                parents.append(entry.parent_id)
1276
 
        return self._merge_names(file_id, parents, names,
 
1215
        return self._merge_names(file_id, paths, parents, names,
1277
1216
                                 resolver=self._three_way)
1278
1217
 
1279
 
    def _merge_names(self, file_id, parents, names, resolver):
 
1218
    def _merge_names(self, file_id, paths, parents, names, resolver):
1280
1219
        """Perform a merge on file_id names and parents"""
1281
1220
        base_name, other_name, this_name = names
1282
1221
        base_parent, other_parent, this_parent = parents
 
1222
        unused_base_path, other_path, this_path = paths
1283
1223
 
1284
1224
        name_winner = resolver(*names)
1285
1225
 
1299
1239
            self._raw_conflicts.append(('path conflict', trans_id, file_id,
1300
1240
                                        this_parent, this_name,
1301
1241
                                        other_parent, other_name))
1302
 
        if other_name is None:
 
1242
        if other_path is None:
1303
1243
            # it doesn't matter whether the result was 'other' or
1304
 
            # 'conflict'-- if there's no 'other', we leave it alone.
 
1244
            # 'conflict'-- if it has no file id, we leave it alone.
1305
1245
            return
1306
1246
        parent_id = parents[self.winner_idx[parent_id_winner]]
1307
 
        if parent_id is not None:
 
1247
        name = names[self.winner_idx[name_winner]]
 
1248
        if parent_id is not None or name is not None:
1308
1249
            # if we get here, name_winner and parent_winner are set to safe
1309
1250
            # values.
1310
 
            self.tt.adjust_path(names[self.winner_idx[name_winner]],
1311
 
                                self.tt.trans_id_file_id(parent_id),
 
1251
            if parent_id is None and name is not None:
 
1252
                # if parent_id is None and name is non-None, current file is
 
1253
                # the tree root.
 
1254
                if names[self.winner_idx[parent_id_winner]] != '':
 
1255
                    raise AssertionError(
 
1256
                        'File looks like a root, but named %s' %
 
1257
                        names[self.winner_idx[parent_id_winner]])
 
1258
                parent_trans_id = transform.ROOT_PARENT
 
1259
            else:
 
1260
                parent_trans_id = self.tt.trans_id_file_id(parent_id)
 
1261
            self.tt.adjust_path(name, parent_trans_id,
1312
1262
                                self.tt.trans_id_file_id(file_id))
1313
1263
 
1314
 
    def _do_merge_contents(self, file_id):
 
1264
    def _do_merge_contents(self, paths, file_id):
1315
1265
        """Performs a merge on file_id contents."""
1316
 
        def contents_pair(tree):
1317
 
            if file_id not in tree:
1318
 
                return (None, None)
1319
 
            kind = tree.kind(file_id)
 
1266
        def contents_pair(tree, path):
 
1267
            if path is None:
 
1268
                return (None, None)
 
1269
            try:
 
1270
                kind = tree.kind(path, file_id)
 
1271
            except errors.NoSuchFile:
 
1272
                return (None, None)
1320
1273
            if kind == "file":
1321
 
                contents = tree.get_file_sha1(file_id)
 
1274
                contents = tree.get_file_sha1(path, file_id)
1322
1275
            elif kind == "symlink":
1323
 
                contents = tree.get_symlink_target(file_id)
 
1276
                contents = tree.get_symlink_target(path, file_id)
1324
1277
            else:
1325
1278
                contents = None
1326
1279
            return kind, contents
1327
1280
 
 
1281
        base_path, other_path, this_path = paths
1328
1282
        # See SPOT run.  run, SPOT, run.
1329
1283
        # So we're not QUITE repeating ourselves; we do tricky things with
1330
1284
        # file kind...
1331
 
        base_pair = contents_pair(self.base_tree)
1332
 
        other_pair = contents_pair(self.other_tree)
 
1285
        other_pair = contents_pair(self.other_tree, other_path)
 
1286
        this_pair = contents_pair(self.this_tree, this_path)
1333
1287
        if self._lca_trees:
1334
 
            this_pair = contents_pair(self.this_tree)
1335
 
            lca_pairs = [contents_pair(tree) for tree in self._lca_trees]
 
1288
            (base_path, lca_paths) = base_path
 
1289
            base_pair = contents_pair(self.base_tree, base_path)
 
1290
            lca_pairs = [contents_pair(tree, path)
 
1291
                         for tree, path in zip(self._lca_trees, lca_paths)]
1336
1292
            winner = self._lca_multi_way((base_pair, lca_pairs), other_pair,
1337
1293
                                         this_pair, allow_overriding_lca=False)
1338
1294
        else:
 
1295
            base_pair = contents_pair(self.base_tree, base_path)
1339
1296
            if base_pair == other_pair:
1340
1297
                winner = 'this'
1341
1298
            else:
1342
1299
                # We delayed evaluating this_pair as long as we can to avoid
1343
1300
                # unnecessary sha1 calculation
1344
 
                this_pair = contents_pair(self.this_tree)
 
1301
                this_pair = contents_pair(self.this_tree, this_path)
1345
1302
                winner = self._three_way(base_pair, other_pair, this_pair)
1346
1303
        if winner == 'this':
1347
1304
            # No interesting changes introduced by OTHER
1349
1306
        # We have a hypothetical conflict, but if we have files, then we
1350
1307
        # can try to merge the content
1351
1308
        trans_id = self.tt.trans_id_file_id(file_id)
1352
 
        params = MergeHookParams(self, file_id, trans_id, this_pair[0],
 
1309
        params = MergeFileHookParams(
 
1310
            self, file_id, (base_path, other_path,
 
1311
            this_path), trans_id, this_pair[0],
1353
1312
            other_pair[0], winner)
1354
1313
        hooks = self.active_hooks
1355
1314
        hook_status = 'not_applicable'
1358
1317
            if hook_status != 'not_applicable':
1359
1318
                # Don't try any more hooks, this one applies.
1360
1319
                break
 
1320
        # If the merge ends up replacing the content of the file, we get rid of
 
1321
        # it at the end of this method (this variable is used to track the
 
1322
        # exceptions to this rule).
 
1323
        keep_this = False
1361
1324
        result = "modified"
1362
1325
        if hook_status == 'not_applicable':
1363
 
            # This is a contents conflict, because none of the available
1364
 
            # functions could merge it.
 
1326
            # No merge hook was able to resolve the situation. Two cases exist:
 
1327
            # a content conflict or a duplicate one.
1365
1328
            result = None
1366
1329
            name = self.tt.final_name(trans_id)
1367
1330
            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))
 
1331
            duplicate = False
 
1332
            inhibit_content_conflict = False
 
1333
            if params.this_kind is None: # file_id is not in THIS
 
1334
                # Is the name used for a different file_id ?
 
1335
                if self.this_tree.is_versioned(other_path):
 
1336
                    # Two entries for the same path
 
1337
                    keep_this = True
 
1338
                    # versioning the merged file will trigger a duplicate
 
1339
                    # conflict
 
1340
                    self.tt.version_file(file_id, trans_id)
 
1341
                    transform.create_from_tree(
 
1342
                        self.tt, trans_id, self.other_tree,
 
1343
                        other_path, file_id=file_id,
 
1344
                        filter_tree_path=self._get_filter_tree_path(file_id))
 
1345
                    inhibit_content_conflict = True
 
1346
            elif params.other_kind is None: # file_id is not in OTHER
 
1347
                # Is the name used for a different file_id ?
 
1348
                if self.other_tree.is_versioned(this_path):
 
1349
                    # Two entries for the same path again, but here, the other
 
1350
                    # entry will also be merged.  We simply inhibit the
 
1351
                    # 'content' conflict creation because we know OTHER will
 
1352
                    # create (or has already created depending on ordering) an
 
1353
                    # entry at the same path. This will trigger a 'duplicate'
 
1354
                    # conflict later.
 
1355
                    keep_this = True
 
1356
                    inhibit_content_conflict = True
 
1357
            if not inhibit_content_conflict:
 
1358
                if params.this_kind is not None:
 
1359
                    self.tt.unversion_file(trans_id)
 
1360
                # This is a contents conflict, because none of the available
 
1361
                # functions could merge it.
 
1362
                file_group = self._dump_conflicts(
 
1363
                        name, (base_path, other_path, this_path), parent_id,
 
1364
                        file_id, set_version=True)
 
1365
                self._raw_conflicts.append(('contents conflict', file_group))
1373
1366
        elif hook_status == 'success':
1374
1367
            self.tt.create_file(lines, trans_id)
1375
1368
        elif hook_status == 'conflicted':
1379
1372
            self._raw_conflicts.append(('text conflict', trans_id))
1380
1373
            name = self.tt.final_name(trans_id)
1381
1374
            parent_id = self.tt.final_parent(trans_id)
1382
 
            self._dump_conflicts(name, parent_id, file_id)
 
1375
            self._dump_conflicts(
 
1376
                name, (base_path, other_path, this_path), parent_id, file_id)
1383
1377
        elif hook_status == 'delete':
1384
1378
            self.tt.unversion_file(trans_id)
1385
1379
            result = "deleted"
1389
1383
            pass
1390
1384
        else:
1391
1385
            raise AssertionError('unknown hook_status: %r' % (hook_status,))
1392
 
        if not self.this_tree.has_id(file_id) and result == "modified":
 
1386
        if not this_path and result == "modified":
1393
1387
            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:
 
1388
        if not keep_this:
 
1389
            # The merge has been performed and produced a new content, so the
 
1390
            # old contents should not be retained.
1397
1391
            self.tt.delete_contents(trans_id)
1398
 
        except errors.NoSuchFile:
1399
 
            pass
1400
1392
        return result
1401
1393
 
1402
1394
    def _default_other_winner_merge(self, merge_hook_params):
1403
1395
        """Replace this contents with other."""
1404
1396
        file_id = merge_hook_params.file_id
1405
1397
        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):
 
1398
        if merge_hook_params.other_path is not None:
1408
1399
            # 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)
 
1400
            transform.create_from_tree(
 
1401
                self.tt, trans_id, self.other_tree,
 
1402
                merge_hook_params.other_path, file_id=file_id,
 
1403
                filter_tree_path=self._get_filter_tree_path(file_id))
1425
1404
            return 'done', None
1426
 
        elif file_in_this:
 
1405
        elif merge_hook_params.this_path is not None:
1427
1406
            # OTHER deleted the file
1428
1407
            return 'delete', None
1429
1408
        else:
1434
1413
    def merge_contents(self, merge_hook_params):
1435
1414
        """Fallback merge logic after user installed hooks."""
1436
1415
        # This function is used in merge hooks as the fallback instance.
1437
 
        # Perhaps making this function and the functions it calls be a 
 
1416
        # Perhaps making this function and the functions it calls be a
1438
1417
        # a separate class would be better.
1439
1418
        if merge_hook_params.winner == 'other':
1440
1419
            # OTHER is a straight winner, so replace this contents with other
1444
1423
            # BASE is a file, or both converted to files, so at least we
1445
1424
            # have agreement that output should be a file.
1446
1425
            try:
1447
 
                self.text_merge(merge_hook_params.file_id,
1448
 
                    merge_hook_params.trans_id)
 
1426
                self.text_merge(merge_hook_params.trans_id,
 
1427
                                merge_hook_params.paths, merge_hook_params.file_id)
1449
1428
            except errors.BinaryFile:
1450
1429
                return 'not_applicable', None
1451
1430
            return 'done', None
1452
1431
        else:
1453
1432
            return 'not_applicable', None
1454
1433
 
1455
 
    def get_lines(self, tree, file_id):
 
1434
    def get_lines(self, tree, path, file_id=None):
1456
1435
        """Return the lines in a file, or an empty list."""
1457
 
        if tree.has_id(file_id):
1458
 
            return tree.get_file(file_id).readlines()
 
1436
        if path is None:
 
1437
            return []
 
1438
        try:
 
1439
            kind = tree.kind(path, file_id)
 
1440
        except errors.NoSuchFile:
 
1441
            return []
1459
1442
        else:
1460
 
            return []
 
1443
            if kind != 'file':
 
1444
                return []
 
1445
            return tree.get_file_lines(path, file_id)
1461
1446
 
1462
 
    def text_merge(self, file_id, trans_id):
 
1447
    def text_merge(self, trans_id, paths, file_id):
1463
1448
        """Perform a three-way text merge on a file_id"""
1464
1449
        # it's possible that we got here with base as a different type.
1465
1450
        # if so, we just want two-way text conflicts.
1466
 
        if self.base_tree.has_id(file_id) and \
1467
 
            self.base_tree.kind(file_id) == "file":
1468
 
            base_lines = self.get_lines(self.base_tree, file_id)
1469
 
        else:
1470
 
            base_lines = []
1471
 
        other_lines = self.get_lines(self.other_tree, file_id)
1472
 
        this_lines = self.get_lines(self.this_tree, file_id)
 
1451
        base_path, other_path, this_path = paths
 
1452
        base_lines = self.get_lines(self.base_tree, base_path, file_id)
 
1453
        other_lines = self.get_lines(self.other_tree, other_path, file_id)
 
1454
        this_lines = self.get_lines(self.this_tree, this_path, file_id)
1473
1455
        m3 = merge3.Merge3(base_lines, this_lines, other_lines,
1474
1456
                           is_cherrypick=self.cherrypick)
1475
 
        start_marker = "!START OF MERGE CONFLICT!" + "I HOPE THIS IS UNIQUE"
 
1457
        start_marker = b"!START OF MERGE CONFLICT!" + b"I HOPE THIS IS UNIQUE"
1476
1458
        if self.show_base is True:
1477
1459
            base_marker = '|' * 7
1478
1460
        else:
1480
1462
 
1481
1463
        def iter_merge3(retval):
1482
1464
            retval["text_conflicts"] = False
1483
 
            for line in m3.merge_lines(name_a = "TREE",
1484
 
                                       name_b = "MERGE-SOURCE",
1485
 
                                       name_base = "BASE-REVISION",
 
1465
            for line in m3.merge_lines(name_a = b"TREE",
 
1466
                                       name_b = b"MERGE-SOURCE",
 
1467
                                       name_base = b"BASE-REVISION",
1486
1468
                                       start_marker=start_marker,
1487
1469
                                       base_marker=base_marker,
1488
1470
                                       reprocess=self.reprocess):
1489
1471
                if line.startswith(start_marker):
1490
1472
                    retval["text_conflicts"] = True
1491
 
                    yield line.replace(start_marker, '<' * 7)
 
1473
                    yield line.replace(start_marker, b'<' * 7)
1492
1474
                else:
1493
1475
                    yield line
1494
1476
        retval = {}
1498
1480
            self._raw_conflicts.append(('text conflict', trans_id))
1499
1481
            name = self.tt.final_name(trans_id)
1500
1482
            parent_id = self.tt.final_parent(trans_id)
1501
 
            file_group = self._dump_conflicts(name, parent_id, file_id,
 
1483
            file_group = self._dump_conflicts(name, paths, parent_id, file_id,
1502
1484
                                              this_lines, base_lines,
1503
1485
                                              other_lines)
1504
1486
            file_group.append(trans_id)
1505
1487
 
1506
 
    def _dump_conflicts(self, name, parent_id, file_id, this_lines=None,
 
1488
    def _get_filter_tree_path(self, file_id):
 
1489
        if self.this_tree.supports_content_filtering():
 
1490
            # We get the path from the working tree if it exists.
 
1491
            # That fails though when OTHER is adding a file, so
 
1492
            # we fall back to the other tree to find the path if
 
1493
            # it doesn't exist locally.
 
1494
            try:
 
1495
                return self.this_tree.id2path(file_id)
 
1496
            except errors.NoSuchId:
 
1497
                return self.other_tree.id2path(file_id)
 
1498
        # Skip the id2path lookup for older formats
 
1499
        return None
 
1500
 
 
1501
    def _dump_conflicts(self, name, paths, parent_id, file_id, this_lines=None,
1507
1502
                        base_lines=None, other_lines=None, set_version=False,
1508
1503
                        no_base=False):
1509
1504
        """Emit conflict files.
1511
1506
        determined automatically.  If set_version is true, the .OTHER, .THIS
1512
1507
        or .BASE (in that order) will be created as versioned files.
1513
1508
        """
1514
 
        data = [('OTHER', self.other_tree, other_lines),
1515
 
                ('THIS', self.this_tree, this_lines)]
 
1509
        base_path, other_path, this_path = paths
 
1510
        data = [('OTHER', self.other_tree, other_path, other_lines),
 
1511
                ('THIS', self.this_tree, this_path, this_lines)]
1516
1512
        if not no_base:
1517
 
            data.append(('BASE', self.base_tree, base_lines))
 
1513
            data.append(('BASE', self.base_tree, base_path, base_lines))
1518
1514
 
1519
1515
        # We need to use the actual path in the working tree of the file here,
1520
1516
        # ignoring the conflict suffixes
1531
1527
 
1532
1528
        versioned = False
1533
1529
        file_group = []
1534
 
        for suffix, tree, lines in data:
1535
 
            if tree.has_id(file_id):
1536
 
                trans_id = self._conflict_file(name, parent_id, tree, file_id,
1537
 
                                               suffix, lines, filter_tree_path)
 
1530
        for suffix, tree, path, lines in data:
 
1531
            if path is not None:
 
1532
                trans_id = self._conflict_file(
 
1533
                        name, parent_id, path, tree, file_id, suffix, lines,
 
1534
                        filter_tree_path)
1538
1535
                file_group.append(trans_id)
1539
1536
                if set_version and not versioned:
1540
1537
                    self.tt.version_file(file_id, trans_id)
1541
1538
                    versioned = True
1542
1539
        return file_group
1543
1540
 
1544
 
    def _conflict_file(self, name, parent_id, tree, file_id, suffix,
 
1541
    def _conflict_file(self, name, parent_id, path, tree, file_id, suffix,
1545
1542
                       lines=None, filter_tree_path=None):
1546
1543
        """Emit a single conflict file."""
1547
1544
        name = name + '.' + suffix
1548
1545
        trans_id = self.tt.create_path(name, parent_id)
1549
 
        transform.create_from_tree(self.tt, trans_id, tree, file_id, lines,
1550
 
            filter_tree_path)
 
1546
        transform.create_from_tree(
 
1547
                self.tt, trans_id, tree, path,
 
1548
                file_id=file_id, chunks=lines,
 
1549
                filter_tree_path=filter_tree_path)
1551
1550
        return trans_id
1552
1551
 
1553
 
    def merge_executable(self, file_id, file_status):
 
1552
    def merge_executable(self, paths, file_id, file_status):
1554
1553
        """Perform a merge on the execute bit."""
1555
 
        executable = [self.executable(t, file_id) for t in (self.base_tree,
1556
 
                      self.other_tree, self.this_tree)]
1557
 
        self._merge_executable(file_id, executable, file_status,
 
1554
        executable = [self.executable(t, p, file_id) for t, p in zip([self.base_tree,
 
1555
                      self.other_tree, self.this_tree], paths)]
 
1556
        self._merge_executable(paths, file_id, executable, file_status,
1558
1557
                               resolver=self._three_way)
1559
1558
 
1560
 
    def _merge_executable(self, file_id, executable, file_status,
 
1559
    def _merge_executable(self, paths, file_id, executable, file_status,
1561
1560
                          resolver):
1562
1561
        """Perform a merge on the execute bit."""
1563
1562
        base_executable, other_executable, this_executable = executable
 
1563
        base_path, other_path, this_path = paths
1564
1564
        if file_status == "deleted":
1565
1565
            return
1566
1566
        winner = resolver(*executable)
1567
1567
        if winner == "conflict":
1568
1568
        # There must be a None in here, if we have a conflict, but we
1569
1569
        # need executability since file status was not deleted.
1570
 
            if self.executable(self.other_tree, file_id) is None:
 
1570
            if other_path is None:
1571
1571
                winner = "this"
1572
1572
            else:
1573
1573
                winner = "other"
1574
1574
        if winner == 'this' and file_status != "modified":
1575
1575
            return
1576
1576
        trans_id = self.tt.trans_id_file_id(file_id)
1577
 
        try:
1578
 
            if self.tt.final_kind(trans_id) != "file":
1579
 
                return
1580
 
        except errors.NoSuchFile:
 
1577
        if self.tt.final_kind(trans_id) != "file":
1581
1578
            return
1582
1579
        if winner == "this":
1583
1580
            executability = this_executable
1584
1581
        else:
1585
 
            if self.other_tree.has_id(file_id):
 
1582
            if other_path is not None:
1586
1583
                executability = other_executable
1587
 
            elif self.this_tree.has_id(file_id):
 
1584
            elif this_path is not None:
1588
1585
                executability = this_executable
1589
 
            elif self.base_tree_has_id(file_id):
 
1586
            elif base_path is not None:
1590
1587
                executability = base_executable
1591
1588
        if executability is not None:
1592
1589
            trans_id = self.tt.trans_id_file_id(file_id)
1594
1591
 
1595
1592
    def cook_conflicts(self, fs_conflicts):
1596
1593
        """Convert all conflicts into a form that doesn't depend on trans_id"""
1597
 
        self.cooked_conflicts.extend(transform.cook_conflicts(
1598
 
                fs_conflicts, self.tt))
 
1594
        content_conflict_file_ids = set()
 
1595
        cooked_conflicts = transform.cook_conflicts(fs_conflicts, self.tt)
1599
1596
        fp = transform.FinalPaths(self.tt)
1600
1597
        for conflict in self._raw_conflicts:
1601
1598
            conflict_type = conflict[0]
1612
1609
                if other_parent is None or other_name is None:
1613
1610
                    other_path = '<deleted>'
1614
1611
                else:
1615
 
                    parent_path =  fp.get_path(
1616
 
                        self.tt.trans_id_file_id(other_parent))
 
1612
                    if other_parent == self.other_tree.get_root_id():
 
1613
                        # The tree transform doesn't know about the other root,
 
1614
                        # so we special case here to avoid a NoFinalPath
 
1615
                        # exception
 
1616
                        parent_path = ''
 
1617
                    else:
 
1618
                        parent_path =  fp.get_path(
 
1619
                            self.tt.trans_id_file_id(other_parent))
1617
1620
                    other_path = osutils.pathjoin(parent_path, other_name)
1618
1621
                c = _mod_conflicts.Conflict.factory(
1619
1622
                    'path conflict', path=this_path,
1623
1626
                for trans_id in conflict[1]:
1624
1627
                    file_id = self.tt.final_file_id(trans_id)
1625
1628
                    if file_id is not None:
 
1629
                        # Ok we found the relevant file-id
1626
1630
                        break
1627
1631
                path = fp.get_path(trans_id)
1628
1632
                for suffix in ('.BASE', '.THIS', '.OTHER'):
1629
1633
                    if path.endswith(suffix):
 
1634
                        # Here is the raw path
1630
1635
                        path = path[:-len(suffix)]
1631
1636
                        break
1632
1637
                c = _mod_conflicts.Conflict.factory(conflict_type,
1633
1638
                                                    path=path, file_id=file_id)
 
1639
                content_conflict_file_ids.add(file_id)
1634
1640
            elif conflict_type == 'text conflict':
1635
1641
                trans_id = conflict[1]
1636
1642
                path = fp.get_path(trans_id)
1639
1645
                                                    path=path, file_id=file_id)
1640
1646
            else:
1641
1647
                raise AssertionError('bad conflict type: %r' % (conflict,))
 
1648
            cooked_conflicts.append(c)
 
1649
 
 
1650
        self.cooked_conflicts = []
 
1651
        # We want to get rid of path conflicts when a corresponding contents
 
1652
        # conflict exists. This can occur when one branch deletes a file while
 
1653
        # the other renames *and* modifies it. In this case, the content
 
1654
        # conflict is enough.
 
1655
        for c in cooked_conflicts:
 
1656
            if (c.typestring == 'path conflict'
 
1657
                and c.file_id in content_conflict_file_ids):
 
1658
                continue
1642
1659
            self.cooked_conflicts.append(c)
1643
1660
        self.cooked_conflicts.sort(key=_mod_conflicts.Conflict.sort_key)
1644
1661
 
1649
1666
    supports_show_base = False
1650
1667
    supports_reverse_cherrypick = False
1651
1668
    history_based = True
 
1669
    requires_file_merge_plan = True
1652
1670
 
1653
1671
    def _generate_merge_plan(self, file_id, base):
1654
1672
        return self.this_tree.plan_file_merge(file_id, self.other_tree,
1668
1686
            plan = list(plan)
1669
1687
            trans_id = self.tt.trans_id_file_id(file_id)
1670
1688
            name = self.tt.final_name(trans_id) + '.plan'
1671
 
            contents = ('%11s|%s' % l for l in plan)
 
1689
            contents = (b'%11s|%s' % l for l in plan)
1672
1690
            self.tt.new_file(name, self.tt.final_parent(trans_id), contents)
1673
 
        textmerge = versionedfile.PlanWeaveMerge(plan, '<<<<<<< TREE\n',
1674
 
                                                 '>>>>>>> MERGE-SOURCE\n')
 
1691
        textmerge = versionedfile.PlanWeaveMerge(plan, b'<<<<<<< TREE\n',
 
1692
                                                 b'>>>>>>> MERGE-SOURCE\n')
1675
1693
        lines, conflicts = textmerge.merge_lines(self.reprocess)
1676
1694
        if conflicts:
1677
1695
            base_lines = textmerge.base_from_plan()
1679
1697
            base_lines = None
1680
1698
        return lines, base_lines
1681
1699
 
1682
 
    def text_merge(self, file_id, trans_id):
 
1700
    def text_merge(self, trans_id, paths, file_id):
1683
1701
        """Perform a (weave) text merge for a given file and file-id.
1684
1702
        If conflicts are encountered, .THIS and .OTHER files will be emitted,
1685
1703
        and a conflict will be noted.
1686
1704
        """
 
1705
        base_path, other_path, this_path = paths
1687
1706
        lines, base_lines = self._merged_lines(file_id)
1688
1707
        lines = list(lines)
1689
1708
        # Note we're checking whether the OUTPUT is binary in this case,
1695
1714
            self._raw_conflicts.append(('text conflict', trans_id))
1696
1715
            name = self.tt.final_name(trans_id)
1697
1716
            parent_id = self.tt.final_parent(trans_id)
1698
 
            file_group = self._dump_conflicts(name, parent_id, file_id,
 
1717
            file_group = self._dump_conflicts(name, paths, parent_id, file_id,
1699
1718
                                              no_base=False,
1700
1719
                                              base_lines=base_lines)
1701
1720
            file_group.append(trans_id)
1703
1722
 
1704
1723
class LCAMerger(WeaveMerger):
1705
1724
 
 
1725
    requires_file_merge_plan = True
 
1726
 
1706
1727
    def _generate_merge_plan(self, file_id, base):
1707
1728
        return self.this_tree.plan_file_lca_merge(file_id, self.other_tree,
1708
1729
                                                  base=base)
1710
1731
class Diff3Merger(Merge3Merger):
1711
1732
    """Three-way merger using external diff3 for text merging"""
1712
1733
 
1713
 
    def dump_file(self, temp_dir, name, tree, file_id):
 
1734
    requires_file_merge_plan = False
 
1735
 
 
1736
    def dump_file(self, temp_dir, name, tree, path, file_id=None):
1714
1737
        out_path = osutils.pathjoin(temp_dir, name)
1715
 
        out_file = open(out_path, "wb")
1716
 
        try:
1717
 
            in_file = tree.get_file(file_id)
 
1738
        with open(out_path, "wb") as out_file:
 
1739
            in_file = tree.get_file(path, file_id=None)
1718
1740
            for line in in_file:
1719
1741
                out_file.write(line)
1720
 
        finally:
1721
 
            out_file.close()
1722
1742
        return out_path
1723
1743
 
1724
 
    def text_merge(self, file_id, trans_id):
 
1744
    def text_merge(self, trans_id, paths, file_id):
1725
1745
        """Perform a diff3 merge using a specified file-id and trans-id.
1726
1746
        If conflicts are encountered, .BASE, .THIS. and .OTHER conflict files
1727
1747
        will be dumped, and a will be conflict noted.
1728
1748
        """
1729
 
        import bzrlib.patch
 
1749
        import breezy.patch
 
1750
        base_path, other_path, this_path = paths
1730
1751
        temp_dir = osutils.mkdtemp(prefix="bzr-")
1731
1752
        try:
1732
1753
            new_file = osutils.pathjoin(temp_dir, "new")
1733
 
            this = self.dump_file(temp_dir, "this", self.this_tree, file_id)
1734
 
            base = self.dump_file(temp_dir, "base", self.base_tree, file_id)
1735
 
            other = self.dump_file(temp_dir, "other", self.other_tree, file_id)
1736
 
            status = bzrlib.patch.diff3(new_file, this, base, other)
 
1754
            this = self.dump_file(temp_dir, "this", self.this_tree, this_path, file_id)
 
1755
            base = self.dump_file(temp_dir, "base", self.base_tree, base_path, file_id)
 
1756
            other = self.dump_file(temp_dir, "other", self.other_tree, other_path, file_id)
 
1757
            status = breezy.patch.diff3(new_file, this, base, other)
1737
1758
            if status not in (0, 1):
1738
1759
                raise errors.BzrError("Unhandled diff3 exit code")
1739
 
            f = open(new_file, 'rb')
1740
 
            try:
 
1760
            with open(new_file, 'rb') as f:
1741
1761
                self.tt.create_file(f, trans_id)
1742
 
            finally:
1743
 
                f.close()
1744
1762
            if status == 1:
1745
1763
                name = self.tt.final_name(trans_id)
1746
1764
                parent_id = self.tt.final_parent(trans_id)
1747
 
                self._dump_conflicts(name, parent_id, file_id)
 
1765
                self._dump_conflicts(name, paths, parent_id, file_id)
1748
1766
                self._raw_conflicts.append(('text conflict', trans_id))
1749
1767
        finally:
1750
1768
            osutils.rmtree(temp_dir)
1751
1769
 
1752
1770
 
 
1771
class PathNotInTree(errors.BzrError):
 
1772
 
 
1773
    _fmt = """Merge-into failed because %(tree)s does not contain %(path)s."""
 
1774
 
 
1775
    def __init__(self, path, tree):
 
1776
        errors.BzrError.__init__(self, path=path, tree=tree)
 
1777
 
 
1778
 
 
1779
class MergeIntoMerger(Merger):
 
1780
    """Merger that understands other_tree will be merged into a subdir.
 
1781
 
 
1782
    This also changes the Merger api so that it uses real Branch, revision_id,
 
1783
    and RevisonTree objects, rather than using revision specs.
 
1784
    """
 
1785
 
 
1786
    def __init__(self, this_tree, other_branch, other_tree, target_subdir,
 
1787
            source_subpath, other_rev_id=None):
 
1788
        """Create a new MergeIntoMerger object.
 
1789
 
 
1790
        source_subpath in other_tree will be effectively copied to
 
1791
        target_subdir in this_tree.
 
1792
 
 
1793
        :param this_tree: The tree that we will be merging into.
 
1794
        :param other_branch: The Branch we will be merging from.
 
1795
        :param other_tree: The RevisionTree object we want to merge.
 
1796
        :param target_subdir: The relative path where we want to merge
 
1797
            other_tree into this_tree
 
1798
        :param source_subpath: The relative path specifying the subtree of
 
1799
            other_tree to merge into this_tree.
 
1800
        """
 
1801
        # It is assumed that we are merging a tree that is not in our current
 
1802
        # ancestry, which means we are using the "EmptyTree" as our basis.
 
1803
        null_ancestor_tree = this_tree.branch.repository.revision_tree(
 
1804
                                _mod_revision.NULL_REVISION)
 
1805
        super(MergeIntoMerger, self).__init__(
 
1806
            this_branch=this_tree.branch,
 
1807
            this_tree=this_tree,
 
1808
            other_tree=other_tree,
 
1809
            base_tree=null_ancestor_tree,
 
1810
            )
 
1811
        self._target_subdir = target_subdir
 
1812
        self._source_subpath = source_subpath
 
1813
        self.other_branch = other_branch
 
1814
        if other_rev_id is None:
 
1815
            other_rev_id = other_tree.get_revision_id()
 
1816
        self.other_rev_id = self.other_basis = other_rev_id
 
1817
        self.base_is_ancestor = True
 
1818
        self.backup_files = True
 
1819
        self.merge_type = Merge3Merger
 
1820
        self.show_base = False
 
1821
        self.reprocess = False
 
1822
        self.interesting_files = None
 
1823
        self.merge_type = _MergeTypeParameterizer(MergeIntoMergeType,
 
1824
              target_subdir=self._target_subdir,
 
1825
              source_subpath=self._source_subpath)
 
1826
        if self._source_subpath != '':
 
1827
            # If this isn't a partial merge make sure the revisions will be
 
1828
            # present.
 
1829
            self._maybe_fetch(self.other_branch, self.this_branch,
 
1830
                self.other_basis)
 
1831
 
 
1832
    def set_pending(self):
 
1833
        if self._source_subpath != '':
 
1834
            return
 
1835
        Merger.set_pending(self)
 
1836
 
 
1837
 
 
1838
class _MergeTypeParameterizer(object):
 
1839
    """Wrap a merge-type class to provide extra parameters.
 
1840
 
 
1841
    This is hack used by MergeIntoMerger to pass some extra parameters to its
 
1842
    merge_type.  Merger.do_merge() sets up its own set of parameters to pass to
 
1843
    the 'merge_type' member.  It is difficult override do_merge without
 
1844
    re-writing the whole thing, so instead we create a wrapper which will pass
 
1845
    the extra parameters.
 
1846
    """
 
1847
 
 
1848
    def __init__(self, merge_type, **kwargs):
 
1849
        self._extra_kwargs = kwargs
 
1850
        self._merge_type = merge_type
 
1851
 
 
1852
    def __call__(self, *args, **kwargs):
 
1853
        kwargs.update(self._extra_kwargs)
 
1854
        return self._merge_type(*args, **kwargs)
 
1855
 
 
1856
    def __getattr__(self, name):
 
1857
        return getattr(self._merge_type, name)
 
1858
 
 
1859
 
 
1860
class MergeIntoMergeType(Merge3Merger):
 
1861
    """Merger that incorporates a tree (or part of a tree) into another."""
 
1862
 
 
1863
    def __init__(self, *args, **kwargs):
 
1864
        """Initialize the merger object.
 
1865
 
 
1866
        :param args: See Merge3Merger.__init__'s args.
 
1867
        :param kwargs: See Merge3Merger.__init__'s keyword args, except for
 
1868
            source_subpath and target_subdir.
 
1869
        :keyword source_subpath: The relative path specifying the subtree of
 
1870
            other_tree to merge into this_tree.
 
1871
        :keyword target_subdir: The relative path where we want to merge
 
1872
            other_tree into this_tree
 
1873
        """
 
1874
        # All of the interesting work happens during Merge3Merger.__init__(),
 
1875
        # so we have have to hack in to get our extra parameters set.
 
1876
        self._source_subpath = kwargs.pop('source_subpath')
 
1877
        self._target_subdir = kwargs.pop('target_subdir')
 
1878
        super(MergeIntoMergeType, self).__init__(*args, **kwargs)
 
1879
 
 
1880
    def _compute_transform(self):
 
1881
        with ui.ui_factory.nested_progress_bar() as child_pb:
 
1882
            entries = self._entries_to_incorporate()
 
1883
            entries = list(entries)
 
1884
            for num, (entry, parent_id, relpath) in enumerate(entries):
 
1885
                child_pb.update(gettext('Preparing file merge'), num, len(entries))
 
1886
                parent_trans_id = self.tt.trans_id_file_id(parent_id)
 
1887
                path = osutils.pathjoin(self._source_subpath, relpath)
 
1888
                trans_id = transform.new_by_entry(path, self.tt, entry,
 
1889
                    parent_trans_id, self.other_tree)
 
1890
        self._finish_computing_transform()
 
1891
 
 
1892
    def _entries_to_incorporate(self):
 
1893
        """Yields pairs of (inventory_entry, new_parent)."""
 
1894
        other_inv = self.other_tree.root_inventory
 
1895
        subdir_id = other_inv.path2id(self._source_subpath)
 
1896
        if subdir_id is None:
 
1897
            # XXX: The error would be clearer if it gave the URL of the source
 
1898
            # branch, but we don't have a reference to that here.
 
1899
            raise PathNotInTree(self._source_subpath, "Source tree")
 
1900
        subdir = other_inv.get_entry(subdir_id)
 
1901
        parent_in_target = osutils.dirname(self._target_subdir)
 
1902
        target_id = self.this_tree.path2id(parent_in_target)
 
1903
        if target_id is None:
 
1904
            raise PathNotInTree(self._target_subdir, "Target tree")
 
1905
        name_in_target = osutils.basename(self._target_subdir)
 
1906
        merge_into_root = subdir.copy()
 
1907
        merge_into_root.name = name_in_target
 
1908
        if self.this_tree.has_id(merge_into_root.file_id):
 
1909
            # Give the root a new file-id.
 
1910
            # This can happen fairly easily if the directory we are
 
1911
            # incorporating is the root, and both trees have 'TREE_ROOT' as
 
1912
            # their root_id.  Users will expect this to Just Work, so we
 
1913
            # change the file-id here.
 
1914
            # Non-root file-ids could potentially conflict too.  That's really
 
1915
            # an edge case, so we don't do anything special for those.  We let
 
1916
            # them cause conflicts.
 
1917
            merge_into_root.file_id = generate_ids.gen_file_id(name_in_target)
 
1918
        yield (merge_into_root, target_id, '')
 
1919
        if subdir.kind != 'directory':
 
1920
            # No children, so we are done.
 
1921
            return
 
1922
        for path, entry in other_inv.iter_entries_by_dir(subdir_id):
 
1923
            parent_id = entry.parent_id
 
1924
            if parent_id == subdir.file_id:
 
1925
                # The root's parent ID has changed, so make sure children of
 
1926
                # the root refer to the new ID.
 
1927
                parent_id = merge_into_root.file_id
 
1928
            yield (entry, parent_id, path)
 
1929
 
 
1930
 
1753
1931
def merge_inner(this_branch, other_tree, base_tree, ignore_zero=False,
1754
1932
                backup_files=False,
1755
1933
                merge_type=Merge3Merger,
1756
 
                interesting_ids=None,
1757
1934
                show_base=False,
1758
1935
                reprocess=False,
1759
1936
                other_rev_id=None,
1760
1937
                interesting_files=None,
1761
1938
                this_tree=None,
1762
 
                pb=None,
1763
1939
                change_reporter=None):
1764
1940
    """Primary interface for merging.
1765
1941
 
1766
 
        typical use is probably
1767
 
        'merge_inner(branch, branch.get_revision_tree(other_revision),
1768
 
                     branch.get_revision_tree(base_revision))'
1769
 
        """
 
1942
    Typical use is probably::
 
1943
 
 
1944
        merge_inner(branch, branch.get_revision_tree(other_revision),
 
1945
                    branch.get_revision_tree(base_revision))
 
1946
    """
1770
1947
    if this_tree is None:
1771
 
        raise errors.BzrError("bzrlib.merge.merge_inner requires a this_tree "
1772
 
                              "parameter as of bzrlib version 0.8.")
 
1948
        raise errors.BzrError("breezy.merge.merge_inner requires a this_tree "
 
1949
                              "parameter")
1773
1950
    merger = Merger(this_branch, other_tree, base_tree, this_tree=this_tree,
1774
 
                    pb=pb, change_reporter=change_reporter)
 
1951
                    change_reporter=change_reporter)
1775
1952
    merger.backup_files = backup_files
1776
1953
    merger.merge_type = merge_type
1777
 
    merger.interesting_ids = interesting_ids
1778
1954
    merger.ignore_zero = ignore_zero
1779
 
    if interesting_files:
1780
 
        if interesting_ids:
1781
 
            raise ValueError('Only supply interesting_ids'
1782
 
                             ' or interesting_files')
1783
 
        merger.interesting_files = interesting_files
 
1955
    merger.interesting_files = interesting_files
1784
1956
    merger.show_base = show_base
1785
1957
    merger.reprocess = reprocess
1786
1958
    merger.other_rev_id = other_rev_id
1792
1964
    merger.set_base_revision(get_revision_id(), this_branch)
1793
1965
    return merger.do_merge()
1794
1966
 
 
1967
 
 
1968
merge_type_registry = registry.Registry()
 
1969
merge_type_registry.register('diff3', Diff3Merger,
 
1970
                             "Merge using external diff3.")
 
1971
merge_type_registry.register('lca', LCAMerger,
 
1972
                             "LCA-newness merge.")
 
1973
merge_type_registry.register('merge3', Merge3Merger,
 
1974
                             "Native diff3-style merge.")
 
1975
merge_type_registry.register('weave', WeaveMerger,
 
1976
                             "Weave-based merge.")
 
1977
 
 
1978
 
1795
1979
def get_merge_type_registry():
1796
 
    """Merge type registry is in bzrlib.option to avoid circular imports.
 
1980
    """Merge type registry was previously in breezy.option
1797
1981
 
1798
 
    This method provides a sanctioned way to retrieve it.
 
1982
    This method provides a backwards compatible way to retrieve it.
1799
1983
    """
1800
 
    from bzrlib import option
1801
 
    return option._merge_type_registry
 
1984
    return merge_type_registry
1802
1985
 
1803
1986
 
1804
1987
def _plan_annotate_merge(annotated_a, annotated_b, ancestors_a, ancestors_b):
2025
2208
        while True:
2026
2209
            next_lcas = self.graph.find_lca(*cur_ancestors)
2027
2210
            # Map a plain NULL_REVISION to a simple no-ancestors
2028
 
            if next_lcas == set([_mod_revision.NULL_REVISION]):
 
2211
            if next_lcas == {_mod_revision.NULL_REVISION}:
2029
2212
                next_lcas = ()
2030
2213
            # Order the lca's based on when they were merged into the tip
2031
2214
            # While the actual merge portion of weave merge uses a set() of
2119
2302
        filtered_parent_map = {}
2120
2303
        child_map = {}
2121
2304
        tails = []
2122
 
        for key, parent_keys in parent_map.iteritems():
 
2305
        for key, parent_keys in viewitems(parent_map):
2123
2306
            culled_parent_keys = [p for p in parent_keys if p in parent_map]
2124
2307
            if not culled_parent_keys:
2125
2308
                tails.append(key)
2175
2358
        return all_texts
2176
2359
 
2177
2360
    def _build_weave(self):
2178
 
        from bzrlib import weave
 
2361
        from .bzr import weave
2179
2362
        self._weave = weave.Weave(weave_name='in_memory_weave',
2180
2363
                                  allow_reserved=True)
2181
2364
        parent_map = self._find_recursive_lcas()
2229
2412
class _PlanLCAMerge(_PlanMergeBase):
2230
2413
    """
2231
2414
    This merge algorithm differs from _PlanMerge in that:
 
2415
 
2232
2416
    1. comparisons are done against LCAs only
2233
2417
    2. cases where a contested line is new versus one LCA but old versus
2234
2418
       another are marked as conflicts, by emitting the line as conflicted-a
2275
2459
 
2276
2460
        If a line is killed and new, this indicates that the two merge
2277
2461
        revisions contain differing conflict resolutions.
 
2462
 
2278
2463
        :param revision_id: The id of the revision in which the lines are
2279
2464
            unique
2280
2465
        :param unique_line_numbers: The line numbers of unique lines.
2281
 
        :return a tuple of (new_this, killed_other):
 
2466
        :return: a tuple of (new_this, killed_other)
2282
2467
        """
2283
2468
        new = set()
2284
2469
        killed = set()