← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/conflicts.py

  • Committer: Tarmac
  • Author(s): Vincent Ladeuil
  • Date: 2017-01-30 14:42:05 UTC
  • mfrom: (6620.1.1 trunk)
  • Revision ID: tarmac-20170130144205-r8fh2xpmiuxyozpv
Merge  2.7 into trunk including fix for bug #1657238 [r=vila]

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, 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
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
 
 
20
from __future__ import absolute_import
 
21
 
22
22
import os
23
23
 
24
24
from bzrlib.lazy_import import lazy_import
26
26
import errno
27
27
 
28
28
from bzrlib import (
29
 
    builtins,
30
 
    commands,
 
29
    cleanup,
31
30
    errors,
32
31
    osutils,
33
32
    rio,
34
33
    trace,
 
34
    transform,
 
35
    workingtree,
35
36
    )
 
37
from bzrlib.i18n import gettext, ngettext
36
38
""")
37
 
from bzrlib.option import Option
 
39
from bzrlib import (
 
40
    commands,
 
41
    option,
 
42
    registry,
 
43
    )
38
44
 
39
45
 
40
46
CONFLICT_SUFFIXES = ('.THIS', '.BASE', '.OTHER')
41
47
 
42
48
 
43
49
class cmd_conflicts(commands.Command):
44
 
    """List files with conflicts.
 
50
    __doc__ = """List files with conflicts.
45
51
 
46
52
    Merge will do its best to combine the changes in two branches, but there
47
53
    are some kinds of problems only a human can fix.  When it encounters those,
48
54
    it will mark a conflict.  A conflict means that you need to fix something,
49
 
    before you should commit.
 
55
    before you can commit.
50
56
 
51
57
    Conflicts normally are listed as short, human-readable messages.  If --text
52
58
    is supplied, the pathnames of files with text conflicts are listed,
55
61
    Use bzr resolve when you have fixed a problem.
56
62
    """
57
63
    takes_options = [
58
 
            Option('text',
59
 
                   help='List paths of files with text conflicts.'),
 
64
            'directory',
 
65
            option.Option('text',
 
66
                          help='List paths of files with text conflicts.'),
60
67
        ]
61
68
    _see_also = ['resolve', 'conflict-types']
62
69
 
63
 
    def run(self, text=False):
64
 
        from bzrlib.workingtree import WorkingTree
65
 
        wt = WorkingTree.open_containing(u'.')[0]
 
70
    def run(self, text=False, directory=u'.'):
 
71
        wt = workingtree.WorkingTree.open_containing(directory)[0]
66
72
        for conflict in wt.conflicts():
67
73
            if text:
68
74
                if conflict.typestring != 'text conflict':
69
75
                    continue
70
76
                self.outf.write(conflict.path + '\n')
71
77
            else:
72
 
                self.outf.write(str(conflict) + '\n')
 
78
                self.outf.write(unicode(conflict) + '\n')
 
79
 
 
80
 
 
81
resolve_action_registry = registry.Registry()
 
82
 
 
83
 
 
84
resolve_action_registry.register(
 
85
    'done', 'done', 'Marks the conflict as resolved.')
 
86
resolve_action_registry.register(
 
87
    'take-this', 'take_this',
 
88
    'Resolve the conflict preserving the version in the working tree.')
 
89
resolve_action_registry.register(
 
90
    'take-other', 'take_other',
 
91
    'Resolve the conflict taking the merged version into account.')
 
92
resolve_action_registry.default_key = 'done'
 
93
 
 
94
class ResolveActionOption(option.RegistryOption):
 
95
 
 
96
    def __init__(self):
 
97
        super(ResolveActionOption, self).__init__(
 
98
            'action', 'How to resolve the conflict.',
 
99
            value_switches=True,
 
100
            registry=resolve_action_registry)
73
101
 
74
102
 
75
103
class cmd_resolve(commands.Command):
76
 
    """Mark a conflict as resolved.
 
104
    __doc__ = """Mark a conflict as resolved.
77
105
 
78
106
    Merge will do its best to combine the changes in two branches, but there
79
107
    are some kinds of problems only a human can fix.  When it encounters those,
80
108
    it will mark a conflict.  A conflict means that you need to fix something,
