/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/conflicts.py

  • Committer: Robert Collins
  • Date: 2007-04-19 02:27:44 UTC
  • mto: This revision was merged to the branch mainline in revision 2426.
  • Revision ID: robertc@robertcollins.net-20070419022744-pfdqz42kp1wizh43
``make docs`` now creates a man page at ``man1/bzr.1`` fixing bug 107388.
(Robert Collins)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/conflicts.py
1
 
# Copyright (C) 2005, 2006, 2007, 2009, 2010, 2011 Canonical Ltd
 
1
# Copyright (C) 2005 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
 
    cleanup,
 
29
    builtins,
28
30
    commands,
29
31
    errors,
30
32
    osutils,
31
33
    rio,
32
34
    trace,
33
 
    transform,
34
 
    workingtree,
35
35
    )
36
36
""")
37
 
from bzrlib import (
38
 
    option,
39
 
    registry,
40
 
    )
 
37
from bzrlib.option import Option
41
38
 
42
39
 
43
40
CONFLICT_SUFFIXES = ('.THIS', '.BASE', '.OTHER')
44
41
 
45
42
 
46
43
class cmd_conflicts(commands.Command):
47
 
    __doc__ = """List files with conflicts.
 
44
    """List files with conflicts.
48
45
 
49
46
    Merge will do its best to combine the changes in two branches, but there
50
47
    are some kinds of problems only a human can fix.  When it encounters those,
56
53
    instead.  (This is useful for editing all files with text conflicts.)
57
54
 
58
55
    Use bzr resolve when you have fixed a problem.
 
56
 
 
57
    See also bzr resolve.
59
58
    """
60
 
    takes_options = [
61
 
            'directory',
62
 
            option.Option('text',
63
 
                          help='List paths of files with text conflicts.'),
64
 
        ]
65
 
    _see_also = ['resolve', 'conflict-types']
 
59
    takes_options = [Option('text', help='list text conflicts by pathname')]
66
60
 
67
 
    def run(self, text=False, directory=u'.'):
68
 
        wt = workingtree.WorkingTree.open_containing(directory)[0]
 
61
    def run(self, text=False):
 
62
        from bzrlib.workingtree import WorkingTree
 
63
        wt = WorkingTree.open_containing(u'.')[0]
69
64
        for conflict in wt.conflicts():
70
65
            if text:
71
66
                if conflict.typestring != 'text conflict':
75
70
                self.outf.write(str(conflict) + '\n')
76
71
 
77
72
 
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
73
class cmd_resolve(commands.Command):
101
 
    __doc__ = """Mark a conflict as resolved.
 
74
    """Mark a conflict as resolved.
102
75
 
103
76
    Merge will do its best to combine the changes in two branches, but there
104
77
    are some kinds of problems only a human can fix.  When it encounters those,
106
79
    before you should commit.
107
80
 
108
81
    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
 
82
    text conflicts as fixed, resolve FILE to mark a specific conflict as
110
83
    resolved, or "bzr resolve --all" to mark all conflicts as resolved.
 
84
 
 
85
    See also bzr conflicts.
