← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/conflicts.py

(vila) Revise legal option names to be less drastic. (Vincent Ladeuil)

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
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
 
20
22
import os
21
 
import re
22
23
 
23
24
from bzrlib.lazy_import import lazy_import
24
25
lazy_import(globals(), """
25
26
import errno
26
27
 
27
28
from bzrlib import (
28
 
    builtins,
29
29
    cleanup,
30
 
    commands,
31
30
    errors,
32
31
    osutils,
33
32
    rio,
35
34
    transform,
36
35
    workingtree,
37
36
    )
 
37
from bzrlib.i18n import gettext, ngettext
38
38
""")
39
39
from bzrlib import (
 
40
    commands,
40
41
    option,
41
42
    registry,
42
43
    )
46
47
 
47
48
 
48
49
class cmd_conflicts(commands.Command):
49
 
    """List files with conflicts.
 
50
    __doc__ = """List files with conflicts.
50
51
 
51
52
    Merge will do its best to combine the changes in two branches, but there
52
53
    are some kinds of problems only a human can fix.  When it encounters those,
53
54
    it will mark a conflict.  A conflict means that you need to fix something,
54
 
    before you should commit.
 
55
    before you can commit.
55
56
 
56
57
    Conflicts normally are listed as short, human-readable messages.  If --text
57
58
    is supplied, the pathnames of files with text conflicts are listed,
60
61
    Use bzr resolve when you have fixed a problem.
61
62
    """
62
63
    takes_options = [
 
64
            'directory',
63
65
            option.Option('text',
64
66
                          help='List paths of files with text conflicts.'),
65
67
        ]
66
68
    _see_also = ['resolve', 'conflict-types']
67
69
 
68
 
    def run(self, text=False):
69
 
        wt = workingtree.WorkingTree.open_containing(u'.')[0]
 
70
    def run(self, text=False, directory=u'.'):
 
71
        wt = workingtree.WorkingTree.open_containing(directory)[0]
70
72
        for conflict in wt.conflicts():
71
73
            if text:
72
74
                if conflict.typestring != 'text conflict':
73
75
                    continue
74
76
                self.outf.write(conflict.path + '\n')
75
77
            else:
76
 
                self.outf.write(str(conflict) + '\n')
 
78
                self.outf.write(unicode(conflict) + '\n')
77
79
 
78
80
 
79
81
resolve_action_registry = registry.Registry()
80
82
 
81
83
 
82
84
resolve_action_registry.register(
83
 
    'done', 'done', 'Marks the conflict as resolved' )
 
85
    'done', 'done', 'Marks the conflict as resolved.')
84
86
resolve_action_registry.register(
85
87
    'take-this', 'take_this',
86
 
    'Resolve the conflict preserving the version in the working tree' )
 
88
    'Resolve the conflict preserving the version in the working tree.')
87
89
resolve_action_registry.register(
88
90
    'take-other', 'take_other',
89
 
    'Resolve the conflict taking the merged version into account' )
 
91
    'Resolve the conflict taking the merged version into account.')
90
92
resolve_action_registry.default_key = 'done'
91
93
 
92
94
class ResolveActionOption(option.RegistryOption):
99
101
 
100
102
 
101
103
class cmd_resolve(commands.Command):
102
 
    """Mark a conflict as resolved.
 