81
 
    before you should commit.
 
109
    before you can commit.
82
110
 
83
111
    Once you have fixed a problem, use "bzr resolve" to automatically mark
84
112
    text conflicts as fixed, "bzr resolve FILE" to mark a specific conflict as
87
115
    aliases = ['resolved']
88
116
    takes_args = ['file*']
89
117
    takes_options = [
90
 
            Option('all', help='Resolve all conflicts in this tree.'),
 
118
            'directory',
 
119
            option.Option('all', help='Resolve all conflicts in this tree.'),
 
120
            ResolveActionOption(),
91
121
            ]
92
122
    _see_also = ['conflicts']
93
 
    def run(self, file_list=None, all=False):
94
 
        from bzrlib.workingtree import WorkingTree
 
123
    def run(self, file_list=None, all=False, action=None, directory=None):
95
124
        if all:
96
125
            if file_list:
97
 
                raise errors.BzrCommandError("If --all is specified,"
98
 
                                             " no FILE may be provided")
99
 
            tree = WorkingTree.open_containing('.')[0]
100
 
            resolve(tree)
 
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]
 
131
            if action is None:
 
132
                action = 'done'
101
133
        else:
102
 
            tree, file_list = builtins.tree_files(file_list)
 
134
            tree, file_list = workingtree.WorkingTree.open_containing_paths(
 
135
                file_list, directory)
 
136
            if file_list is None:
 
137
                if action is None:
 
138
                    # FIXME: There is a special case here related to the option
 
139
                    # handling that could be clearer and easier to discover by
 
140
                    # providing an --auto action (bug #344013 and #383396) and
 
141
                    # make it mandatory instead of implicit and active only
 
142
                    # when no file_list is provided -- vila 091229
 
143
                    action = 'auto'
 
144
            else:
 
145
                if action is None:
 
146
                    action = 'done'
 
147
        if action == 'auto':
103
148
            if file_list is None:
104
149
                un_resolved, resolved = tree.auto_resolve()
105
150
                if len(un_resolved) > 0:
106
 
                    trace.note('%d conflict(s) auto-resolved.', len(resolved))
107
 
                    trace.note('Remaining conflicts:')
 
151
                    trace.note(ngettext('%d conflict auto-resolved.',
 
152
                        '%d conflicts auto-resolved.', len(resolved)),
 
153
                        len(resolved))
 
154
                    trace.note(gettext('Remaining conflicts:'))
108
155
                    for conflict in un_resolved:
109
 
                        trace.note(conflict)
 
156
                        trace.note(unicode(conflict))
110
157
                    return 1
111
158
                else:
112
 
                    trace.note('All conflicts resolved.')
 
159
                    trace.note(gettext('All conflicts resolved.'))
113
160
                    return 0
114
161
            else:
115
 
                resolve(tree, file_list)
116
 
 
117
 
 
118
 
def resolve(tree, paths=None, ignore_misses=False, recursive=False):
 
162
                # FIXME: This can never occur but the block above needs some
 
163
                # refactoring to transfer tree.auto_resolve() to
 
164
                # conflict.auto(tree) --vila 091242
 
165
                pass
 
166
        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))
 
171
 
 
172
 
 
173
def resolve(tree, paths=None, ignore_misses=False, recursive=False,
 
174
            action='done'):
119
175
    """Resolve some or all of the conflicts in a working tree.
120
176
 
121
177
    :param paths: If None, resolve all conflicts.  Otherwise, select only
125
181
        recursive commands like revert, this should be True.  For commands
126
182
        or applications wishing finer-grained control, like the resolve
127
183
        command, this should be False.
128
 
    :ignore_misses: If False, warnings will be printed if the supplied paths
129
 
        do not have conflicts.
 
184
    :param ignore_misses: If False, warnings will be printed if the supplied
 
185
        paths do not have conflicts.
 
186
    :param action: How the conflict should be resolved,
130
187
    """
131
188
    tree.lock_tree_write()
 
189
    nb_conflicts_after = None
132
190
    try:
133
191
        tree_conflicts = tree.conflicts()
 
192
        nb_conflicts_before = len(tree_conflicts)