111
86
    """
112
87
    aliases = ['resolved']
113
88
    takes_args = ['file*']
114
 
    takes_options = [
115
 
            'directory',
116
 
            option.Option('all', help='Resolve all conflicts in this tree.'),
117
 
            ResolveActionOption(),
118
 
            ]
119
 
    _see_also = ['conflicts']
120
 
    def run(self, file_list=None, all=False, action=None, directory=None):
 
89
    takes_options = [Option('all', help='Resolve all conflicts in this tree')]
 
90
    def run(self, file_list=None, all=False):
 
91
        from bzrlib.workingtree import WorkingTree
121
92
        if all:
122
93
            if file_list:
123
94
                raise errors.BzrCommandError("If --all is specified,"
124
95
                                             " no FILE may be provided")
125
 
            if directory is None:
126
 
                directory = u'.'
127
 
            tree = workingtree.WorkingTree.open_containing(directory)[0]
128
 
            if action is None:
129
 
                action = 'done'
 
96
            tree = WorkingTree.open_containing('.')[0]
 
97
            resolve(tree)
130
98
        else:
131
 
            tree, file_list = workingtree.WorkingTree.open_containing_paths(
132
 
                file_list, directory)
133
 
            if file_list is None:
134
 
                if action is None:
135
 
                    # FIXME: There is a special case here related to the option
136
 
                    # handling that could be clearer and easier to discover by
137
 
                    # providing an --auto action (bug #344013 and #383396) and
138
 
                    # make it mandatory instead of implicit and active only
139
 
                    # when no file_list is provided -- vila 091229
140
 
                    action = 'auto'
141
 
            else:
142
 
                if action is None:
143
 
                    action = 'done'
144
 
        if action == 'auto':
 
99
            tree, file_list = builtins.tree_files(file_list)
145
100
            if file_list is None:
146
101
                un_resolved, resolved = tree.auto_resolve()
147
102
                if len(un_resolved) > 0:
154
109
                    trace.note('All conflicts resolved.')
155
110
                    return 0
156
111
            else:
157
 
                # FIXME: This can never occur but the block above needs some
158
 
                # refactoring to transfer tree.auto_resolve() to
159
 
                # conflict.auto(tree) --vila 091242
160
 
                pass
161
 
        else:
162
 
            before, after = resolve(tree, file_list, action=action)
163
 
            trace.note('%d conflict(s) resolved, %d remaining'
164
 
                       % (before - after, after))
165
 
 
166
 
 
167
 
def resolve(tree, paths=None, ignore_misses=False, recursive=False,
168
 
            action='done'):
169
 
    """Resolve some or all of the conflicts in a working tree.
170
 
 
171
 
    :param paths: If None, resolve all conflicts.  Otherwise, select only
172
 
        specified conflicts.
173
 
    :param recursive: If True, then elements of paths which are directories
174
 
        have all their children resolved, etc.  When invoked as part of
175
 
        recursive commands like revert, this should be True.  For commands
176
 
        or applications wishing finer-grained control, like the resolve
177
 
        command, this should be False.
178
 
    :param ignore_misses: If False, warnings will be printed if the supplied
179
 
        paths do not have conflicts.
180
 
    :param action: How the conflict should be resolved,
181
 
    """
 
112
                resolve(tree, file_list)
 
113
 
 
114
 
 
115
def resolve(tree, paths=None, ignore_misses=False):
182
116
    tree.lock_tree_write()
183
 
    nb_conflicts_after = None
184
117
    try:
185
118
        tree_conflicts = tree.conflicts()
186
 
        nb_conflicts_before = len(tree_conflicts)
187
119
        if paths is None:
188
120
            new_conflicts = ConflictList()
189
 
            to_process = tree_conflicts
 
121
            selected_conflicts = tree_conflicts
190
122
        else:
191
 
            new_conflicts, to_process = tree_conflicts.select_conflicts(
192
 
                tree, paths, ignore_misses, recursive)
193
 
        for conflict in to_process:
194
 
            try:
195
 
                conflict._do(action, tree)
196
 
                conflict.cleanup(tree)
197
 
            except NotImplementedError:
198
 
                new_conflicts.append(conflict)
 
123
            new_conflicts, selected_conflicts = \
 
124
                tree_conflicts.select_conflicts(tree, paths, ignore_misses)
199
125
        try:
200
 
            nb_conflicts_after = len(new_conflicts)
201
126
            tree.set_conflicts(new_conflicts)
202
127
        except errors.UnsupportedOperation:
203
128
            pass
 
129
        selected_conflicts.remove_files(tree)
204
130
    finally:
205
131
        tree.unlock()
206
 
    if nb_conflicts_after is None:
207
 
        nb_conflicts_after = nb_conflicts_before
208
 
    return nb_conflicts_before, nb_conflicts_after
209
132
 
210
133
 
211
134
def restore(filename):
212
 
    """Restore a conflicted file to the state it was in before merging.