104
    __doc__ = """Mark a conflict as resolved.
103
105
 
104
106
    Merge will do its best to combine the changes in two branches, but there
105
107
    are some kinds of problems only a human can fix.  When it encounters those,
106
108
    it will mark a conflict.  A conflict means that you need to fix something,
107
 
    before you should commit.
 
109
    before you can commit.
108
110
 
109
111
    Once you have fixed a problem, use "bzr resolve" to automatically mark
110
112
    text conflicts as fixed, "bzr resolve FILE" to mark a specific conflict as
113
115
    aliases = ['resolved']
114
116
    takes_args = ['file*']
115
117
    takes_options = [
 
118
            'directory',
116
119
            option.Option('all', help='Resolve all conflicts in this tree.'),
117
120
            ResolveActionOption(),
118
121
            ]
119
122
    _see_also = ['conflicts']
120
 
    def run(self, file_list=None, all=False, action=None):
 
123
    def run(self, file_list=None, all=False, action=None, directory=None):
121
124
        if all:
122
125
            if file_list:
123
 
                raise errors.BzrCommandError("If --all is specified,"
124
 
                                             " no FILE may be provided")
125
 
            tree = workingtree.WorkingTree.open_containing('.')[0]
 
126
                raise errors.BzrCommandError(gettext("If --all is specified,"
 
127
                                             " no FILE may be provided"))
 
128
            if directory is None:
 
129
                directory = u'.'
 
130
            tree = workingtree.WorkingTree.open_containing(directory)[0]
126
131
            if action is None:
127
132
                action = 'done'
128
133
        else:
129
 
            tree, file_list = builtins.tree_files(file_list)
 
134
            tree, file_list = workingtree.WorkingTree.open_containing_paths(
 
135
                file_list, directory)
130
136
            if file_list is None:
131
137
                if action is None:
132
138
                    # FIXME: There is a special case here related to the option
142
148
            if file_list is None:
143
149
                un_resolved, resolved = tree.auto_resolve()
144
150
                if len(un_resolved) > 0:
145
 
                    trace.note('%d conflict(s) auto-resolved.', len(resolved))
146
 
                    trace.note('Remaining conflicts:')
 
151
                    trace.note(ngettext('%d conflict auto-resolved.',
 
152
                        '%d conflicts auto-resolved.', len(resolved)),
 
153
                        len(resolved))
 
154
                    trace.note(gettext('Remaining conflicts:'))
147
155
                    for conflict in un_resolved:
148
 
                        trace.note(conflict)
 
156
                        trace.note(unicode(conflict))
149
157
                    return 1
150
158
                else:
151
 
                    trace.note('All conflicts resolved.')
 
159
                    trace.note(gettext('All conflicts resolved.'))
152
160
                    return 0
153
161
            else:
154
162
                # FIXME: This can never occur but the block above needs some
156
164
                # conflict.auto(tree) --vila 091242
157
165
                pass
158
166
        else:
159
 
            resolve(tree, file_list, action=action)
 
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
171
 
161
172
 
162
173
def resolve(tree, paths=None, ignore_misses=False, recursive=False,
175
186
    :param action: How the conflict should be resolved,
176
187
    """
177
188
    tree.lock_tree_write()
 
189
    nb_conflicts_after = None
178
190
    try:
179
191
        tree_conflicts = tree.conflicts()
 
192
        nb_conflicts_before = len(tree_conflicts)
180
193
        if paths is None:
181
194
            new_conflicts = ConflictList()
182
195
            to_process = tree_conflicts
190
203
            except NotImplementedError:
191
204
                new_conflicts.append(conflict)
192
205
        try:
 
206
            nb_conflicts_after = len(new_conflicts)
193
207
            tree.set_conflicts(new_conflicts)
194
208
        except errors.UnsupportedOperation:
195
209
            pass
196
210
    finally:
197
211
        tree.unlock()
 
212
    if nb_conflicts_after is None:
 
213
        nb_conflicts_after = nb_conflicts_before
 
214
    return nb_conflicts_before, nb_conflicts_after
198
215
 
199
216
 
200
217
def restore(filename):
280
297
    def to_strings(self):
281
298
        """Generate strings for the provided conflicts"""
282
299
        for conflict in self:
283
 
            yield str(conflict)
 
300
            yield unicode(conflict)
284
301
 
285
302
    def remove_files(self, tree):
286
303
        """Remove the THIS, BASE and OTHER files for listed conflicts"""
379
396
    def __ne__(self, other):
380
397
        return not self.__eq__(other)
381
398
 
382
 
    def __str__(self):
 
399
    def __unicode__(self):
383
400
        return self.format % self.__dict__
384
401
 
385
402
    def __repr__(self):
496
513
        if path_to_create is not None:
