← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/conflicts.py

  • Committer: Jelmer Vernooij
  • Date: 2011-12-16 16:40:10 UTC
  • mto: This revision was merged to the branch mainline in revision 6391.
  • Revision ID: jelmer@samba.org-20111216164010-z3hy00xrnclnkf7a
Update tests.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/conflicts.py
1
 
# Copyright (C) 2005, 2006, 2007, 2009, 2010 Canonical Ltd
 
1
# Copyright (C) 2005, 2006, 2007, 2009, 2010, 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
25
25
 
26
26
from bzrlib import (
27
27
    cleanup,
28
 
    commands,
29
28
    errors,
30
29
    osutils,
31
30
    rio,
33
32
    transform,
34
33
    workingtree,
35
34
    )
 
35
from bzrlib.i18n import gettext, ngettext
36
36
""")
37
37
from bzrlib import (
 
38
    commands,
38
39
    option,
39
40
    registry,
40
41
    )
72
73
                    continue
73
74
                self.outf.write(conflict.path + '\n')
74
75
            else:
75
 
                self.outf.write(str(conflict) + '\n')
 
76
                self.outf.write(unicode(conflict) + '\n')
76
77
 
77
78
 
78
79
resolve_action_registry = registry.Registry()
79
80
 
80
81
 
81
82
resolve_action_registry.register(
82
 
    'done', 'done', 'Marks the conflict as resolved' )
 
83
    'done', 'done', 'Marks the conflict as resolved.')
83
84
resolve_action_registry.register(
84
85
    'take-this', 'take_this',
85
 
    'Resolve the conflict preserving the version in the working tree' )
 
86
    'Resolve the conflict preserving the version in the working tree.')
86
87
resolve_action_registry.register(
87
88
    'take-other', 'take_other',
88
 
    'Resolve the conflict taking the merged version into account' )
 
89
    'Resolve the conflict taking the merged version into account.')
89
90
resolve_action_registry.default_key = 'done'
90
91
 
91
92
class ResolveActionOption(option.RegistryOption):
117
118
            ResolveActionOption(),
118
119
            ]
119
120
    _see_also = ['conflicts']
120
 
    def run(self, file_list=None, all=False, action=None, directory=u'.'):
 
121
    def run(self, file_list=None, all=False, action=None, directory=None):
121
122
        if all:
122
123
            if file_list:
123
 
                raise errors.BzrCommandError("If --all is specified,"
124
 
                                             " no FILE may be provided")
 
124
                raise errors.BzrCommandError(gettext("If --all is specified,"
 
125
                                             " no FILE may be provided"))
 
126
            if directory is None:
 
127
                directory = u'.'
125
128
            tree = workingtree.WorkingTree.open_containing(directory)[0]
126
129
            if action is None:
127
130
                action = 'done'
128
131
        else:
129
132
            tree, file_list = workingtree.WorkingTree.open_containing_paths(
130
 
                file_list)
 
133
                file_list, directory)
131
134
            if file_list is None:
132
135
                if action is None:
133
136
                    # FIXME: There is a special case here related to the option
143
146
            if file_list is None:
144
147
                un_resolved, resolved = tree.auto_resolve()
145
148
                if len(un_resolved) > 0:
146
 
                    trace.note('%d conflict(s) auto-resolved.', len(resolved))
147
 
                    trace.note('Remaining conflicts:')
 
149
                    trace.note(ngettext('%d conflict auto-resolved.',
 
150
                        '%d conflicts auto-resolved.', len(resolved)),
 
151
                        len(resolved))
 
152
                    trace.note(gettext('Remaining conflicts:'))
148
153
                    for conflict in un_resolved:
149
 
                        trace.note(conflict)
 
154
                        trace.note(unicode(conflict))
150
155
                    return 1
151
156
                else:
152
 
                    trace.note('All conflicts resolved.')
 
157
                    trace.note(gettext('All conflicts resolved.'))
153
158
                    return 0
154
159
            else:
155
160
                # FIXME: This can never occur but the block above needs some
157
162
                # conflict.auto(tree) --vila 091242
158
163
                pass
159
164
        else:
160
 
            resolve(tree, file_list, action=action)
 
165
            before, after = resolve(tree, file_list, action=action)
 
166
            trace.note(ngettext('{0} conflict resolved, {1} remaining',
 
167
                                '{0} conflicts resolved, {1} remaining',
 
168
                                before-after).format(before - after, after))
161
169
 
162
170
 
163
171
def resolve(tree, paths=None, ignore_misses=False, recursive=False,
176
184
    :param action: How the conflict should be resolved,
177
185
    """