213
 
 
214
 
    Only text restoration is supported at present.
 
135
    """\
 
136
    Restore a conflicted file to the state it was in before merging.
 
137
    Only text restoration supported at present.
215
138
    """
216
139
    conflicted = False
217
140
    try:
287
210
        """Generator of stanzas"""
288
211
        for conflict in self:
289
212
            yield conflict.as_stanza()
290
 
 
 
213
            
291
214
    def to_strings(self):
292
215
        """Generate strings for the provided conflicts"""
293
216
        for conflict in self:
298
221
        for conflict in self:
299
222
            if not conflict.has_files:
300
223
                continue
301
 
            conflict.cleanup(tree)
 
224
            for suffix in CONFLICT_SUFFIXES:
 
225
                try:
 
226
                    osutils.delete_any(tree.abspath(conflict.path+suffix))
 
227
                except OSError, e:
 
228
                    if e.errno != errno.ENOENT:
 
229
                        raise
302
230
 
303
 
    def select_conflicts(self, tree, paths, ignore_misses=False,
304
 
                         recurse=False):
 
231
    def select_conflicts(self, tree, paths, ignore_misses=False):
305
232
        """Select the conflicts associated with paths in a tree.
306
 
 
 
233
        
307
234
        File-ids are also used for this.
308
235
        :return: a pair of ConflictLists: (not_selected, selected)
309
236
        """
326
253
                if cpath in path_set:
327
254
                    selected = True
328
255
                    selected_paths.add(cpath)
329
 
                if recurse:
330
 
                    if osutils.is_inside_any(path_set, cpath):
331
 
                        selected = True
332
 
                        selected_paths.add(cpath)
333
 
 
334
256
            for key in ('file_id', 'conflict_file_id'):
335
257
                cfile_id = getattr(conflict, key, None)
336
258
                if cfile_id is None:
353
275
                    print "%s is not conflicted" % path
354
276
        return new_conflicts, selected_conflicts
355
277
 
356
 
 
 
278
 
357
279
class Conflict(object):
358
280
    """Base class for all types of conflict"""
359
281
 
360
 
    # FIXME: cleanup should take care of that ? -- vila 091229
361
282
    has_files = False
362
283
 
363
284
    def __init__(self, path, file_id=None):
412
333
        else:
413
334
            return None, conflict.typestring
414
335
 
415
 
    def _do(self, action, tree):
416
 
        """Apply the specified action to the conflict.
417
 
 
418
 
        :param action: The method name to call.
419
 
 
420
 
        :param tree: The tree passed as a parameter to the method.
421
 
        """
422
 
        meth = getattr(self, 'action_%s' % action, None)
423
 
        if meth is None:
424
 
            raise NotImplementedError(self.__class__.__name__ + '.' + action)
425
 
        meth(tree)
426
 
 
427
 
    def associated_filenames(self):
428
 
        """The names of the files generated to help resolve the conflict."""
429
 
        raise NotImplementedError(self.associated_filenames)
430
 
 
431
 
    def cleanup(self, tree):
432
 
        for fname in self.associated_filenames():
433
 
            try:
434
 
                osutils.delete_any(tree.abspath(fname))
435
 
            except OSError, e:
436
 
                if e.errno != errno.ENOENT:
437
 
                    raise
438
 
 
439
 
    def action_done(self, tree):
440
 
        """Mark the conflict as solved once it has been handled."""
441
 
        # This method does nothing but simplifies the design of upper levels.
442
 
        pass
443
 
 
444
 
    def action_take_this(self, tree):
445
 
        raise NotImplementedError(self.action_take_this)
446
 
 
447
 
    def action_take_other(self, tree):
448
 
        raise NotImplementedError(self.action_take_other)
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
 
 
456
336
 
