/brz/remove-bazaar

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

« back to all changes in this revision

Viewing changes to bzrlib/merge.py

  • Committer: Andrew Bennetts
  • Date: 2010-01-15 03:58:20 UTC
  • mfrom: (4963 +trunk)
  • mto: (4973.1.1 integration)
  • mto: This revision was merged to the branch mainline in revision 4975.
  • Revision ID: andrew.bennetts@canonical.com-20100115035820-ilb3t36swgzq6v1l
Merge lp:bzr.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/merge.py
1
 
# Copyright (C) 2005-2010 Canonical Ltd
 
1
# Copyright (C) 2005, 2006, 2008 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
14
14
# along with this program; if not, write to the Free Software
15
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
16
 
17
 
import warnings
18
17
 
19
18
from bzrlib import (
20
19
    branch as _mod_branch,
27
26
    merge3,
28
27
    osutils,
29
28
    patiencediff,
 
29
    progress,
30
30
    revision as _mod_revision,
31
31
    textfile,
32
32
    trace,
36
36
    ui,
37
37
    versionedfile
38
38
    )
39
 
from bzrlib.cleanup import OperationWithCleanups
40
39
from bzrlib.symbol_versioning import (
41
40
    deprecated_in,
42
41
    deprecated_method,
46
45
 
47
46
def transform_tree(from_tree, to_tree, interesting_ids=None):
48
47
    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)
 
48
    try:
 
49
        merge_inner(from_tree.branch, to_tree, from_tree, ignore_zero=True,
 
50
                    interesting_ids=interesting_ids, this_tree=from_tree)
 
51
    finally:
 
52
        from_tree.unlock()
53
53
 
54
54
 
55
55
class MergeHooks(hooks.Hooks):
57
57
    def __init__(self):
58
58
        hooks.Hooks.__init__(self)
59
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.",
 
60
            "Called when file content needs to be merged (including when one "
 
61
            "side has deleted the file and the other has changed it)."
 
62
            "merge_file_content is called with a "
 
63
            "bzrlib.merge.MergeHookParams. The function should return a tuple "
 
64
            "of (status, lines), where status is one of 'not_applicable', "
 
65
            "'success', 'conflicted', or 'delete'.  If status is success or "
 
66
            "conflicted, then lines should be an iterable of the new lines "
 
67
            "for the file.",
69
68
            (2, 1), None))
70
69
 
71
70
 
72
 
class AbstractPerFileMerger(object):
73
 
    """PerFileMerger objects are used by plugins extending merge for bzrlib.
74
 
 
75
 
    See ``bzrlib.plugins.news_merge.news_merge`` for an example concrete class.
76
 
    
77
 
    :ivar merger: The Merge3Merger performing the merge.
78
 
    """
79
 
 
80
 
    def __init__(self, merger):
81
 
        """Create a PerFileMerger for use with merger."""
82
 
        self.merger = merger
83
 
 
84
 
    def merge_contents(self, merge_params):
85
 
        """Attempt to merge the contents of a single file.
86
 
        
87
 
        :param merge_params: A bzrlib.merge.MergeHookParams
88
 
        :return : A tuple of (status, chunks), where status is one of
89
 
            'not_applicable', 'success', 'conflicted', or 'delete'.  If status
90
 
            is 'success' or 'conflicted', then chunks should be an iterable of
91
 
            strings for the new file contents.
92
 
        """
93
 
        return ('not applicable', None)
94
 
 
95
 
 
96
 
class PerFileMerger(AbstractPerFileMerger):
97
 
    """Merge individual files when self.file_matches returns True.
98
 
 
99
 
    This class is intended to be subclassed.  The file_matches and
100
 
    merge_matching methods should be overridden with concrete implementations.
101
 
    """
102
 
 
103
 
    def file_matches(self, params):
104
 
        """Return True if merge_matching should be called on this file.
105
 
 
106
 
        Only called with merges of plain files with no clear winner.
107
 
 
108
 
        Subclasses must override this.
109
 
        """
110
 
        raise NotImplementedError(self.file_matches)
111
 
 
112
 
    def get_filename(self, params, tree):
113
 
        """Lookup the filename (i.e. basename, not path), given a Tree (e.g.
114
 
        self.merger.this_tree) and a MergeHookParams.
115
 
        """
116
 
        return osutils.basename(tree.id2path(params.file_id))
117
 
 
118
 
    def get_filepath(self, params, tree):
119
 
        """Calculate the path to the file in a tree.
120
 
 
121
 
        :param params: A MergeHookParams describing the file to merge
122
 
        :param tree: a Tree, e.g. self.merger.this_tree.
123
 
        """
124
 
        return tree.id2path(params.file_id)
125
 
 
126
 
    def merge_contents(self, params):
