← 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-09-01 08:02:42 UTC
  • mfrom: (5390.3.3 faster-revert-593560)
  • Revision ID: pqm@pqm.ubuntu.com-20100901080242-esg62ody4frwmy66
(spiv) Avoid repeatedly calling self.target.all_file_ids() in
 InterTree.iter_changes. (Andrew Bennetts)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/conflicts.py
1
 
# Copyright (C) 2005, 2007 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
14
14
# along with this program; if not, write to the Free Software
15
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
16
 
17
 
# TODO: Move this into builtins
18
 
 
19
17
# TODO: 'bzr resolve' should accept a directory name and work from that
20
18
# point down
21
19
 
26
24
import errno
27
25
 
28
26
from bzrlib import (
29
 
    builtins,
 
27
    cleanup,
30
28
    commands,
31
29
    errors,
32
30
    osutils,
33
31
    rio,
34
32
    trace,
 
33
    transform,
 
34
    workingtree,
35
35
    )
36
36
""")
37
 
from bzrlib.option import Option
 
37
from bzrlib import (
 
38
    option,
 
39
    registry,
 
40
    )
38
41
 
39
42
 
40
43
CONFLICT_SUFFIXES = ('.THIS', '.BASE', '.OTHER')
41
44
 
42
45
 
43
46
class cmd_conflicts(commands.Command):
44
 
    """List files with conflicts.
 
47
    __doc__ = """List files with conflicts.
45
48
 
46
49
    Merge will do its best to combine the changes in two branches, but there
47
50
    are some kinds of problems only a human can fix.  When it encounters those,
53
56
    instead.  (This is useful for editing all files with text conflicts.)
54
57
 
55
58
    Use bzr resolve when you have fixed a problem.
56
 
 
57
 
    See also bzr resolve.
58
59
    """
59
60
    takes_options = [
60
 
            Option('text',
61
 
                   help='List paths of files with text conflicts.'),
 
61
            'directory',
 
62
            option.Option('text',
 
63
                          help='List paths of files with text conflicts.'),
62
64
        ]
 
65
    _see_also = ['resolve', 'conflict-types']
63
66
 
64
 
    def run(self, text=False):
65
 
        from bzrlib.workingtree import WorkingTree
66
 
        wt = WorkingTree.open_containing(u'.')[0]
 
67
    def run(self, text=False, directory=u'.'):
 
68
        wt = workingtree.WorkingTree.open_containing(directory)[0]
67
69
        for conflict in wt.conflicts():
68
70
            if text:
69
71
                if conflict.typestring != 'text conflict':
73
75
                self.outf.write(str(conflict) + '\n')
74
76
 
75
77
 
 
78
resolve_action_registry = registry.Registry()
 
79
 
 
80
 
 
81
resolve_action_registry.register(
 
82
    'done', 'done', 'Marks the conflict as resolved' )
 
83
resolve_action_registry.register(
 
84
    'take-this', 'take_this',
 
85
    'Resolve the conflict preserving the version in the working tree' )
 
86
resolve_action_registry.register(
 
87
    'take-other', 'take_other',
 
88
    'Resolve the conflict taking the merged version into account' )
 
89
resolve_action_registry.default_key = 'done'
 
90
 
 
91
class ResolveActionOption(option.RegistryOption):
 
92
 
 
93
    def __init__(self):
 
94
        super(ResolveActionOption, self).__init__(
 
95
            'action', 'How to resolve the conflict.',
 
96
            value_switches=True,
 
97
            registry=resolve_action_registry)
 
98
 
 
99
 
76
100
class cmd_resolve(commands.Command):
77
 
    """Mark a conflict as resolved.
 
101
    __doc__ = """Mark a conflict as resolved.
78
102
 
79
103
    Merge will do its best to combine the changes in two branches, but there
80
104
    are some kinds of problems only a human can fix.  When it encounters those,
82
106
    before you should commit.
83
107
 
84
108
    Once you have fixed a problem, use "bzr resolve" to automatically mark
85
 
    text conflicts as fixed, resolve FILE to mark a specific conflict as
 
109
    text conflicts as fixed, "bzr resolve FILE" to mark a specific conflict as
86
110
    resolved, or "bzr resolve --all" to mark all conflicts as resolved.
87
 
 
88
 
    See also bzr conflicts.
