← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/conflicts.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2011-04-29 11:54:29 UTC
  • mfrom: (5813.2.1 integration)
  • Revision ID: pqm@pqm.ubuntu.com-20110429115429-bi5nv4kqmyrbtzx0
(jameinel) Skip a test that called os.utime(dir) if the filesystem doesn't
 support it. (John A Meinel)

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