← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/conflicts.py

  • Committer: Martin
  • Date: 2010-04-16 12:59:03 UTC
  • mto: (5177.1.1 integration2)
  • mto: This revision was merged to the branch mainline in revision 5179.
  • Revision ID: gzlist@googlemail.com-20100416125903-yjm9d5uc7l8ilxpf
Catch a couple of missed plugin module docstrings, note need for assignment to __doc__ in developer documentation and NEWS

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
18
18
# point down
19
19
 
20
20
import os
 
21
import re
21
22
 
22
23
from bzrlib.lazy_import import lazy_import
23
24
lazy_import(globals(), """
24
25
import errno
25
26
 
26
27
from bzrlib import (
 
28
    builtins,
27
29
    cleanup,
 
30
    commands,
28
31
    errors,
29
32
    osutils,
30
33
    rio,
32
35
    transform,
33
36
    workingtree,
34
37
    )
35
 
from bzrlib.i18n import gettext, ngettext
36
38
""")
37
39
from bzrlib import (
38
 
    commands,
39
40
    option,
40
41
    registry,
41
42
    )
59
60
    Use bzr resolve when you have fixed a problem.
60
61
    """
61
62
    takes_options = [
62
 
            'directory',
63
63
            option.Option('text',
64
64
                          help='List paths of files with text conflicts.'),
65
65
        ]
66
66
    _see_also = ['resolve', 'conflict-types']
67
67
 
68
 
    def run(self, text=False, directory=u'.'):
69
 
        wt = workingtree.WorkingTree.open_containing(directory)[0]
 
68
    def run(self, text=False):
 
69
        wt = workingtree.WorkingTree.open_containing(u'.')[0]
70
70
        for conflict in wt.conflicts():
71
71
            if text:
72
72
                if conflict.typestring != 'text conflict':
73
73
                    continue
74
74
                self.outf.write(conflict.path + '\n')
75
75
            else:
76
 
                self.outf.write(unicode(conflict) + '\n')
 
76
                self.outf.write(str(conflict) + '\n')
77
77
 
78
78
 
79
79
resolve_action_registry = registry.Registry()
113
113
    aliases = ['resolved']
114
114
    takes_args = ['file*']
115
115
    takes_options = [
116
 
            'directory',
117
116
            option.Option('all', help='Resolve all conflicts in this tree.'),
118
117
            ResolveActionOption(),
119
118
            ]
120
119
    _see_also = ['conflicts']
121
 
    def run(self, file_list=None, all=False, action=None, directory=None):
 
120
    def run(self, file_list=None, all=False, action=None):
122
121
        if all:
123
122
            if file_list:
124
 
                raise errors.BzrCommandError(gettext("If --all is specified,"
125
 
                                             " no FILE may be provided"))
126
 
            if directory is None:
127
 
                directory = u'.'
128
 
            tree = workingtree.WorkingTree.open_containing(directory)[0]
 
123
                raise errors.BzrCommandError("If --all is specified,"
 
124
                                             " no FILE may be provided")
 
125
            tree = workingtree.WorkingTree.open_containing('.')[0]
129
126
            if action is None:
130
127
                action = 'done'
131
128
        else:
132
 
            tree, file_list = workingtree.WorkingTree.open_containing_paths(
133
 
                file_list, directory)
 
129
            tree, file_list = builtins.tree_files(file_list)
134
130
            if file_list is None:
135
131
                if action is None:
136
132
                    # FIXME: There is a special case here related to the option
146
142
            if file_list is None:
147
143
                un_resolved, resolved = tree.auto_resolve()
148
144
                if len(un_resolved) > 0:
149
 
                    trace.note(ngettext('%d conflict auto-resolved.',
150
 
                        '%d conflicts auto-resolved.', len(resolved)),
151
 
                        len(resolved))
152
 
                    trace.note(gettext('Remaining conflicts:'))
 
145
                    trace.note('%d conflict(s) auto-resolved.', len(resolved))
 
146
                    trace.note('Remaining conflicts:')
153
147
                    for conflict in un_resolved:
154
 
                        trace.note(unicode(conflict))
 
148
                        trace.note(conflict)
155
149
                    return 1
156
150
                else:
157
 
                    trace.note(gettext('All conflicts resolved.'))
 
151
                    trace.note('All conflicts resolved.')
158
152
                    return 0
159
153
            else:
160
154
                # FIXME: This can never occur but the block above needs some
162
156
                # conflict.auto(tree) --vila 091242
163
157
                pass
164
158
        else:
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))
 
159
            resolve(tree, file_list, action=action)
169
160
 
170
161
 
171
162
def resolve(tree, paths=None, ignore_misses=False, recursive=False,
184
175
    :param action: How the conflict should be resolved,
185
176
    """