457
337
class PathConflict(Conflict):
458
338
    """A conflict was encountered merging file paths"""
462
342
    format = 'Path conflict: %(path)s / %(conflict_path)s'
463
343
 
464
344
    rformat = '%(class)s(%(path)r, %(conflict_path)r, %(file_id)r)'
465
 
 
466
345
    def __init__(self, path, conflict_path=None, file_id=None):
467
346
        Conflict.__init__(self, path, file_id)
468
347
        self.conflict_path = conflict_path
473
352
            s.add('conflict_path', self.conflict_path)
474
353
        return s
475
354
 
476
 
    def associated_filenames(self):
477
 
        # No additional files have been generated here
478
 
        return []
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, tt.trans_id_tree_path(path_to_create),
511
 
                self._revision_tree(tt._tree, revid), file_id)
512
 
            tt.version_file(file_id, tid)
513
 
 
514
 
        # Adjust the path for the retained file id
515
 
        tid = tt.trans_id_file_id(file_id)
516
 
        parent_tid = tt.get_tree_parent(tid)
517
 
        tt.adjust_path(osutils.basename(path), parent_tid, tid)
518
 
        tt.apply()
519
 
 
520
 
    def _revision_tree(self, tree, revid):
521
 
        return tree.branch.repository.revision_tree(revid)
522
 
 
523
 
    def _infer_file_id(self, tree):
524
 
        # Prior to bug #531967, file_id wasn't always set, there may still be
525
 
        # conflict files in the wild so we need to cope with them
526
 
        # Establish which path we should use to find back the file-id
527
 
        possible_paths = []
528
 
        for p in (self.path, self.conflict_path):
529
 
            if p == '<deleted>':
530
 
                # special hard-coded path 
531
 
                continue
532
 
            if p is not None:
533
 
                possible_paths.append(p)
534
 
        # Search the file-id in the parents with any path available
535
 
        file_id = None
536
 
        for revid in tree.get_parent_ids():
537
 
            revtree = self._revision_tree(tree, revid)
538
 
            for p in possible_paths:
539
 
                file_id = revtree.path2id(p)
540
 
                if file_id is not None:
541
 
                    return revtree, file_id
542
 
        return None, None
543
 
 
544
 
    def action_take_this(self, tree):
545
 
        if self.file_id is not None:
546
 
            self._resolve_with_cleanups(tree, self.file_id, self.path,
547
 
                                        winner='this')
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
 
    def action_take_other(self, tree):
556
 
        if self.file_id is not None:
557
 
            self._resolve_with_cleanups(tree, self.file_id,
558
 
                                        self.conflict_path,
559
 
                                        winner='other')
560
 
        else:
561
 
            # Prior to bug #531967 we need to find back the file_id and restore
562
 
            # the content from there
563
 
            revtree, file_id = self._infer_file_id(tree)
564
 
            tree.revert([revtree.id2path(file_id)],
565
 
                        old_tree=revtree, backups=False)
566
 
 
567
355
 
568
356
class ContentsConflict(PathConflict):
569
 
    """The files are of different types (or both binary), or not present"""
 
357
    """The files are of different types, or not present"""
570
358
 
571
359
    has_files = True
572
360
 
574
362
 
575
363
    format = 'Contents conflict in %(path)s'
576
364
 
577
 
    def associated_filenames(self):
578
 
        return [self.path + suffix for suffix in ('.BASE', '.OTHER')]
579
 
 
580
 
    def _resolve(self, tt, suffix_to_remove):
581
 
        """Resolve the conflict.
582
 
 
583
 
        :param tt: The TreeTransform where the conflict is resolved.
584
 
        :param suffix_to_remove: Either 'THIS' or 'OTHER'
585
 
 
586
 
        The resolution is symmetric, when taking THIS, OTHER is deleted and
587
 
        item.THIS is renamed into item and vice-versa.
588
 
        """
589
 
        try:
