/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

The ParentLoop.format has been updated, fix fallouts.

Show diffs side-by-side

added added

removed removed

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