/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 breezy/conflicts.py

  • Committer: Breezy landing bot
  • Author(s): Jelmer Vernooij
  • Date: 2020-08-23 01:15:41 UTC
  • mfrom: (7520.1.4 merge-3.1)
  • Revision ID: breezy.the.bot@gmail.com-20200823011541-nv0oh7nzaganx2qy
Merge lp:brz/3.1.

Merged from https://code.launchpad.net/~jelmer/brz/merge-3.1/+merge/389690

Show diffs side-by-side

added added

removed removed

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