← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/conflicts.py

  • Committer: Robert Collins
  • Date: 2007-05-07 16:48:14 UTC
  • mto: This revision was merged to the branch mainline in revision 2485.
  • Revision ID: robertc@robertcollins.net-20070507164814-wpagonutf4b5cf8s
Move HACKING to docs/developers/HACKING and adjust Makefile to accomodate this.

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