178
186
    tree.lock_tree_write()
 
187
    nb_conflicts_after = None
179
188
    try:
180
189
        tree_conflicts = tree.conflicts()
 
190
        nb_conflicts_before = len(tree_conflicts)
181
191
        if paths is None:
182
192
            new_conflicts = ConflictList()
183
193
            to_process = tree_conflicts
191
201
            except NotImplementedError:
192
202
                new_conflicts.append(conflict)
193
203
        try:
 
204
            nb_conflicts_after = len(new_conflicts)
194
205
            tree.set_conflicts(new_conflicts)
195
206
        except errors.UnsupportedOperation:
196
207
            pass
197
208
    finally:
198
209
        tree.unlock()
 
210
    if nb_conflicts_after is None:
 
211
        nb_conflicts_after = nb_conflicts_before
 
212
    return nb_conflicts_before, nb_conflicts_after
199
213
 
200
214
 
201
215
def restore(filename):
281
295
    def to_strings(self):
282
296
        """Generate strings for the provided conflicts"""
283
297
        for conflict in self:
284
 
            yield str(conflict)
 
298
            yield unicode(conflict)
285
299
 
286
300
    def remove_files(self, tree):
287
301
        """Remove the THIS, BASE and OTHER files for listed conflicts"""
380
394
    def __ne__(self, other):
381
395
        return not self.__eq__(other)
382
396
 
383
 
    def __str__(self):
 
397
    def __unicode__(self):
384
398
        return self.format % self.__dict__
385
399
 
386
400
    def __repr__(self):
497
511
        if path_to_create is not None:
498
512
            tid = tt.trans_id_tree_path(path_to_create)
499
513
            transform.create_from_tree(
500
 
                tt, tt.trans_id_tree_path(path_to_create),
501
 
                self._revision_tree(tt._tree, revid), file_id)
 
514
                tt, tid, self._revision_tree(tt._tree, revid), file_id)
502
515
            tt.version_file(file_id, tid)
503
 
 
 
516
        else:
 
517
            tid = tt.trans_id_file_id(file_id)
504
518
        # Adjust the path for the retained file id
505
 
        tid = tt.trans_id_file_id(file_id)
506
519
        parent_tid = tt.get_tree_parent(tid)
507
 
        tt.adjust_path(path, parent_tid, tid)
 
520
        tt.adjust_path(osutils.basename(path), parent_tid, tid)
508
521
        tt.apply()
509
522
 
510
523
    def _revision_tree(self, tree, revid):
573
586
        :param tt: The TreeTransform where the conflict is resolved.
574
587
        :param suffix_to_remove: Either 'THIS' or 'OTHER'
575
588
 
576
 
        The resolution is symmetric, when taking THIS, OTHER is deleted and
 
589
        The resolution is symmetric: when taking THIS, OTHER is deleted and
577
590
        item.THIS is renamed into item and vice-versa.