89
111
    """
90
112
    aliases = ['resolved']
91
113
    takes_args = ['file*']
92
114
    takes_options = [
93
 
            Option('all', help='Resolve all conflicts in this tree.'),
 
115
            'directory',
 
116
            option.Option('all', help='Resolve all conflicts in this tree.'),
 
117
            ResolveActionOption(),
94
118
            ]
95
 
    def run(self, file_list=None, all=False):
96
 
        from bzrlib.workingtree import WorkingTree
 
119
    _see_also = ['conflicts']
 
120
    def run(self, file_list=None, all=False, action=None, directory=u'.'):
97
121
        if all:
98
122
            if file_list:
99
123
                raise errors.BzrCommandError("If --all is specified,"
100
124
                                             " no FILE may be provided")
101
 
            tree = WorkingTree.open_containing('.')[0]
102
 
            resolve(tree)
 
125
            tree = workingtree.WorkingTree.open_containing(directory)[0]
 
126
            if action is None:
 
127
                action = 'done'
103
128
        else:
104
 
            tree, file_list = builtins.tree_files(file_list)
 
129
            tree, file_list = workingtree.WorkingTree.open_containing_paths(
 
130
                file_list)
 
131
            if file_list is None:
 
132
                if action is None:
 
133
                    # FIXME: There is a special case here related to the option
 
134
                    # handling that could be clearer and easier to discover by
 
135
                    # providing an --auto action (bug #344013 and #383396) and
 
136
                    # make it mandatory instead of implicit and active only
 
137
                    # when no file_list is provided -- vila 091229
 
138
                    action = 'auto'
 
139
            else:
 
140
                if action is None:
 
141
                    action = 'done'
 
142
        if action == 'auto':
105
143
            if file_list is None:
106
144
                un_resolved, resolved = tree.auto_resolve()
107
145
                if len(un_resolved) > 0:
114
152
                    trace.note('All conflicts resolved.')
115
153
                    return 0
116
154
            else:
117
 
                resolve(tree, file_list)
118
 
 
119
 
 
120
 
def resolve(tree, paths=None, ignore_misses=False, recursive=False):
 
155
                # FIXME: This can never occur but the block above needs some
 
156
                # refactoring to transfer tree.auto_resolve() to
 
157
                # conflict.auto(tree) --vila 091242
 
158
                pass
 
159
        else:
 
160
            resolve(tree, file_list, action=action)
 
161
 
 
162
 
 
163
def resolve(tree, paths=None, ignore_misses=False, recursive=False,
 
164
            action='done'):
121
165
    """Resolve some or all of the conflicts in a working tree.
122
166
 
123
167
    :param paths: If None, resolve all conflicts.  Otherwise, select only
127
171
        recursive commands like revert, this should be True.  For commands
128
172
        or applications wishing finer-grained control, like the resolve
129
173
        command, this should be False.
130
 
    :ignore_misses: If False, warnings will be printed if the supplied paths
131
 
        do not have conflicts.
 
174
    :param ignore_misses: If False, warnings will be printed if the supplied
 
175
        paths do not have conflicts.
 
176
    :param action: How the conflict should be resolved,
132
177
    """
133
178
    tree.lock_tree_write()
134
179
    try:
135
180
        tree_conflicts = tree.conflicts()
136
181
        if paths is None:
137
182
            new_conflicts = ConflictList()
138
 
            selected_conflicts = tree_conflicts
 
183
            to_process = tree_conflicts
139
184
        else:
140
 
            new_conflicts, selected_conflicts = \
141
 
                tree_conflicts.select_conflicts(tree, paths, ignore_misses,
142
 
                    recursive)
 
185
            new_conflicts, to_process = tree_conflicts.select_conflicts(
 
186
                tree, paths, ignore_misses, recursive)
 
187
        for conflict in to_process:
 
188
            try:
 
189
                conflict._do(action, tree)
 
190
                conflict.cleanup(tree)
 
191
            except NotImplementedError:
 
192
                new_conflicts.append(conflict)
143
193
        try:
144
194
            tree.set_conflicts(new_conflicts)
145
195
        except errors.UnsupportedOperation:
146
196
            pass
147
 
        selected_conflicts.remove_files(tree)
148
197
    finally:
149
198
        tree.unlock()
150
199
 
151
200
 
152
201
def restore(filename):
153
 
    """\
