/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/conflicts.py

  • Committer: Robert Collins
  • Date: 2010-05-05 00:05:29 UTC
  • mto: This revision was merged to the branch mainline in revision 5206.
  • Revision ID: robertc@robertcollins.net-20100505000529-ltmllyms5watqj5u
Make 'pydoc bzrlib.tests.build_tree_shape' useful.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/conflicts.py
1
 
# Copyright (C) 2005 by Aaron Bentley
2
 
 
 
1
# Copyright (C) 2005, 2006, 2007, 2009, 2010 Canonical Ltd
 
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., 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 
 
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
20
18
# point down
21
19
 
22
20
import os
 
21
 
 
22
from bzrlib.lazy_import import lazy_import
 
23
lazy_import(globals(), """
23
24
import errno
24
25
 
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
 
26
from bzrlib import (
 
27
    builtins,
 
28
    cleanup,
 
29
    commands,
 
30
    errors,
 
31
    osutils,
 
32
    rio,
 
33
    trace,
 
34
    transform,
 
35
    workingtree,
 
36
    )
 
37
""")
 
38
from bzrlib import (
 
39
    option,
 
40
    registry,
 
41
    )
31
42
 
32
43
 
33
44
CONFLICT_SUFFIXES = ('.THIS', '.BASE', '.OTHER')
34
45
 
35
46
 
36
 
class cmd_conflicts(bzrlib.commands.Command):
37
 
    """List files with conflicts.
 
47
class cmd_conflicts(commands.Command):
 
48
    __doc__ = """List files with conflicts.
38
49
 
39
50
    Merge will do its best to combine the changes in two branches, but there
40
51
    are some kinds of problems only a human can fix.  When it encounters those,
41
52
    it will mark a conflict.  A conflict means that you need to fix something,
42
53
    before you should commit.
43
54
 
 
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
 
44
59
    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.
50
60
    """
51
 
    def run(self):
52
 
        from bzrlib.workingtree import WorkingTree
53
 
        wt = WorkingTree.open_containing(u'.')[0]
 
61
    takes_options = [
 
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):
 
68
        wt = workingtree.WorkingTree.open_containing(u'.')[0]
54
69
        for conflict in wt.conflicts():
55
 
            print conflict
56
 
 
57
 
 
58
 
class cmd_resolve(bzrlib.commands.Command):
59
 
    """Mark a conflict as resolved.
 
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.
60
102
 
61
103
    Merge will do its best to combine the changes in two branches, but there
62
104
    are some kinds of problems only a human can fix.  When it encounters those,
63
105
    it will mark a conflict.  A conflict means that you need to fix something,
64
106
    before you should commit.
65
107
 
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.
 
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.
71
111
    """
72
112
    aliases = ['resolved']
73
113
    takes_args = ['file*']
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
 
114
    takes_options = [
 
115
            option.Option('all', help='Resolve all conflicts in this tree.'),
 
116
            ResolveActionOption(),
 
117
            ]
 
118
    _see_also = ['conflicts']
 
119
    def run(self, file_list=None, all=False, action=None):
77
120
        if all:
78
121
            if file_list:
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()
 
122
                raise errors.BzrCommandError("If --all is specified,"
 
123
                                             " no FILE may be provided")
 
124
            tree = workingtree.WorkingTree.open_containing('.')[0]
 
125
            if action is None:
 
126
                action = 'done'
 
127
        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
 
136
                    action = 'auto'
 
137
            else:
 
138
                if action is None:
 
139
                    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
 
152
            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
 
157
        else:
 
158
            resolve(tree, file_list, action=action)
 
159
 
 
160
 
 
161
def resolve(tree, paths=None, ignore_misses=False, recursive=False,
 
162
            action='done'):
 
163
    """Resolve some or all of the conflicts in a working tree.
 
164
 
 
165
    :param paths: If None, resolve all conflicts.  Otherwise, select only
 
166
        specified conflicts.
 
167
    :param recursive: If True, then elements of paths which are directories
 
168
        have all their children resolved, etc.  When invoked as part of
 
169
        recursive commands like revert, this should be True.  For commands
 
170
        or applications wishing finer-grained control, like the resolve
 
171
        command, this should be False.
 
172
    :param ignore_misses: If False, warnings will be printed if the supplied
 
173
        paths do not have conflicts.
 
174
    :param action: How the conflict should be resolved,
 
