/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

Merge 2.0 into 2.1 resolving conflicts

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/merge.py
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,
93
93
        return ('not applicable', None)
94
94
 
95
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):
 
96
class ConfigurableFileMerger(AbstractPerFileMerger):
150
97
    """Merge individual files when configured via a .conf file.
151
98
 
152
99
    This is a base class for concrete custom file merging logic. Concrete
175
122
        if self.name_prefix is None:
176
123
            raise ValueError("name_prefix must be set.")
177
124
 
178
 
    def file_matches(self, params):
 
125
    def filename_matches_config(self, params):
179
126
        """Check whether the file should call the merge hook.
180
127
 
181
128
        <name_prefix>_merge_files configuration variable is a list of files
195
142
                affected_files = self.default_files
196
143
            self.affected_files = affected_files
197
144
        if affected_files:
198
 
            filepath = self.get_filepath(params, self.merger.this_tree)
199
 
            if filepath in affected_files:
 
145
            filename = self.merger.this_tree.id2path(params.file_id)
 
146
            if filename in affected_files:
200
147
                return True
201
148
        return False
202
149
 
203
 
    def merge_matching(self, params):
 
150
    def merge_contents(self, params):
 
151
        """Merge the contents of a single file."""
 
152
        # First, check whether this custom merge logic should be used.  We
 
153
        # expect most files should not be merged by this handler.
 
154
        if (
 
155
            # OTHER is a straight winner, rely on default merge.
 
156
            params.winner == 'other' or
 
157
            # THIS and OTHER aren't both files.
 
158
            not params.is_file_merge() or
 
159
            # The filename isn't listed in the 'NAME_merge_files' config
 
160
            # option.
 
161
            not self.filename_matches_config(params)):
 
162
            return 'not_applicable', None
204
163
        return self.merge_text(params)
205
164
 
206
165
    def merge_text(self, params):
278
237
        self.interesting_files = None
279
238
        self.show_base = False
280
239
        self.reprocess = False
281
 
        if pb is not None:
282
 
            warnings.warn("pb parameter to Merger() is deprecated and ignored")
 
240
        if pb is None:
 
241
            pb = progress.DummyProgress()
 
242
        self._pb = pb
283
243
        self.pp = None
284
244
        self.recurse = recurse
285
245
        self.change_reporter = change_reporter
634
594
                  'other_tree': self.other_tree,
635
595
                  'interesting_ids': self.interesting_ids,
636
596
                  'interesting_files': self.interesting_files,
637
 
                  'this_branch': self.this_branch,
 
597
                  'pp': self.pp, 'this_branch': self.this_branch,
638
598
                  'do_merge': False}
639
599
        if self.merge_type.requires_base:
640
600
            kwargs['base_tree'] = self.base_tree
658
618
        if self._is_criss_cross and getattr(self.merge_type,
659
619
                                            'supports_lca_trees', False):
660
620
            kwargs['lca_trees'] = self._lca_trees
