/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: 2019-07-12 01:01:45 UTC
  • mto: This revision was merged to the branch mainline in revision 7375.
  • Revision ID: jelmer@jelmer.uk-20190712010145-m7224qumb8w068zw
Fix importing from remote git repositories.

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