55
60
Use bzr resolve when you have fixed a problem.
59
help='List paths of files with text conflicts.'),
64
help='List paths of files with text conflicts.'),
61
66
_see_also = ['resolve', 'conflict-types']
63
68
def run(self, text=False):
64
from bzrlib.workingtree import WorkingTree
65
wt = WorkingTree.open_containing(u'.')[0]
69
wt = workingtree.WorkingTree.open_containing(u'.')[0]
66
70
for conflict in wt.conflicts():
68
72
if conflict.typestring != 'text conflict':
72
76
self.outf.write(str(conflict) + '\n')
79
resolve_action_registry = registry.Registry()
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'
92
class ResolveActionOption(option.RegistryOption):
95
super(ResolveActionOption, self).__init__(
96
'action', 'How to resolve the conflict.',
98
registry=resolve_action_registry)
75
101
class cmd_resolve(commands.Command):
76
102
"""Mark a conflict as resolved.
87
113
aliases = ['resolved']
88
114
takes_args = ['file*']
90
Option('all', help='Resolve all conflicts in this tree.'),
116
option.Option('all', help='Resolve all conflicts in this tree.'),
117
ResolveActionOption(),
92
119
_see_also = ['conflicts']
93
def run(self, file_list=None, all=False):
94
from bzrlib.workingtree import WorkingTree
120
def run(self, file_list=None, all=False, action=None):
97
123
raise errors.BzrCommandError("If --all is specified,"
98
124
" no FILE may be provided")
99
tree = WorkingTree.open_containing('.')[0]
125
tree = workingtree.WorkingTree.open_containing('.')[0]
102
129
tree, file_list = builtins.tree_files(file_list)
103
130
if file_list is None:
132
# FIXME: There is a special case here related to the option
133
# handling that could be clearer and easier to discover by
134
# providing an --auto action (bug #344013 and #383396) and
135
# make it mandatory instead of implicit and active only
136
# when no file_list is provided -- vila 091229
142
if file_list is None:
104
143
un_resolved, resolved = tree.auto_resolve()
105
144
if len(un_resolved) > 0:
106
145
trace.note('%d conflict(s) auto-resolved.', len(resolved))
112
151
trace.note('All conflicts resolved.')
115
resolve(tree, file_list)
118
def resolve(tree, paths=None, ignore_misses=False, recursive=False):
154
# FIXME: This can never occur but the block above needs some
155
# refactoring to transfer tree.auto_resolve() to
156
# conflict.auto(tree) --vila 091242
159
resolve(tree, file_list, action=action)
162
def resolve(tree, paths=None, ignore_misses=False, recursive=False,
119
164
"""Resolve some or all of the conflicts in a working tree.
121
166
:param paths: If None, resolve all conflicts. Otherwise, select only
125
170
recursive commands like revert, this should be True. For commands
126
171
or applications wishing finer-grained control, like the resolve
127
172
command, this should be False.
128
:ignore_misses: If False, warnings will be printed if the supplied paths
129
do not have conflicts.
173
:param ignore_misses: If False, warnings will be printed if the supplied
174
paths do not have conflicts.
175
:param action: How the conflict should be resolved,
131
177
tree.lock_tree_write()
133
179
tree_conflicts = tree.conflicts()
134
180
if paths is None:
135
181
new_conflicts = ConflictList()
136
selected_conflicts = tree_conflicts
182
to_process = tree_conflicts
138
new_conflicts, selected_conflicts = \
139
tree_conflicts.select_conflicts(tree, paths, ignore_misses,
184
new_conflicts, to_process = tree_conflicts.select_conflicts(
185
tree, paths, ignore_misses, recursive)
186
for conflict in to_process:
188
conflict._do(action, tree)
189
conflict.cleanup(tree)
190
except NotImplementedError:
191
new_conflicts.append(conflict)
142
193
tree.set_conflicts(new_conflicts)
143
194
except errors.UnsupportedOperation:
145
selected_conflicts.remove_files(tree)
356
402
return None, conflict.typestring
404
def _do(self, action, tree):
405
"""Apply the specified action to the conflict.
407
:param action: The method name to call.
409
:param tree: The tree passed as a parameter to the method.
411
meth = getattr(self, 'action_%s' % action, None)
413
raise NotImplementedError(self.__class__.__name__ + '.' + action)
416
def associated_filenames(self):
417
"""The names of the files generated to help resolve the conflict."""
418
raise NotImplementedError(self.associated_filenames)
420
def cleanup(self, tree):
421
for fname in self.associated_filenames():
423
osutils.delete_any(tree.abspath(fname))
425
if e.errno != errno.ENOENT:
428
def action_done(self, tree):
429
"""Mark the conflict as solved once it has been handled."""
430
# This method does nothing but simplifies the design of upper levels.
433
def action_take_this(self, tree):
434
raise NotImplementedError(self.action_take_this)
436
def action_take_other(self, tree):
437
raise NotImplementedError(self.action_take_other)
439
def _resolve_with_cleanups(self, tree, *args, **kwargs):
440
tt = transform.TreeTransform(tree)
441
op = cleanup.OperationWithCleanups(self._resolve)
442
op.add_cleanup(tt.finalize)
443
op.run_simple(tt, *args, **kwargs)
359
446
class PathConflict(Conflict):
360
447
"""A conflict was encountered merging file paths"""
374
462
s.add('conflict_path', self.conflict_path)
465
def associated_filenames(self):
466
# No additional files have been generated here
469
def _resolve(self, tt, file_id, path, winner):
470
"""Resolve the conflict.
472
:param tt: The TreeTransform where the conflict is resolved.
473
:param file_id: The retained file id.
474
:param path: The retained path.
475
:param winner: 'this' or 'other' indicates which side is the winner.
477
path_to_create = None
479
if self.path == '<deleted>':
480
return # Nothing to do
481
if self.conflict_path == '<deleted>':
482
path_to_create = self.path
483
revid = tt._tree.get_parent_ids()[0]
484
elif winner == 'other':
485
if self.conflict_path == '<deleted>':
486
return # Nothing to do
487
if self.path == '<deleted>':
488
path_to_create = self.conflict_path
489
# FIXME: If there are more than two parents we may need to
490
# iterate. Taking the last parent is the safer bet in the mean
491
# time. -- vila 20100309
492
revid = tt._tree.get_parent_ids()[-1]
495
raise AssertionError('bad winner: %r' % (winner,))
496
if path_to_create is not None:
497
tid = tt.trans_id_tree_path(path_to_create)
498
transform.create_from_tree(
499
tt, tt.trans_id_tree_path(path_to_create),
500
self._revision_tree(tt._tree, revid), file_id)
501
tt.version_file(file_id, tid)
503
# Adjust the path for the retained file id
504
tid = tt.trans_id_file_id(file_id)
505
parent_tid = tt.get_tree_parent(tid)
506
tt.adjust_path(path, parent_tid, tid)
509
def _revision_tree(self, tree, revid):
510
return tree.branch.repository.revision_tree(revid)
512
def _infer_file_id(self, tree):
513
# Prior to bug #531967, file_id wasn't always set, there may still be
514
# conflict files in the wild so we need to cope with them
515
# Establish which path we should use to find back the file-id
517
for p in (self.path, self.conflict_path):
519
# special hard-coded path
522
possible_paths.append(p)
523
# Search the file-id in the parents with any path available
525
for revid in tree.get_parent_ids():
526
revtree = self._revision_tree(tree, revid)
527
for p in possible_paths:
528
file_id = revtree.path2id(p)
529
if file_id is not None:
530
return revtree, file_id
533
def action_take_this(self, tree):
534
if self.file_id is not None:
535
self._resolve_with_cleanups(tree, self.file_id, self.path,
538
# Prior to bug #531967 we need to find back the file_id and restore
539
# the content from there
540
revtree, file_id = self._infer_file_id(tree)
541
tree.revert([revtree.id2path(file_id)],
542
old_tree=revtree, backups=False)
544
def action_take_other(self, tree):
545
if self.file_id is not None:
546
self._resolve_with_cleanups(tree, self.file_id,
550
# Prior to bug #531967 we need to find back the file_id and restore
551
# the content from there
552
revtree, file_id = self._infer_file_id(tree)
553
tree.revert([revtree.id2path(file_id)],
554
old_tree=revtree, backups=False)
378
557
class ContentsConflict(PathConflict):
379
"""The files are of different types, or not present"""
558
"""The files are of different types (or both binary), or not present"""
385
564
format = 'Contents conflict in %(path)s'
566
def associated_filenames(self):
567
return [self.path + suffix for suffix in ('.BASE', '.OTHER')]
569
def _resolve(self, tt, suffix_to_remove):
570
"""Resolve the conflict.
572
:param tt: The TreeTransform where the conflict is resolved.
573
:param suffix_to_remove: Either 'THIS' or 'OTHER'
575
The resolution is symmetric, when taking THIS, OTHER is deleted and
576
item.THIS is renamed into item and vice-versa.
579
# Delete 'item.THIS' or 'item.OTHER' depending on
582
tt.trans_id_tree_path(self.path + '.' + suffix_to_remove))
583
except errors.NoSuchFile:
584
# There are valid cases where 'item.suffix_to_remove' either
585
# never existed or was already deleted (including the case
586
# where the user deleted it)
588
# Rename 'item.suffix_to_remove' (note that if
589
# 'item.suffix_to_remove' has been deleted, this is a no-op)
590
this_tid = tt.trans_id_file_id(self.file_id)
591
parent_tid = tt.get_tree_parent(this_tid)
592
tt.adjust_path(self.path, parent_tid, this_tid)
595
def action_take_this(self, tree):
596
self._resolve_with_cleanups(tree, 'OTHER')
598
def action_take_other(self, tree):
599
self._resolve_with_cleanups(tree, 'THIS')
602
# FIXME: TextConflict is about a single file-id, there never is a conflict_path
603
# attribute so we shouldn't inherit from PathConflict but simply from Conflict
605
# TODO: There should be a base revid attribute to better inform the user about
606
# how the conflicts were generated.
388
607
class TextConflict(PathConflict):
389
608
"""The merge algorithm could not resolve all differences encountered."""
461
687
format = 'Conflict adding file %(conflict_path)s. %(action)s %(path)s.'
689
def action_take_this(self, tree):
690
tree.remove([self.conflict_path], force=True, keep_files=False)
691
tree.rename_one(self.path, self.conflict_path)
693
def action_take_other(self, tree):
694
tree.remove([self.path], force=True, keep_files=False)
464
697
class ParentLoop(HandledPathConflict):
465
698
"""An attempt to create an infinitely-looping directory structure.
466
699
This is rare, but can be produced like so:
475
708
typestring = 'parent loop'
477
format = 'Conflict moving %(conflict_path)s into %(path)s. %(action)s.'
710
format = 'Conflict moving %(path)s into %(conflict_path)s. %(action)s.'
712
def action_take_this(self, tree):
713
# just acccept bzr proposal
716
def action_take_other(self, tree):
717
# FIXME: We shouldn't have to manipulate so many paths here (and there
718
# is probably a bug or two...)
719
base_path = osutils.basename(self.path)
720
conflict_base_path = osutils.basename(self.conflict_path)
721
tt = transform.TreeTransform(tree)
723
p_tid = tt.trans_id_file_id(self.file_id)
724
parent_tid = tt.get_tree_parent(p_tid)
725
cp_tid = tt.trans_id_file_id(self.conflict_file_id)
726
cparent_tid = tt.get_tree_parent(cp_tid)
727
tt.adjust_path(base_path, cparent_tid, cp_tid)
728
tt.adjust_path(conflict_base_path, parent_tid, p_tid)
480
734
class UnversionedParent(HandledConflict):
488
742
format = 'Conflict because %(path)s is not versioned, but has versioned'\
489
743
' children. %(action)s.'
745
# FIXME: We silently do nothing to make tests pass, but most probably the
746
# conflict shouldn't exist (the long story is that the conflict is
747
# generated with another one that can be resolved properly) -- vila 091224
748
def action_take_this(self, tree):
751
def action_take_other(self, tree):
492
755
class MissingParent(HandledConflict):
493
756
"""An attempt to add files to a directory that is not present.
494
757
Typically, the result of a merge where THIS deleted the directory and
495
758
the OTHER added a file to it.
496
See also: DeletingParent (same situation, reversed THIS and OTHER)
759
See also: DeletingParent (same situation, THIS and OTHER reversed)
499
762
typestring = 'missing parent'
501
764
format = 'Conflict adding files to %(path)s. %(action)s.'
766
def action_take_this(self, tree):
767
tree.remove([self.path], force=True, keep_files=False)
769
def action_take_other(self, tree):
770
# just acccept bzr proposal
504
774
class DeletingParent(HandledConflict):
505
775
"""An attempt to add files to a directory that is not present.
512
782
format = "Conflict: can't delete %(path)s because it is not empty. "\
785
# FIXME: It's a bit strange that the default action is not coherent with
786
# MissingParent from the *user* pov.
788
def action_take_this(self, tree):
789
# just acccept bzr proposal
792
def action_take_other(self, tree):
793
tree.remove([self.path], force=True, keep_files=False)
516
796
class NonDirectoryParent(HandledConflict):
517
"""An attempt to add files to a directory that is not a director or
797
"""An attempt to add files to a directory that is not a directory or
518
798
an attempt to change the kind of a directory with files.
523
803
format = "Conflict: %(path)s is not a directory, but has files in it."\
806
# FIXME: .OTHER should be used instead of .new when the conflict is created
808
def action_take_this(self, tree):
809
# FIXME: we should preserve that path when the conflict is generated !
810
if self.path.endswith('.new'):
811
conflict_path = self.path[:-(len('.new'))]
812
tree.remove([self.path], force=True, keep_files=False)
813
tree.add(conflict_path)
815
raise NotImplementedError(self.action_take_this)
817
def action_take_other(self, tree):
818
# FIXME: we should preserve that path when the conflict is generated !
819
if self.path.endswith('.new'):
820
conflict_path = self.path[:-(len('.new'))]
821
tree.remove([conflict_path], force=True, keep_files=False)
822
tree.rename_one(self.path, conflict_path)
824
raise NotImplementedError(self.action_take_other)
added
removed
bzrlib/conflicts.py