186
177
    tree.lock_tree_write()
187
 
    nb_conflicts_after = None
188
178
    try:
189
179
        tree_conflicts = tree.conflicts()
190
 
        nb_conflicts_before = len(tree_conflicts)
191
180
        if paths is None:
192
181
            new_conflicts = ConflictList()
193
182
            to_process = tree_conflicts
201
190
            except NotImplementedError:
202
191
                new_conflicts.append(conflict)
203
192
        try:
204
 
            nb_conflicts_after = len(new_conflicts)
205
193
            tree.set_conflicts(new_conflicts)
206
194
        except errors.UnsupportedOperation:
207
195
            pass
208
196
    finally:
209
197
        tree.unlock()
210
 
    if nb_conflicts_after is None:
211
 
        nb_conflicts_after = nb_conflicts_before
212
 
    return nb_conflicts_before, nb_conflicts_after
213
198
 
214
199
 
215
200
def restore(filename):
295
280
    def to_strings(self):
296
281
        """Generate strings for the provided conflicts"""
297
282
        for conflict in self:
298
 
            yield unicode(conflict)
 
283
            yield str(conflict)
299
284
 
300
285
    def remove_files(self, tree):
301
286
        """Remove the THIS, BASE and OTHER files for listed conflicts"""
394
379
    def __ne__(self, other):
395
380
        return not self.__eq__(other)
396
381
 
397
 
    def __unicode__(self):
 
382
    def __str__(self):
398
383
        return self.format % self.__dict__
399
384
 
400
385
    def __repr__(self):
511
496
        if path_to_create is not None:
512
497
            tid = tt.trans_id_tree_path(path_to_create)
513
498
            transform.create_from_tree(
514
 
                tt, tid, self._revision_tree(tt._tree, revid), file_id)
 
499
                tt, tt.trans_id_tree_path(path_to_create),
 
500
                self._revision_tree(tt._tree, revid), file_id)
515
501
            tt.version_file(file_id, tid)
516
 
        else:
517
 
            tid = tt.trans_id_file_id(file_id)
 
502
 
518
503
        # Adjust the path for the retained file id
 
504
        tid = tt.trans_id_file_id(file_id)
519
505
        parent_tid = tt.get_tree_parent(tid)
520
 
        tt.adjust_path(osutils.basename(path), parent_tid, tid)
 
506
        tt.adjust_path(path, parent_tid, tid)
521
507
        tt.apply()
522
508
 
523
509
    def _revision_tree(self, tree, revid):
586
572
        :param tt: The TreeTransform where the conflict is resolved.
587
573
        :param suffix_to_remove: Either 'THIS' or 'OTHER'
588
574
 
589
 
        The resolution is symmetric: when taking THIS, OTHER is deleted and
 
575
        The resolution is symmetric, when taking THIS, OTHER is deleted and
590
576
        item.THIS is renamed into item and vice-versa.
591
577
        """
592
578
        try:
599
585
            # never existed or was already deleted (including the case
600
586
            # where the user deleted it)
601
587
            pass
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()
 
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()
619
594
 
620
595
    def action_take_this(self, tree):
621
596
        self._resolve_with_cleanups(tree, 'OTHER')
624
599
        self._resolve_with_cleanups(tree, 'THIS')
625
600
 
626
601
 
 
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
 
627
605
# TODO: There should be a base revid attribute to better inform the user about
628
606
# how the conflicts were generated.
629
 
class TextConflict(Conflict):
 
607
class TextConflict(PathConflict):
630
608
    """The merge algorithm could not resolve all differences encountered."""
631
609
 
632
610
    has_files = True
635
613
 
636
614
    format = 'Text conflict in %(path)s'
637
615
 
638
 
    rformat = '%(class)s(%(path)r, %(file_id)r)'
639
 
 
640
616
    def associated_filenames(self):
641
617
        return [self.path + suffix for suffix in CONFLICT_SUFFIXES]
642
618
 
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
 
 
675
619
 
676
620
class HandledConflict(Conflict):
677
621
    """A path problem that has been provisionally resolved.
770
714
        pass
771
715
 
772
716
    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)
773
721
        tt = transform.TreeTransform(tree)
774
722
        try:
775
723
            p_tid = tt.trans_id_file_id(self.file_id)
776
724
            parent_tid = tt.get_tree_parent(p_tid)
777
725
            cp_tid = tt.trans_id_file_id(self.conflict_file_id)
778
726
            cparent_tid = tt.get_tree_parent(cp_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)
 
727
            tt.adjust_path(base_path, cparent_tid, cp_tid)
 
728
            tt.adjust_path(conflict_base_path, parent_tid, p_tid)
782
729
            tt.apply()
783
730
        finally:
784
731
            tt.finalize()