661
 
        return self.merge_type(pb=None,
 
621
        return self.merge_type(pb=self._pb,
662
622
                               change_reporter=self.change_reporter,
663
623
                               **kwargs)
664
624
 
736
696
 
737
697
    def __init__(self, working_tree, this_tree, base_tree, other_tree,
738
698
                 interesting_ids=None, reprocess=False, show_base=False,
739
 
                 pb=None, pp=None, change_reporter=None,
 
699
                 pb=progress.DummyProgress(), pp=None, change_reporter=None,
740
700
                 interesting_files=None, do_merge=True,
741
701
                 cherrypick=False, lca_trees=None, this_branch=None):
742
702
        """Initialize the merger object and perform the merge.
753
713
        :param: reprocess If True, perform conflict-reduction processing.
754
714
        :param show_base: If True, show the base revision in text conflicts.
755
715
            (incompatible with reprocess)
756
 
        :param pb: ignored
 
716
        :param pb: A Progress bar
757
717
        :param pp: A ProgressPhase object
758
718
        :param change_reporter: An object that should report changes made
759
719
        :param interesting_files: The tree-relative paths of files that should
788
748
        # making sure we haven't missed any corner cases.
789
749
        # if lca_trees is None:
790
750
        #     self._lca_trees = [self.base_tree]
 
751
        self.pb = pb
 
752
        self.pp = pp
791
753
        self.change_reporter = change_reporter
792
754
        self.cherrypick = cherrypick
 
755
        if self.pp is None:
 
756
            self.pp = progress.ProgressPhase("Merge phase", 3, self.pb)
793
757
        if do_merge:
794
758
            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
759
 
800
760
    def do_merge(self):
801
761
        operation = OperationWithCleanups(self._do_merge)
 
762
        operation.add_cleanup(self.pb.clear)
802
763
        self.this_tree.lock_tree_write()
803
764
        operation.add_cleanup(self.this_tree.unlock)
804
765
        self.base_tree.lock_read()
808
769
        operation.run()
809
770
 
810
771
    def _do_merge(self, operation):
811
 
        self.tt = transform.TreeTransform(self.this_tree, None)
 
772
        self.tt = transform.TreeTransform(self.this_tree, self.pb)
812
773
        operation.add_cleanup(self.tt.finalize)
 
774
        self.pp.next_phase()
813
775
        self._compute_transform()
 
776
        self.pp.next_phase()
814
777
        results = self.tt.apply(no_conflicts=True)
815
778
        self.write_modified(results)
816
779
        try:
820
783
 
821
784
    def make_preview_transform(self):
822
785
        operation = OperationWithCleanups(self._make_preview_transform)
 
786
        operation.add_cleanup(self.pb.clear)
823
787
        self.base_tree.lock_read()
824
788
        operation.add_cleanup(self.base_tree.unlock)
825
789
        self.other_tree.lock_read()
828
792
 
829
793
    def _make_preview_transform(self):
830
794
        self.tt = transform.TransformPreview(self.this_tree)
 
795
        self.pp.next_phase()
831
796
        self._compute_transform()
 
797
        self.pp.next_phase()
832
798
        return self.tt
833
799
 
834
800
    def _compute_transform(self):
856
822
        finally:
857
823
            child_pb.finished()
858
824
        self.fix_root()
 
825
        self.pp.next_phase()
859
826
        child_pb = ui.ui_factory.nested_progress_bar()
860
827
        try:
861
828
            fs_conflicts = transform.resolve_conflicts(self.tt, child_pb,
1059
1026
                        continue
1060
1027
                else:
1061
1028
                    raise AssertionError('unhandled kind: %s' % other_ie.kind)
 
1029
                # XXX: We need to handle kind == 'symlink'
1062
1030
 
1063
1031
            # If we have gotten this far, that means something has changed
1064
1032
            result.append((file_id, content_changed,
1170
1138
 
1171
1139
    @staticmethod
1172
1140
    def _three_way(base, other, this):
 
1141
        #if base == other, either they all agree, or only THIS has changed.
1173
1142
        if base == other:
1174
 
            # if 'base == other', either they all agree, or only 'this' has
1175
 
            # changed.
1176
1143
            return 'this'
1177
1144
        elif this not in (base, other):
1178
 
            # 'this' is neither 'base' nor 'other', so both sides changed
1179
1145
            return 'conflict'
 
1146
        # "Ambiguous clean merge" -- both sides have made the same change.
1180
1147
        elif this == other:
1181
 
            # "Ambiguous clean merge" -- both sides have made the same change.
1182
1148
            return "this"
 
1149
        # this == base: only other has changed.
1183
1150
        else:
1184
 
            # this == base: only other has changed.
1185
1151
            return "other"
1186
1152
 
1187
1153
    @staticmethod
1231
1197
                # only has an lca value
1232
1198
                return 'other'
1233
1199
 
1234
 
        # At this point, the lcas disagree, and the tip disagree
 
1200
        # At this point, the lcas disagree, and the tips disagree
1235
1201
        return 'conflict'
1236
1202
 
1237
1203
    @staticmethod
1238
 
    @deprecated_method(deprecated_in((2, 2, 0)))
1239
1204
    def scalar_three_way(this_tree, base_tree, other_tree, file_id, key):
1240
1205
        """Do a three-way test on a scalar.
1241
1206
        Return "this", "other" or "conflict", depending whether a value wins.
1291
1256
                parent_id_winner = "other"
1292
1257
        if name_winner == "this" and parent_id_winner == "this":
1293
1258
            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))
 
1259
        if name_winner == "conflict":
 
1260
            trans_id = self.tt.trans_id_file_id(file_id)
 
1261
            self._raw_conflicts.append(('name conflict', trans_id,
 
1262
                                        this_name, other_name))
 
1263
        if parent_id_winner == "conflict":
 
1264
            trans_id = self.tt.trans_id_file_id(file_id)
 
1265
            self._raw_conflicts.append(('parent conflict', trans_id,
 
1266
                                        this_parent, other_parent))
1302
1267
        if other_name is None:
1303
1268
            # it doesn't matter whether the result was 'other' or