590
 
            # Delete 'item.THIS' or 'item.OTHER' depending on
591
 
            # suffix_to_remove
592
 
            tt.delete_contents(
593
 
                tt.trans_id_tree_path(self.path + '.' + suffix_to_remove))
594
 
        except errors.NoSuchFile:
595
 
            # There are valid cases where 'item.suffix_to_remove' either
596
 
            # never existed or was already deleted (including the case
597
 
            # where the user deleted it)
598
 
            pass
599
 
        # Rename 'item.suffix_to_remove' (note that if
600
 
        # 'item.suffix_to_remove' has been deleted, this is a no-op)
601
 
        this_tid = tt.trans_id_file_id(self.file_id)
602
 
        parent_tid = tt.get_tree_parent(this_tid)
603
 
        tt.adjust_path(osutils.basename(self.path), parent_tid, this_tid)
604
 
        tt.apply()
605
 
 
606
 
    def action_take_this(self, tree):
607
 
        self._resolve_with_cleanups(tree, 'OTHER')
608
 
 
609
 
    def action_take_other(self, tree):
610
 
        self._resolve_with_cleanups(tree, 'THIS')
611
 
 
612
 
 
613
 
# TODO: There should be a base revid attribute to better inform the user about
614
 
# how the conflicts were generated.
615
 
class TextConflict(Conflict):
 
365
 
 
366
class TextConflict(PathConflict):
616
367
    """The merge algorithm could not resolve all differences encountered."""
617
368
 
618
369
    has_files = True
621
372
 
622
373
    format = 'Text conflict in %(path)s'
623
374
 
624
 
    rformat = '%(class)s(%(path)r, %(file_id)r)'
625
 
 
626
 
    def associated_filenames(self):
627
 
        return [self.path + suffix for suffix in CONFLICT_SUFFIXES]
628
 
 
629
 
    def _resolve(self, tt, winner_suffix):
630
 
        """Resolve the conflict by copying one of .THIS or .OTHER into file.
631
 
 
632
 
        :param tt: The TreeTransform where the conflict is resolved.
633
 
        :param winner_suffix: Either 'THIS' or 'OTHER'
634
 
 
635
 
        The resolution is symmetric, when taking THIS, item.THIS is renamed
636
 
        into item and vice-versa. This takes one of the files as a whole
637
 
        ignoring every difference that could have been merged cleanly.
638
 
        """
639
 
        # To avoid useless copies, we switch item and item.winner_suffix, only
640
 
        # item will exist after the conflict has been resolved anyway.
641
 
        item_tid = tt.trans_id_file_id(self.file_id)
642
 
        item_parent_tid = tt.get_tree_parent(item_tid)
643
 
        winner_path = self.path + '.' + winner_suffix
644
 
        winner_tid = tt.trans_id_tree_path(winner_path)
645
 
        winner_parent_tid = tt.get_tree_parent(winner_tid)
646
 
        # Switch the paths to preserve the content
647
 
        tt.adjust_path(osutils.basename(self.path),
648
 
                       winner_parent_tid, winner_tid)
649
 
        tt.adjust_path(osutils.basename(winner_path), item_parent_tid, item_tid)
650
 
        # Associate the file_id to the right content
651
 
        tt.unversion_file(item_tid)
652
 
        tt.version_file(self.file_id, winner_tid)
653
 
        tt.apply()
654
 
 
655
 
    def action_take_this(self, tree):
656
 
        self._resolve_with_cleanups(tree, 'THIS')
657
 
 
658
 
    def action_take_other(self, tree):
659
 
        self._resolve_with_cleanups(tree, 'OTHER')
660
 
 
661
375
 
662
376
class HandledConflict(Conflict):
663
377
    """A path problem that has been provisionally resolved.
665
379
    """
666
380
 
667
381
    rformat = "%(class)s(%(action)r, %(path)r, %(file_id)r)"
668
 
 
 
382
    
