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(), """
44
CONFLICT_SUFFIXES = ('.THIS', '.BASE', '.OTHER')
47
class cmd_conflicts(commands.Command):
48
"""List files with conflicts.
50
Merge will do its best to combine the changes in two branches, but there
51
are some kinds of problems only a human can fix. When it encounters those,
52
it will mark a conflict. A conflict means that you need to fix something,
53
before you should commit.
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.)
59
Use bzr resolve when you have fixed a problem.
63
help='List paths of files with text conflicts.'),
65
_see_also = ['resolve', 'conflict-types']
67
def run(self, text=False):
68
wt = workingtree.WorkingTree.open_containing(u'.')[0]
69
for conflict in wt.conflicts():
71
if conflict.typestring != 'text conflict':
73
self.outf.write(conflict.path + '\n')
75
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
class cmd_resolve(commands.Command):
101
"""Mark a conflict as resolved.
103
Merge will do its best to combine the changes in two branches, but there
104
are some kinds of problems only a human can fix. When it encounters those,
105
it will mark a conflict. A conflict means that you need to fix something,
106
before you should commit.
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.
112
aliases = ['resolved']
113
takes_args = ['file*']
115
option.Option('all', help='Resolve all conflicts in this tree.'),
116
ResolveActionOption(),
118
_see_also = ['conflicts']
119
def run(self, file_list=None, all=False, action=None):
122
raise errors.BzrCommandError("If --all is specified,"
123
" no FILE may be provided")
124
tree = workingtree.WorkingTree.open_containing('.')[0]
128
tree, file_list = builtins.tree_files(file_list)
129
if file_list 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
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:
150
trace.note('All conflicts resolved.')
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
158
resolve(tree, file_list, action=action)
161
def resolve(tree, paths=None, ignore_misses=False, recursive=False,
163
"""Resolve some or all of the conflicts in a working tree.
165
:param paths: If None, resolve all conflicts. Otherwise, select only
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,
176
tree.lock_tree_write()
178
tree_conflicts = tree.conflicts()
180
new_conflicts = ConflictList()
181
to_process = tree_conflicts
183
new_conflicts, to_process = tree_conflicts.select_conflicts(
184
tree, paths, ignore_misses, recursive)
185
for conflict in to_process:
187
conflict._do(action, tree)
188
conflict.cleanup(tree)
189
except NotImplementedError:
190
new_conflicts.append(conflict)
192
tree.set_conflicts(new_conflicts)
193
except errors.UnsupportedOperation:
199
def restore(filename):
200
"""Restore a conflicted file to the state it was in before merging.
202
Only text restoration is supported at present.
206
osutils.rename(filename + ".THIS", filename)
209
if e.errno != errno.ENOENT:
212
os.unlink(filename + ".BASE")
215
if e.errno != errno.ENOENT:
218
os.unlink(filename + ".OTHER")
221
if e.errno != errno.ENOENT:
224
raise errors.NotConflicted(filename)
227
class ConflictList(object):
228
"""List of conflicts.
230
Typically obtained from WorkingTree.conflicts()
232
Can be instantiated from stanzas or from Conflict subclasses.
235
def __init__(self, conflicts=None):
236
object.__init__(self)
237
if conflicts is None:
240
self.__list = conflicts
243
return len(self.__list) == 0
246
return len(self.__list)
249
return iter(self.__list)
251
def __getitem__(self, key):
252
return self.__list[key]
254
def append(self, conflict):
255
return self.__list.append(conflict)
257
def __eq__(self, other_list):
258
return list(self) == list(other_list)
260
def __ne__(self, other_list):
261
return not (self == other_list)
264
return "ConflictList(%r)" % self.__list
267
def from_stanzas(stanzas):
268
"""Produce a new ConflictList from an iterable of stanzas"""
269
conflicts = ConflictList()
270
for stanza in stanzas:
271
conflicts.append(Conflict.factory(**stanza.as_dict()))
274
def to_stanzas(self):
275
"""Generator of stanzas"""
276
for conflict in self:
277
yield conflict.as_stanza()
279
def to_strings(self):
280
"""Generate strings for the provided conflicts"""
281
for conflict in self:
284
def remove_files(self, tree):
285
"""Remove the THIS, BASE and OTHER files for listed conflicts"""
286
for conflict in self:
287
if not conflict.has_files:
289
conflict.cleanup(tree)
291
def select_conflicts(self, tree, paths, ignore_misses=False,
293
"""Select the conflicts associated with paths in a tree.
295
File-ids are also used for this.
296
:return: a pair of ConflictLists: (not_selected, selected)
298
path_set = set(paths)
300
selected_paths = set()
301
new_conflicts = ConflictList()
302
selected_conflicts = ConflictList()
304
file_id = tree.path2id(path)
305
if file_id is not None:
308
for conflict in self:
310
for key in ('path', 'conflict_path'):
311
cpath = getattr(conflict, key, None)
314
if cpath in path_set:
316
selected_paths.add(cpath)
318
if osutils.is_inside_any(path_set, cpath):
320
selected_paths.add(cpath)
322
for key in ('file_id', 'conflict_file_id'):
323
cfile_id = getattr(conflict, key, None)
327
cpath = ids[cfile_id]
331
selected_paths.add(cpath)
333
selected_conflicts.append(conflict)
335
new_conflicts.append(conflict)
336
if ignore_misses is not True:
337
for path in [p for p in paths if p not in selected_paths]:
338
if not os.path.exists(tree.abspath(path)):
339
print "%s does not exist" % path
341
print "%s is not conflicted" % path
342
return new_conflicts, selected_conflicts
345
class Conflict(object):
346
"""Base class for all types of conflict"""
348
# FIXME: cleanup should take care of that ? -- vila 091229
351
def __init__(self, path, file_id=None):
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)
358
s = rio.Stanza(type=self.typestring, path=self.path)
359
if self.file_id is not None:
360
# Stanza requires Unicode apis
361
s.add('file_id', self.file_id.decode('utf8'))
365
return [type(self), self.path, self.file_id]
367
def __cmp__(self, other):
368
if getattr(other, "_cmp_list", None) is None:
370
return cmp(self._cmp_list(), other._cmp_list())
373
return hash((type(self), self.path, self.file_id))
375
def __eq__(self, other):
376
return self.__cmp__(other) == 0
378
def __ne__(self, other):
379
return not self.__eq__(other)
382
return self.format % self.__dict__
385
rdict = dict(self.__dict__)
386
rdict['class'] = self.__class__.__name__
387
return self.rformat % rdict
390
def factory(type, **kwargs):
392
return ctype[type](**kwargs)
395
def sort_key(conflict):
396
if conflict.path is not None:
397
return conflict.path, conflict.typestring
398
elif getattr(conflict, "conflict_path", None) is not None:
399
return conflict.conflict_path, conflict.typestring
401
return None, conflict.typestring
403
def _do(self, action, tree):
404
"""Apply the specified action to the conflict.
406
:param action: The method name to call.
408
:param tree: The tree passed as a parameter to the method.
410
meth = getattr(self, 'action_%s' % action, None)
412
raise NotImplementedError(self.__class__.__name__ + '.' + action)
415
def cleanup(self, tree):
416
raise NotImplementedError(self.cleanup)
418
def action_done(self, tree):
419
"""Mark the conflict as solved once it has been handled."""
420
# This method does nothing but simplifies the design of upper levels.
423
def action_take_this(self, tree):
424
raise NotImplementedError(self.action_take_this)
426
def action_take_other(self, tree):
427
raise NotImplementedError(self.action_take_other)
430
class PathConflict(Conflict):
431
"""A conflict was encountered merging file paths"""
433
typestring = 'path conflict'
435
format = 'Path conflict: %(path)s / %(conflict_path)s'
437
rformat = '%(class)s(%(path)r, %(conflict_path)r, %(file_id)r)'
439
def __init__(self, path, conflict_path=None, file_id=None):
440
Conflict.__init__(self, path, file_id)
441
self.conflict_path = conflict_path
444
s = Conflict.as_stanza(self)
445
if self.conflict_path is not None:
446
s.add('conflict_path', self.conflict_path)
449
def cleanup(self, tree):
450
# No additional files have been generated here
453
def action_take_this(self, tree):
454
tree.rename_one(self.conflict_path, self.path)
456
def action_take_other(self, tree):
457
# just acccept bzr proposal
461
class ContentsConflict(PathConflict):
462
"""The files are of different types, or not present"""
466
typestring = 'contents conflict'
468
format = 'Contents conflict in %(path)s'
470
def cleanup(self, tree):
471
for suffix in ('.BASE', '.OTHER'):
473
osutils.delete_any(tree.abspath(self.path + suffix))
475
if e.errno != errno.ENOENT:
478
# FIXME: I smell something weird here and it seems we should be able to be
479
# more coherent with some other conflict ? bzr *did* a choice there but
480
# neither action_take_this nor action_take_other reflect that...
482
def action_take_this(self, tree):
483
tree.remove([self.path + '.OTHER'], force=True, keep_files=False)
485
def action_take_other(self, tree):
486
tree.remove([self.path], force=True, keep_files=False)
490
# FIXME: TextConflict is about a single file-id, there never is a conflict_path
491
# attribute so we shouldn't inherit from PathConflict but simply from Conflict
493
# TODO: There should be a base revid attribute to better inform the user about
494
# how the conflicts were generated.
495
class TextConflict(PathConflict):
496
"""The merge algorithm could not resolve all differences encountered."""
500
typestring = 'text conflict'
502
format = 'Text conflict in %(path)s'
504
def cleanup(self, tree):
505
for suffix in CONFLICT_SUFFIXES:
507
osutils.delete_any(tree.abspath(self.path+suffix))
509
if e.errno != errno.ENOENT:
513
class HandledConflict(Conflict):
514
"""A path problem that has been provisionally resolved.
515
This is intended to be a base class.
518
rformat = "%(class)s(%(action)r, %(path)r, %(file_id)r)"
520
def __init__(self, action, path, file_id=None):
521
Conflict.__init__(self, path, file_id)
525
return Conflict._cmp_list(self) + [self.action]
528
s = Conflict.as_stanza(self)
529
s.add('action', self.action)
532
def cleanup(self, tree):
533
"""Nothing to cleanup."""
537
class HandledPathConflict(HandledConflict):
538
"""A provisionally-resolved path problem involving two paths.
539
This is intended to be a base class.
542
rformat = "%(class)s(%(action)r, %(path)r, %(conflict_path)r,"\
543
" %(file_id)r, %(conflict_file_id)r)"
545
def __init__(self, action, path, conflict_path, file_id=None,
546
conflict_file_id=None):
547
HandledConflict.__init__(self, action, path, file_id)
548
self.conflict_path = conflict_path
549
# warn turned off, because the factory blindly transfers the Stanza
550
# values to __init__.
551
self.conflict_file_id = osutils.safe_file_id(conflict_file_id,
555
return HandledConflict._cmp_list(self) + [self.conflict_path,
556
self.conflict_file_id]
559
s = HandledConflict.as_stanza(self)
560
s.add('conflict_path', self.conflict_path)
561
if self.conflict_file_id is not None:
562
s.add('conflict_file_id', self.conflict_file_id.decode('utf8'))
567
class DuplicateID(HandledPathConflict):
568
"""Two files want the same file_id."""
570
typestring = 'duplicate id'
572
format = 'Conflict adding id to %(conflict_path)s. %(action)s %(path)s.'
575
class DuplicateEntry(HandledPathConflict):
576
"""Two directory entries want to have the same name."""
578
typestring = 'duplicate'
580
format = 'Conflict adding file %(conflict_path)s. %(action)s %(path)s.'
582
def action_take_this(self, tree):
583
tree.remove([self.conflict_path], force=True, keep_files=False)
584
tree.rename_one(self.path, self.conflict_path)
586
def action_take_other(self, tree):
587
tree.remove([self.path], force=True, keep_files=False)
590
class ParentLoop(HandledPathConflict):
591
"""An attempt to create an infinitely-looping directory structure.
592
This is rare, but can be produced like so:
601
typestring = 'parent loop'
603
format = 'Conflict moving %(conflict_path)s into %(path)s. %(action)s.'
605
def action_take_this(self, tree):
606
# just acccept bzr proposal
609
def action_take_other(self, tree):
610
# FIXME: We shouldn't have to manipulate so many paths here (and there
611
# is probably a bug or two...)
612
base_path = osutils.basename(self.path)
613
conflict_base_path = osutils.basename(self.conflict_path)
614
tt = transform.TreeTransform(tree)
616
p_tid = tt.trans_id_file_id(self.file_id)
617
parent_tid = tt.get_tree_parent(p_tid)
618
cp_tid = tt.trans_id_file_id(self.conflict_file_id)
619
cparent_tid = tt.get_tree_parent(cp_tid)
620
tt.adjust_path(base_path, cparent_tid, cp_tid)
621
tt.adjust_path(conflict_base_path, parent_tid, p_tid)
627
class UnversionedParent(HandledConflict):
628
"""An attempt to version a file whose parent directory is not versioned.
629
Typically, the result of a merge where one tree unversioned the directory
630
and the other added a versioned file to it.
633
typestring = 'unversioned parent'
635
format = 'Conflict because %(path)s is not versioned, but has versioned'\
636
' children. %(action)s.'
638
# FIXME: We silently do nothing to make tests pass, but most probably the
639
# conflict shouldn't exist (the long story is that the conflict is
640
# generated with another one that can be resolved properly) -- vila 091224
641
def action_take_this(self, tree):
644
def action_take_other(self, tree):
648
class MissingParent(HandledConflict):
649
"""An attempt to add files to a directory that is not present.
650
Typically, the result of a merge where THIS deleted the directory and
651
the OTHER added a file to it.
652
See also: DeletingParent (same situation, THIS and OTHER reversed)
655
typestring = 'missing parent'
657
format = 'Conflict adding files to %(path)s. %(action)s.'
659
def action_take_this(self, tree):
660
tree.remove([self.path], force=True, keep_files=False)
662
def action_take_other(self, tree):
663
# just acccept bzr proposal
667
class DeletingParent(HandledConflict):
668
"""An attempt to add files to a directory that is not present.
669
Typically, the result of a merge where one OTHER deleted the directory and
670
the THIS added a file to it.
673
typestring = 'deleting parent'
675
format = "Conflict: can't delete %(path)s because it is not empty. "\
678
# FIXME: It's a bit strange that the default action is not coherent with
679
# MissingParent from the *user* pov.
681
def action_take_this(self, tree):
682
# just acccept bzr proposal
685
def action_take_other(self, tree):
686
tree.remove([self.path], force=True, keep_files=False)
689
class NonDirectoryParent(HandledConflict):
690
"""An attempt to add files to a directory that is not a directory or
691
an attempt to change the kind of a directory with files.
694
typestring = 'non-directory parent'
696
format = "Conflict: %(path)s is not a directory, but has files in it."\
699
# FIXME: .OTHER should be used instead of .new when the conflict is created
701
def action_take_this(self, tree):
702
# FIXME: we should preserve that path when the conflict is generated !
703
if self.path.endswith('.new'):
704
conflict_path = self.path[:-(len('.new'))]
705
tree.remove([self.path], force=True, keep_files=False)
706
tree.add(conflict_path)
708
raise NotImplementedError(self.action_take_this)
710
def action_take_other(self, tree):
711
# FIXME: we should preserve that path when the conflict is generated !
712
if self.path.endswith('.new'):
713
conflict_path = self.path[:-(len('.new'))]
714
tree.remove([conflict_path], force=True, keep_files=False)
715
tree.rename_one(self.path, conflict_path)
717
raise NotImplementedError(self.action_take_other)
723
def register_types(*conflict_types):
724
"""Register a Conflict subclass for serialization purposes"""
726
for conflict_type in conflict_types:
727
ctype[conflict_type.typestring] = conflict_type
729
register_types(ContentsConflict, TextConflict, PathConflict, DuplicateID,
730
DuplicateEntry, ParentLoop, UnversionedParent, MissingParent,
731
DeletingParent, NonDirectoryParent)
added
removed
bzrlib/conflicts.py
