← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/conflicts.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2011-08-17 18:13:57 UTC
  • mfrom: (5268.7.29 transport-segments)
  • Revision ID: pqm@pqm.ubuntu.com-20110817181357-y5q5eth1hk8bl3om
(jelmer) Allow specifying the colocated branch to use in the branch URL,
 and retrieving the branch name using ControlDir._get_selected_branch.
 (Jelmer Vernooij)

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
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., 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 
 
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
20
18
# point down
21
19
 
22
20
import os
26
24
import errno
27
25
 
28
26
from bzrlib import (
29
 
    builtins,
30
 
    commands,
 
27
    cleanup,
31
28
    errors,
32
29
    osutils,
33
30
    rio,
34
31
    trace,
 
32
    transform,
 
33
    workingtree,
35
34
    )
36
35
""")
37
 
from bzrlib.option import Option
 
36
from bzrlib import (
 
37
    commands,
 
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':
70
72
                    continue
71
73
                self.outf.write(conflict.path + '\n')
72
74
            else:
73
 
                self.outf.write(str(conflict) + '\n')
 
75
                self.outf.write(unicode(conflict) + '\n')
 
76
 
 
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)
74
98
 
75
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=None):
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
            if directory is None:
 
126
                directory = u'.'
 
127
            tree = workingtree.WorkingTree.open_containing(directory)[0]
 
128
            if action is None:
 
129
                action = 'done'
103
130
        else:
104
 
            tree, file_list = builtins.tree_files(file_list)
 
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':
105
145
            if file_list is None:
106
146
                un_resolved, resolved = tree.auto_resolve()
107
147
                if len(un_resolved) > 0:
108
148
                    trace.note('%d conflict(s) auto-resolved.', len(resolved))
109
149
                    trace.note('Remaining conflicts:')
110
150
                    for conflict in un_resolved:
111
 
                        trace.note(conflict)
 
151
                        trace.note(unicode(conflict))
112
152
                    return 1
113
153
                else:
114
154
                    trace.note('All conflicts resolved.')
115
155
                    return 0
116
156
            else:
117
 
                resolve(tree, file_list)
118
 
 
119
 
 
120
 
def resolve(tree, paths=None, ignore_misses=False, recursive=False):
 
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'):
121
169
    """Resolve some or all of the conflicts in a working tree.
122
170
 
123
171
    :param paths: If None, resolve all conflicts.  Otherwise, select only
127
175
        recursive commands like revert, this should be True.  For commands
128
176
        or applications wishing finer-grained control, like the resolve
129
177
        command, this should be False.
130
 
    :ignore_misses: If False, warnings will be printed if the supplied paths
131
 
        do not have conflicts.
 
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,
132
181
    """
133
182
    tree.lock_tree_write()
 
183
    nb_conflicts_after = None
134
184
    try:
135
185
        tree_conflicts = tree.conflicts()
 
186
        nb_conflicts_before = len(tree_conflicts)
136
187
        if paths is None:
137
188
            new_conflicts = ConflictList()
138
 
            selected_conflicts = tree_conflicts
 
189
            to_process = tree_conflicts
139
190
        else:
140
 
            new_conflicts, selected_conflicts = \
141
 
                tree_conflicts.select_conflicts(tree, paths, ignore_misses,
142
 
                    recursive)
 
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)
143
199
        try:
 
200
            nb_conflicts_after = len(new_conflicts)
144
201
            tree.set_conflicts(new_conflicts)
145
202
        except errors.UnsupportedOperation:
146
203
            pass
147
 
        selected_conflicts.remove_files(tree)
148
204
    finally:
149
205
        tree.unlock()
 
206
    if nb_conflicts_after is None:
 
207
        nb_conflicts_after = nb_conflicts_before
 
208
    return nb_conflicts_before, nb_conflicts_after
150
209
 
151
210
 
152
211
def restore(filename):
153
 
    """\
154
 
    Restore a conflicted file to the state it was in before merging.
155
 
    Only text restoration supported at present.
 
212
    """Restore a conflicted file to the state it was in before merging.
 
213
 
 
214
    Only text restoration is supported at present.
156
215
    """
157
216
    conflicted = False
158
217
    try:
228
287
        """Generator of stanzas"""
229
288
        for conflict in self:
230
289
            yield conflict.as_stanza()
231
 
            
 
290
 
232
291
    def to_strings(self):
233
292
        """Generate strings for the provided conflicts"""
234
293
        for conflict in self:
235
 
            yield str(conflict)
 
294
            yield unicode(conflict)
236
295
 
237
296
    def remove_files(self, tree):
238
297
        """Remove the THIS, BASE and OTHER files for listed conflicts"""
239
298
        for conflict in self:
240
299
            if not conflict.has_files:
241
300
                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
 
301
            conflict.cleanup(tree)
248
302
 
249
303
    def select_conflicts(self, tree, paths, ignore_misses=False,
250
304
                         recurse=False):
251
305
        """Select the conflicts associated with paths in a tree.
252
 
        
 
306
 
253
307
        File-ids are also used for this.
254
308
        :return: a pair of ConflictLists: (not_selected, selected)
255
309
        """
299
353
                    print "%s is not conflicted" % path
300
354
        return new_conflicts, selected_conflicts
301
355
 
302
 
 
 
356
 
303
357
class Conflict(object):
304
358
    """Base class for all types of conflict"""
305
359
 
 
360
    # FIXME: cleanup should take care of that ? -- vila 091229
306
361
    has_files = False
307
362
 
308
363
    def __init__(self, path, file_id=None):
335
390
    def __ne__(self, other):
336
391
        return not self.__eq__(other)
337
392
 
338
 
    def __str__(self):
 
393
    def __unicode__(self):
339
394
        return self.format % self.__dict__
340
395
 
341
396
    def __repr__(self):
357
412
        else:
358
413
            return None, conflict.typestring
359
414
 
 
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
 
360
456
 
361
457
class PathConflict(Conflict):
362
458
    """A conflict was encountered merging file paths"""
366
462
    format = 'Path conflict: %(path)s / %(conflict_path)s'
367
463
 
368
464
    rformat = '%(class)s(%(path)r, %(conflict_path)r, %(file_id)r)'
 
465
 
369
466
    def __init__(self, path, conflict_path=None, file_id=None):
370
467
        Conflict.__init__(self, path, file_id)
371
468
        self.conflict_path = conflict_path
376
473
            s.add('conflict_path', self.conflict_path)
377
474
        return s
378
475
 
 
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, tid, self._revision_tree(tt._tree, revid), file_id)
 
511
            tt.version_file(file_id, tid)
 
512
        else:
 
513
            tid = tt.trans_id_file_id(file_id)
 
514
        # Adjust the path for the retained file id
 
515
        parent_tid = tt.get_tree_parent(tid)
 
516
        tt.adjust_path(osutils.basename(path), parent_tid, tid)
 
517
        tt.apply()
 
518
 
 
519
    def _revision_tree(self, tree, revid):
 
520
        return tree.branch.repository.revision_tree(revid)
 
521
 
 
522
    def _infer_file_id(self, tree):
 
523
        # Prior to bug #531967, file_id wasn't always set, there may still be
 
524
        # conflict files in the wild so we need to cope with them
 
525
        # Establish which path we should use to find back the file-id
 
526
        possible_paths = []
 
527
        for p in (self.path, self.conflict_path):
 
528
            if p == '<deleted>':
 
529
                # special hard-coded path 
 
530
                continue
 
531
            if p is not None:
 
532
                possible_paths.append(p)
 
533
        # Search the file-id in the parents with any path available
 
534
        file_id = None
 
535
        for revid in tree.get_parent_ids():
 
536
            revtree = self._revision_tree(tree, revid)
 
537
            for p in possible_paths:
 
538
                file_id = revtree.path2id(p)
 
539
                if file_id is not None:
 
540
                    return revtree, file_id
 
541
        return None, None
 
542
 
 
543
    def action_take_this(self, tree):
 
544
        if self.file_id is not None:
 
545
            self._resolve_with_cleanups(tree, self.file_id, self.path,
 
546
                                        winner='this')
 
547
        else:
 
548
            # Prior to bug #531967 we need to find back the file_id and restore
 
549
            # the content from there
 
550
            revtree, file_id = self._infer_file_id(tree)
 
551
            tree.revert([revtree.id2path(file_id)],
 
552
                        old_tree=revtree, backups=False)
 
553
 
 
554
    def action_take_other(self, tree):
 
555
        if self.file_id is not None:
 
556
            self._resolve_with_cleanups(tree, self.file_id,
 
557
                                        self.conflict_path,
 
558
                                        winner='other')
 
559
        else:
 
560
            # Prior to bug #531967 we need to find back the file_id and restore
 
561
            # the content from there
 
