← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/conflicts.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2010-02-17 08:59:19 UTC
  • mfrom: (5037.2.1 doc)
  • Revision ID: pqm@pqm.ubuntu.com-20100217085919-23vc62bvq8848q65
(mbp) rest markup fixes

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
 
21
import re
23
22
 
24
23
from bzrlib.lazy_import import lazy_import
25
24
lazy_import(globals(), """
26
25
import errno
27
26
 
28
27
from bzrlib import (
29
 
    cleanup,
 
28
    builtins,
 
29
    commands,
30
30
    errors,
31
31
    osutils,
32
32
    rio,
34
34
    transform,
35
35
    workingtree,
36
36
    )
37
 
from bzrlib.i18n import gettext, ngettext
38
37
""")
39
38
from bzrlib import (
40
 
    commands,
41
39
    option,
42
40
    registry,
43
41
    )
47
45
 
48
46
 
49
47
class cmd_conflicts(commands.Command):
50
 
    __doc__ = """List files with conflicts.
 
48
    """List files with conflicts.
51
49
 
52
50
    Merge will do its best to combine the changes in two branches, but there
53
51
    are some kinds of problems only a human can fix.  When it encounters those,
54
52
    it will mark a conflict.  A conflict means that you need to fix something,
55
 
    before you can commit.
 
53
    before you should commit.
56
54
 
57
55
    Conflicts normally are listed as short, human-readable messages.  If --text
58
56
    is supplied, the pathnames of files with text conflicts are listed,
61
59
    Use bzr resolve when you have fixed a problem.
62
60
    """
63
61
    takes_options = [
64
 
            'directory',
65
62
            option.Option('text',
66
63
                          help='List paths of files with text conflicts.'),
67
64
        ]
68
65
    _see_also = ['resolve', 'conflict-types']
69
66
 
70
 
    def run(self, text=False, directory=u'.'):
71
 
        wt = workingtree.WorkingTree.open_containing(directory)[0]
 
67
    def run(self, text=False):
 
68
        wt = workingtree.WorkingTree.open_containing(u'.')[0]
72
69
        for conflict in wt.conflicts():
73
70
            if text:
74
71
                if conflict.typestring != 'text conflict':
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):
101
98
 
102
99
 
103
100
class cmd_resolve(commands.Command):
104
 
    __doc__ = """Mark a conflict as resolved.
 
101
    """Mark a conflict as resolved.
105
102
 
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
115
112
    aliases = ['resolved']
116
113
    takes_args = ['file*']
117
114
    takes_options = [
118
 
            'directory',
119
115
            option.Option('all', help='Resolve all conflicts in this tree.'),
120
116
            ResolveActionOption(),
121
117
            ]
122
118
    _see_also = ['conflicts']
123
 
    def run(self, file_list=None, all=False, action=None, directory=None):
 
119
    def run(self, file_list=None, all=False, action=None):
124
120
        if all:
125
121
            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'.'
130
 
            tree = workingtree.WorkingTree.open_containing(directory)[0]
 
122
                raise errors.BzrCommandError("If --all is specified,"
 
123
                                             " no FILE may be provided")
 
124
            tree = workingtree.WorkingTree.open_containing('.')[0]
131
125
            if action is None:
132
126
                action = 'done'
133
127
        else:
134
 
            tree, file_list = workingtree.WorkingTree.open_containing_paths(
135
 
                file_list, directory)
 
128
            tree, file_list = builtins.tree_files(file_list)
136
129
            if file_list is None:
137
130
                if action is None:
138
131
                    # FIXME: There is a special case here related to the option
148
141
            if file_list is None:
149
142
                un_resolved, resolved = tree.auto_resolve()
150
143
                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:'))
 
144
                    trace.note('%d conflict(s) auto-resolved.', len(resolved))
 
145
                    trace.note('Remaining conflicts:')
155
146
                    for conflict in un_resolved:
156
 
                        trace.note(unicode(conflict))
 
147
                        trace.note(conflict)
157
148
                    return 1
158
149
                else:
159
 
                    trace.note(gettext('All conflicts resolved.'))
 
150
                    trace.note('All conflicts resolved.')
160
151
                    return 0
161
152
            else:
162
153
                # FIXME: This can never occur but the block above needs some
164
155
                # conflict.auto(tree) --vila 091242
165
156
                pass
166
157
        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))
 
158
            resolve(tree, file_list, action=action)
171
159
 
172
160
 
173
161
def resolve(tree, paths=None, ignore_misses=False, recursive=False,
186
174
    :param action: How the conflict should be resolved,
187
175
    """
188
176
    tree.lock_tree_write()
189
 
    nb_conflicts_after = None
190
177
    try:
191
178
        tree_conflicts = tree.conflicts()
192
 
        nb_conflicts_before = len(tree_conflicts)
193
179
        if paths is None:
194
180
            new_conflicts = ConflictList()
195
181
            to_process = tree_conflicts
203
189
            except NotImplementedError:
204
190
                new_conflicts.append(conflict)
205
191
        try:
206
 
            nb_conflicts_after = len(new_conflicts)
207
192
            tree.set_conflicts(new_conflicts)
208
193
        except errors.UnsupportedOperation:
209
194
            pass
210
195
    finally:
211
196
        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
197
 
216
198
 
217
199
def restore(filename):
297
279
    def to_strings(self):
298
280
        """Generate strings for the provided conflicts"""
299
281
        for conflict in self:
300
 
            yield unicode(conflict)
 
282
            yield str(conflict)
301
283
 
302
284
    def remove_files(self, tree):
303
285
        """Remove the THIS, BASE and OTHER files for listed conflicts"""
396
378
    def __ne__(self, other):
397
379
        return not self.__eq__(other)
398
380
 
399
 
    def __unicode__(self):
 
381
    def __str__(self):
400
382
        return self.format % self.__dict__
401
383
 
402
384
    def __repr__(self):
453
435
    def action_take_other(self, tree):
454
436
        raise NotImplementedError(self.action_take_other)
455
437
 
456
 
    def _resolve_with_cleanups(self, tree, *args, **kwargs):
457
 
        tt = transform.TreeTransform(tree)
458
 
        op = cleanup.OperationWithCleanups(self._resolve)
459
 
        op.add_cleanup(tt.finalize)
460
 
        op.run_simple(tt, *args, **kwargs)
461
 
 
462
438
 
463
439
class PathConflict(Conflict):
464
440
    """A conflict was encountered merging file paths"""
483
459
        # No additional files have been generated here
484
460
        return []
485
461
 
486
 
    def _resolve(self, tt, file_id, path, winner):
487
 
        """Resolve the conflict.
488
 
 
489
 
        :param tt: The TreeTransform where the conflict is resolved.
490
 
        :param file_id: The retained file id.
491
 
        :param path: The retained path.
492
 
        :param winner: 'this' or 'other' indicates which side is the winner.
493
 
        """
494
 
        path_to_create = None
495
 
        if winner == 'this':
496
 
            if self.path == '<deleted>':
497
 
                return # Nothing to do
498
 
            if self.conflict_path == '<deleted>':
499
 
                path_to_create = self.path
500
 
                revid = tt._tree.get_parent_ids()[0]
501
 
        elif winner == 'other':
502
 
            if self.conflict_path == '<deleted>':
503
 
                return  # Nothing to do
504
 
            if self.path == '<deleted>':
505
 
                path_to_create = self.conflict_path
506
 
                # FIXME: If there are more than two parents we may need to
507
 
                # iterate. Taking the last parent is the safer bet in the mean
508
 
                # time. -- vila 20100309
509
 
                revid = tt._tree.get_parent_ids()[-1]
510
 
        else:
511
 
            # Programmer error
512
 
            raise AssertionError('bad winner: %r' % (winner,))
513
 
        if path_to_create is not None:
514
 
            tid = tt.trans_id_tree_path(path_to_create)
515
 
            transform.create_from_tree(
516
 
                tt, tid, self._revision_tree(tt._tree, revid), file_id)
517
 
            tt.version_file(file_id, tid)
518
 
        else:
519
 
            tid = tt.trans_id_file_id(file_id)
520
 
        # Adjust the path for the retained file id
521
 
        parent_tid = tt.get_tree_parent(tid)
522
 
        tt.adjust_path(osutils.basename(path), parent_tid, tid)
523
 
        tt.apply()
524
 
 
525
 
    def _revision_tree(self, tree, revid):
526
 
        return tree.branch.repository.revision_tree(revid)
527
 
 
528
 
    def _infer_file_id(self, tree):
529
 
        # Prior to bug #531967, file_id wasn't always set, there may still be
530
 
        # conflict files in the wild so we need to cope with them
531
 
        # Establish which path we should use to find back the file-id
532
 
        possible_paths = []
533
 
        for p in (self.path, self.conflict_path):
534
 
            if p == '<deleted>':
535
 
                # special hard-coded path 
536
 
                continue
537
 
            if p is not None:
538
 
                possible_paths.append(p)
539
 
        # Search the file-id in the parents with any path available
540
 
        file_id = None
541
 
        for revid in tree.get_parent_ids():
542
 
            revtree = self._revision_tree(tree, revid)
543
 
            for p in possible_paths:
544
 
                file_id = revtree.path2id(p)
545
 
                if file_id is not None:
546
 
                    return revtree, file_id
547
 
        return None, None
548
 
 
549
462
    def action_take_this(self, tree):
550
 
        if self.file_id is not None:
551
 
            self._resolve_with_cleanups(tree, self.file_id, self.path,
552
 
                                        winner='this')
553
 
        else:
554
 
            # Prior to bug #531967 we need to find back the file_id and restore
555
 
            # the content from there
556
 
            revtree, file_id = self._infer_file_id(tree)
557
 
            tree.revert([revtree.id2path(file_id)],
558
 
                        old_tree=revtree, backups=False)
 