669
383
    def __init__(self, action, path, file_id=None):
670
384
        Conflict.__init__(self, path, file_id)
671
385
        self.action = action
678
392
        s.add('action', self.action)
679
393
        return s
680
394
 
681
 
    def associated_filenames(self):
682
 
        # Nothing has been generated here
683
 
        return []
684
 
 
685
395
 
686
396
class HandledPathConflict(HandledConflict):
687
397
    """A provisionally-resolved path problem involving two paths.
694
404
    def __init__(self, action, path, conflict_path, file_id=None,
695
405
                 conflict_file_id=None):
696
406
        HandledConflict.__init__(self, action, path, file_id)
697
 
        self.conflict_path = conflict_path
 
407
        self.conflict_path = conflict_path 
698
408
        # warn turned off, because the factory blindly transfers the Stanza
699
409
        # values to __init__.
700
410
        self.conflict_file_id = osutils.safe_file_id(conflict_file_id,
701
411
                                                     warn=False)
702
 
 
 
412
        
703
413
    def _cmp_list(self):
704
 
        return HandledConflict._cmp_list(self) + [self.conflict_path,
 
414
        return HandledConflict._cmp_list(self) + [self.conflict_path, 
705
415
                                                  self.conflict_file_id]
706
416
 
707
417
    def as_stanza(self):
709
419
        s.add('conflict_path', self.conflict_path)
710
420
        if self.conflict_file_id is not None:
711
421
            s.add('conflict_file_id', self.conflict_file_id.decode('utf8'))
712
 
 
 
422
            
713
423
        return s
714
424
 
715
425
 
728
438
 
729
439
    format = 'Conflict adding file %(conflict_path)s.  %(action)s %(path)s.'
730
440
 
731
 
    def action_take_this(self, tree):
732
 
        tree.remove([self.conflict_path], force=True, keep_files=False)
733
 
        tree.rename_one(self.path, self.conflict_path)
734
 
 
735
 
    def action_take_other(self, tree):
736
 
        tree.remove([self.path], force=True, keep_files=False)
737
 
 
738
441
 
739
442
class ParentLoop(HandledPathConflict):
740
443
    """An attempt to create an infinitely-looping directory structure.
741
444
    This is rare, but can be produced like so:
742
445
 
743
446
    tree A:
744
 
      mv foo bar
 
447
      mv foo/bar
745
448
    tree B:
746
 
      mv bar foo
 
449
      mv bar/foo
747
450
    merge A and B
748
451
    """
749
452
 
750
453
    typestring = 'parent loop'
751
454
 
752
 
    format = 'Conflict moving %(path)s into %(conflict_path)s. %(action)s.'
753
 
 
754
 
    def action_take_this(self, tree):
755
 
        # just acccept bzr proposal
756
 
        pass
757
 
 
758
 
    def action_take_other(self, tree):
759
 
        tt = transform.TreeTransform(tree)
760
 
        try:
761
 
            p_tid = tt.trans_id_file_id(self.file_id)
762
 
            parent_tid = tt.get_tree_parent(p_tid)
763
 
            cp_tid = tt.trans_id_file_id(self.conflict_file_id)
764
 
            cparent_tid = tt.get_tree_parent(cp_tid)
765
 
            tt.adjust_path(osutils.basename(self.path), cparent_tid, cp_tid)
766
 
            tt.adjust_path(osutils.basename(self.conflict_path),
767
 
                           parent_tid, p_tid)
768
 
            tt.apply()
769
 
        finally:
770
 
            tt.finalize()
 
455
    format = 'Conflict moving %(conflict_path)s into %(path)s.  %(action)s.'
771
456
 
772
457
 
773
458
class UnversionedParent(HandledConflict):
774
 
    """An attempt to version a file whose parent directory is not versioned.
 
459
    """An attempt to version an file whose parent directory is not versioned.
775
460
    Typically, the result of a merge where one tree unversioned the directory
776
461
    and the other added a versioned file to it.
777
462
    """