175
    """
 
176
    tree.lock_tree_write()
92
177
    try:
93
178
        tree_conflicts = tree.conflicts()
94
179
        if paths is None:
95
180
            new_conflicts = ConflictList()
96
 
            selected_conflicts = tree_conflicts
 
181
            to_process = tree_conflicts
97
182
        else:
98
 
            new_conflicts, selected_conflicts = \
99
 
                tree_conflicts.select_conflicts(tree, paths, ignore_misses)
 
183
            new_conflicts, to_process = tree_conflicts.select_conflicts(
 
184
                tree, paths, ignore_misses, recursive)
 
185
        for conflict in to_process:
 
186
            try:
 
187
                conflict._do(action, tree)
 
188
                conflict.cleanup(tree)
 
189
            except NotImplementedError:
 
190
                new_conflicts.append(conflict)
100
191
        try:
101
192
            tree.set_conflicts(new_conflicts)
102
 
        except UnsupportedOperation:
 
193
        except errors.UnsupportedOperation:
103
194
            pass
104
 
        selected_conflicts.remove_files(tree)
105
195
    finally:
106
196
        tree.unlock()
107
197
 
108
198
 
109
199
def restore(filename):
110
 
    """\
111
 
    Restore a conflicted file to the state it was in before merging.
112
 
    Only text restoration supported at present.
 
200
    """Restore a conflicted file to the state it was in before merging.
 
201
 
 
202
    Only text restoration is supported at present.
113
203
    """
114
204
    conflicted = False
115
205
    try:
116
 
        rename(filename + ".THIS", filename)
 
206
        osutils.rename(filename + ".THIS", filename)
117
207
        conflicted = True
118
208
    except OSError, e:
119
209
        if e.errno != errno.ENOENT:
131
221
        if e.errno != errno.ENOENT:
132
222
            raise
133
223
    if not conflicted:
134
 
        raise NotConflicted(filename)
 
224
        raise errors.NotConflicted(filename)
135
225
 
136
226
 
137
227
class ConflictList(object):
185
275
        """Generator of stanzas"""
186
276
        for conflict in self:
187
277
            yield conflict.as_stanza()
188
 
            
 
278
 
189
279
    def to_strings(self):
190
280
        """Generate strings for the provided conflicts"""
191
281
        for conflict in self:
196
286
        for conflict in self:
197
287
            if not conflict.has_files:
198
288
                continue
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
 
289
            conflict.cleanup(tree)
205
290
 
206
 
    def select_conflicts(self, tree, paths, ignore_misses=False):
 
291
    def select_conflicts(self, tree, paths, ignore_misses=False,
 
292
                         recurse=False):
207
293
        """Select the conflicts associated with paths in a tree.
208
 
        
 
294
 
209
295
        File-ids are also used for this.
 
296
        :return: a pair of ConflictLists: (not_selected, selected)
210
297
        """
211
298
        path_set = set(paths)
212
299
        ids = {}
227
314
                if cpath in path_set:
228
315
                    selected = True
229
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)
 
321
 
230
322
            for key in ('file_id', 'conflict_file_id'):
231
323
                cfile_id = getattr(conflict, key, None)
232
324
                if cfile_id is None:
249
341
                    print "%s is not conflicted" % path
250
342
        return new_conflicts, selected_conflicts
251
343
 
252
 
 
 
344
 
253
345
class Conflict(object):
254
346
    """Base class for all types of conflict"""
255
347
 
 
348
    # FIXME: cleanup should take care of that ? -- vila 091229
256
349
    has_files = False
257
350
 
258
351
    def __init__(self, path, file_id=None):
259
352
        self.path = path
260
 
        self.file_id = file_id
 
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)
261
356
 
262
357
    def as_stanza(self):
263
 
        s = Stanza(type=self.typestring, path=self.path)
 
358
        s = rio.Stanza(type=self.typestring, path=self.path)
264
359
        if self.file_id is not None:
265
 
            s.add('file_id', self.file_id)
 
360
            # Stanza requires Unicode apis
 
361
            s.add('file_id', self.file_id.decode('utf8'))
266
362
        return s
267
363
 
268
364
    def _cmp_list(self):
273
369
            return -1
274
370
        return cmp(self._cmp_list(), other._cmp_list())
275
371
 
 
372
    def __hash__(self):
 
373
        return hash((type(self), self.path, self.file_id))
 
374
 
276
375
    def __eq__(self, other):
277
376
        return self.__cmp__(other) == 0
278
377
 
301
400
        else:
302
401
            return None, conflict.typestring
303
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
 
 
415
    def associated_filenames(self):
 
416
        """The names of the files generated to help resolve the conflict."""
 
417
        raise NotImplementedError(self.associated_filenames)
 
418
 
 
419
    def cleanup(self, tree):
 
420
        for fname in self.associated_filenames():
 
421
            try:
 
422
                osutils.delete_any(tree.abspath(fname))
 
423
            except OSError, e:
 
424
                if e.errno != errno.ENOENT:
 
425
                    raise
 
426
 
 
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
 
304
444
 
305
445
class PathConflict(Conflict):
306
446
    """A conflict was encountered merging file paths"""
310
450
    format = 'Path conflict: %(path)s / %(conflict_path)s'
311
451
 
312
452
    rformat = '%(class)s(%(path)r, %(conflict_path)r, %(file_id)r)'
 
453
 
313
454
    def __init__(self, path, conflict_path=None, file_id=None):