1304
1269
            # 'conflict'-- if there's no 'other', we leave it alone.
1305
1270
            return
 
1271
        # if we get here, name_winner and parent_winner are set to safe values.
 
1272
        trans_id = self.tt.trans_id_file_id(file_id)
1306
1273
        parent_id = parents[self.winner_idx[parent_id_winner]]
1307
1274
        if parent_id is not None:
1308
 
            # if we get here, name_winner and parent_winner are set to safe
1309
 
            # values.
 
1275
            parent_trans_id = self.tt.trans_id_file_id(parent_id)
1310
1276
            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))
 
1277
                                parent_trans_id, trans_id)
1313
1278
 
1314
1279
    def _do_merge_contents(self, file_id):
1315
1280
        """Performs a merge on file_id contents."""
1594
1559
 
1595
1560
    def cook_conflicts(self, fs_conflicts):
1596
1561
        """Convert all conflicts into a form that doesn't depend on trans_id"""
 
1562
        name_conflicts = {}
1597
1563
        self.cooked_conflicts.extend(transform.cook_conflicts(
1598
1564
                fs_conflicts, self.tt))
1599
1565
        fp = transform.FinalPaths(self.tt)
1600
1566
        for conflict in self._raw_conflicts:
1601
1567
            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':
 
1568
            if conflict_type in ('name conflict', 'parent conflict'):
 
1569
                trans_id = conflict[1]
 
1570
                conflict_args = conflict[2:]
 
1571
                if trans_id not in name_conflicts:
 
1572
                    name_conflicts[trans_id] = {}
 
1573
                transform.unique_add(name_conflicts[trans_id], conflict_type,
 
1574
                                     conflict_args)
 
1575
            if conflict_type == 'contents conflict':
1623
1576
                for trans_id in conflict[1]:
1624
1577
                    file_id = self.tt.final_file_id(trans_id)
1625
1578
                    if file_id is not None:
1631
1584
                        break
1632
1585
                c = _mod_conflicts.Conflict.factory(conflict_type,
1633
1586
                                                    path=path, file_id=file_id)
1634
 
            elif conflict_type == 'text conflict':
 
1587
                self.cooked_conflicts.append(c)
 
1588
            if conflict_type == 'text conflict':
1635
1589
                trans_id = conflict[1]
1636
1590
                path = fp.get_path(trans_id)
1637
1591
                file_id = self.tt.final_file_id(trans_id)
1638
1592
                c = _mod_conflicts.Conflict.factory(conflict_type,
1639
1593
                                                    path=path, file_id=file_id)
 
1594
                self.cooked_conflicts.append(c)
 
1595
 
 
1596
        for trans_id, conflicts in name_conflicts.iteritems():
 
1597
            try:
 
1598
                this_parent, other_parent = conflicts['parent conflict']
 
1599
                if this_parent == other_parent:
 
1600
                    raise AssertionError()
 
1601
            except KeyError:
 
1602
                this_parent = other_parent = \
 
1603
                    self.tt.final_file_id(self.tt.final_parent(trans_id))
 
1604
            try:
 
1605
                this_name, other_name = conflicts['name conflict']
 
1606
                if this_name == other_name:
 
1607
                    raise AssertionError()
 
1608
            except KeyError:
 
1609
                this_name = other_name = self.tt.final_name(trans_id)
 
1610
            other_path = fp.get_path(trans_id)
 
1611
            if this_parent is not None and this_name is not None:
 
1612
                this_parent_path = \
 
1613
                    fp.get_path(self.tt.trans_id_file_id(this_parent))
 
1614
                this_path = osutils.pathjoin(this_parent_path, this_name)
1640
1615
            else:
1641
 
                raise AssertionError('bad conflict type: %r' % (conflict,))
 
1616
                this_path = "<deleted>"
 
1617
            file_id = self.tt.final_file_id(trans_id)
 
1618
            c = _mod_conflicts.Conflict.factory('path conflict', path=this_path,
 
1619
                                                conflict_path=other_path,
 
1620
                                                file_id=file_id)
1642
1621
            self.cooked_conflicts.append(c)
1643
1622
        self.cooked_conflicts.sort(key=_mod_conflicts.Conflict.sort_key)
1644
1623
 
1759
1738
                other_rev_id=None,
1760
1739
                interesting_files=None,
1761
1740
                this_tree=None,
1762
 
                pb=None,
 
1741
                pb=progress.DummyProgress(),
1763
1742
                change_reporter=None):
1764
1743
    """Primary interface for merging.
1765
1744