134
193
        if paths is None:
135
194
            new_conflicts = ConflictList()
136
 
            selected_conflicts = tree_conflicts
 
195
            to_process = tree_conflicts
137
196
        else:
138
 
            new_conflicts, selected_conflicts = \
139
 
                tree_conflicts.select_conflicts(tree, paths, ignore_misses,
140
 
                    recursive)
 
197
            new_conflicts, to_process = tree_conflicts.select_conflicts(
 
198
                tree, paths, ignore_misses, recursive)
 
199
        for conflict in to_process:
 
200
            try:
 
201
                conflict._do(action, tree)
 
202
                conflict.cleanup(tree)
 
203
            except NotImplementedError:
 
204
                new_conflicts.append(conflict)
141
205
        try:
 
206
            nb_conflicts_after = len(new_conflicts)
142
207
            tree.set_conflicts(new_conflicts)
143
208
        except errors.UnsupportedOperation:
144
209
            pass
145
 
        selected_conflicts.remove_files(tree)
146
210
    finally:
147
211
        tree.unlock()
 
212
    if nb_conflicts_after is None:
 
213
        nb_conflicts_after = nb_conflicts_before
 
214
    return nb_conflicts_before, nb_conflicts_after
148
215
 
149
216
 
150
217
def restore(filename):
230
297
    def to_strings(self):
231
298
        """Generate strings for the provided conflicts"""
232
299
        for conflict in self:
233
 
            yield str(conflict)
 
300
            yield unicode(conflict)
234
301
 
235
302
    def remove_files(self, tree):
236
303
        """Remove the THIS, BASE and OTHER files for listed conflicts"""
237
304
        for conflict in self:
238
305
            if not conflict.has_files:
239
306
                continue
240
 
            for suffix in CONFLICT_SUFFIXES:
241
 
                try:
242
 
                    osutils.delete_any(tree.abspath(conflict.path+suffix))
243
 
                except OSError, e:
244
 
                    if e.errno != errno.ENOENT:
245
 
                        raise
 
307
            conflict.cleanup(tree)
246
308
 
247
309
    def select_conflicts(self, tree, paths, ignore_misses=False,
248
310
                         recurse=False):
301
363
class Conflict(object):
302
364
    """Base class for all types of conflict"""
303
365
 
 
366
    # FIXME: cleanup should take care of that ? -- vila 091229
304
367
    has_files = False
305
368
 
306
369
    def __init__(self, path, file_id=None):
333
396
    def __ne__(self, other):
334
397
        return not self.__eq__(other)
335
398
 
336
 
    def __str__(self):
 
399
    def __unicode__(self):
337
400
        return self.format % self.__dict__
338
401
 
339
402
    def __repr__(self):
355
418
        else:
356
419
            return None, conflict.typestring
357
420
 
 
421
    def _do(self, action, tree):
 
422
        """Apply the specified action to the conflict.
 
423
 
 
424
        :param action: The method name to call.
 
425
 
 
426
        :param tree: The tree passed as a parameter to the method.
 
427
        """
 
428
        meth = getattr(self, 'action_%s' % action, None)
 
429
        if meth is None:
 
430
            raise NotImplementedError(self.__class__.__name__ + '.' + action)
 
431
        meth(tree)
 
432
 
 
433
    def associated_filenames(self):
 
434
        """The names of the files generated to help resolve the conflict."""
 
435
        raise NotImplementedError(self.associated_filenames)
 
436
 
 
437
    def cleanup(self, tree):
 
438
        for fname in self.associated_filenames():
 
439
            try:
 
440
                osutils.delete_any(tree.abspath(fname))
 
441
            except OSError, e:
 
442
                if e.errno != errno.ENOENT:
 
443
                    raise
 
444
 
 
445
    def action_done(self, tree):
 
446
        """Mark the conflict as solved once it has been handled."""
 
447
        # This method does nothing but simplifies the design of upper levels.
 
448
        pass
 
449
 
 
450
    def action_take_this(self, tree):
 
451
        raise NotImplementedError(self.action_take_this)
 
452
 
 
453
    def action_take_other(self, tree):
 
454
        raise NotImplementedError(self.action_take_other)
 
455
 
 
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
 