314
455
        Conflict.__init__(self, path, file_id)
315
456
        self.conflict_path = conflict_path
320
461
            s.add('conflict_path', self.conflict_path)
321
462
        return s
322
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
 
323
555
 
324
556
class ContentsConflict(PathConflict):
325
 
    """The files are of different types, or not present"""
 
557
    """The files are of different types (or both binary), or not present"""
326
558
 
327
559
    has_files = True
328
560
 
330
562
 
331
563
    format = 'Contents conflict in %(path)s'
332
564
 
333
 
 
 
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.
334
606
class TextConflict(PathConflict):
335
607
    """The merge algorithm could not resolve all differences encountered."""
336
608
 
340
612
 
341
613
    format = 'Text conflict in %(path)s'
342
614
 
 
615
    def associated_filenames(self):
 
616
        return [self.path + suffix for suffix in CONFLICT_SUFFIXES]
 
617
 
343
618
 
344
619
class HandledConflict(Conflict):
345
620
    """A path problem that has been provisionally resolved.
347
622
    """
348
623
 
349
624
    rformat = "%(class)s(%(action)r, %(path)r, %(file_id)r)"
350
 
    
 
625
 
351
626
    def __init__(self, action, path, file_id=None):
352
627
        Conflict.__init__(self, path, file_id)
353
628
        self.action = action
360
635
        s.add('action', self.action)
361
636
        return s
362
637
 
 
638
    def associated_filenames(self):
 
639
        # Nothing has been generated here
 
640
        return []
 
641
 
363
642
 
364
643
class HandledPathConflict(HandledConflict):
365
644
    """A provisionally-resolved path problem involving two paths.
372
651
    def __init__(self, action, path, conflict_path, file_id=None,
373
652
                 conflict_file_id=None):
374
653
        HandledConflict.__init__(self, action, path, file_id)
375
 
        self.conflict_path = conflict_path 
376
 
        self.conflict_file_id = conflict_file_id
377
 
        
 
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
 
378
660
    def _cmp_list(self):
379
 
        return HandledConflict._cmp_list(self) + [self.conflict_path, 
 
661
        return HandledConflict._cmp_list(self) + [self.conflict_path,
380
662
                                                  self.conflict_file_id]
381
663
 
382
664
    def as_stanza(self):
383
665
        s = HandledConflict.as_stanza(self)
384
666
        s.add('conflict_path', self.conflict_path)
385
667
        if self.conflict_file_id is not None:
386
 
            s.add('conflict_file_id', self.conflict_file_id)
387
 
            
 
668
            s.add('conflict_file_id', self.conflict_file_id.decode('utf8'))
 
669
 
388
670
        return s
389
671
 
390
672
 
403
685
 
404
686
    format = 'Conflict adding file %(conflict_path)s.  %(action)s %(path)s.'
405
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
 
406
695
 
407
696
class ParentLoop(HandledPathConflict):
408
697
    """An attempt to create an infinitely-looping directory structure.
409
698
    This is rare, but can be produced like so:
410
699
 
411
700
    tree A:
412
 
      mv foo/bar
 
701
      mv foo bar
413
702
    tree B:
414
 
      mv bar/foo
 
703
      mv bar foo
415
704
    merge A and B
416
705
    """
417
706
 
418
707
    typestring = 'parent loop'
419
708
 
420
 
    format = 'Conflict moving %(conflict_path)s into %(path)s.  %(action)s.'
 
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()
421
731
 
422
732
 
423
733
class UnversionedParent(HandledConflict):
424
 
    """An attempt to version an file whose parent directory is not versioned.
 
734
    """An attempt to version a file whose parent directory is not versioned.
425
735
    Typically, the result of a merge where one tree unversioned the directory
426
736
    and the other added a versioned file to it.
427
737
    """
428
738
 
429
739
    typestring = 'unversioned parent'
430
740
 
431
 
    format = 'Conflict adding versioned files to %(path)s.  %(action)s.'
 
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
432
752
 
433
753
 
434
754
class MissingParent(HandledConflict):
435
755
    """An attempt to add files to a directory that is not present.
436
 
    Typically, the result of a merge where one tree deleted the directory and
437
 
    the other added a file to it.
 
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)
438
759
    """
439
760
 
440
761
    typestring = 'missing parent'
441
762
 
442
763
    format = 'Conflict adding files to %(path)s.  %(action)s.'
443
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)
444
824
 
445
825
 
446
826
ctype = {}
452
832
    for conflict_type in conflict_types:
453
833
        ctype[conflict_type.typestring] = conflict_type
454
834
 
455
 
 
456
835
register_types(ContentsConflict, TextConflict, PathConflict, DuplicateID,
457
 
               DuplicateEntry, ParentLoop, UnversionedParent, MissingParent,)
 
836
               DuplicateEntry, ParentLoop, UnversionedParent, MissingParent,
 
837
               DeletingParent, NonDirectoryParent)