56
53
instead. (This is useful for editing all files with text conflicts.)
58
55
Use bzr resolve when you have fixed a problem.
63
help='List paths of files with text conflicts.'),
61
help='List paths of files with text conflicts.'),
65
_see_also = ['resolve', 'conflict-types']
67
def run(self, text=False, directory=u'.'):
68
wt = workingtree.WorkingTree.open_containing(directory)[0]
64
def run(self, text=False):
65
from bzrlib.workingtree import WorkingTree
66
wt = WorkingTree.open_containing(u'.')[0]
69
67
for conflict in wt.conflicts():
71
69
if conflict.typestring != 'text conflict':
75
73
self.outf.write(str(conflict) + '\n')
78
resolve_action_registry = registry.Registry()
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'
91
class ResolveActionOption(option.RegistryOption):
94
super(ResolveActionOption, self).__init__(
95
'action', 'How to resolve the conflict.',
97
registry=resolve_action_registry)
100
76
class cmd_resolve(commands.Command):
101
__doc__ = """Mark a conflict as resolved.
77
"""Mark a conflict as resolved.
103
79
Merge will do its best to combine the changes in two branches, but there
104
80
are some kinds of problems only a human can fix. When it encounters those,
106
82
before you should commit.
108
84
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
85
text conflicts as fixed, resolve FILE to mark a specific conflict as
110
86
resolved, or "bzr resolve --all" to mark all conflicts as resolved.
88
See also bzr conflicts.
112
90
aliases = ['resolved']
113
91
takes_args = ['file*']
116
option.Option('all', help='Resolve all conflicts in this tree.'),
117
ResolveActionOption(),
93
Option('all', help='Resolve all conflicts in this tree.'),
119
_see_also = ['conflicts']
120
def run(self, file_list=None, all=False, action=None, directory=u'.'):
95
def run(self, file_list=None, all=False):
96
from bzrlib.workingtree import WorkingTree
123
99
raise errors.BzrCommandError("If --all is specified,"
124
100
" no FILE may be provided")
125
tree = workingtree.WorkingTree.open_containing(directory)[0]
101
tree = WorkingTree.open_containing('.')[0]
129
tree, file_list = workingtree.WorkingTree.open_containing_paths(
131
if file_list is None:
133
# FIXME: There is a special case here related to the option
134
# handling that could be clearer and easier to discover by
135
# providing an --auto action (bug #344013 and #383396) and
136
# make it mandatory instead of implicit and active only
137
# when no file_list is provided -- vila 091229
104
tree, file_list = builtins.tree_files(file_list)
143
105
if file_list is None:
144
106
un_resolved, resolved = tree.auto_resolve()
145
107
if len(un_resolved) > 0:
152
114
trace.note('All conflicts resolved.')
155
# FIXME: This can never occur but the block above needs some
156
# refactoring to transfer tree.auto_resolve() to
157
# conflict.auto(tree) --vila 091242
160
resolve(tree, file_list, action=action)
163
def resolve(tree, paths=None, ignore_misses=False, recursive=False,
117
resolve(tree, file_list)
120
def resolve(tree, paths=None, ignore_misses=False, recursive=False):
165
121
"""Resolve some or all of the conflicts in a working tree.
167
123
:param paths: If None, resolve all conflicts. Otherwise, select only
171
127
recursive commands like revert, this should be True. For commands
172
128
or applications wishing finer-grained control, like the resolve
173
129
command, this should be False.
174
:param ignore_misses: If False, warnings will be printed if the supplied
175
paths do not have conflicts.
176
:param action: How the conflict should be resolved,
130
:ignore_misses: If False, warnings will be printed if the supplied paths
131
do not have conflicts.
178
133
tree.lock_tree_write()
180
135
tree_conflicts = tree.conflicts()
181
136
if paths is None:
182
137
new_conflicts = ConflictList()
183
to_process = tree_conflicts
138
selected_conflicts = tree_conflicts
185
new_conflicts, to_process = tree_conflicts.select_conflicts(
186
tree, paths, ignore_misses, recursive)
187
for conflict in to_process:
189
conflict._do(action, tree)
190
conflict.cleanup(tree)
191
except NotImplementedError:
192
new_conflicts.append(conflict)
140
new_conflicts, selected_conflicts = \
141
tree_conflicts.select_conflicts(tree, paths, ignore_misses,
194
144
tree.set_conflicts(new_conflicts)
195
145
except errors.UnsupportedOperation:
147
selected_conflicts.remove_files(tree)
201
152
def restore(filename):
202
"""Restore a conflicted file to the state it was in before merging.
204
Only text restoration is supported at present.
154
Restore a conflicted file to the state it was in before merging.
155
Only text restoration supported at present.
206
157
conflicted = False
403
358
return None, conflict.typestring
405
def _do(self, action, tree):
406
"""Apply the specified action to the conflict.
408
:param action: The method name to call.
410
:param tree: The tree passed as a parameter to the method.
412
meth = getattr(self, 'action_%s' % action, None)
414
raise NotImplementedError(self.__class__.__name__ + '.' + action)
417
def associated_filenames(self):
418
"""The names of the files generated to help resolve the conflict."""
419
raise NotImplementedError(self.associated_filenames)
421
def cleanup(self, tree):
422
for fname in self.associated_filenames():
424
osutils.delete_any(tree.abspath(fname))
426
if e.errno != errno.ENOENT:
429
def action_done(self, tree):
430
"""Mark the conflict as solved once it has been handled."""
431
# This method does nothing but simplifies the design of upper levels.
434
def action_take_this(self, tree):
435
raise NotImplementedError(self.action_take_this)
437
def action_take_other(self, tree):
438
raise NotImplementedError(self.action_take_other)
440
def _resolve_with_cleanups(self, tree, *args, **kwargs):
441
tt = transform.TreeTransform(tree)
442
op = cleanup.OperationWithCleanups(self._resolve)
443
op.add_cleanup(tt.finalize)
444
op.run_simple(tt, *args, **kwargs)
447
361
class PathConflict(Conflict):
448
362
"""A conflict was encountered merging file paths"""
463
376
s.add('conflict_path', self.conflict_path)
466
def associated_filenames(self):
467
# No additional files have been generated here
470
def _resolve(self, tt, file_id, path, winner):
471
"""Resolve the conflict.
473
:param tt: The TreeTransform where the conflict is resolved.
474
:param file_id: The retained file id.
475
:param path: The retained path.
476
:param winner: 'this' or 'other' indicates which side is the winner.
478
path_to_create = None
480
if self.path == '<deleted>':
481
return # Nothing to do
482
if self.conflict_path == '<deleted>':
483
path_to_create = self.path
484
revid = tt._tree.get_parent_ids()[0]
485
elif winner == 'other':
486
if self.conflict_path == '<deleted>':
487
return # Nothing to do
488
if self.path == '<deleted>':
489
path_to_create = self.conflict_path
490
# FIXME: If there are more than two parents we may need to
491
# iterate. Taking the last parent is the safer bet in the mean
492
# time. -- vila 20100309
493
revid = tt._tree.get_parent_ids()[-1]
496
raise AssertionError('bad winner: %r' % (winner,))
497
if path_to_create is not None:
498
tid = tt.trans_id_tree_path(path_to_create)
499
transform.create_from_tree(
500
tt, tt.trans_id_tree_path(path_to_create),
501
self._revision_tree(tt._tree, revid), file_id)
502
tt.version_file(file_id, tid)
504
# Adjust the path for the retained file id
505
tid = tt.trans_id_file_id(file_id)
506
parent_tid = tt.get_tree_parent(tid)
507
tt.adjust_path(path, parent_tid, tid)
510
def _revision_tree(self, tree, revid):
511
return tree.branch.repository.revision_tree(revid)
513
def _infer_file_id(self, tree):
514
# Prior to bug #531967, file_id wasn't always set, there may still be
515
# conflict files in the wild so we need to cope with them
516
# Establish which path we should use to find back the file-id
518
for p in (self.path, self.conflict_path):
520
# special hard-coded path
523
possible_paths.append(p)
524
# Search the file-id in the parents with any path available
526
for revid in tree.get_parent_ids():
527
revtree = self._revision_tree(tree, revid)
528
for p in possible_paths:
529
file_id = revtree.path2id(p)
530
if file_id is not None:
531
return revtree, file_id
534
def action_take_this(self, tree):
535
if self.file_id is not None:
536
self._resolve_with_cleanups(tree, self.file_id, self.path,
539
# Prior to bug #531967 we need to find back the file_id and restore
540
# the content from there
541
revtree, file_id = self._infer_file_id(tree)
542
tree.revert([revtree.id2path(file_id)],
543
old_tree=revtree, backups=False)
545
def action_take_other(self, tree):
546
if self.file_id is not None:
547
self._resolve_with_cleanups(tree, self.file_id,
551
# Prior to bug #531967 we need to find back the file_id and restore
552
# the content from there
553
revtree, file_id = self._infer_file_id(tree)
554
tree.revert([revtree.id2path(file_id)],
555
old_tree=revtree, backups=False)
558
380
class ContentsConflict(PathConflict):
559
"""The files are of different types (or both binary), or not present"""
381
"""The files are of different types, or not present"""
565
387
format = 'Contents conflict in %(path)s'
567
def associated_filenames(self):
568
return [self.path + suffix for suffix in ('.BASE', '.OTHER')]
570
def _resolve(self, tt, suffix_to_remove):
571
"""Resolve the conflict.
573
:param tt: The TreeTransform where the conflict is resolved.
574
:param suffix_to_remove: Either 'THIS' or 'OTHER'
576
The resolution is symmetric, when taking THIS, OTHER is deleted and
577
item.THIS is renamed into item and vice-versa.
580
# Delete 'item.THIS' or 'item.OTHER' depending on
583
tt.trans_id_tree_path(self.path + '.' + suffix_to_remove))
584
except errors.NoSuchFile:
585
# There are valid cases where 'item.suffix_to_remove' either
586
# never existed or was already deleted (including the case
587
# where the user deleted it)
589
# Rename 'item.suffix_to_remove' (note that if
590
# 'item.suffix_to_remove' has been deleted, this is a no-op)
591
this_tid = tt.trans_id_file_id(self.file_id)
592
parent_tid = tt.get_tree_parent(this_tid)
593
tt.adjust_path(self.path, parent_tid, this_tid)
596
def action_take_this(self, tree):
597
self._resolve_with_cleanups(tree, 'OTHER')
599
def action_take_other(self, tree):
600
self._resolve_with_cleanups(tree, 'THIS')
603
# FIXME: TextConflict is about a single file-id, there never is a conflict_path
604
# attribute so we shouldn't inherit from PathConflict but simply from Conflict
606
# TODO: There should be a base revid attribute to better inform the user about
607
# how the conflicts were generated.
608
390
class TextConflict(PathConflict):
609
391
"""The merge algorithm could not resolve all differences encountered."""
688
463
format = 'Conflict adding file %(conflict_path)s. %(action)s %(path)s.'
690
def action_take_this(self, tree):
691
tree.remove([self.conflict_path], force=True, keep_files=False)
692
tree.rename_one(self.path, self.conflict_path)
694
def action_take_other(self, tree):
695
tree.remove([self.path], force=True, keep_files=False)
698
466
class ParentLoop(HandledPathConflict):
699
467
"""An attempt to create an infinitely-looping directory structure.
700
468
This is rare, but can be produced like so:
709
477
typestring = 'parent loop'
711
format = 'Conflict moving %(path)s into %(conflict_path)s. %(action)s.'
713
def action_take_this(self, tree):
714
# just acccept bzr proposal
717
def action_take_other(self, tree):
718
# FIXME: We shouldn't have to manipulate so many paths here (and there
719
# is probably a bug or two...)
720
base_path = osutils.basename(self.path)
721
conflict_base_path = osutils.basename(self.conflict_path)
722
tt = transform.TreeTransform(tree)
724
p_tid = tt.trans_id_file_id(self.file_id)
725
parent_tid = tt.get_tree_parent(p_tid)
726
cp_tid = tt.trans_id_file_id(self.conflict_file_id)
727
cparent_tid = tt.get_tree_parent(cp_tid)
728
tt.adjust_path(base_path, cparent_tid, cp_tid)
729
tt.adjust_path(conflict_base_path, parent_tid, p_tid)
479
format = 'Conflict moving %(conflict_path)s into %(path)s. %(action)s.'
735
482
class UnversionedParent(HandledConflict):
736
"""An attempt to version a file whose parent directory is not versioned.
483
"""An attempt to version an file whose parent directory is not versioned.
737
484
Typically, the result of a merge where one tree unversioned the directory
738
485
and the other added a versioned file to it.
743
490
format = 'Conflict because %(path)s is not versioned, but has versioned'\
744
491
' children. %(action)s.'
746
# FIXME: We silently do nothing to make tests pass, but most probably the
747
# conflict shouldn't exist (the long story is that the conflict is
748
# generated with another one that can be resolved properly) -- vila 091224
749
def action_take_this(self, tree):
752
def action_take_other(self, tree):
756
494
class MissingParent(HandledConflict):
757
495
"""An attempt to add files to a directory that is not present.
758
496
Typically, the result of a merge where THIS deleted the directory and
759
497
the OTHER added a file to it.
760
See also: DeletingParent (same situation, THIS and OTHER reversed)
498
See also: DeletingParent (same situation, reversed THIS and OTHER)
763
501
typestring = 'missing parent'
765
503
format = 'Conflict adding files to %(path)s. %(action)s.'
767
def action_take_this(self, tree):
768
tree.remove([self.path], force=True, keep_files=False)
770
def action_take_other(self, tree):
771
# just acccept bzr proposal
775
506
class DeletingParent(HandledConflict):
776
507
"""An attempt to add files to a directory that is not present.
783
514
format = "Conflict: can't delete %(path)s because it is not empty. "\
786
# FIXME: It's a bit strange that the default action is not coherent with
787
# MissingParent from the *user* pov.
789
def action_take_this(self, tree):
790
# just acccept bzr proposal
793
def action_take_other(self, tree):
794
tree.remove([self.path], force=True, keep_files=False)
797
518
class NonDirectoryParent(HandledConflict):
798
"""An attempt to add files to a directory that is not a directory or
519
"""An attempt to add files to a directory that is not a director or
799
520
an attempt to change the kind of a directory with files.
804
525
format = "Conflict: %(path)s is not a directory, but has files in it."\
807
# FIXME: .OTHER should be used instead of .new when the conflict is created
809
def action_take_this(self, tree):
810
# FIXME: we should preserve that path when the conflict is generated !
811
if self.path.endswith('.new'):
812
conflict_path = self.path[:-(len('.new'))]
813
tree.remove([self.path], force=True, keep_files=False)
814
tree.add(conflict_path)
816
raise NotImplementedError(self.action_take_this)
818
def action_take_other(self, tree):
819
# FIXME: we should preserve that path when the conflict is generated !
820
if self.path.endswith('.new'):
821
conflict_path = self.path[:-(len('.new'))]
822
tree.remove([conflict_path], force=True, keep_files=False)
823
tree.rename_one(self.path, conflict_path)
825
raise NotImplementedError(self.action_take_other)
added
removed
bzrlib/conflicts.py