358
462
 
359
463
class PathConflict(Conflict):
360
464
    """A conflict was encountered merging file paths"""
364
468
    format = 'Path conflict: %(path)s / %(conflict_path)s'
365
469
 
366
470
    rformat = '%(class)s(%(path)r, %(conflict_path)r, %(file_id)r)'
 
471
 
367
472
    def __init__(self, path, conflict_path=None, file_id=None):
368
473
        Conflict.__init__(self, path, file_id)
369
474
        self.conflict_path = conflict_path
374
479
            s.add('conflict_path', self.conflict_path)
375
480
        return s
376
481
 
 
482
    def associated_filenames(self):
 
483
        # No additional files have been generated here
 
484
        return []
 
485
 
 
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
    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)
 
559
 
 
560
    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)
 
571
 
377
572
 
378
573
class ContentsConflict(PathConflict):
379
 
    """The files are of different types, or not present"""
 
574
    """The files are of different types (or both binary), or not present"""
380
575
 
381
576
    has_files = True
382
577
 
384
579
 
385
580
    format = 'Contents conflict in %(path)s'
386
581
 
387
 
 
388
 
class TextConflict(PathConflict):
 
582
    def associated_filenames(self):
 
583
        return [self.path + suffix for suffix in ('.BASE', '.OTHER')]
 
584
 
 
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
 
 
622
    def action_take_this(self, tree):
 
623
        self._resolve_with_cleanups(tree, 'OTHER')
 
624
 
 
625
    def action_take_other(self, tree):
 
626
        self._resolve_with_cleanups(tree, 'THIS')
 
627
 
 
628
 
 
629
# TODO: There should be a base revid attribute to better inform the user about
 
630
# how the conflicts were generated.
 
631
class TextConflict(Conflict):
389
632
    """The merge algorithm could not resolve all differences encountered."""
390
633
 
391
634
    has_files = True
394
637
 
395
638
    format = 'Text conflict in %(path)s'
396
639
 
 
640
    rformat = '%(class)s(%(path)r, %(file_id)r)'
 
641
 
 
642
    def associated_filenames(self):
 
643
        return [self.path + suffix for suffix in CONFLICT_SUFFIXES]
 
644
 
 
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
 
397
677
 
398
678
class HandledConflict(Conflict):
399
679
    """A path problem that has been provisionally resolved.
414
694
        s.add('action', self.action)
415
695
        return s
416
696
 
 
697
    def associated_filenames(self):
 
698
        # Nothing has been generated here
 
699
        return []
 
700
 
417
701
 
418
702
class HandledPathConflict(HandledConflict):
419
703
    """A provisionally-resolved path problem involving two paths.
460
744
 
461
745
    format = 'Conflict adding file %(conflict_path)s.  %(action)s %(path)s.'
462
746
 
 
747
    def action_take_this(self, tree):
 
748
        tree.remove([self.conflict_path], force=True, keep_files=False)
 
749
        tree.rename_one(self.path, self.conflict_path)
 
750
 
 
751
    def action_take_other(self, tree):
 
752
        tree.remove([self.path], force=True, keep_files=False)
 
753
 
463
754
 
464
755
class ParentLoop(HandledPathConflict):
465
756
    """An attempt to create an infinitely-looping directory structure.
466
757
    This is rare, but can be produced like so:
467
758
 
468
759
    tree A:
469
 
      mv foo/bar
 
760
      mv foo bar
470
761
    tree B:
471
 
      mv bar/foo
 
762
      mv bar foo
472
763
    merge A and B
473
764
    """
474
765
 
475
766
    typestring = 'parent loop'
476
767
 
477
 
    format = 'Conflict moving %(conflict_path)s into %(path)s.  %(action)s.'
 
768
    format = 'Conflict moving %(path)s into %(conflict_path)s. %(action)s.'
 
769
 
 
770
    def action_take_this(self, tree):
 
771
        # just acccept bzr proposal
 
772
        pass
 
773
 
 
774
    def action_take_other(self, tree):
 
775
        tt = transform.TreeTransform(tree)
 
776
        try:
 
777
            p_tid = tt.trans_id_file_id(self.file_id)
 