127
 
        """Merge the contents of a single file."""
128
 
        # Check whether this custom merge logic should be used.
129
 
        if (
130
 
            # OTHER is a straight winner, rely on default merge.
131
 
            params.winner == 'other' or
132
 
            # THIS and OTHER aren't both files.
133
 
            not params.is_file_merge() or
134
 
            # The filename doesn't match *.xml
135
 
            not self.file_matches(params)):
136
 
            return 'not_applicable', None
137
 
        return self.merge_matching(params)
138
 
 
139
 
    def merge_matching(self, params):
140
 
        """Merge the contents of a single file that has matched the criteria
141
 
        in PerFileMerger.merge_contents (is a conflict, is a file,
142
 
        self.file_matches is True).
143
 
 
144
 
        Subclasses must override this.
145
 
        """
146
 
        raise NotImplementedError(self.merge_matching)
147
 
 
148
 
 
149
 
class ConfigurableFileMerger(PerFileMerger):
150
 
    """Merge individual files when configured via a .conf file.
151
 
 
152
 
    This is a base class for concrete custom file merging logic. Concrete
153
 
    classes should implement ``merge_text``.
154
 
 
155
 
    See ``bzrlib.plugins.news_merge.news_merge`` for an example concrete class.
156
 
    
157
 
    :ivar affected_files: The configured file paths to merge.
158
 
 
159
 
    :cvar name_prefix: The prefix to use when looking up configuration
160
 
        details. <name_prefix>_merge_files describes the files targeted by the
161
 
        hook for example.
162
 
        
163
 
    :cvar default_files: The default file paths to merge when no configuration
164
 
        is present.
165
 
    """
166
 
 
167
 
    name_prefix = None
168
 
    default_files = None
169
 
 
170
 
    def __init__(self, merger):
171
 
        super(ConfigurableFileMerger, self).__init__(merger)
172
 
        self.affected_files = None
173
 
        self.default_files = self.__class__.default_files or []
174
 
        self.name_prefix = self.__class__.name_prefix
175
 
        if self.name_prefix is None:
176
 
            raise ValueError("name_prefix must be set.")
177
 
 
178
 
    def file_matches(self, params):
179
 
        """Check whether the file should call the merge hook.
180
 
 
181
 
        <name_prefix>_merge_files configuration variable is a list of files
182
 
        that should use the hook.
183
 
        """
184
 
        affected_files = self.affected_files
185
 
        if affected_files is None:
186
 
            config = self.merger.this_branch.get_config()
187
 
            # Until bzr provides a better policy for caching the config, we
188
 
            # just add the part we're interested in to the params to avoid
189
 
            # reading the config files repeatedly (bazaar.conf, location.conf,
190
 
            # branch.conf).
191
 
            config_key = self.name_prefix + '_merge_files'
192
 
            affected_files = config.get_user_option_as_list(config_key)
193
 
            if affected_files is None:
194
 
                # If nothing was specified in the config, use the default.
195
 
                affected_files = self.default_files
196
 
            self.affected_files = affected_files
197
 
        if affected_files:
198
 
            filepath = self.get_filepath(params, self.merger.this_tree)
199
 
            if filepath in affected_files:
200
 
                return True
201
 
        return False
202
 
 
203
 
    def merge_matching(self, params):
204
 
        return self.merge_text(params)
205
 
 
206
 
    def merge_text(self, params):
207
 
        """Merge the byte contents of a single file.
208
 
 
209
 
        This is called after checking that the merge should be performed in
210
 
        merge_contents, and it should behave as per
211
 
        ``bzrlib.merge.AbstractPerFileMerger.merge_contents``.
212
 
        """
213
 
        raise NotImplementedError(self.merge_text)
214
 
 
215
 
 
216
71
class MergeHookParams(object):
217
72
    """Object holding parameters passed to merge_file_content hooks.
218
73
 
219
 
    There are some fields hooks can access:
 
74
    There are 3 fields hooks can access:
220
75
 
 
76
    :ivar merger: the Merger object
221
77
    :ivar file_id: the file ID of the file being merged
222
 
    :ivar trans_id: the transform ID for the merge of this file
223
 
    :ivar this_kind: kind of file_id in 'this' tree
224
 
    :ivar other_kind: kind of file_id in 'other' tree
225
 
    :ivar winner: one of 'this', 'other', 'conflict'
 
78
    :ivar trans_id: the transform ID for the merge of this file.
 
79
 
 
80
    The lines of versions of the file being merged can be retrieved from the
 
81
    merger, e.g.::
 
82
 
 
83
        params.merger.get_lines(params.merger.this_tree, params.file_id)
226
84
    """
227
85
 
