← 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: 2011-08-17 08:40:16 UTC
  • mfrom: (5642.4.6 712474-module-available)
  • Revision ID: pqm@pqm.ubuntu.com-20110817084016-600z65qzqmmt44w7
(vila) ModuleAvailableFeature don't try to imported already imported
 modules. (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
18
18
# point down
19
19
 
20
20
import os
21
 
import re
22
21
 
23
22
from bzrlib.lazy_import import lazy_import
24
23
lazy_import(globals(), """
25
24
import errno
26
25
 
27
26
from bzrlib import (
28
 
    builtins,
29
 
    commands,
 
27
    cleanup,
30
28
    errors,
31
29
    osutils,
32
30
    rio,
36
34
    )
37
35
""")
38
36
from bzrlib import (
 
37
    commands,
39
38
    option,
40
39
    registry,
41
40
    )
45
44
 
46
45
 
47
46
class cmd_conflicts(commands.Command):
48
 
    """List files with conflicts.
 
47
    __doc__ = """List files with conflicts.
49
48
 
50
49
    Merge will do its best to combine the changes in two branches, but there
51
50
    are some kinds of problems only a human can fix.  When it encounters those,
59
58
    Use bzr resolve when you have fixed a problem.
60
59
    """
61
60
    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):
68
 
        wt = workingtree.WorkingTree.open_containing(u'.')[0]
 
67
    def run(self, text=False, directory=u'.'):
 
68
        wt = workingtree.WorkingTree.open_containing(directory)[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(str(conflict) + '\n')
 
75
                self.outf.write(unicode(conflict) + '\n')
76
76
 
77
77
 
78
78
resolve_action_registry = registry.Registry()
98
98
 
99
99
 
100
100
class cmd_resolve(commands.Command):
101
 
    """Mark a conflict as resolved.
 
101
    __doc__ = """Mark a conflict as resolved.
102
102
 
103
103
    Merge will do its best to combine the changes in two branches, but there
104
104
    are some kinds of problems only a human can fix.  When it encounters those,
112
112
    aliases = ['resolved']
113
113
    takes_args = ['file*']
114
114
    takes_options = [
 
115
            'directory',
115
116
            option.Option('all', help='Resolve all conflicts in this tree.'),
116
117
            ResolveActionOption(),
117
118
            ]
118
119
    _see_also = ['conflicts']
119
 
    def run(self, file_list=None, all=False, action=None):
 
120
    def run(self, file_list=None, all=False, action=None, directory=None):
120
121
        if all:
121
122
            if file_list:
122
123
                raise errors.BzrCommandError("If --all is specified,"
123
124
                                             " no FILE may be provided")
124
 
            tree = workingtree.WorkingTree.open_containing('.')[0]
 
125
            if directory is None:
 
126
                directory = u'.'
 
127
            tree = workingtree.WorkingTree.open_containing(directory)[0]
125
128
            if action is None:
126
129
                action = 'done'
127
130
        else:
128
 
            tree, file_list = builtins.tree_files(file_list)
 
131
            tree, file_list = workingtree.WorkingTree.open_containing_paths(
 
132
                file_list, directory)
129
133
            if file_list is None:
130
134
                if action is None:
131
135
                    # FIXME: There is a special case here related to the option
144
148
                    trace.note('%d conflict(s) auto-resolved.', len(resolved))
145
149
                    trace.note('Remaining conflicts:')
146
150
                    for conflict in un_resolved:
147
 
                        trace.note(conflict)
 
151
                        trace.note(unicode(conflict))
148
152
                    return 1
149
153
                else:
150
154
                    trace.note('All conflicts resolved.')
155
159
                # conflict.auto(tree) --vila 091242
156
160
                pass
157
161
        else:
158
 
            resolve(tree, file_list, action=action)
 
162
            before, after = resolve(tree, file_list, action=action)
 
163
            trace.note('%d conflict(s) resolved, %d remaining'
 
164
                       % (before - after, after))
159
165
 
160
166
 
161
167
def resolve(tree, paths=None, ignore_misses=False, recursive=False,
174
180
    :param action: How the conflict should be resolved,
175
181
    """
176
182
    tree.lock_tree_write()
 
183
    nb_conflicts_after = None
177
184
    try:
178
185
        tree_conflicts = tree.conflicts()
 
186
        nb_conflicts_before = len(tree_conflicts)
179
187
        if paths is None:
180
188
            new_conflicts = ConflictList()
181
189
            to_process = tree_conflicts
189
197
            except NotImplementedError:
190
198
                new_conflicts.append(conflict)
191
199
        try:
 
200
            nb_conflicts_after = len(new_conflicts)
192
201
            tree.set_conflicts(new_conflicts)
193
202
        except errors.UnsupportedOperation:
194
203
            pass
195
204
    finally:
196
205
        tree.unlock()
 
206
    if nb_conflicts_after is None:
 
207
        nb_conflicts_after = nb_conflicts_before
 
208
    return nb_conflicts_before, nb_conflicts_after
197
209
 
198
210
 
199
211
def restore(filename):
279
291
    def to_strings(self):
280
292
        """Generate strings for the provided conflicts"""
281
293
        for conflict in self:
282
 
            yield str(conflict)
 
294
            yield unicode(conflict)
283
295
 
284
296
    def remove_files(self, tree):
285
297
        """Remove the THIS, BASE and OTHER files for listed conflicts"""
378
390
    def __ne__(self, other):
379
391
        return not self.__eq__(other)
380
392
 
381
 
    def __str__(self):
 
393
    def __unicode__(self):
382
394
        return self.format % self.__dict__
383
395
 
384
396
    def __repr__(self):
435
447
    def action_take_other(self, tree):
436
448
        raise NotImplementedError(self.action_take_other)
437
449
 
 
450
    def _resolve_with_cleanups(self, tree, *args, **kwargs):
 
451
        tt = transform.TreeTransform(tree)
 
452
        op = cleanup.OperationWithCleanups(self._resolve)
 
453
        op.add_cleanup(tt.finalize)
 
454
        op.run_simple(tt, *args, **kwargs)
 
455
 
438
456
 
439
457
class PathConflict(Conflict):
440
458
    """A conflict was encountered merging file paths"""
459
477
        # No additional files have been generated here
460
478
        return []
461
479
 
 
480
    def _resolve(self, tt, file_id, path, winner):
 
481
        """Resolve the conflict.
 
482
 
 
483
        :param tt: The TreeTransform where the conflict is resolved.
 
484
        :param file_id: The retained file id.
 
485
        :param path: The retained path.
 
486
        :param winner: 'this' or 'other' indicates which side is the winner.
 
487
        """
 
488
        path_to_create = None
 
489
        if winner == 'this':
 
490
            if self.path == '<deleted>':
 
491
                return # Nothing to do
 
492
            if self.conflict_path == '<deleted>':
 
493
                path_to_create = self.path
 
494
                revid = tt._tree.get_parent_ids()[0]
 
495
        elif winner == 'other':
 
496
            if self.conflict_path == '<deleted>':
 
497
                return  # Nothing to do
 
498
            if self.path == '<deleted>':
 
499
                path_to_create = self.conflict_path
 
500
                # FIXME: If there are more than two parents we may need to
 
501
                # iterate. Taking the last parent is the safer bet in the mean
 
502
                # time. -- vila 20100309
 
503
                revid = tt._tree.get_parent_ids()[-1]
 
504
        else:
 
505
            # Programmer error
 
506
            raise AssertionError('bad winner: %r' % (winner,))
 
507
        if path_to_create is not None:
 
508
            tid = tt.trans_id_tree_path(path_to_create)
 
509
            transform.create_from_tree(
 
510
                tt, tid, self._revision_tree(tt._tree, revid), file_id)
 
511
            tt.version_file(file_id, tid)
 
512
        else:
 
513
            tid = tt.trans_id_file_id(file_id)
 
514
        # Adjust the path for the retained file id
 
515
        parent_tid = tt.get_tree_parent(tid)
 
516
        tt.adjust_path(osutils.basename(path), parent_tid, tid)
 
517
        tt.apply()
 
518
 
 
519
    def _revision_tree(self, tree, revid):
 
520
        return tree.branch.repository.revision_tree(revid)
 
521
 
 
522
    def _infer_file_id(self, tree):
 
523
        # Prior to bug #531967, file_id wasn't always set, there may still be
 
524
        # conflict files in the wild so we need to cope with them
 
525
        # Establish which path we should use to find back the file-id
 
526
        possible_paths = []
 
527
        for p in (self.path, self.conflict_path):
 
528
            if p == '<deleted>':
 
529
                # special hard-coded path 
 
530
                continue
 
531
            if p is not None:
 
532
                possible_paths.append(p)
 
533
        # Search the file-id in the parents with any path available
 
534
        file_id = None
 
535
        for revid in tree.get_parent_ids():
 
536
            revtree = self._revision_tree(tree, revid)
 
537
            for p in possible_paths:
 
538
                file_id = revtree.path2id(p)
 
539
                if file_id is not None:
 
540
                    return revtree, file_id
 
541
        return None, None
 
542
 
462
543
    def action_take_this(self, tree):
463
 
        tree.rename_one(self.conflict_path, self.path)
 
544
        if self.file_id is not None:
 
545
            self._resolve_with_cleanups(tree, self.file_id, self.path,
 
546
                                        winner='this')
 
547
        else:
 
548
            # Prior to bug #531967 we need to find back the file_id and restore
 
549
            # the content from there
 
550
            revtree, file_id = self._infer_file_id(tree)
 
551
            tree.revert([revtree.id2path(file_id)],
 
552
                        old_tree=revtree, backups=False)
464
553
 
465
554
    def action_take_other(self, tree):
466
 
        # just acccept bzr proposal
467
 
        pass
 
555
        if self.file_id is not None:
 
556
            self._resolve_with_cleanups(tree, self.file_id,
 
557
                                        self.conflict_path,
 
558
                                        winner='other')
 
559
        else:
 
560
            # Prior to bug #531967 we need to find back the file_id and restore
 
561
            # the content from there
 
562
            revtree, file_id = self._infer_file_id(tree)
 
563
            tree.revert([revtree.id2path(file_id)],
 
564
                        old_tree=revtree, backups=False)
468
565
 
469
566
 
470
567
class ContentsConflict(PathConflict):
471
 
    """The files are of different types, or not present"""
 
568
    """The files are of different types (or both binary), or not present"""
472
569
 
473
570
    has_files = True
474
571
 
479
576
    def associated_filenames(self):
480
577
        return [self.path + suffix for suffix in ('.BASE', '.OTHER')]
481
578
 
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
 
579
    def _resolve(self, tt, suffix_to_remove):
 
580
        """Resolve the conflict.
 
581
 
 
582
        :param tt: The TreeTransform where the conflict is resolved.
 
583
        :param suffix_to_remove: Either 'THIS' or 'OTHER'
 
584
 
 
585
        The resolution is symmetric: when taking THIS, OTHER is deleted and
 
586
        item.THIS is renamed into item and vice-versa.
 
587
        """
 
588
        try:
 
589
            # Delete 'item.THIS' or 'item.OTHER' depending on
 
590
            # suffix_to_remove
 
591
            tt.delete_contents(
 
592
                tt.trans_id_tree_path(self.path + '.' + suffix_to_remove))
 
593
        except errors.NoSuchFile:
 
594
            # There are valid cases where 'item.suffix_to_remove' either
 
595
            # never existed or was already deleted (including the case
 
596
            # where the user deleted it)
 
597
            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()
 
615
 
486
616
    def action_take_this(self, tree):
487
 
        tree.remove([self.path + '.OTHER'], force=True, keep_files=False)
 
617
        self._resolve_with_cleanups(tree, 'OTHER')
488
618
 
489
619
    def action_take_other(self, tree):
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
 
620
        self._resolve_with_cleanups(tree, 'THIS')
 
621
 
496
622
 
497
623
# TODO: There should be a base revid attribute to better inform the user about
498
624
# how the conflicts were generated.
499
 
class TextConflict(PathConflict):
 
625
class TextConflict(Conflict):
500
626
    """The merge algorithm could not resolve all differences encountered."""
501
627
 
502
628
    has_files = True
505
631
 
506
632
    format = 'Text conflict in %(path)s'
507
633
 
 
634
    rformat = '%(class)s(%(path)r, %(file_id)r)'
 
635
 
508
636
    def associated_filenames(self):
509
637
        return [self.path + suffix for suffix in CONFLICT_SUFFIXES]
510
638
 
 
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
 
511
671
 
512
672
class HandledConflict(Conflict):
513
673
    """A path problem that has been provisionally resolved.
599
759
 
600
760
    typestring = 'parent loop'
601
761
 
602
 
    format = 'Conflict moving %(conflict_path)s into %(path)s.  %(action)s.'
 
762
    format = 'Conflict moving %(path)s into %(conflict_path)s. %(action)s.'
603
763
 
604
764
    def action_take_this(self, tree):
605
765
        # just acccept bzr proposal
606
766
        pass
607
767
 
608
768
    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)
613
769
        tt = transform.TreeTransform(tree)
614
770
        try:
615
771
            p_tid = tt.trans_id_file_id(self.file_id)
616
772
            parent_tid = tt.get_tree_parent(p_tid)
617
773
            cp_tid = tt.trans_id_file_id(self.conflict_file_id)
618
774
            cparent_tid = tt.get_tree_parent(cp_tid)
619
 
            tt.adjust_path(base_path, cparent_tid, cp_tid)
620
 
            tt.adjust_path(conflict_base_path, parent_tid, p_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)
621
778
            tt.apply()
622
779
        finally:
623
780
            tt.finalize()