497
514
            tid = tt.trans_id_tree_path(path_to_create)
498
515
            transform.create_from_tree(
499
 
                tt, tt.trans_id_tree_path(path_to_create),
500
 
                self._revision_tree(tt._tree, revid), file_id)
 
516
                tt, tid, self._revision_tree(tt._tree, revid), file_id)
501
517
            tt.version_file(file_id, tid)
502
 
 
 
518
        else:
 
519
            tid = tt.trans_id_file_id(file_id)
503
520
        # Adjust the path for the retained file id
504
 
        tid = tt.trans_id_file_id(file_id)
505
521
        parent_tid = tt.get_tree_parent(tid)
506
 
        tt.adjust_path(path, parent_tid, tid)
 
522
        tt.adjust_path(osutils.basename(path), parent_tid, tid)
507
523
        tt.apply()
508
524
 
509
525
    def _revision_tree(self, tree, revid):
572
588
        :param tt: The TreeTransform where the conflict is resolved.
573
589
        :param suffix_to_remove: Either 'THIS' or 'OTHER'
574
590
 
575
 
        The resolution is symmetric, when taking THIS, OTHER is deleted and
 
591
        The resolution is symmetric: when taking THIS, OTHER is deleted and
576
592
        item.THIS is renamed into item and vice-versa.
577
593
        """
578
594
        try:
585
601
            # never existed or was already deleted (including the case
586
602
            # where the user deleted it)
587
603
            pass
588
 
        # Rename 'item.suffix_to_remove' (note that if
589
 
        # 'item.suffix_to_remove' has been deleted, this is a no-op)
590
 
        this_tid = tt.trans_id_file_id(self.file_id)
591
 
        parent_tid = tt.get_tree_parent(this_tid)
592
 
        tt.adjust_path(self.path, parent_tid, this_tid)
593
 
        tt.apply()
 
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()
594
621
 
595
622
    def action_take_this(self, tree):
596
623
        self._resolve_with_cleanups(tree, 'OTHER')
599
626
        self._resolve_with_cleanups(tree, 'THIS')
600
627
 
601
628
 
602
 
# FIXME: TextConflict is about a single file-id, there never is a conflict_path
603
 
# attribute so we shouldn't inherit from PathConflict but simply from Conflict
604
 
 
605
629
# TODO: There should be a base revid attribute to better inform the user about
606
630
# how the conflicts were generated.
607
 
class TextConflict(PathConflict):
 
631
class TextConflict(Conflict):
608
632
    """The merge algorithm could not resolve all differences encountered."""
609
633
 
610
634
    has_files = True
613
637
 
614
638
    format = 'Text conflict in %(path)s'
615
639
 
 
640
    rformat = '%(class)s(%(path)r, %(file_id)r)'
 
641
 
616
642
    def associated_filenames(self):
617
643
        return [self.path + suffix for suffix in CONFLICT_SUFFIXES]
618
644
 
 
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
 
619
677
 
620
678
class HandledConflict(Conflict):
621
679
    """A path problem that has been provisionally resolved.
714
772
        pass
715
773
 
716
774
    def action_take_other(self, tree):
717
 
        # FIXME: We shouldn't have to manipulate so many paths here (and there
718
 
        # is probably a bug or two...)
719
 
        base_path = osutils.basename(self.path)
720
 
        conflict_base_path = osutils.basename(self.conflict_path)
721
775
        tt = transform.TreeTransform(tree)
722
776
        try:
723
777
            p_tid = tt.trans_id_file_id(self.file_id)
724
778
            parent_tid = tt.get_tree_parent(p_tid)
725
779
            cp_tid = tt.trans_id_file_id(self.conflict_file_id)
726
780
            cparent_tid = tt.get_tree_parent(cp_tid)
727
 
            tt.adjust_path(base_path, cparent_tid, cp_tid)
728
 
            tt.adjust_path(conflict_base_path, parent_tid, p_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)
729
784
            tt.apply()
730
785
        finally:
731
786
            tt.finalize()