781
466
    format = 'Conflict because %(path)s is not versioned, but has versioned'\
782
467
             ' children.  %(action)s.'
783
468
 
784
 
    # FIXME: We silently do nothing to make tests pass, but most probably the
785
 
    # conflict shouldn't exist (the long story is that the conflict is
786
 
    # generated with another one that can be resolved properly) -- vila 091224
787
 
    def action_take_this(self, tree):
788
 
        pass
789
 
 
790
 
    def action_take_other(self, tree):
791
 
        pass
792
 
 
793
469
 
794
470
class MissingParent(HandledConflict):
795
471
    """An attempt to add files to a directory that is not present.
796
472
    Typically, the result of a merge where THIS deleted the directory and
797
473
    the OTHER added a file to it.
798
 
    See also: DeletingParent (same situation, THIS and OTHER reversed)
 
474
    See also: DeletingParent (same situation, reversed THIS and OTHER)
799
475
    """
800
476
 
801
477
    typestring = 'missing parent'
802
478
 
803
479
    format = 'Conflict adding files to %(path)s.  %(action)s.'
804
480
 
805
 
    def action_take_this(self, tree):
806
 
        tree.remove([self.path], force=True, keep_files=False)
807
 
 
808
 
    def action_take_other(self, tree):
809
 
        # just acccept bzr proposal
810
 
        pass
811
 
 
812
481
 
813
482
class DeletingParent(HandledConflict):
814
483
    """An attempt to add files to a directory that is not present.
821
490
    format = "Conflict: can't delete %(path)s because it is not empty.  "\
822
491
             "%(action)s."
823
492
 
824
 
    # FIXME: It's a bit strange that the default action is not coherent with
825
 
    # MissingParent from the *user* pov.
826
 
 
827
 
    def action_take_this(self, tree):
828
 
        # just acccept bzr proposal
829
 
        pass
830
 
 
831
 
    def action_take_other(self, tree):
832
 
        tree.remove([self.path], force=True, keep_files=False)
833
 
 
834
 
 
835
 
class NonDirectoryParent(HandledConflict):
836
 
    """An attempt to add files to a directory that is not a directory or
837
 
    an attempt to change the kind of a directory with files.
838
 
    """
839
 
 
840
 
    typestring = 'non-directory parent'
841
 
 
842
 
    format = "Conflict: %(path)s is not a directory, but has files in it."\
843
 
             "  %(action)s."
844
 
 
845
 
    # FIXME: .OTHER should be used instead of .new when the conflict is created
846
 
 
847
 
    def action_take_this(self, tree):
848
 
        # FIXME: we should preserve that path when the conflict is generated !
849
 
        if self.path.endswith('.new'):
850
 
            conflict_path = self.path[:-(len('.new'))]
851
 
            tree.remove([self.path], force=True, keep_files=False)
852
 
            tree.add(conflict_path)
853
 
        else:
854
 
            raise NotImplementedError(self.action_take_this)
855
 
 
856
 
    def action_take_other(self, tree):
857
 
        # FIXME: we should preserve that path when the conflict is generated !
858
 
        if self.path.endswith('.new'):
859
 
            conflict_path = self.path[:-(len('.new'))]
860
 
            tree.remove([conflict_path], force=True, keep_files=False)
861
 
            tree.rename_one(self.path, conflict_path)
862
 
        else:
863
 
            raise NotImplementedError(self.action_take_other)
864
 
 
865
493
 
866
494
ctype = {}
867
495
 
872
500
    for conflict_type in conflict_types:
873
501
        ctype[conflict_type.typestring] = conflict_type
874
502
 
 
503
 
875
504
register_types(ContentsConflict, TextConflict, PathConflict, DuplicateID,
876
505
               DuplicateEntry, ParentLoop, UnversionedParent, MissingParent,
877
 
               DeletingParent, NonDirectoryParent)
 
506
               DeletingParent,)