← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/conflicts.py

(parthm) 'bzr status' now displays shelve summary (#403687). (Parth
 Malwankar)

Show diffs side-by-side

added added

removed removed

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