154
 
    Restore a conflicted file to the state it was in before merging.
155
 
    Only text restoration supported at present.
 
202
    """Restore a conflicted file to the state it was in before merging.
 
203
 
 
204
    Only text restoration is supported at present.
156
205
    """
157
206
    conflicted = False
158
207
    try:
239
288
        for conflict in self:
240
289
            if not conflict.has_files:
241
290
                continue
242
 
            for suffix in CONFLICT_SUFFIXES:
243
 
                try:
244
 
                    osutils.delete_any(tree.abspath(conflict.path+suffix))
245
 
                except OSError, e:
246
 
                    if e.errno != errno.ENOENT:
247
 
                        raise
 
291
            conflict.cleanup(tree)
248
292
 
249
293
    def select_conflicts(self, tree, paths, ignore_misses=False,
250
294
                         recurse=False):
303
347
class Conflict(object):
304
348
    """Base class for all types of conflict"""
305
349
 
 
350
    # FIXME: cleanup should take care of that ? -- vila 091229
306
351
    has_files = False
307
352
 
308
353
    def __init__(self, path, file_id=None):
357
402
        else:
358
403
            return None, conflict.typestring
359
404
 
 
405
    def _do(self, action, tree):
 
406
        """Apply the specified action to the conflict.
 
407
 
 
408
        :param action: The method name to call.
 
409
 
 
410
        :param tree: The tree passed as a parameter to the method.
 
411
        """
 
412
        meth = getattr(self, 'action_%s' % action, None)
 
413
        if meth is None:
 
414
            raise NotImplementedError(self.__class__.__name__ + '.' + action)
 
415
        meth(tree)
 
416
 
 
417
    def associated_filenames(self):
 
418
        """The names of the files generated to help resolve the conflict."""
 
419
        raise NotImplementedError(self.associated_filenames)
 
420
 
 
421
    def cleanup(self, tree):
 
422
        for fname in self.associated_filenames():
 
423
            try:
 
424
                osutils.delete_any(tree.abspath(fname))
 
425
            except OSError, e:
 
426
                if e.errno != errno.ENOENT:
 
427
                    raise
 
428
 
 
429
    def action_done(self, tree):
 
430
        """Mark the conflict as solved once it has been handled."""
 
431
        # This method does nothing but simplifies the design of upper levels.
 
432
        pass
 
433
 
 
434
    def action_take_this(self, tree):
 
435
        raise NotImplementedError(self.action_take_this)
 
436
 
 
437
    def action_take_other(self, tree):
 
438
        raise NotImplementedError(self.action_take_other)
 
439
 
 
440
    def _resolve_with_cleanups(self, tree, *args, **kwargs):
 
441
        tt = transform.TreeTransform(tree)
 
442
        op = cleanup.OperationWithCleanups(self._resolve)
 
443
        op.add_cleanup(tt.finalize)
 
444
        op.run_simple(tt, *args, **kwargs)
 
445
 
360
446
 
361
447
class PathConflict(Conflict):
362
448
    """A conflict was encountered merging file paths"""
366
452
    format = 'Path conflict: %(path)s / %(conflict_path)s'
367
453
 
368
454
    rformat = '%(class)s(%(path)r, %(conflict_path)r, %(file_id)r)'
 
455
 
369
456
    def __init__(self, path, conflict_path=None, file_id=None):
370
457
        Conflict.__init__(self, path, file_id)
371
458
        self.conflict_path = conflict_path
376
463
            s.add('conflict_path', self.conflict_path)
377
464
        return s
378
465
 
 
466
    def associated_filenames(self):
 
467
        # No additional files have been generated here
 
468
        return []
 
469
 
 
470
    def _resolve(self, tt, file_id, path, winner):
 
471
        """Resolve the conflict.
 
472
 
 
473
        :param tt: The TreeTransform where the conflict is resolved.
 
474
        :param file_id: The retained file id.
 
475
        :param path: The retained path.
 
476
        :param winner: 'this' or 'other' indicates which side is the winner.
 
477
        """
 
478
        path_to_create = None
 
479
        if winner == 'this':
 
480
            if self.path == '<deleted>':
 
481
                return # Nothing to do
 
482
            if self.conflict_path == '<deleted>':
 
483
                path_to_create = self.path
 
484
                revid = tt._tree.get_parent_ids()[0]
 