578
591
        """
579
592
        try:
586
599
            # never existed or was already deleted (including the case
587
600
            # where the user deleted it)
588
601
            pass
589
 
        # Rename 'item.suffix_to_remove' (note that if
590
 
        # 'item.suffix_to_remove' has been deleted, this is a no-op)
591
 
        this_tid = tt.trans_id_file_id(self.file_id)
592
 
        parent_tid = tt.get_tree_parent(this_tid)
593
 
        tt.adjust_path(self.path, parent_tid, this_tid)
594
 
        tt.apply()
 
602
        try:
 
603
            this_path = tt._tree.id2path(self.file_id)
 
604
        except errors.NoSuchId:
 
605
            # The file is not present anymore. This may happen if the user
 
606
            # deleted the file either manually or when resolving a conflict on
 
607
            # the parent.  We may raise some exception to indicate that the
 
608
            # conflict doesn't exist anymore and as such doesn't need to be
 
609
            # resolved ? -- vila 20110615 
 
610
            this_tid = None
 
611
        else:
 
612
            this_tid = tt.trans_id_tree_path(this_path)
 
613
        if this_tid is not None:
 
614
            # Rename 'item.suffix_to_remove' (note that if
 
615
            # 'item.suffix_to_remove' has been deleted, this is a no-op)
 
616
            parent_tid = tt.get_tree_parent(this_tid)
 
617
            tt.adjust_path(osutils.basename(self.path), parent_tid, this_tid)
 
618
            tt.apply()
595
619
 
596
620
    def action_take_this(self, tree):
597
621
        self._resolve_with_cleanups(tree, 'OTHER')
600
624
        self._resolve_with_cleanups(tree, 'THIS')
601
625
 
602
626
 
603
 
# FIXME: TextConflict is about a single file-id, there never is a conflict_path
604
 
# attribute so we shouldn't inherit from PathConflict but simply from Conflict
605
 
 
606
627
# TODO: There should be a base revid attribute to better inform the user about
607
628
# how the conflicts were generated.
608
 
class TextConflict(PathConflict):
 
629
class TextConflict(Conflict):
609
630
    """The merge algorithm could not resolve all differences encountered."""
610
631
 
611
632
    has_files = True
614
635
 
615
636
    format = 'Text conflict in %(path)s'
616
637
 
 
638
    rformat = '%(class)s(%(path)r, %(file_id)r)'
 
639
 
617
640
    def associated_filenames(self):
618
641
        return [self.path + suffix for suffix in CONFLICT_SUFFIXES]
619
642
 
 
643
    def _resolve(self, tt, winner_suffix):
 
644
        """Resolve the conflict by copying one of .THIS or .OTHER into file.
 
645
 
 
646
        :param tt: The TreeTransform where the conflict is resolved.
 
647
        :param winner_suffix: Either 'THIS' or 'OTHER'
 
648
 
 
649
        The resolution is symmetric, when taking THIS, item.THIS is renamed
 
650
        into item and vice-versa. This takes one of the files as a whole
 
651
        ignoring every difference that could have been merged cleanly.
 
652
        """
 
653
        # To avoid useless copies, we switch item and item.winner_suffix, only
 
654
        # item will exist after the conflict has been resolved anyway.
 
655
        item_tid = tt.trans_id_file_id(self.file_id)
 
656
        item_parent_tid = tt.get_tree_parent(item_tid)
 
657
        winner_path = self.path + '.' + winner_suffix
 
658
        winner_tid = tt.trans_id_tree_path(winner_path)
 
659
        winner_parent_tid = tt.get_tree_parent(winner_tid)
 
660
        # Switch the paths to preserve the content
 
661
        tt.adjust_path(osutils.basename(self.path),
 
662
                       winner_parent_tid, winner_tid)
 
663
        tt.adjust_path(osutils.basename(winner_path), item_parent_tid, item_tid)
 
664
        # Associate the file_id to the right content
 
665
        tt.unversion_file(item_tid)
 
666
        tt.version_file(self.file_id, winner_tid)
 
667
        tt.apply()
 
668
 
 
669
    def action_take_this(self, tree):
 
670
        self._resolve_with_cleanups(tree, 'THIS')
 
671
 
 
672
    def action_take_other(self, tree):
 
673
        self._resolve_with_cleanups(tree, 'OTHER')
 
674
 
620
675
 
621
676
class HandledConflict(Conflict):
622
677
    """A path problem that has been provisionally resolved.
715
770
        pass
716
771
 
717
772
    def action_take_other(self, tree):
718
 
        # FIXME: We shouldn't have to manipulate so many paths here (and there
719
 
        # is probably a bug or two...)
720
 
        base_path = osutils.basename(self.path)
721
 
        conflict_base_path = osutils.basename(self.conflict_path)
722
773
        tt = transform.TreeTransform(tree)
723
774
        try:
724
775
            p_tid = tt.trans_id_file_id(self.file_id)
725
776
            parent_tid = tt.get_tree_parent(p_tid)
726
777
            cp_tid = tt.trans_id_file_id(self.conflict_file_id)
727
778
            cparent_tid = tt.get_tree_parent(cp_tid)
728
 
            tt.adjust_path(base_path, cparent_tid, cp_tid)
729
 
            tt.adjust_path(conflict_base_path, parent_tid, p_tid)
 
779
            tt.adjust_path(osutils.basename(self.path), cparent_tid, cp_tid)
 
780
            tt.adjust_path(osutils.basename(self.conflict_path),
 
781
                           parent_tid, p_tid)
730
782
            tt.apply()
731
783
        finally:
732
784
            tt.finalize()