562
            revtree, file_id = self._infer_file_id(tree)
 
563
            tree.revert([revtree.id2path(file_id)],
 
564
                        old_tree=revtree, backups=False)
 
565
 
379
566
 
380
567
class ContentsConflict(PathConflict):
381
 
    """The files are of different types, or not present"""
 
568
    """The files are of different types (or both binary), or not present"""
382
569
 
383
570
    has_files = True
384
571
 
386
573
 
387
574
    format = 'Contents conflict in %(path)s'
388
575
 
389
 
 
390
 
class TextConflict(PathConflict):
 
576
    def associated_filenames(self):
 
577
        return [self.path + suffix for suffix in ('.BASE', '.OTHER')]
 
578
 
 
579
    def _resolve(self, tt, suffix_to_remove):
 
580
        """Resolve the conflict.
 
581
 
 
582
        :param tt: The TreeTransform where the conflict is resolved.
 
583
        :param suffix_to_remove: Either 'THIS' or 'OTHER'
 
584
 
 
585
        The resolution is symmetric: when taking THIS, OTHER is deleted and
 
586
        item.THIS is renamed into item and vice-versa.
 
587
        """
 
588
        try:
 
589
            # Delete 'item.THIS' or 'item.OTHER' depending on
 
590
            # suffix_to_remove
 
591
            tt.delete_contents(
 
592
                tt.trans_id_tree_path(self.path + '.' + suffix_to_remove))
 
593
        except errors.NoSuchFile:
 
594
            # There are valid cases where 'item.suffix_to_remove' either
 
595
            # never existed or was already deleted (including the case
 
596
            # where the user deleted it)
 
597
            pass
 
598
        try:
 
599
            this_path = tt._tree.id2path(self.file_id)
 
600
        except errors.NoSuchId:
 
601
            # The file is not present anymore. This may happen if the user
 
602
            # deleted the file either manually or when resolving a conflict on
 
603
            # the parent.  We may raise some exception to indicate that the
 
604
            # conflict doesn't exist anymore and as such doesn't need to be
 
605
            # resolved ? -- vila 20110615 
 
606
            this_tid = None
 
607
        else:
 
608
            this_tid = tt.trans_id_tree_path(this_path)
 
609
        if this_tid is not None:
 
610
            # Rename 'item.suffix_to_remove' (note that if
 
611
            # 'item.suffix_to_remove' has been deleted, this is a no-op)
 
612
            parent_tid = tt.get_tree_parent(this_tid)
 
613
            tt.adjust_path(osutils.basename(self.path), parent_tid, this_tid)
 
614
            tt.apply()
 
615
 
 
616
    def action_take_this(self, tree):
 
617
        self._resolve_with_cleanups(tree, 'OTHER')
 
618
 
 
619
    def action_take_other(self, tree):
 
620
        self._resolve_with_cleanups(tree, 'THIS')
 
621
 
 
622
 
 
623
# TODO: There should be a base revid attribute to better inform the user about
 
624
# how the conflicts were generated.
 
625
class TextConflict(Conflict):
391
626
    """The merge algorithm could not resolve all differences encountered."""
392
627
 
393
628
    has_files = True
396
631
 
397
632
    format = 'Text conflict in %(path)s'
398
633
 
 
634
    rformat = '%(class)s(%(path)r, %(file_id)r)'
 
635
 
 
636
    def associated_filenames(self):
 
637
        return [self.path + suffix for suffix in CONFLICT_SUFFIXES]
 
638
 
 
639
    def _resolve(self, tt, winner_suffix):
 
640
        """Resolve the conflict by copying one of .THIS or .OTHER into file.
 
641
 
 
642
        :param tt: The TreeTransform where the conflict is resolved.
 
643
        :param winner_suffix: Either 'THIS' or 'OTHER'
 
644
 
 
645
        The resolution is symmetric, when taking THIS, item.THIS is renamed
 
646
        into item and vice-versa. This takes one of the files as a whole
 
647
        ignoring every difference that could have been merged cleanly.
 
648
        """
 
649
        # To avoid useless copies, we switch item and item.winner_suffix, only
 
650
        # item will exist after the conflict has been resolved anyway.
 
651
        item_tid = tt.trans_id_file_id(self.file_id)
 
652
        item_parent_tid = tt.get_tree_parent(item_tid)
 
653
        winner_path = self.path + '.' + winner_suffix
 
654
        winner_tid = tt.trans_id_tree_path(winner_path)
 