463
        tree.rename_one(self.conflict_path, self.path)
559
464
 
560
465
    def action_take_other(self, tree):
561
 
        if self.file_id is not None:
562
 
            self._resolve_with_cleanups(tree, self.file_id,
563
 
                                        self.conflict_path,
564
 
                                        winner='other')
565
 
        else:
566
 
            # Prior to bug #531967 we need to find back the file_id and restore
567
 
            # the content from there
568
 
            revtree, file_id = self._infer_file_id(tree)
569
 
            tree.revert([revtree.id2path(file_id)],
570
 
                        old_tree=revtree, backups=False)
 
466
        # just acccept bzr proposal
 
467
        pass
571
468
 
572
469
 
573
470
class ContentsConflict(PathConflict):
574
 
    """The files are of different types (or both binary), or not present"""
 
471
    """The files are of different types, or not present"""
575
472
 
576
473
    has_files = True
577
474
 
582
479
    def associated_filenames(self):
583
480
        return [self.path + suffix for suffix in ('.BASE', '.OTHER')]
584
481
 
585
 
    def _resolve(self, tt, suffix_to_remove):
586
 
        """Resolve the conflict.
587
 
 
588
 
        :param tt: The TreeTransform where the conflict is resolved.
589
 
        :param suffix_to_remove: Either 'THIS' or 'OTHER'
590
 
 
591
 
        The resolution is symmetric: when taking THIS, OTHER is deleted and
592
 
        item.THIS is renamed into item and vice-versa.
593
 
        """
594
 
        try:
595
 
            # Delete 'item.THIS' or 'item.OTHER' depending on
596
 
            # suffix_to_remove
597
 
            tt.delete_contents(
598
 
                tt.trans_id_tree_path(self.path + '.' + suffix_to_remove))
599
 
        except errors.NoSuchFile:
600
 
            # There are valid cases where 'item.suffix_to_remove' either
601
 
            # never existed or was already deleted (including the case
602
 
            # where the user deleted it)
603
 
            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()
621
 
 
 
482
    # FIXME: I smell something weird here and it seems we should be able to be
 
483
    # more coherent with some other conflict ? bzr *did* a choice there but
 
484
    # neither action_take_this nor action_take_other reflect that...
 
485
    # -- vila 20091224
622
486
    def action_take_this(self, tree):
623
 
        self._resolve_with_cleanups(tree, 'OTHER')
 
487
        tree.remove([self.path + '.OTHER'], force=True, keep_files=False)
624
488
 
625
489
    def action_take_other(self, tree):
626
 
        self._resolve_with_cleanups(tree, 'THIS')
627
 
 
 
490
        tree.remove([self.path], force=True, keep_files=False)
 
491
 
 
492
 
 
493
 
 
494
# FIXME: TextConflict is about a single file-id, there never is a conflict_path
 
495
# attribute so we shouldn't inherit from PathConflict but simply from Conflict
628
496
 
629
497
# TODO: There should be a base revid attribute to better inform the user about
630
498
# how the conflicts were generated.
631
 
class TextConflict(Conflict):
 
499
class TextConflict(PathConflict):
632
500
    """The merge algorithm could not resolve all differences encountered."""
633
501
 
634
502
    has_files = True
637
505
 
638
506
    format = 'Text conflict in %(path)s'
639
507
 
640
 
    rformat = '%(class)s(%(path)r, %(file_id)r)'
641
 
 
642
508
    def associated_filenames(self):
643
509
        return [self.path + suffix for suffix in CONFLICT_SUFFIXES]
644
510
 
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
511
 
678
512
class HandledConflict(Conflict):
679
513
    """A path problem that has been provisionally resolved.
765
599
 
766
600
    typestring = 'parent loop'
767
601
 
768
 
    format = 'Conflict moving %(path)s into %(conflict_path)s. %(action)s.'
 
602
    format = 'Conflict moving %(conflict_path)s into %(path)s.  %(action)s.'
769
603
 
770
604
    def action_take_this(self, tree):
771
605
        # just acccept bzr proposal
772
606
        pass
773
607
 
774
608
    def action_take_other(self, tree):
 
609
        # FIXME: We shouldn't have to manipulate so many paths here (and there
 
610
        # is probably a bug or two...)
 
611
        base_path = osutils.basename(self.path)
 
612
        conflict_base_path = osutils.basename(self.conflict_path)
775
613
        tt = transform.TreeTransform(tree)
776
614
        try:
777
615
            p_tid = tt.trans_id_file_id(self.file_id)
778
616
            parent_tid = tt.get_tree_parent(p_tid)
779
617
            cp_tid = tt.trans_id_file_id(self.conflict_file_id)
780
618
            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)
 
619
            tt.adjust_path(base_path, cparent_tid, cp_tid)
 
620
            tt.adjust_path(conflict_base_path, parent_tid, p_tid)
784
621
            tt.apply()
785
622
        finally:
786
623
            tt.finalize()