485
        elif winner == 'other':
 
486
            if self.conflict_path == '<deleted>':
 
487
                return  # Nothing to do
 
488
            if self.path == '<deleted>':
 
489
                path_to_create = self.conflict_path
 
490
                # FIXME: If there are more than two parents we may need to
 
491
                # iterate. Taking the last parent is the safer bet in the mean
 
492
                # time. -- vila 20100309
 
493
                revid = tt._tree.get_parent_ids()[-1]
 
494
        else:
 
495
            # Programmer error
 
496
            raise AssertionError('bad winner: %r' % (winner,))
 
497
        if path_to_create is not None:
 
498
            tid = tt.trans_id_tree_path(path_to_create)
 
499
            transform.create_from_tree(
 
500
                tt, tt.trans_id_tree_path(path_to_create),
 
501
                self._revision_tree(tt._tree, revid), file_id)
 
502
            tt.version_file(file_id, tid)
 
503
 
 
504
        # Adjust the path for the retained file id
 
505
        tid = tt.trans_id_file_id(file_id)
 
506
        parent_tid = tt.get_tree_parent(tid)
 
507
        tt.adjust_path(path, parent_tid, tid)
 
508
        tt.apply()
 
509
 
 
510
    def _revision_tree(self, tree, revid):
 
511
        return tree.branch.repository.revision_tree(revid)
 
512
 
 
513
    def _infer_file_id(self, tree):
 
514
        # Prior to bug #531967, file_id wasn't always set, there may still be
 
515
        # conflict files in the wild so we need to cope with them
 
516
        # Establish which path we should use to find back the file-id
 
517
        possible_paths = []
 
518
        for p in (self.path, self.conflict_path):
 
519
            if p == '<deleted>':
 
520
                # special hard-coded path 
 
521
                continue
 
522
            if p is not None:
 
523
                possible_paths.append(p)
 
524
        # Search the file-id in the parents with any path available
 
525
        file_id = None
 
526
        for revid in tree.get_parent_ids():
 
527
            revtree = self._revision_tree(tree, revid)
 
528
            for p in possible_paths:
 
529
                file_id = revtree.path2id(p)
 
530
                if file_id is not None:
 
531
                    return revtree, file_id
 
532
        return None, None
 
533
 
 
534
    def action_take_this(self, tree):
 
535
        if self.file_id is not None:
 
536
            self._resolve_with_cleanups(tree, self.file_id, self.path,
 
537
                                        winner='this')
 
538
        else:
 
539
            # Prior to bug #531967 we need to find back the file_id and restore
 
540
            # the content from there
 
541
            revtree, file_id = self._infer_file_id(tree)
 
542
            tree.revert([revtree.id2path(file_id)],
 
543
                        old_tree=revtree, backups=False)
 
544
 
 
545
    def action_take_other(self, tree):
 
546
        if self.file_id is not None:
 
547
            self._resolve_with_cleanups(tree, self.file_id,
 
548
                                        self.conflict_path,
 
549
                                        winner='other')
 
550
        else:
 
551
            # Prior to bug #531967 we need to find back the file_id and restore
 
552
            # the content from there
 
553
            revtree, file_id = self._infer_file_id(tree)
 
554
            tree.revert([revtree.id2path(file_id)],
 
555
                        old_tree=revtree, backups=False)
 
556
 
379
557
 
380
558
class ContentsConflict(PathConflict):
381
 
    """The files are of different types, or not present"""
 
559
    """The files are of different types (or both binary), or not present"""
382
560
 
383
561
    has_files = True
384
562
 
386
564
 
387
565
    format = 'Contents conflict in %(path)s'
388
566
 
389
 
 
 
567
    def associated_filenames(self):
 
568
        return [self.path + suffix for suffix in ('.BASE', '.OTHER')]
 
569
 
 
570
    def _resolve(self, tt, suffix_to_remove):
 
571
        """Resolve the conflict.
 
572
 
 
573
        :param tt: The TreeTransform where the conflict is resolved.
 
574
        :param suffix_to_remove: Either 'THIS' or 'OTHER'
 
575
 
 
576
        The resolution is symmetric, when taking THIS, OTHER is deleted and
 
577
        item.THIS is renamed into item and vice-versa.
 
578
        """
 
579
        try:
 
580
            # Delete 'item.THIS' or 'item.OTHER' depending on
 