655
        winner_parent_tid = tt.get_tree_parent(winner_tid)
 
656
        # Switch the paths to preserve the content
 
657
        tt.adjust_path(osutils.basename(self.path),
 
658
                       winner_parent_tid, winner_tid)
 
659
        tt.adjust_path(osutils.basename(winner_path), item_parent_tid, item_tid)
 
660
        # Associate the file_id to the right content
 
661
        tt.unversion_file(item_tid)
 
662
        tt.version_file(self.file_id, winner_tid)
 
663
        tt.apply()
 
664
 
 
665
    def action_take_this(self, tree):
 
666
        self._resolve_with_cleanups(tree, 'THIS')
 
667
 
 
668
    def action_take_other(self, tree):
 
669
        self._resolve_with_cleanups(tree, 'OTHER')
 
670
 
399
671
 
400
672
class HandledConflict(Conflict):
401
673
    """A path problem that has been provisionally resolved.
403
675
    """
404
676
 
405
677
    rformat = "%(class)s(%(action)r, %(path)r, %(file_id)r)"
406
 
    
 
678
 
407
679
    def __init__(self, action, path, file_id=None):
408
680
        Conflict.__init__(self, path, file_id)
409
681
        self.action = action
416
688
        s.add('action', self.action)
417
689
        return s
418
690
 
 
691
    def associated_filenames(self):
 
692
        # Nothing has been generated here
 
693
        return []
 
694
 
419
695
 
420
696
class HandledPathConflict(HandledConflict):
421
697
    """A provisionally-resolved path problem involving two paths.
428
704
    def __init__(self, action, path, conflict_path, file_id=None,
429
705
                 conflict_file_id=None):
430
706
        HandledConflict.__init__(self, action, path, file_id)
431
 
        self.conflict_path = conflict_path 
 
707
        self.conflict_path = conflict_path
432
708
        # warn turned off, because the factory blindly transfers the Stanza
433
709
        # values to __init__.
434
710
        self.conflict_file_id = osutils.safe_file_id(conflict_file_id,
435
711
                                                     warn=False)
436
 
        
 
712
 
437
713
    def _cmp_list(self):
438
 
        return HandledConflict._cmp_list(self) + [self.conflict_path, 
 
714
        return HandledConflict._cmp_list(self) + [self.conflict_path,
439
715
                                                  self.conflict_file_id]
440
716
 
441
717
    def as_stanza(self):
443
719
        s.add('conflict_path', self.conflict_path)
444
720
        if self.conflict_file_id is not None:
445
721
            s.add('conflict_file_id', self.conflict_file_id.decode('utf8'))
446
 
            
 
722
 
447
723
        return s
448
724
 
449
725
 
462
738
 
463
739
    format = 'Conflict adding file %(conflict_path)s.  %(action)s %(path)s.'
464
740
 
 
741
    def action_take_this(self, tree):
 
742
        tree.remove([self.conflict_path], force=True, keep_files=False)
 
743
        tree.rename_one(self.path, self.conflict_path)
 
744
 
 
745
    def action_take_other(self, tree):
 
746
        tree.remove([self.path], force=True, keep_files=False)
 
747
 
465
748
 
466
749
class ParentLoop(HandledPathConflict):
467
750
    """An attempt to create an infinitely-looping directory structure.
468
751
    This is rare, but can be produced like so:
469
752
 
470
753
    tree A:
471
 
      mv foo/bar
 
754
      mv foo bar
472
755
    tree B:
473
 
      mv bar/foo
 
756
      mv bar foo
474
757
    merge A and B
475
758
    """
476
759
 
477
760
    typestring = 'parent loop'
478
761
 
479
 
    format = 'Conflict moving %(conflict_path)s into %(path)s.  %(action)s.'
 
762
    format = 'Conflict moving %(path)s into %(conflict_path)s. %(action)s.'
 
763
 
 
764
    def action_take_this(self, tree):
 
765
        # just acccept bzr proposal
 
766
        pass
 
767
 
 
768
    def action_take_other(self, tree):
 
769
        tt = transform.TreeTransform(tree)
 
770
        try:
 
771
            p_tid = tt.trans_id_file_id(self.file_id)
 
772
            parent_tid = tt.get_tree_parent(p_tid)
 
773
            cp_tid = tt.trans_id_file_id(self.conflict_file_id)
 
774
            cparent_tid = tt.get_tree_parent(cp_tid)
 
775
            tt.adjust_path(osutils.basename(self.path), cparent_tid, cp_tid)
 
776
            tt.adjust_path(osutils.basename(self.conflict_path),
 
777
                           parent_tid, p_tid)
 
778
            tt.apply()
 
779
        finally:
 
780
            tt.finalize()
480
781
 
481
782
 
482
783
class UnversionedParent(HandledConflict):
483
 
    """An attempt to version an file whose parent directory is not versioned.
 