228
 
    def __init__(self, merger, file_id, trans_id, this_kind, other_kind,
 
86
    def __init__(self, merger, file_id, trans_id, this_pair, other_pair,
229
87
            winner):
230
 
        self._merger = merger
 
88
        self.merger = merger
231
89
        self.file_id = file_id
232
90
        self.trans_id = trans_id
233
 
        self.this_kind = this_kind
234
 
        self.other_kind = other_kind
 
91
        self.this_pair = this_pair
 
92
        self.other_pair = other_pair
235
93
        self.winner = winner
236
 
 
 
94
        
237
95
    def is_file_merge(self):
238
 
        """True if this_kind and other_kind are both 'file'."""
239
 
        return self.this_kind == 'file' and self.other_kind == 'file'
240
 
 
 
96
        return self.this_pair[0] == 'file' and self.other_pair[0] == 'file'
 
97
    
241
98
    @decorators.cachedproperty
242
99
    def base_lines(self):
243
100
        """The lines of the 'base' version of the file."""
244
 
        return self._merger.get_lines(self._merger.base_tree, self.file_id)
 
101
        return self.merger.get_lines(self.merger.base_tree, self.file_id)
245
102
 
246
103
    @decorators.cachedproperty
247
104
    def this_lines(self):
248
105
        """The lines of the 'this' version of the file."""
249
 
        return self._merger.get_lines(self._merger.this_tree, self.file_id)
 
106
        return self.merger.get_lines(self.merger.this_tree, self.file_id)
250
107
 
251
108
    @decorators.cachedproperty
252
109
    def other_lines(self):
253
110
        """The lines of the 'other' version of the file."""
254
 
        return self._merger.get_lines(self._merger.other_tree, self.file_id)
 
111
        return self.merger.get_lines(self.merger.other_tree, self.file_id)
255
112
 
256
113
 
257
114
class Merger(object):
278
135
        self.interesting_files = None
279
136
        self.show_base = False
280
137
        self.reprocess = False
281
 
        if pb is not None:
282
 
            warnings.warn("pb parameter to Merger() is deprecated and ignored")
 
138
        if pb is None:
 
139
            pb = progress.DummyProgress()
 
140
        self._pb = pb
283
141
        self.pp = None
284
142
        self.recurse = recurse
285
143
        self.change_reporter = change_reporter
495
353
    def _add_parent(self):
496
354
        new_parents = self.this_tree.get_parent_ids() + [self.other_rev_id]
497
355
        new_parent_trees = []
498
 
        operation = OperationWithCleanups(self.this_tree.set_parent_trees)
499
356
        for revision_id in new_parents:
500
357
            try:
501
358
                tree = self.revision_tree(revision_id)
503
360
                tree = None
504
361
            else:
505
362
                tree.lock_read()
506
 
                operation.add_cleanup(tree.unlock)
507
363
            new_parent_trees.append((revision_id, tree))
508
 
        operation.run_simple(new_parent_trees, allow_leftmost_as_ghost=True)
 
364
        try:
 
365
            self.this_tree.set_parent_trees(new_parent_trees,
 
366
                                            allow_leftmost_as_ghost=True)
 
367
        finally:
 
368
            for _revision_id, tree in new_parent_trees:
 
369
                if tree is not None:
 
370
                    tree.unlock()
509
371
 
510
372
    def set_other(self, other_revision, possible_transports=None):
511
373
        """Set the revision and tree to merge from.
634
496
                  'other_tree': self.other_tree,
635
497
                  'interesting_ids': self.interesting_ids,
636
498
                  'interesting_files': self.interesting_files,
637
 
                  'this_branch': self.this_branch,
 
499
                  'pp': self.pp,
638
500
                  'do_merge': False}
639
501
        if self.merge_type.requires_base:
640
502
            kwargs['base_tree'] = self.base_tree
658
520
        if self._is_criss_cross and getattr(self.merge_type,
659
521
                                            'supports_lca_trees', False):
660
522
            kwargs['lca_trees'] = self._lca_trees
661
 
        return self.merge_type(pb=None,
 
523
        return self.merge_type(pb=self._pb,
662
524
                               change_reporter=self.change_reporter,
663
525
                               **kwargs)
664
526
 
665
 
    def _do_merge_to(self):
666
 
        merge = self.make_merger()
 
527
    def _do_merge_to(self, merge):
667
528
        if self.other_branch is not None:
668
529
            self.other_branch.update_references(self.this_branch)
669
530
        merge.do_merge()
683
544
                    sub_tree.branch.repository.revision_tree(base_revision)
684
545
                sub_merge.base_rev_id = base_revision
685
546
                sub_merge.do_merge()
686
 
        return merge
687
547
 
688
548
    def do_merge(self):
689
 
        operation = OperationWithCleanups(self._do_merge_to)
690
549
        self.this_tree.lock_tree_write()
691
 
        operation.add_cleanup(self.this_tree.unlock)
692
 
        if self.base_tree is not None:
693
 
            self.base_tree.lock_read()
694
 
            operation.add_cleanup(self.base_tree.unlock)
695
 
        if self.other_tree is not None:
696
 
            self.other_tree.lock_read()
697
 
            operation.add_cleanup(self.other_tree.unlock)
698
 
        merge = operation.run_simple()
 
550
        try:
 
551
            if self.base_tree is not None:
 
552
                self.base_tree.lock_read()
 
553
            try:
 
554
                if self.other_tree is not None:
 
555
                    self.other_tree.lock_read()
 
556
                try:
 
557
                    merge = self.make_merger()
 
558
                    self._do_merge_to(merge)
 
559
                finally:
 
560
                    if self.other_tree is not None:
 
561
                        self.other_tree.unlock()
 
562
            finally:
 
563
                if self.base_tree is not None:
 
564
                    self.base_tree.unlock()
 
565
        finally:
 
566
            self.this_tree.unlock()
699
567
        if len(merge.cooked_conflicts) == 0:
700
568
            if not self.ignore_zero and not trace.is_quiet():
701
569
                trace.note("All changes applied successfully.")
736
604
 
737
605
    def __init__(self, working_tree, this_tree, base_tree, other_tree,
738
606
                 interesting_ids=None, reprocess=False, show_base=False,
739
 
                 pb=None, pp=None, change_reporter=None,
 
607
                 pb=progress.DummyProgress(), pp=None, change_reporter=None,
740
608
                 interesting_files=None, do_merge=True,
741
 
                 cherrypick=False, lca_trees=None, this_branch=None):
 
609
                 cherrypick=False, lca_trees=None):
742
610
        """Initialize the merger object and perform the merge.
743
611
 
744
612
        :param working_tree: The working tree to apply the merge to
745
613
        :param this_tree: The local tree in the merge operation
746
614
        :param base_tree: The common tree in the merge operation
747
615
        :param other_tree: The other tree to merge changes from
748
 
        :param this_branch: The branch associated with this_tree.  Defaults to
749
 
            this_tree.branch if not supplied.
750
616
        :param interesting_ids: The file_ids of files that should be
751
617
            participate in the merge.  May not be combined with
752
618
            interesting_files.
753
619
        :param: reprocess If True, perform conflict-reduction processing.
754
620
        :param show_base: If True, show the base revision in text conflicts.
755
621
            (incompatible with reprocess)
756
 
        :param pb: ignored
 
622
        :param pb: A Progress bar
757
623
        :param pp: A ProgressPhase object
758
624
        :param change_reporter: An object that should report changes made
759
625
        :param interesting_files: The tree-relative paths of files that should
770
636
        if interesting_files is not None and interesting_ids is not None:
771
637
            raise ValueError(
772
638
                'specify either interesting_ids or interesting_files')
773
 
        if this_branch is None:
774
 
            this_branch = this_tree.branch
775
639
        self.interesting_ids = interesting_ids
776
640
        self.interesting_files = interesting_files
777
641
        self.this_tree = working_tree
778
642
        self.base_tree = base_tree
779
643
        self.other_tree = other_tree
780
 
        self.this_branch = this_branch
781
644
        self._raw_conflicts = []
782
645
        self.cooked_conflicts = []
783
646
        self.reprocess = reprocess
788
651
        # making sure we haven't missed any corner cases.
789
652
        # if lca_trees is None:
790
653
        #     self._lca_trees = [self.base_tree]
 
654
        self.pb = pb
 
655
        self.pp = pp
791
656
        self.change_reporter = change_reporter
792
657
        self.cherrypick = cherrypick
 
658
        if self.pp is None:
 
659
            self.pp = progress.ProgressPhase("Merge phase", 3, self.pb)
793
660
        if do_merge:
794
661
            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
662
 
800
663
    def do_merge(self):
801
 
        operation = OperationWithCleanups(self._do_merge)
802
664
        self.this_tree.lock_tree_write()
803
 
        operation.add_cleanup(self.this_tree.unlock)
804
665
        self.base_tree.lock_read()
805
 
        operation.add_cleanup(self.base_tree.unlock)
806
666
        self.other_tree.lock_read()
807
 
        operation.add_cleanup(self.other_tree.unlock)
808
 
        operation.run()
809
 
 
810
 
    def _do_merge(self, operation):
811
 
        self.tt = transform.TreeTransform(self.this_tree, None)
812
 
        operation.add_cleanup(self.tt.finalize)
813
 
        self._compute_transform()
814
 
        results = self.tt.apply(no_conflicts=True)
815
 
        self.write_modified(results)
816
667
        try:
817
 
            self.this_tree.add_conflicts(self.cooked_conflicts)
818
 
        except errors.UnsupportedOperation:
819
 
            pass
 
668
            self.tt = transform.TreeTransform(self.this_tree, self.pb)
 
669
            try:
 
670
                self.pp.next_phase()
 
671
                self._compute_transform()
 
672
                self.pp.next_phase()
 
673
                results = self.tt.apply(no_conflicts=True)
 
674
                self.write_modified(results)
 
675
                try:
 
676
                    self.this_tree.add_conflicts(self.cooked_conflicts)
 
677
                except errors.UnsupportedOperation:
 
678
                    pass
 
679
            finally:
 
680
                self.tt.finalize()
 
681
        finally:
 
682
            self.other_tree.unlock()
 
683
            self.base_tree.unlock()
 
684
            self.this_tree.unlock()
 
685
            self.pb.clear()
820
686
 
821
687
    def make_preview_transform(self):
822
 
        operation = OperationWithCleanups(self._make_preview_transform)
823
688
        self.base_tree.lock_read()
824
 
        operation.add_cleanup(self.base_tree.unlock)
825
689
        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
690
        self.tt = transform.TransformPreview(self.this_tree)
831
 
        self._compute_transform()
 
691
        try:
 
692
            self.pp.next_phase()
 
693
            self._compute_transform()
 
694
            self.pp.next_phase()
 
695
        finally:
 
696
            self.other_tree.unlock()
 
697
            self.base_tree.unlock()
 
698
            self.pb.clear()
832
699
        return self.tt
833
700
 
834
701
    def _compute_transform(self):
840
707
            resolver = self._lca_multi_way
841
708
        child_pb = ui.ui_factory.nested_progress_bar()
842
709
        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
710
            for num, (file_id, changed, parents3, names3,
847
711
                      executable3) in enumerate(entries):
848
712
                child_pb.update('Preparing file merge', num, len(entries))
849
713
                self._merge_names(file_id, parents3, names3, resolver=resolver)
850
714
                if changed:
851
 
                    file_status = self._do_merge_contents(file_id)
 
715
                    file_status = self.merge_contents(file_id)
852
716
                else:
853
717
                    file_status = 'unmodified'
854
718
                self._merge_executable(file_id,
856
720
        finally:
857
721
            child_pb.finished()
858
722
        self.fix_root()
 
723
        self.pp.next_phase()
859
724
        child_pb = ui.ui_factory.nested_progress_bar()
860
725
        try:
861
726
            fs_conflicts = transform.resolve_conflicts(self.tt, child_pb,
1059
924
                        continue
1060
925
                else:
1061
926
                    raise AssertionError('unhandled kind: %s' % other_ie.kind)
 
927
                # XXX: We need to handle kind == 'symlink'
1062
928
 
1063
929
            # If we have gotten this far, that means something has changed
1064
930
            result.append((file_id, content_changed,
1086
952
        other_root = self.tt.trans_id_file_id(other_root_file_id)
1087
953
        if other_root == self.tt.root:
1088
954
            return
 
955
        try:
 
956
            self.tt.final_kind(other_root)
 
957
        except errors.NoSuchFile:
 
958
            return
1089
959
        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)
 
960
            # the other tree's root is a non-root in the current tree
1092
961
            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():
 
962
        self.reparent_children(self.other_tree.inventory.root, self.tt.root)
 
963
        self.tt.cancel_creation(other_root)
 
964
        self.tt.cancel_versioning(other_root)
 
965
 
 
966
    def reparent_children(self, ie, target):
 
967
        for thing, child in ie.children.iteritems():
1104
968
            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)
 
969
            self.tt.adjust_path(self.tt.final_name(trans_id), target, trans_id)
1121
970
 
1122
971
    def write_modified(self, results):
1123
972
        modified_hashes = {}
1155
1004
    @staticmethod
1156
1005
    def executable(tree, file_id):
1157
1006
        """Determine the executability of a file-id (used as a key method)."""
1158
 
        if not tree.has_id(file_id):
 
1007
        if file_id not in tree:
1159
1008
            return None
1160
1009
        if tree.kind(file_id) != "file":
1161
1010
            return False
1164
1013
    @staticmethod
1165
1014
    def kind(tree, file_id):
1166
1015
        """Determine the kind of a file-id (used as a key method)."""
1167
 
        if not tree.has_id(file_id):
 
1016
        if file_id not in tree:
1168
1017
            return None
1169
1018
        return tree.kind(file_id)
1170
1019
 
1171
1020
    @staticmethod
1172
1021
    def _three_way(base, other, this):
 
1022
        #if base == other, either they all agree, or only THIS has changed.
1173
1023
        if base == other:
1174
 
            # if 'base == other', either they all agree, or only 'this' has
1175
 
            # changed.
1176
1024
            return 'this'
1177
1025
        elif this not in (base, other):
1178
 
            # 'this' is neither 'base' nor 'other', so both sides changed
1179
1026
            return 'conflict'
 
1027
        # "Ambiguous clean merge" -- both sides have made the same change.
1180
1028
        elif this == other:
1181
 
            # "Ambiguous clean merge" -- both sides have made the same change.
1182
1029
            return "this"
 
1030
        # this == base: only other has changed.
1183
1031
        else:
1184
 
            # this == base: only other has changed.
1185
1032
            return "other"
1186
1033
 
1187
1034
    @staticmethod
1231
1078
                # only has an lca value
1232
1079
                return 'other'
1233
1080
 
1234
 
        # At this point, the lcas disagree, and the tip disagree
 
1081
        # At this point, the lcas disagree, and the tips disagree
1235
1082
        return 'conflict'
1236
1083
 
1237
1084
    @staticmethod
1238
 
    @deprecated_method(deprecated_in((2, 2, 0)))
1239
1085
    def scalar_three_way(this_tree, base_tree, other_tree, file_id, key):
1240
1086
        """Do a three-way test on a scalar.
1241
1087
        Return "this", "other" or "conflict", depending whether a value wins.
1256
1102
 
1257
1103
    def merge_names(self, file_id):
1258
1104
        def get_entry(tree):
1259
 
            if tree.has_id(file_id):
 
1105
            if file_id in tree.inventory:
1260
1106
                return tree.inventory[file_id]
1261
1107
            else:
1262
1108
                return None
1291
1137
                parent_id_winner = "other"
1292
1138
        if name_winner == "this" and parent_id_winner == "this":
1293
1139
            return
1294
 
        if name_winner == 'conflict' or parent_id_winner == 'conflict':
1295
 
            # Creating helpers (.OTHER or .THIS) here cause problems down the
1296
 
            # road if a ContentConflict needs to be created so we should not do
1297
 
            # that
1298
 
            trans_id = self.tt.trans_id_file_id(file_id)
1299
 
            self._raw_conflicts.append(('path conflict', trans_id, file_id,
1300
 
                                        this_parent, this_name,
1301
 
                                        other_parent, other_name))
 
1140
        if name_winner == "conflict":
 
1141
            trans_id = self.tt.trans_id_file_id(file_id)
 
1142
            self._raw_conflicts.append(('name conflict', trans_id,
 
1143
                                        this_name, other_name))
 
1144
        if parent_id_winner == "conflict":
 
1145
            trans_id = self.tt.trans_id_file_id(file_id)
 
1146
            self._raw_conflicts.append(('parent conflict', trans_id,
 
1147
                                        this_parent, other_parent))
1302
1148
        if other_name is None:
1303
1149
            # it doesn't matter whether the result was 'other' or
1304
1150
            # 'conflict'-- if there's no 'other', we leave it alone.
1305
1151
            return
 
1152
        # if we get here, name_winner and parent_winner are set to safe values.
 
1153
        trans_id = self.tt.trans_id_file_id(file_id)
1306
1154
        parent_id = parents[self.winner_idx[parent_id_winner]]
1307
1155
        if parent_id is not None:
1308
 
            # if we get here, name_winner and parent_winner are set to safe
1309
 
            # values.
 
1156
            parent_trans_id = self.tt.trans_id_file_id(parent_id)
1310
1157
            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))
 
1158
                                parent_trans_id, trans_id)
1313
1159
 
1314
 
    def _do_merge_contents(self, file_id):
 
1160
    def merge_contents(self, file_id):
1315
1161
        """Performs a merge on file_id contents."""
1316
1162
        def contents_pair(tree):
1317
1163
            if file_id not in tree:
1349
1195
        # We have a hypothetical conflict, but if we have files, then we
1350
1196
        # can try to merge the content
1351
1197
        trans_id = self.tt.trans_id_file_id(file_id)
1352
 
        params = MergeHookParams(self, file_id, trans_id, this_pair[0],
1353
 
            other_pair[0], winner)
1354
 
        hooks = self.active_hooks
 
1198
        params = MergeHookParams(self, file_id, trans_id, this_pair,
 
1199
            other_pair, winner)
 
1200
        hooks = Merger.hooks['merge_file_content']
 
1201
        hooks = list(hooks) + [self.default_text_merge]
1355
1202
        hook_status = 'not_applicable'
1356
1203
        for hook in hooks:
1357
 
            hook_status, lines = hook.merge_contents(params)
 
1204
            hook_status, lines = hook(params)
1358
1205
            if hook_status != 'not_applicable':
1359
1206
                # Don't try any more hooks, this one applies.
1360
1207
                break
1365
1212
            result = None
1366
1213
            name = self.tt.final_name(trans_id)
1367
1214
            parent_id = self.tt.final_parent(trans_id)
1368
 
            if self.this_tree.has_id(file_id):
 
1215
            if file_id in self.this_tree.inventory:
1369
1216
                self.tt.unversion_file(trans_id)
1370
1217
            file_group = self._dump_conflicts(name, parent_id, file_id,
1371
1218
                                              set_version=True)
1379
1226
            self._raw_conflicts.append(('text conflict', trans_id))
1380
1227
            name = self.tt.final_name(trans_id)
1381
1228
            parent_id = self.tt.final_parent(trans_id)
1382
 
            self._dump_conflicts(name, parent_id, file_id)
 
1229
            file_group = self._dump_conflicts(name, parent_id, file_id)
 
1230
            file_group.append(trans_id)
1383
1231
        elif hook_status == 'delete':
1384
1232
            self.tt.unversion_file(trans_id)
1385
1233
            result = "deleted"
1389
1237
            pass
1390
1238
        else:
1391
1239
            raise AssertionError('unknown hook_status: %r' % (hook_status,))
1392
 
        if not self.this_tree.has_id(file_id) and result == "modified":
 
1240
        if file_id not in self.this_tree and result == "modified":
1393
1241
            self.tt.version_file(file_id, trans_id)
1394
 
        # The merge has been performed, so the old contents should not be
1395
 
        # retained.
1396
1242
        try:
 
1243
            self.tt.tree_kind(trans_id)
1397
1244
            self.tt.delete_contents(trans_id)
1398
1245
        except errors.NoSuchFile:
1399
1246
            pass
1403
1250
        """Replace this contents with other."""
1404
1251
        file_id = merge_hook_params.file_id
1405
1252
        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):
 
1253
        file_in_this = file_id in self.this_tree
 
1254
        if file_id in self.other_tree:
1408
1255
            # OTHER changed the file
1409
1256
            wt = self.this_tree
1410
1257
            if wt.supports_content_filtering():
1431
1278
                'winner is OTHER, but file_id %r not in THIS or OTHER tree'
1432
1279
                % (file_id,))
1433
1280
 
1434
 
    def merge_contents(self, merge_hook_params):
1435
 
        """Fallback merge logic after user installed hooks."""
1436
 
        # This function is used in merge hooks as the fallback instance.
1437
 
        # Perhaps making this function and the functions it calls be a 
1438
 
        # a separate class would be better.
 
1281
    def default_text_merge(self, merge_hook_params):
1439
1282
        if merge_hook_params.winner == 'other':
1440
1283
            # OTHER is a straight winner, so replace this contents with other
1441
1284
            return self._default_other_winner_merge(merge_hook_params)
1454
1297
 
1455
1298
    def get_lines(self, tree, file_id):
1456
1299
        """Return the lines in a file, or an empty list."""
1457
 
        if tree.has_id(file_id):
 
1300
        if file_id in tree:
1458
1301
            return tree.get_file(file_id).readlines()
1459
1302
        else:
1460
1303
            return []
1463
1306
        """Perform a three-way text merge on a file_id"""
1464
1307
        # it's possible that we got here with base as a different type.
1465
1308
        # if so, we just want two-way text conflicts.
1466
 
        if self.base_tree.has_id(file_id) and \
 
1309
        if file_id in self.base_tree and \
1467
1310
            self.base_tree.kind(file_id) == "file":
1468
1311
            base_lines = self.get_lines(self.base_tree, file_id)
1469
1312
        else:
1532
1375
        versioned = False
1533
1376
        file_group = []
1534
1377
        for suffix, tree, lines in data:
1535
 
            if tree.has_id(file_id):
 
1378
            if file_id in tree:
1536
1379
                trans_id = self._conflict_file(name, parent_id, tree, file_id,
1537
1380
                                               suffix, lines, filter_tree_path)
1538
1381
                file_group.append(trans_id)
1582
1425
        if winner == "this":
1583
1426
            executability = this_executable
1584
1427
        else:
1585
 
            if self.other_tree.has_id(file_id):
 
1428
            if file_id in self.other_tree:
1586
1429
                executability = other_executable
1587
 
            elif self.this_tree.has_id(file_id):
 
1430
            elif file_id in self.this_tree:
1588
1431
                executability = this_executable
1589
 
            elif self.base_tree_has_id(file_id):
 
1432
            elif file_id in self.base_tree:
1590
1433
                executability = base_executable
1591
1434
        if executability is not None:
1592
1435
            trans_id = self.tt.trans_id_file_id(file_id)
1594
1437
 
1595
1438
    def cook_conflicts(self, fs_conflicts):
1596
1439
        """Convert all conflicts into a form that doesn't depend on trans_id"""
 
1440
        name_conflicts = {}
1597
1441
        self.cooked_conflicts.extend(transform.cook_conflicts(
1598
1442
                fs_conflicts, self.tt))
1599
1443
        fp = transform.FinalPaths(self.tt)
1600
1444
        for conflict in self._raw_conflicts:
1601
1445
            conflict_type = conflict[0]
1602
 
            if conflict_type == 'path conflict':
1603
 
                (trans_id, file_id,
1604
 
                this_parent, this_name,
1605
 
                other_parent, other_name) = conflict[1:]
1606
 
                if this_parent is None or this_name is None:
1607
 
                    this_path = '<deleted>'
1608
 
                else:
1609
 
                    parent_path =  fp.get_path(
1610
 
                        self.tt.trans_id_file_id(this_parent))
1611
 
                    this_path = osutils.pathjoin(parent_path, this_name)
1612
 
                if other_parent is None or other_name is None:
1613
 
                    other_path = '<deleted>'
1614
 
                else:
1615
 
                    parent_path =  fp.get_path(
1616
 
                        self.tt.trans_id_file_id(other_parent))
1617
 
                    other_path = osutils.pathjoin(parent_path, other_name)
1618
 
                c = _mod_conflicts.Conflict.factory(
1619
 
                    'path conflict', path=this_path,
1620
 
                    conflict_path=other_path,
1621
 
                    file_id=file_id)
1622
 
            elif conflict_type == 'contents conflict':
 
1446
            if conflict_type in ('name conflict', 'parent conflict'):
 
1447
                trans_id = conflict[1]
 
1448
                conflict_args = conflict[2:]
 
1449
                if trans_id not in name_conflicts:
 
1450
                    name_conflicts[trans_id] = {}
 
1451
                transform.unique_add(name_conflicts[trans_id], conflict_type,
 
1452
                                     conflict_args)
 
1453
            if conflict_type == 'contents conflict':
1623
1454
                for trans_id in conflict[1]:
1624
1455
                    file_id = self.tt.final_file_id(trans_id)
1625
1456
                    if file_id is not None:
1631
1462
                        break
1632
1463
                c = _mod_conflicts.Conflict.factory(conflict_type,
1633
1464
                                                    path=path, file_id=file_id)
1634
 
            elif conflict_type == 'text conflict':
 
1465
                self.cooked_conflicts.append(c)
 
1466
            if conflict_type == 'text conflict':
1635
1467
                trans_id = conflict[1]
1636
1468
                path = fp.get_path(trans_id)
1637
1469
                file_id = self.tt.final_file_id(trans_id)
1638
1470
                c = _mod_conflicts.Conflict.factory(conflict_type,
1639
1471
                                                    path=path, file_id=file_id)
 
1472
                self.cooked_conflicts.append(c)
 
1473
 
 
1474
        for trans_id, conflicts in name_conflicts.iteritems():
 
1475
            try:
 
1476
                this_parent, other_parent = conflicts['parent conflict']
 
1477
                if this_parent == other_parent:
 
1478
                    raise AssertionError()
 
1479
            except KeyError:
 
1480
                this_parent = other_parent = \
 
1481
                    self.tt.final_file_id(self.tt.final_parent(trans_id))
 
1482
            try:
 
1483
                this_name, other_name = conflicts['name conflict']
 
1484
                if this_name == other_name:
 
1485
                    raise AssertionError()
 
1486
            except KeyError:
 
1487
                this_name = other_name = self.tt.final_name(trans_id)
 
1488
            other_path = fp.get_path(trans_id)
 
1489
            if this_parent is not None and this_name is not None:
 
1490
                this_parent_path = \
 
1491
                    fp.get_path(self.tt.trans_id_file_id(this_parent))
 
1492
                this_path = osutils.pathjoin(this_parent_path, this_name)
1640
1493
            else:
1641
 
                raise AssertionError('bad conflict type: %r' % (conflict,))
 
1494
                this_path = "<deleted>"
 
1495
            file_id = self.tt.final_file_id(trans_id)
 
1496
            c = _mod_conflicts.Conflict.factory('path conflict', path=this_path,
 
1497
                                                conflict_path=other_path,
 
1498
                                                file_id=file_id)
1642
1499
            self.cooked_conflicts.append(c)
1643
1500
        self.cooked_conflicts.sort(key=_mod_conflicts.Conflict.sort_key)
1644
1501
 
1759
1616
                other_rev_id=None,
1760
1617
                interesting_files=None,
1761
1618
                this_tree=None,
1762
 
                pb=None,
 
1619
                pb=progress.DummyProgress(),
1763
1620
                change_reporter=None):
1764
1621
    """Primary interface for merging.
1765
1622