← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/conflicts.py

  • Committer: Robert Collins
  • Date: 2010-05-06 23:54:05 UTC
  • mto: This revision was merged to the branch mainline in revision 5223.
  • Revision ID: robertc@robertcollins.net-20100506235405-wii4elupfhzl3jvy
Add __str__ to the new helper classes.

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
24
24
import errno
25
25
 
26
26
from bzrlib import (
 
27
    builtins,
27
28
    cleanup,
 
29
    commands,
28
30
    errors,
29
31
    osutils,
30
32
    rio,
34
36
    )
35
37
""")
36
38
from bzrlib import (
37
 
    commands,
38
39
    option,
39
40
    registry,
40
41
    )
58
59
    Use bzr resolve when you have fixed a problem.
59
60
    """
60
61
    takes_options = [
61
 
            'directory',
62
62
            option.Option('text',
63
63
                          help='List paths of files with text conflicts.'),
64
64
        ]
65
65
    _see_also = ['resolve', 'conflict-types']
66
66
 
67
 
    def run(self, text=False, directory=u'.'):
68
 
        wt = workingtree.WorkingTree.open_containing(directory)[0]
 
67
    def run(self, text=False):
 
68
        wt = workingtree.WorkingTree.open_containing(u'.')[0]
69
69
        for conflict in wt.conflicts():
70
70
            if text:
71
71
                if conflict.typestring != 'text conflict':
72
72
                    continue
73
73
                self.outf.write(conflict.path + '\n')
74
74
            else:
75
 
                self.outf.write(unicode(conflict) + '\n')
 
75
                self.outf.write(str(conflict) + '\n')
76
76
 
77
77
 
78
78
resolve_action_registry = registry.Registry()
112
112
    aliases = ['resolved']
113
113
    takes_args = ['file*']
114
114
    takes_options = [
115
 
            'directory',
116
115
            option.Option('all', help='Resolve all conflicts in this tree.'),
117
116
            ResolveActionOption(),
118
117
            ]
119
118
    _see_also = ['conflicts']
120
 
    def run(self, file_list=None, all=False, action=None, directory=None):
 
119
    def run(self, file_list=None, all=False, action=None):
121
120
        if all:
122
121
            if file_list:
123
122
                raise errors.BzrCommandError("If --all is specified,"
124
123
                                             " no FILE may be provided")
125
 
            if directory is None:
126
 
                directory = u'.'
127
 
            tree = workingtree.WorkingTree.open_containing(directory)[0]
 
124
            tree = workingtree.WorkingTree.open_containing('.')[0]
128
125
            if action is None:
129
126
                action = 'done'
130
127
        else:
131
 
            tree, file_list = workingtree.WorkingTree.open_containing_paths(
132
 
                file_list, directory)
 
128
            tree, file_list = builtins.tree_files(file_list)
133
129
            if file_list is None:
134
130
                if action is None:
135
131
                    # FIXME: There is a special case here related to the option
148
144
                    trace.note('%d conflict(s) auto-resolved.', len(resolved))
149
145
                    trace.note('Remaining conflicts:')
150
146
                    for conflict in un_resolved:
151
 
                        trace.note(unicode(conflict))
 
147
                        trace.note(conflict)
152
148
                    return 1
153
149
                else:
154
150
                    trace.note('All conflicts resolved.')
159
155
                # conflict.auto(tree) --vila 091242
160
156
                pass
161
157
        else:
162
 
            before, after = resolve(tree, file_list, action=action)
163
 
            trace.note('%d conflict(s) resolved, %d remaining'
164
 
                       % (before - after, after))
 
158
            resolve(tree, file_list, action=action)
165
159
 
166
160
 