784
    """An attempt to version a file whose parent directory is not versioned.
484
785
    Typically, the result of a merge where one tree unversioned the directory
485
786
    and the other added a versioned file to it.
486
787
    """
490
791
    format = 'Conflict because %(path)s is not versioned, but has versioned'\
491
792
             ' children.  %(action)s.'
492
793
 
 
794
    # FIXME: We silently do nothing to make tests pass, but most probably the
 
795
    # conflict shouldn't exist (the long story is that the conflict is
 
796
    # generated with another one that can be resolved properly) -- vila 091224
 
797
    def action_take_this(self, tree):
 
798
        pass
 
799
 
 
800
    def action_take_other(self, tree):
 
801
        pass
 
802
 
493
803
 
494
804
class MissingParent(HandledConflict):
495
805
    """An attempt to add files to a directory that is not present.
496
806
    Typically, the result of a merge where THIS deleted the directory and
497
807
    the OTHER added a file to it.
498
 
    See also: DeletingParent (same situation, reversed THIS and OTHER)
 
808
    See also: DeletingParent (same situation, THIS and OTHER reversed)
499
809
    """
500
810
 
501
811
    typestring = 'missing parent'
502
812
 
503
813
    format = 'Conflict adding files to %(path)s.  %(action)s.'
504
814
 
 
815
    def action_take_this(self, tree):
 
816
        tree.remove([self.path], force=True, keep_files=False)
 
817
 
 
818
    def action_take_other(self, tree):
 
819
        # just acccept bzr proposal
 
820
        pass
 
821
 
505
822
 
506
823
class DeletingParent(HandledConflict):
507
824
    """An attempt to add files to a directory that is not present.
514
831
    format = "Conflict: can't delete %(path)s because it is not empty.  "\
515
832
             "%(action)s."
516
833
 
 
834
    # FIXME: It's a bit strange that the default action is not coherent with
 
835
    # MissingParent from the *user* pov.
 
836
 
 
837
    def action_take_this(self, tree):
 
838
        # just acccept bzr proposal
 
839
        pass
 
840
 
 
841
    def action_take_other(self, tree):
 
842
        tree.remove([self.path], force=True, keep_files=False)
 
843
 
517
844
 
518
845
class NonDirectoryParent(HandledConflict):
519
 
    """An attempt to add files to a directory that is not a director or
 
846
    """An attempt to add files to a directory that is not a directory or
520
847
    an attempt to change the kind of a directory with files.
521
848
    """
522
849
 
525
852
    format = "Conflict: %(path)s is not a directory, but has files in it."\
526
853
             "  %(action)s."
527
854
 
 
855
    # FIXME: .OTHER should be used instead of .new when the conflict is created
 
856
 
 
857
    def action_take_this(self, tree):
 
858
        # FIXME: we should preserve that path when the conflict is generated !
 
859
        if self.path.endswith('.new'):
 
860
            conflict_path = self.path[:-(len('.new'))]
 
861
            tree.remove([self.path], force=True, keep_files=False)
 
862
            tree.add(conflict_path)
 
863
        else:
 
864
            raise NotImplementedError(self.action_take_this)
 
865
 
 
866
    def action_take_other(self, tree):
 
867
        # FIXME: we should preserve that path when the conflict is generated !
 
868
        if self.path.endswith('.new'):
 
869
            conflict_path = self.path[:-(len('.new'))]
 
870
            tree.remove([conflict_path], force=True, keep_files=False)
 
871
            tree.rename_one(self.path, conflict_path)
 
872
        else:
 
873
            raise NotImplementedError(self.action_take_other)
 
874
 
 
875
 
528
876
ctype = {}
529
877
 
530
878
 
534
882
    for conflict_type in conflict_types:
535
883
        ctype[conflict_type.typestring] = conflict_type
536
884
 
537
 
 
538
885
register_types(ContentsConflict, TextConflict, PathConflict, DuplicateID,
539
886
               DuplicateEntry, ParentLoop, UnversionedParent, MissingParent,
540
887
               DeletingParent, NonDirectoryParent)