← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/conflicts.py

  • Committer: John Arbash Meinel
  • Date: 2006-06-10 14:53:51 UTC
  • mto: (1711.7.2 win32)
  • mto: This revision was merged to the branch mainline in revision 1796.
  • Revision ID: john@arbash-meinel.com-20060610145351-9da0c1f8ba8a57e0
the _posix_* routines should use posixpath not os.path, so tests pass on win32

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