167
161
def resolve(tree, paths=None, ignore_misses=False, recursive=False,
180
174
    :param action: How the conflict should be resolved,
181
175
    """
182
176
    tree.lock_tree_write()
183
 
    nb_conflicts_after = None
184
177
    try:
185
178
        tree_conflicts = tree.conflicts()
186
 
        nb_conflicts_before = len(tree_conflicts)
187
179
        if paths is None:
188
180
            new_conflicts = ConflictList()
189
181
            to_process = tree_conflicts
197
189
            except NotImplementedError:
198
190
                new_conflicts.append(conflict)
199
191
        try:
200
 
            nb_conflicts_after = len(new_conflicts)
201
192
            tree.set_conflicts(new_conflicts)
202
193
        except errors.UnsupportedOperation:
203
194
            pass
204
195
    finally:
205
196
        tree.unlock()
206
 
    if nb_conflicts_after is None:
207
 
        nb_conflicts_after = nb_conflicts_before
208
 
    return nb_conflicts_before, nb_conflicts_after
209
197
 
210
198
 
211
199
def restore(filename):
291
279
    def to_strings(self):
292
280
        """Generate strings for the provided conflicts"""
293
281
        for conflict in self:
294
 
            yield unicode(conflict)
 
282
            yield str(conflict)
295
283
 
296
284
    def remove_files(self, tree):
297
285
        """Remove the THIS, BASE and OTHER files for listed conflicts"""
390
378
    def __ne__(self, other):
391
379
        return not self.__eq__(other)
392
380
 
393
 
    def __unicode__(self):
 
381
    def __str__(self):
394
382
        return self.format % self.__dict__
395
383
 
396
384
    def __repr__(self):
507
495
        if path_to_create is not None:
508
496
            tid = tt.trans_id_tree_path(path_to_create)
509
497
            transform.create_from_tree(
510
 
                tt, tid, self._revision_tree(tt._tree, revid), file_id)
 
498
                tt, tt.trans_id_tree_path(path_to_create),
 
499
                self._revision_tree(tt._tree, revid), file_id)
511
500
            tt.version_file(file_id, tid)
512
 
        else:
513
 
            tid = tt.trans_id_file_id(file_id)
 
501
 
514
502
        # Adjust the path for the retained file id
 
503
        tid = tt.trans_id_file_id(file_id)
515
504
        parent_tid = tt.get_tree_parent(tid)
516
 
        tt.adjust_path(osutils.basename(path), parent_tid, tid)
 
505
        tt.adjust_path(path, parent_tid, tid)
517
506
        tt.apply()
518
507
 
519
508
    def _revision_tree(self, tree, revid):
582
571
        :param tt: The TreeTransform where the conflict is resolved.
583
572
        :param suffix_to_remove: Either 'THIS' or 'OTHER'
584
573
 
585
 
        The resolution is symmetric: when taking THIS, OTHER is deleted and
 
574
        The resolution is symmetric, when taking THIS, OTHER is deleted and
586
575
        item.THIS is renamed into item and vice-versa.
587
576
        """
588
577
        try:
595
584
            # never existed or was already deleted (including the case
596
585
            # where the user deleted it)
597
586
            pass
598
 
        try:
599
 
            this_path = tt._tree.id2path(self.file_id)
600
 
        except errors.NoSuchId:
601
 
            # The file is not present anymore. This may happen if the user
602
 
            # deleted the file either manually or when resolving a conflict on
603
 
            # the parent.  We may raise some exception to indicate that the
604
 
            # conflict doesn't exist anymore and as such doesn't need to be
605
 
            # resolved ? -- vila 20110615 
606
 
            this_tid = None
607
 
        else:
608
 
            this_tid = tt.trans_id_tree_path(this_path)
609
 
        if this_tid is not None:
610
 
            # Rename 'item.suffix_to_remove' (note that if
611
 
            # 'item.suffix_to_remove' has been deleted, this is a no-op)
612
 
            parent_tid = tt.get_tree_parent(this_tid)
613
 
            tt.adjust_path(osutils.basename(self.path), parent_tid, this_tid)
614
 
            tt.apply()
 
587
        # Rename 'item.suffix_to_remove' (note that if
 
588
        # 'item.suffix_to_remove' has been deleted, this is a no-op)
 
589
        this_tid = tt.trans_id_file_id(self.file_id)
 
590
        parent_tid = tt.get_tree_parent(this_tid)
 
591
        tt.adjust_path(self.path, parent_tid, this_tid)
 
592
        tt.apply()
615
593
 
616
594
    def action_take_this(self, tree):
617
595
        self._resolve_with_cleanups(tree, 'OTHER')
620
598
        self._resolve_with_cleanups(tree, 'THIS')
621
599
 
622
600
 
 
601
# FIXME: TextConflict is about a single file-id, there never is a conflict_path
 
602
# attribute so we shouldn't inherit from PathConflict but simply from Conflict
 
603
 
623
604
# TODO: There should be a base revid attribute to better inform the user about
624
605
# how the conflicts were generated.
625
 
class TextConflict(Conflict):
 
606
class TextConflict(PathConflict):
626
607
    """The merge algorithm could not resolve all differences encountered."""
627
608
 
628
609
    has_files = True
631
612
 
632
613
    format = 'Text conflict in %(path)s'
633
614
 
634
 
    rformat = '%(class)s(%(path)r, %(file_id)r)'
635
 
 
636
615
    def associated_filenames(self):
637
616
        return [self.path + suffix for suffix in CONFLICT_SUFFIXES]
638
617
 
639
 
    def _resolve(self, tt, winner_suffix):
640
 
        """Resolve the conflict by copying one of .THIS or .OTHER into file.
641
 
 
642
 
        :param tt: The TreeTransform where the conflict is resolved.
643
 
        :param winner_suffix: Either 'THIS' or 'OTHER'
644
 
 
645
 
        The resolution is symmetric, when taking THIS, item.THIS is renamed
646
 
        into item and vice-versa. This takes one of the files as a whole
647
 
        ignoring every difference that could have been merged cleanly.
648
 
        """
649
 
        # To avoid useless copies, we switch item and item.winner_suffix, only
650
 
        # item will exist after the conflict has been resolved anyway.
651
 
        item_tid = tt.trans_id_file_id(self.file_id)
652
 
        item_parent_tid = tt.get_tree_parent(item_tid)
653
 
        winner_path = self.path + '.' + winner_suffix
654
 
        winner_tid = tt.trans_id_tree_path(winner_path)
655
 
        winner_parent_tid = tt.get_tree_parent(winner_tid)
656
 
        # Switch the paths to preserve the content
657
 
        tt.adjust_path(osutils.basename(self.path),
658
 
                       winner_parent_tid, winner_tid)
659
 
        tt.adjust_path(osutils.basename(winner_path), item_parent_tid, item_tid)
660
 
        # Associate the file_id to the right content
661
 
        tt.unversion_file(item_tid)
662
 
        tt.version_file(self.file_id, winner_tid)
663
 
        tt.apply()
664
 
 
665
 
    def action_take_this(self, tree):
666
 
        self._resolve_with_cleanups(tree, 'THIS')
667
 
 
668
 
    def action_take_other(self, tree):
669
 
        self._resolve_with_cleanups(tree, 'OTHER')
670
 
 
671
618
 
672
619
class HandledConflict(Conflict):
673
620
    """A path problem that has been provisionally resolved.
766
713
        pass
767
714
 
768
715
    def action_take_other(self, tree):
 
716
        # FIXME: We shouldn't have to manipulate so many paths here (and there
 
717
        # is probably a bug or two...)
 
718
        base_path = osutils.basename(self.path)
 
719
        conflict_base_path = osutils.basename(self.conflict_path)
769
720
        tt = transform.TreeTransform(tree)
770
721
        try:
771
722
            p_tid = tt.trans_id_file_id(self.file_id)
772
723
            parent_tid = tt.get_tree_parent(p_tid)
773
724
            cp_tid = tt.trans_id_file_id(self.conflict_file_id)
774
725
            cparent_tid = tt.get_tree_parent(cp_tid)
775
 
            tt.adjust_path(osutils.basename(self.path), cparent_tid, cp_tid)
776
 
            tt.adjust_path(osutils.basename(self.conflict_path),
777
 
                           parent_tid, p_tid)
 
726
            tt.adjust_path(base_path, cparent_tid, cp_tid)
 
727
            tt.adjust_path(conflict_base_path, parent_tid, p_tid)
778
728
            tt.apply()
779
729
        finally:
780
730
            tt.finalize()