581
            # suffix_to_remove
 
582
            tt.delete_contents(
 
583
                tt.trans_id_tree_path(self.path + '.' + suffix_to_remove))
 
584
        except errors.NoSuchFile:
 
585
            # There are valid cases where 'item.suffix_to_remove' either
 
586
            # never existed or was already deleted (including the case
 
587
            # where the user deleted it)
 
588
            pass
 
589
        # Rename 'item.suffix_to_remove' (note that if
 
590
        # 'item.suffix_to_remove' has been deleted, this is a no-op)
 
591
        this_tid = tt.trans_id_file_id(self.file_id)
 
592
        parent_tid = tt.get_tree_parent(this_tid)
 
593
        tt.adjust_path(self.path, parent_tid, this_tid)
 
594
        tt.apply()
 
595
 
 
596
    def action_take_this(self, tree):
 
597
        self._resolve_with_cleanups(tree, 'OTHER')
 
598
 
 
599
    def action_take_other(self, tree):
 
600
        self._resolve_with_cleanups(tree, 'THIS')
 
601
 
 
602
 
 
603
# FIXME: TextConflict is about a single file-id, there never is a conflict_path
 
604
# attribute so we shouldn't inherit from PathConflict but simply from Conflict
 
605
 
 
606
# TODO: There should be a base revid attribute to better inform the user about
 
607
# how the conflicts were generated.
390
608
class TextConflict(PathConflict):
391
609
    """The merge algorithm could not resolve all differences encountered."""
392
610
 
396
614
 
397
615
    format = 'Text conflict in %(path)s'
398
616
 
 
617
    def associated_filenames(self):
 
618
        return [self.path + suffix for suffix in CONFLICT_SUFFIXES]
 
619
 
399
620
 
400
621
class HandledConflict(Conflict):
401
622
    """A path problem that has been provisionally resolved.
416
637
        s.add('action', self.action)
417
638
        return s
418
639
 
 
640
    def associated_filenames(self):
 
641
        # Nothing has been generated here
 
642
        return []
 
643
 
419
644
 
420
645
class HandledPathConflict(HandledConflict):
421
646
    """A provisionally-resolved path problem involving two paths.
462
687
 
463
688
    format = 'Conflict adding file %(conflict_path)s.  %(action)s %(path)s.'
464
689
 
 
690
    def action_take_this(self, tree):
 
691
        tree.remove([self.conflict_path], force=True, keep_files=False)
 
692
        tree.rename_one(self.path, self.conflict_path)
 
693
 
 
694
    def action_take_other(self, tree):
 
695
        tree.remove([self.path], force=True, keep_files=False)
 
696
 
465
697
 
466
698
class ParentLoop(HandledPathConflict):
467
699
    """An attempt to create an infinitely-looping directory structure.
468
700
    This is rare, but can be produced like so:
469
701
 
470
702
    tree A:
471
 
      mv foo/bar
 
703
      mv foo bar
472
704
    tree B:
473
 
      mv bar/foo
 
705
      mv bar foo
474
706
    merge A and B
475
707
    """
476
708
 
477
709
    typestring = 'parent loop'
478
710
 
479
 
    format = 'Conflict moving %(conflict_path)s into %(path)s.  %(action)s.'
 
711
    format = 'Conflict moving %(path)s into %(conflict_path)s. %(action)s.'
 
712
 
 
713
    def action_take_this(self, tree):
 
714
        # just acccept bzr proposal
 
715
        pass
 
716
 
 
717
    def action_take_other(self, tree):
 
718
        # FIXME: We shouldn't have to manipulate so many paths here (and there
 
719
        # is probably a bug or two...)
 
720
        base_path = osutils.basename(self.path)
 
721
        conflict_base_path = osutils.basename(self.conflict_path)
 
722
        tt = transform.TreeTransform(tree)
 
723
        try:
 
724
            p_tid = tt.trans_id_file_id(self.file_id)
 
725
            parent_tid = tt.get_tree_parent(p_tid)
 
726
            cp_tid = tt.trans_id_file_id(self.conflict_file_id)
 
727
            cparent_tid = tt.get_tree_parent(cp_tid)
 
728
            tt.adjust_path(base_path, cparent_tid, cp_tid)
 
729
            tt.adjust_path(conflict_base_path, parent_tid, p_tid)
 
