1
# Copyright (C) 2005, 2006, 2007, 2009, 2010 Canonical Ltd
3
# This program is free software; you can redistribute it and/or modify
4
# it under the terms of the GNU General Public License as published by
5
# the Free Software Foundation; either version 2 of the License, or
6
# (at your option) any later version.
8
# This program is distributed in the hope that it will be useful,
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11
# GNU General Public License for more details.
13
# You should have received a copy of the GNU General Public License
14
# along with this program; if not, write to the Free Software
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
17
# TODO: 'bzr resolve' should accept a directory name and work from that
23
from bzrlib.lazy_import import lazy_import
24
lazy_import(globals(), """
45
CONFLICT_SUFFIXES = ('.THIS', '.BASE', '.OTHER')
48
class cmd_conflicts(commands.Command):
49
"""List files with conflicts.
51
Merge will do its best to combine the changes in two branches, but there
52
are some kinds of problems only a human can fix. When it encounters those,
53
it will mark a conflict. A conflict means that you need to fix something,
54
before you should commit.
56
Conflicts normally are listed as short, human-readable messages. If --text
57
is supplied, the pathnames of files with text conflicts are listed,
58
instead. (This is useful for editing all files with text conflicts.)
60
Use bzr resolve when you have fixed a problem.
64
help='List paths of files with text conflicts.'),
66
_see_also = ['resolve', 'conflict-types']
68
def run(self, text=False):
69
wt = workingtree.WorkingTree.open_containing(u'.')[0]
70
for conflict in wt.conflicts():
72
if conflict.typestring != 'text conflict':
74
self.outf.write(conflict.path + '\n')
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)
101
class cmd_resolve(commands.Command):
102
"""Mark a conflict as resolved.
104
Merge will do its best to combine the changes in two branches, but there
105
are some kinds of problems only a human can fix. When it encounters those,
106
it will mark a conflict. A conflict means that you need to fix something,
107
before you should commit.
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.
113
aliases = ['resolved']
114
takes_args = ['file*']
116
option.Option('all', help='Resolve all conflicts in this tree.'),
117
ResolveActionOption(),
119
_see_also = ['conflicts']
120
def run(self, file_list=None, all=False, action=None):
123
raise errors.BzrCommandError("If --all is specified,"
124
" no FILE may be provided")
125
tree = workingtree.WorkingTree.open_containing('.')[0]
129
tree, file_list = builtins.tree_files(file_list)
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:
143
un_resolved, resolved = tree.auto_resolve()
144
if len(un_resolved) > 0:
145
trace.note('%d conflict(s) auto-resolved.', len(resolved))
146
trace.note('Remaining conflicts:')
147
for conflict in un_resolved:
151
trace.note('All conflicts resolved.')
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,
164
"""Resolve some or all of the conflicts in a working tree.
166
:param paths: If None, resolve all conflicts. Otherwise, select only
168
:param recursive: If True, then elements of paths which are directories
169
have all their children resolved, etc. When invoked as part of
170
recursive commands like revert, this should be True. For commands
171
or applications wishing finer-grained control, like the resolve
172
command, this should be False.
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,
177
tree.lock_tree_write()
179
tree_conflicts = tree.conflicts()
181
new_conflicts = ConflictList()
182
to_process = tree_conflicts
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)
193
tree.set_conflicts(new_conflicts)
194
except errors.UnsupportedOperation:
200
def restore(filename):
201
"""Restore a conflicted file to the state it was in before merging.
203
Only text restoration is supported at present.
207
osutils.rename(filename + ".THIS", filename)
210
if e.errno != errno.ENOENT:
213
os.unlink(filename + ".BASE")
216
if e.errno != errno.ENOENT:
219
os.unlink(filename + ".OTHER")
222
if e.errno != errno.ENOENT:
225
raise errors.NotConflicted(filename)
228
class ConflictList(object):
229
"""List of conflicts.
231
Typically obtained from WorkingTree.conflicts()
233
Can be instantiated from stanzas or from Conflict subclasses.
236
def __init__(self, conflicts=None):
237
object.__init__(self)
238
if conflicts is None:
241
self.__list = conflicts
244
return len(self.__list) == 0
247
return len(self.__list)
250
return iter(self.__list)
252
def __getitem__(self, key):
253
return self.__list[key]
255
def append(self, conflict):
256
return self.__list.append(conflict)
258
def __eq__(self, other_list):
259
return list(self) == list(other_list)
261
def __ne__(self, other_list):
262
return not (self == other_list)
265
return "ConflictList(%r)" % self.__list
268
def from_stanzas(stanzas):
269
"""Produce a new ConflictList from an iterable of stanzas"""
270
conflicts = ConflictList()
271
for stanza in stanzas:
272
conflicts.append(Conflict.factory(**stanza.as_dict()))
275
def to_stanzas(self):
276
"""Generator of stanzas"""
277
for conflict in self:
278
yield conflict.as_stanza()
280
def to_strings(self):
281
"""Generate strings for the provided conflicts"""
282
for conflict in self:
285
def remove_files(self, tree):
286
"""Remove the THIS, BASE and OTHER files for listed conflicts"""
287
for conflict in self:
288
if not conflict.has_files:
290
conflict.cleanup(tree)
292
def select_conflicts(self, tree, paths, ignore_misses=False,
294
"""Select the conflicts associated with paths in a tree.
296
File-ids are also used for this.
297
:return: a pair of ConflictLists: (not_selected, selected)
299
path_set = set(paths)
301
selected_paths = set()
302
new_conflicts = ConflictList()
303
selected_conflicts = ConflictList()
305
file_id = tree.path2id(path)
306
if file_id is not None:
309
for conflict in self:
311
for key in ('path', 'conflict_path'):
312
cpath = getattr(conflict, key, None)
315
if cpath in path_set:
317
selected_paths.add(cpath)
319
if osutils.is_inside_any(path_set, cpath):
321
selected_paths.add(cpath)
323
for key in ('file_id', 'conflict_file_id'):
324
cfile_id = getattr(conflict, key, None)
328
cpath = ids[cfile_id]
332
selected_paths.add(cpath)
334
selected_conflicts.append(conflict)
336
new_conflicts.append(conflict)
337
if ignore_misses is not True:
338
for path in [p for p in paths if p not in selected_paths]:
339
if not os.path.exists(tree.abspath(path)):
340
print "%s does not exist" % path
342
print "%s is not conflicted" % path
343
return new_conflicts, selected_conflicts
346
class Conflict(object):
347
"""Base class for all types of conflict"""
349
# FIXME: cleanup should take care of that ? -- vila 091229
352
def __init__(self, path, file_id=None):
354
# warn turned off, because the factory blindly transfers the Stanza
355
# values to __init__ and Stanza is purely a Unicode api.
356
self.file_id = osutils.safe_file_id(file_id, warn=False)
359
s = rio.Stanza(type=self.typestring, path=self.path)
360
if self.file_id is not None:
361
# Stanza requires Unicode apis
362
s.add('file_id', self.file_id.decode('utf8'))
366
return [type(self), self.path, self.file_id]
368
def __cmp__(self, other):
369
if getattr(other, "_cmp_list", None) is None:
371
return cmp(self._cmp_list(), other._cmp_list())
374
return hash((type(self), self.path, self.file_id))
376
def __eq__(self, other):
377
return self.__cmp__(other) == 0
379
def __ne__(self, other):
380
return not self.__eq__(other)
383
return self.format % self.__dict__
386
rdict = dict(self.__dict__)
387
rdict['class'] = self.__class__.__name__
388
return self.rformat % rdict
391
def factory(type, **kwargs):
393
return ctype[type](**kwargs)
396
def sort_key(conflict):
397
if conflict.path is not None:
398
return conflict.path, conflict.typestring
399
elif getattr(conflict, "conflict_path", None) is not None:
400
return conflict.conflict_path, conflict.typestring
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)
440
class PathConflict(Conflict):
441
"""A conflict was encountered merging file paths"""
443
typestring = 'path conflict'
445
format = 'Path conflict: %(path)s / %(conflict_path)s'
447
rformat = '%(class)s(%(path)r, %(conflict_path)r, %(file_id)r)'
449
def __init__(self, path, conflict_path=None, file_id=None):
450
Conflict.__init__(self, path, file_id)
451
self.conflict_path = conflict_path
454
s = Conflict.as_stanza(self)
455
if self.conflict_path is not None:
456
s.add('conflict_path', self.conflict_path)
459
def associated_filenames(self):
460
# No additional files have been generated here
463
def action_take_this(self, tree):
464
tree.rename_one(self.conflict_path, self.path)
466
def action_take_other(self, tree):
467
# just acccept bzr proposal
471
class ContentsConflict(PathConflict):
472
"""The files are of different types, or not present"""
476
typestring = 'contents conflict'
478
format = 'Contents conflict in %(path)s'
480
def associated_filenames(self):
481
return [self.path + suffix for suffix in ('.BASE', '.OTHER')]
483
def _take_it(self, tt, suffix_to_remove):
484
"""Resolve the conflict.
486
:param tt: The TreeTransform where the conflict is resolved.
487
:param suffix_to_remove: Either 'THIS' or 'OTHER'
489
The resolution is symmetric, when taking THIS, OTHER is deleted and
490
item.THIS is renamed into item and vice-versa.
493
# Delete 'item.THIS' or 'item.OTHER' depending on
496
tt.trans_id_tree_path(self.path + '.' + suffix_to_remove))
497
except errors.NoSuchFile:
498
# There are valid cases where 'item.suffix_to_remove' either
499
# never existed or was already deleted (including the case
500
# where the user deleted it)
502
# Rename 'item.suffix_to_remove' (note that if
503
# 'item.suffix_to_remove' has been deleted, this is a no-op)
504
this_tid = tt.trans_id_file_id(self.file_id)
505
parent_tid = tt.get_tree_parent(this_tid)
506
tt.adjust_path(self.path, parent_tid, this_tid)
509
def _take_it_with_cleanups(self, tree, suffix_to_remove):
510
tt = transform.TreeTransform(tree)
511
op = cleanup.OperationWithCleanups(self._take_it)
512
op.add_cleanup(tt.finalize)
513
op.run_simple(tt, suffix_to_remove)
515
def action_take_this(self, tree):
516
self._take_it_with_cleanups(tree, 'OTHER')
518
def action_take_other(self, tree):
519
self._take_it_with_cleanups(tree, 'THIS')
522
# FIXME: TextConflict is about a single file-id, there never is a conflict_path
523
# attribute so we shouldn't inherit from PathConflict but simply from Conflict
525
# TODO: There should be a base revid attribute to better inform the user about
526
# how the conflicts were generated.
527
class TextConflict(PathConflict):
528
"""The merge algorithm could not resolve all differences encountered."""
532
typestring = 'text conflict'
534
format = 'Text conflict in %(path)s'
536
def associated_filenames(self):
537
return [self.path + suffix for suffix in CONFLICT_SUFFIXES]
540
class HandledConflict(Conflict):
541
"""A path problem that has been provisionally resolved.
542
This is intended to be a base class.
545
rformat = "%(class)s(%(action)r, %(path)r, %(file_id)r)"
547
def __init__(self, action, path, file_id=None):
548
Conflict.__init__(self, path, file_id)
552
return Conflict._cmp_list(self) + [self.action]
555
s = Conflict.as_stanza(self)
556
s.add('action', self.action)
559
def associated_filenames(self):
560
# Nothing has been generated here
564
class HandledPathConflict(HandledConflict):
565
"""A provisionally-resolved path problem involving two paths.
566
This is intended to be a base class.
569
rformat = "%(class)s(%(action)r, %(path)r, %(conflict_path)r,"\
570
" %(file_id)r, %(conflict_file_id)r)"
572
def __init__(self, action, path, conflict_path, file_id=None,
573
conflict_file_id=None):
574
HandledConflict.__init__(self, action, path, file_id)
575
self.conflict_path = conflict_path
576
# warn turned off, because the factory blindly transfers the Stanza
577
# values to __init__.
578
self.conflict_file_id = osutils.safe_file_id(conflict_file_id,
582
return HandledConflict._cmp_list(self) + [self.conflict_path,
583
self.conflict_file_id]
586
s = HandledConflict.as_stanza(self)
587
s.add('conflict_path', self.conflict_path)
588
if self.conflict_file_id is not None:
589
s.add('conflict_file_id', self.conflict_file_id.decode('utf8'))
594
class DuplicateID(HandledPathConflict):
595
"""Two files want the same file_id."""
597
typestring = 'duplicate id'
599
format = 'Conflict adding id to %(conflict_path)s. %(action)s %(path)s.'
602
class DuplicateEntry(HandledPathConflict):
603
"""Two directory entries want to have the same name."""
605
typestring = 'duplicate'
607
format = 'Conflict adding file %(conflict_path)s. %(action)s %(path)s.'
609
def action_take_this(self, tree):
610
tree.remove([self.conflict_path], force=True, keep_files=False)
611
tree.rename_one(self.path, self.conflict_path)
613
def action_take_other(self, tree):
614
tree.remove([self.path], force=True, keep_files=False)
617
class ParentLoop(HandledPathConflict):
618
"""An attempt to create an infinitely-looping directory structure.
619
This is rare, but can be produced like so:
628
typestring = 'parent loop'
630
format = 'Conflict moving %(conflict_path)s into %(path)s. %(action)s.'
632
def action_take_this(self, tree):
633
# just acccept bzr proposal
636
def action_take_other(self, tree):
637
# FIXME: We shouldn't have to manipulate so many paths here (and there
638
# is probably a bug or two...)
639
base_path = osutils.basename(self.path)
640
conflict_base_path = osutils.basename(self.conflict_path)
641
tt = transform.TreeTransform(tree)
643
p_tid = tt.trans_id_file_id(self.file_id)
644
parent_tid = tt.get_tree_parent(p_tid)
645
cp_tid = tt.trans_id_file_id(self.conflict_file_id)
646
cparent_tid = tt.get_tree_parent(cp_tid)
647
tt.adjust_path(base_path, cparent_tid, cp_tid)
648
tt.adjust_path(conflict_base_path, parent_tid, p_tid)
654
class UnversionedParent(HandledConflict):
655
"""An attempt to version a file whose parent directory is not versioned.
656
Typically, the result of a merge where one tree unversioned the directory
657
and the other added a versioned file to it.
660
typestring = 'unversioned parent'
662
format = 'Conflict because %(path)s is not versioned, but has versioned'\
663
' children. %(action)s.'
665
# FIXME: We silently do nothing to make tests pass, but most probably the
666
# conflict shouldn't exist (the long story is that the conflict is
667
# generated with another one that can be resolved properly) -- vila 091224
668
def action_take_this(self, tree):
671
def action_take_other(self, tree):
675
class MissingParent(HandledConflict):
676
"""An attempt to add files to a directory that is not present.
677
Typically, the result of a merge where THIS deleted the directory and
678
the OTHER added a file to it.
679
See also: DeletingParent (same situation, THIS and OTHER reversed)
682
typestring = 'missing parent'
684
format = 'Conflict adding files to %(path)s. %(action)s.'
686
def action_take_this(self, tree):
687
tree.remove([self.path], force=True, keep_files=False)
689
def action_take_other(self, tree):
690
# just acccept bzr proposal
694
class DeletingParent(HandledConflict):
695
"""An attempt to add files to a directory that is not present.
696
Typically, the result of a merge where one OTHER deleted the directory and
697
the THIS added a file to it.
700
typestring = 'deleting parent'
702
format = "Conflict: can't delete %(path)s because it is not empty. "\
705
# FIXME: It's a bit strange that the default action is not coherent with
706
# MissingParent from the *user* pov.
708
def action_take_this(self, tree):
709
# just acccept bzr proposal
712
def action_take_other(self, tree):
713
tree.remove([self.path], force=True, keep_files=False)
716
class NonDirectoryParent(HandledConflict):
717
"""An attempt to add files to a directory that is not a directory or
718
an attempt to change the kind of a directory with files.
721
typestring = 'non-directory parent'
723
format = "Conflict: %(path)s is not a directory, but has files in it."\
726
# FIXME: .OTHER should be used instead of .new when the conflict is created
728
def action_take_this(self, tree):
729
# FIXME: we should preserve that path when the conflict is generated !
730
if self.path.endswith('.new'):
731
conflict_path = self.path[:-(len('.new'))]
732
tree.remove([self.path], force=True, keep_files=False)
733
tree.add(conflict_path)
735
raise NotImplementedError(self.action_take_this)
737
def action_take_other(self, tree):
738
# FIXME: we should preserve that path when the conflict is generated !
739
if self.path.endswith('.new'):
740
conflict_path = self.path[:-(len('.new'))]
741
tree.remove([conflict_path], force=True, keep_files=False)
742
tree.rename_one(self.path, conflict_path)
744
raise NotImplementedError(self.action_take_other)
750
def register_types(*conflict_types):
751
"""Register a Conflict subclass for serialization purposes"""
753
for conflict_type in conflict_types:
754
ctype[conflict_type.typestring] = conflict_type
756
register_types(ContentsConflict, TextConflict, PathConflict, DuplicateID,
757
DuplicateEntry, ParentLoop, UnversionedParent, MissingParent,
758
DeletingParent, NonDirectoryParent)
added
removed
bzrlib/conflicts.py