778
            parent_tid = tt.get_tree_parent(p_tid)
 
779
            cp_tid = tt.trans_id_file_id(self.conflict_file_id)
 
780
            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)
 
784
            tt.apply()
 
785
        finally:
 
786
            tt.finalize()
478
787
 
479
788
 
480
789
class UnversionedParent(HandledConflict):
488
797
    format = 'Conflict because %(path)s is not versioned, but has versioned'\
489
798
             ' children.  %(action)s.'
490
799
 
 
800
    # FIXME: We silently do nothing to make tests pass, but most probably the
 
801
    # conflict shouldn't exist (the long story is that the conflict is
 
802
    # generated with another one that can be resolved properly) -- vila 091224
 
803
    def action_take_this(self, tree):
 
804
        pass
 
805
 
 
806
    def action_take_other(self, tree):
 
807
        pass
 
808
 
491
809
 
492
810
class MissingParent(HandledConflict):
493
811
    """An attempt to add files to a directory that is not present.
494
812
    Typically, the result of a merge where THIS deleted the directory and
495
813
    the OTHER added a file to it.
496
 
    See also: DeletingParent (same situation, reversed THIS and OTHER)
 
814
    See also: DeletingParent (same situation, THIS and OTHER reversed)
497
815
    """
498
816
 
499
817
    typestring = 'missing parent'
500
818
 
501
819
    format = 'Conflict adding files to %(path)s.  %(action)s.'
502
820
 
 
821
    def action_take_this(self, tree):
 
822
        tree.remove([self.path], force=True, keep_files=False)
 
823
 
 
824
    def action_take_other(self, tree):
 
825
        # just acccept bzr proposal
 
826
        pass
 
827
 
503
828
 
504
829
class DeletingParent(HandledConflict):
505
830
    """An attempt to add files to a directory that is not present.
512
837
    format = "Conflict: can't delete %(path)s because it is not empty.  "\
513
838
             "%(action)s."
514
839
 
 
840
    # FIXME: It's a bit strange that the default action is not coherent with
 
841
    # MissingParent from the *user* pov.
 
842
 
 
843
    def action_take_this(self, tree):
 
844
        # just acccept bzr proposal
 
845
        pass
 
846
 
 
847
    def action_take_other(self, tree):
 
848
        tree.remove([self.path], force=True, keep_files=False)
 
849
 
515
850
 
516
851
class NonDirectoryParent(HandledConflict):
517
 
    """An attempt to add files to a directory that is not a director or
 
852
    """An attempt to add files to a directory that is not a directory or
518
853
    an attempt to change the kind of a directory with files.
519
854
    """
520
855
 
523
858
    format = "Conflict: %(path)s is not a directory, but has files in it."\
524
859
             "  %(action)s."
525
860
 
 
861
    # FIXME: .OTHER should be used instead of .new when the conflict is created
 
862
 
 
863
    def action_take_this(self, tree):
 
864
        # FIXME: we should preserve that path when the conflict is generated !
 
865
        if self.path.endswith('.new'):
 
866
            conflict_path = self.path[:-(len('.new'))]
 
867
            tree.remove([self.path], force=True, keep_files=False)
 
868
            tree.add(conflict_path)
 
869
        else:
 
870
            raise NotImplementedError(self.action_take_this)
 
871
 
 
872
    def action_take_other(self, tree):
 
873
        # FIXME: we should preserve that path when the conflict is generated !
 
874
        if self.path.endswith('.new'):
 
875
            conflict_path = self.path[:-(len('.new'))]
 
876
            tree.remove([conflict_path], force=True, keep_files=False)
 
877
            tree.rename_one(self.path, conflict_path)
 
878
        else:
 
879
            raise NotImplementedError(self.action_take_other)
 
880
 
 
881
 
526
882
ctype = {}
527
883
 
528
884
 
532
888
    for conflict_type in conflict_types:
533
889
        ctype[conflict_type.typestring] = conflict_type
534
890
 
535
 
 
536
891
register_types(ContentsConflict, TextConflict, PathConflict, DuplicateID,
537
892
               DuplicateEntry, ParentLoop, UnversionedParent, MissingParent,
538
893
               DeletingParent, NonDirectoryParent)