730
            tt.apply()
 
731
        finally:
 
732
            tt.finalize()
480
733
 
481
734
 
482
735
class UnversionedParent(HandledConflict):
483
 
    """An attempt to version an file whose parent directory is not versioned.
 
736
    """An attempt to version a file whose parent directory is not versioned.
484
737
    Typically, the result of a merge where one tree unversioned the directory
485
738
    and the other added a versioned file to it.
486
739
    """
490
743
    format = 'Conflict because %(path)s is not versioned, but has versioned'\
491
744
             ' children.  %(action)s.'
492
745
 
 
746
    # FIXME: We silently do nothing to make tests pass, but most probably the
 
747
    # conflict shouldn't exist (the long story is that the conflict is
 
748
    # generated with another one that can be resolved properly) -- vila 091224
 
749
    def action_take_this(self, tree):
 
750
        pass
 
751
 
 
752
    def action_take_other(self, tree):
 
753
        pass
 
754
 
493
755
 
494
756
class MissingParent(HandledConflict):
495
757
    """An attempt to add files to a directory that is not present.
496
758
    Typically, the result of a merge where THIS deleted the directory and
497
759
    the OTHER added a file to it.
498
 
    See also: DeletingParent (same situation, reversed THIS and OTHER)
 
760
    See also: DeletingParent (same situation, THIS and OTHER reversed)
499
761
    """
500
762
 
501
763
    typestring = 'missing parent'
502
764
 
503
765
    format = 'Conflict adding files to %(path)s.  %(action)s.'
504
766
 
 
767
    def action_take_this(self, tree):
 
768
        tree.remove([self.path], force=True, keep_files=False)
 
769
 
 
770
    def action_take_other(self, tree):
 
771
        # just acccept bzr proposal
 
772
        pass
 
773
 
505
774
 
506
775
class DeletingParent(HandledConflict):
507
776
    """An attempt to add files to a directory that is not present.
514
783
    format = "Conflict: can't delete %(path)s because it is not empty.  "\
515
784
             "%(action)s."
516
785
 
 
786
    # FIXME: It's a bit strange that the default action is not coherent with
 
787
    # MissingParent from the *user* pov.
 
788
 
 
789
    def action_take_this(self, tree):
 
790
        # just acccept bzr proposal
 
791
        pass
 
792
 
 
793
    def action_take_other(self, tree):
 
794
        tree.remove([self.path], force=True, keep_files=False)
 
795
 
517
796
 
518
797
class NonDirectoryParent(HandledConflict):
519
 
    """An attempt to add files to a directory that is not a director or
 
798
    """An attempt to add files to a directory that is not a directory or
520
799
    an attempt to change the kind of a directory with files.
521
800
    """
522
801
 
525
804
    format = "Conflict: %(path)s is not a directory, but has files in it."\
526
805
             "  %(action)s."
527
806
 
 
807
    # FIXME: .OTHER should be used instead of .new when the conflict is created
 
808
 
 
809
    def action_take_this(self, tree):
 
810
        # FIXME: we should preserve that path when the conflict is generated !
 
811
        if self.path.endswith('.new'):
 
812
            conflict_path = self.path[:-(len('.new'))]
 
813
            tree.remove([self.path], force=True, keep_files=False)
 
814
            tree.add(conflict_path)
 
815
        else:
 
816
            raise NotImplementedError(self.action_take_this)
 
817
 
 
818
    def action_take_other(self, tree):
 
819
        # FIXME: we should preserve that path when the conflict is generated !
 
820
        if self.path.endswith('.new'):
 
821
            conflict_path = self.path[:-(len('.new'))]
 
822
            tree.remove([conflict_path], force=True, keep_files=False)
 
823
            tree.rename_one(self.path, conflict_path)
 
824
        else:
 
825
            raise NotImplementedError(self.action_take_other)
 
826
 
 
827
 
528
828
ctype = {}
529
829
 
530
830
 
534
834
    for conflict_type in conflict_types:
535
835
        ctype[conflict_type.typestring] = conflict_type
536
836
 
537
 
 
538
837
register_types(ContentsConflict, TextConflict, PathConflict, DuplicateID,
539
838
               DuplicateEntry, ParentLoop, UnversionedParent, MissingParent,
540
839
               DeletingParent, NonDirectoryParent)