← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/conflicts.py

  • Committer: Martin Pool
  • Date: 2007-01-24 07:12:09 UTC
  • mto: This revision was merged to the branch mainline in revision 2244.
  • Revision ID: mbp@sourcefrog.net-20070124071209-yqiths20n6wxqaqr
Change RepositoryFormat to use a Registry rather than ad-hoc dictionary

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