1
# Copyright (C) 2005, 2006, 2007, 2009, 2010, 2011 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
22
from bzrlib.lazy_import import lazy_import
23
lazy_import(globals(), """
43
CONFLICT_SUFFIXES = ('.THIS', '.BASE', '.OTHER')
46
class cmd_conflicts(commands.Command):
47
__doc__ = """List files with conflicts.
49
Merge will do its best to combine the changes in two branches, but there
50
are some kinds of problems only a human can fix. When it encounters those,
51
it will mark a conflict. A conflict means that you need to fix something,
52
before you should commit.
54
Conflicts normally are listed as short, human-readable messages. If --text
55
is supplied, the pathnames of files with text conflicts are listed,
56
instead. (This is useful for editing all files with text conflicts.)
58
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, directory=u'.'):
68
wt = workingtree.WorkingTree.open_containing(directory)[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
__doc__ = """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*']
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, directory=None):
123
raise errors.BzrCommandError("If --all is specified,"
124
" no FILE may be provided")
125
if directory is None:
127
tree = workingtree.WorkingTree.open_containing(directory)[0]
131
tree, file_list = workingtree.WorkingTree.open_containing_paths(
132
file_list, directory)
133
if file_list is None:
135
# FIXME: There is a special case here related to the option
136
# handling that could be clearer and easier to discover by
137
# providing an --auto action (bug #344013 and #383396) and
138
# make it mandatory instead of implicit and active only
139
# when no file_list is provided -- vila 091229
145
if file_list is None:
146
un_resolved, resolved = tree.auto_resolve()
147
if len(un_resolved) > 0:
148
trace.note('%d conflict(s) auto-resolved.', len(resolved))
149
trace.note('Remaining conflicts:')
150
for conflict in un_resolved:
154
trace.note('All conflicts resolved.')
157
# FIXME: This can never occur but the block above needs some
158
# refactoring to transfer tree.auto_resolve() to
159
# conflict.auto(tree) --vila 091242
162
before, after = resolve(tree, file_list, action=action)
163
trace.note('%d conflict(s) resolved, %d remaining'
164
% (before - after, after))
167
def resolve(tree, paths=None, ignore_misses=False, recursive=False,
169
"""Resolve some or all of the conflicts in a working tree.
171
:param paths: If None, resolve all conflicts. Otherwise, select only
173
:param recursive: If True, then elements of paths which are directories
174
have all their children resolved, etc. When invoked as part of
175
recursive commands like revert, this should be True. For commands
176
or applications wishing finer-grained control, like the resolve
177
command, this should be False.
178
:param ignore_misses: If False, warnings will be printed if the supplied
179
paths do not have conflicts.
180
:param action: How the conflict should be resolved,
182
tree.lock_tree_write()
183
nb_conflicts_after = None
185
tree_conflicts = tree.conflicts()
186
nb_conflicts_before = len(tree_conflicts)
188
new_conflicts = ConflictList()
189
to_process = tree_conflicts
191
new_conflicts, to_process = tree_conflicts.select_conflicts(
192
tree, paths, ignore_misses, recursive)
193
for conflict in to_process:
195
conflict._do(action, tree)
196
conflict.cleanup(tree)
197
except NotImplementedError:
198
new_conflicts.append(conflict)
200
nb_conflicts_after = len(new_conflicts)
201
tree.set_conflicts(new_conflicts)
202
except errors.UnsupportedOperation:
206
if nb_conflicts_after is None:
207
nb_conflicts_after = nb_conflicts_before
208
return nb_conflicts_before, nb_conflicts_after
211
def restore(filename):
212
"""Restore a conflicted file to the state it was in before merging.
214
Only text restoration is supported at present.
218
osutils.rename(filename + ".THIS", filename)
221
if e.errno != errno.ENOENT:
224
os.unlink(filename + ".BASE")
227
if e.errno != errno.ENOENT:
230
os.unlink(filename + ".OTHER")
233
if e.errno != errno.ENOENT:
236
raise errors.NotConflicted(filename)
239
class ConflictList(object):
240
"""List of conflicts.
242
Typically obtained from WorkingTree.conflicts()
244
Can be instantiated from stanzas or from Conflict subclasses.
247
def __init__(self, conflicts=None):
248
object.__init__(self)
249
if conflicts is None:
252
self.__list = conflicts
255
return len(self.__list) == 0
258
return len(self.__list)
261
return iter(self.__list)
263
def __getitem__(self, key):
264
return self.__list[key]
266
def append(self, conflict):
267
return self.__list.append(conflict)
269
def __eq__(self, other_list):
270
return list(self) == list(other_list)
272
def __ne__(self, other_list):
273
return not (self == other_list)
276
return "ConflictList(%r)" % self.__list
279
def from_stanzas(stanzas):
280
"""Produce a new ConflictList from an iterable of stanzas"""
281
conflicts = ConflictList()
282
for stanza in stanzas:
283
conflicts.append(Conflict.factory(**stanza.as_dict()))
286
def to_stanzas(self):
287
"""Generator of stanzas"""
288
for conflict in self:
289
yield conflict.as_stanza()
291
def to_strings(self):
292
"""Generate strings for the provided conflicts"""
293
for conflict in self:
296
def remove_files(self, tree):
297
"""Remove the THIS, BASE and OTHER files for listed conflicts"""
298
for conflict in self:
299
if not conflict.has_files:
301
conflict.cleanup(tree)
303
def select_conflicts(self, tree, paths, ignore_misses=False,
305
"""Select the conflicts associated with paths in a tree.
307
File-ids are also used for this.
308
:return: a pair of ConflictLists: (not_selected, selected)
310
path_set = set(paths)
312
selected_paths = set()
313
new_conflicts = ConflictList()
314
selected_conflicts = ConflictList()
316
file_id = tree.path2id(path)
317
if file_id is not None:
320
for conflict in self:
322
for key in ('path', 'conflict_path'):
323
cpath = getattr(conflict, key, None)
326
if cpath in path_set:
328
selected_paths.add(cpath)
330
if osutils.is_inside_any(path_set, cpath):
332
selected_paths.add(cpath)
334
for key in ('file_id', 'conflict_file_id'):
335
cfile_id = getattr(conflict, key, None)
339
cpath = ids[cfile_id]
343
selected_paths.add(cpath)
345
selected_conflicts.append(conflict)
347
new_conflicts.append(conflict)
348
if ignore_misses is not True:
349
for path in [p for p in paths if p not in selected_paths]:
350
if not os.path.exists(tree.abspath(path)):
351
print "%s does not exist" % path
353
print "%s is not conflicted" % path
354
return new_conflicts, selected_conflicts
357
class Conflict(object):
358
"""Base class for all types of conflict"""
360
# FIXME: cleanup should take care of that ? -- vila 091229
363
def __init__(self, path, file_id=None):
365
# warn turned off, because the factory blindly transfers the Stanza
366
# values to __init__ and Stanza is purely a Unicode api.
367
self.file_id = osutils.safe_file_id(file_id, warn=False)
370
s = rio.Stanza(type=self.typestring, path=self.path)
371
if self.file_id is not None:
372
# Stanza requires Unicode apis
373
s.add('file_id', self.file_id.decode('utf8'))
377
return [type(self), self.path, self.file_id]
379
def __cmp__(self, other):
380
if getattr(other, "_cmp_list", None) is None:
382
return cmp(self._cmp_list(), other._cmp_list())
385
return hash((type(self), self.path, self.file_id))
387
def __eq__(self, other):
388
return self.__cmp__(other) == 0
390
def __ne__(self, other):
391
return not self.__eq__(other)
394
return self.format % self.__dict__
397
rdict = dict(self.__dict__)
398
rdict['class'] = self.__class__.__name__
399
return self.rformat % rdict
402
def factory(type, **kwargs):
404
return ctype[type](**kwargs)
407
def sort_key(conflict):
408
if conflict.path is not None:
409
return conflict.path, conflict.typestring
410
elif getattr(conflict, "conflict_path", None) is not None:
411
return conflict.conflict_path, conflict.typestring
413
return None, conflict.typestring
415
def _do(self, action, tree):
416
"""Apply the specified action to the conflict.
418
:param action: The method name to call.
420
:param tree: The tree passed as a parameter to the method.
422
meth = getattr(self, 'action_%s' % action, None)
424
raise NotImplementedError(self.__class__.__name__ + '.' + action)
427
def associated_filenames(self):
428
"""The names of the files generated to help resolve the conflict."""
429
raise NotImplementedError(self.associated_filenames)
431
def cleanup(self, tree):
432
for fname in self.associated_filenames():
434
osutils.delete_any(tree.abspath(fname))
436
if e.errno != errno.ENOENT:
439
def action_done(self, tree):
440
"""Mark the conflict as solved once it has been handled."""
441
# This method does nothing but simplifies the design of upper levels.
444
def action_take_this(self, tree):
445
raise NotImplementedError(self.action_take_this)
447
def action_take_other(self, tree):
448
raise NotImplementedError(self.action_take_other)
450
def _resolve_with_cleanups(self, tree, *args, **kwargs):
451
tt = transform.TreeTransform(tree)
452
op = cleanup.OperationWithCleanups(self._resolve)
453
op.add_cleanup(tt.finalize)
454
op.run_simple(tt, *args, **kwargs)
457
class PathConflict(Conflict):
458
"""A conflict was encountered merging file paths"""
460
typestring = 'path conflict'
462
format = 'Path conflict: %(path)s / %(conflict_path)s'
464
rformat = '%(class)s(%(path)r, %(conflict_path)r, %(file_id)r)'
466
def __init__(self, path, conflict_path=None, file_id=None):
467
Conflict.__init__(self, path, file_id)
468
self.conflict_path = conflict_path
471
s = Conflict.as_stanza(self)
472
if self.conflict_path is not None:
473
s.add('conflict_path', self.conflict_path)
476
def associated_filenames(self):
477
# No additional files have been generated here
480
def _resolve(self, tt, file_id, path, winner):
481
"""Resolve the conflict.
483
:param tt: The TreeTransform where the conflict is resolved.
484
:param file_id: The retained file id.
485
:param path: The retained path.
486
:param winner: 'this' or 'other' indicates which side is the winner.
488
path_to_create = None
490
if self.path == '<deleted>':
491
return # Nothing to do
492
if self.conflict_path == '<deleted>':
493
path_to_create = self.path
494
revid = tt._tree.get_parent_ids()[0]
495
elif winner == 'other':
496
if self.conflict_path == '<deleted>':
497
return # Nothing to do
498
if self.path == '<deleted>':
499
path_to_create = self.conflict_path
500
# FIXME: If there are more than two parents we may need to
501
# iterate. Taking the last parent is the safer bet in the mean
502
# time. -- vila 20100309
503
revid = tt._tree.get_parent_ids()[-1]
506
raise AssertionError('bad winner: %r' % (winner,))
507
if path_to_create is not None:
508
tid = tt.trans_id_tree_path(path_to_create)
509
transform.create_from_tree(
510
tt, tt.trans_id_tree_path(path_to_create),
511
self._revision_tree(tt._tree, revid), file_id)
512
tt.version_file(file_id, tid)
514
# Adjust the path for the retained file id
515
tid = tt.trans_id_file_id(file_id)
516
parent_tid = tt.get_tree_parent(tid)
517
tt.adjust_path(osutils.basename(path), parent_tid, tid)
520
def _revision_tree(self, tree, revid):
521
return tree.branch.repository.revision_tree(revid)
523
def _infer_file_id(self, tree):
524
# Prior to bug #531967, file_id wasn't always set, there may still be
525
# conflict files in the wild so we need to cope with them
526
# Establish which path we should use to find back the file-id
528
for p in (self.path, self.conflict_path):
530
# special hard-coded path
533
possible_paths.append(p)
534
# Search the file-id in the parents with any path available
536
for revid in tree.get_parent_ids():
537
revtree = self._revision_tree(tree, revid)
538
for p in possible_paths:
539
file_id = revtree.path2id(p)
540
if file_id is not None:
541
return revtree, file_id
544
def action_take_this(self, tree):
545
if self.file_id is not None:
546
self._resolve_with_cleanups(tree, self.file_id, self.path,
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)
555
def action_take_other(self, tree):
556
if self.file_id is not None:
557
self._resolve_with_cleanups(tree, self.file_id,
561
# Prior to bug #531967 we need to find back the file_id and restore
562
# the content from there
563
revtree, file_id = self._infer_file_id(tree)
564
tree.revert([revtree.id2path(file_id)],
565
old_tree=revtree, backups=False)
568
class ContentsConflict(PathConflict):
569
"""The files are of different types (or both binary), or not present"""
573
typestring = 'contents conflict'
575
format = 'Contents conflict in %(path)s'
577
def associated_filenames(self):
578
return [self.path + suffix for suffix in ('.BASE', '.OTHER')]
580
def _resolve(self, tt, suffix_to_remove):
581
"""Resolve the conflict.
583
:param tt: The TreeTransform where the conflict is resolved.
584
:param suffix_to_remove: Either 'THIS' or 'OTHER'
586
The resolution is symmetric, when taking THIS, OTHER is deleted and
587
item.THIS is renamed into item and vice-versa.
590
# Delete 'item.THIS' or 'item.OTHER' depending on
593
tt.trans_id_tree_path(self.path + '.' + suffix_to_remove))
594
except errors.NoSuchFile:
595
# There are valid cases where 'item.suffix_to_remove' either
596
# never existed or was already deleted (including the case
597
# where the user deleted it)
599
# Rename 'item.suffix_to_remove' (note that if
600
# 'item.suffix_to_remove' has been deleted, this is a no-op)
601
this_tid = tt.trans_id_file_id(self.file_id)
602
parent_tid = tt.get_tree_parent(this_tid)
603
tt.adjust_path(osutils.basename(self.path), parent_tid, this_tid)
606
def action_take_this(self, tree):
607
self._resolve_with_cleanups(tree, 'OTHER')
609
def action_take_other(self, tree):
610
self._resolve_with_cleanups(tree, 'THIS')
613
# TODO: There should be a base revid attribute to better inform the user about
614
# how the conflicts were generated.
615
class TextConflict(Conflict):
616
"""The merge algorithm could not resolve all differences encountered."""
620
typestring = 'text conflict'
622
format = 'Text conflict in %(path)s'
624
rformat = '%(class)s(%(path)r, %(file_id)r)'
626
def associated_filenames(self):
627
return [self.path + suffix for suffix in CONFLICT_SUFFIXES]
629
def _resolve(self, tt, winner_suffix):
630
"""Resolve the conflict by copying one of .THIS or .OTHER into file.
632
:param tt: The TreeTransform where the conflict is resolved.
633
:param winner_suffix: Either 'THIS' or 'OTHER'
635
The resolution is symmetric, when taking THIS, item.THIS is renamed
636
into item and vice-versa. This takes one of the files as a whole
637
ignoring every difference that could have been merged cleanly.
639
# To avoid useless copies, we switch item and item.winner_suffix, only
640
# item will exist after the conflict has been resolved anyway.
641
item_tid = tt.trans_id_file_id(self.file_id)
642
item_parent_tid = tt.get_tree_parent(item_tid)
643
winner_path = self.path + '.' + winner_suffix
644
winner_tid = tt.trans_id_tree_path(winner_path)
645
winner_parent_tid = tt.get_tree_parent(winner_tid)
646
# Switch the paths to preserve the content
647
tt.adjust_path(osutils.basename(self.path),
648
winner_parent_tid, winner_tid)
649
tt.adjust_path(osutils.basename(winner_path), item_parent_tid, item_tid)
650
# Associate the file_id to the right content
651
tt.unversion_file(item_tid)
652
tt.version_file(self.file_id, winner_tid)
655
def action_take_this(self, tree):
656
self._resolve_with_cleanups(tree, 'THIS')
658
def action_take_other(self, tree):
659
self._resolve_with_cleanups(tree, 'OTHER')
662
class HandledConflict(Conflict):
663
"""A path problem that has been provisionally resolved.
664
This is intended to be a base class.
667
rformat = "%(class)s(%(action)r, %(path)r, %(file_id)r)"
669
def __init__(self, action, path, file_id=None):
670
Conflict.__init__(self, path, file_id)
674
return Conflict._cmp_list(self) + [self.action]
677
s = Conflict.as_stanza(self)
678
s.add('action', self.action)
681
def associated_filenames(self):
682
# Nothing has been generated here
686
class HandledPathConflict(HandledConflict):
687
"""A provisionally-resolved path problem involving two paths.
688
This is intended to be a base class.
691
rformat = "%(class)s(%(action)r, %(path)r, %(conflict_path)r,"\
692
" %(file_id)r, %(conflict_file_id)r)"
694
def __init__(self, action, path, conflict_path, file_id=None,
695
conflict_file_id=None):
696
HandledConflict.__init__(self, action, path, file_id)
697
self.conflict_path = conflict_path
698
# warn turned off, because the factory blindly transfers the Stanza
699
# values to __init__.
700
self.conflict_file_id = osutils.safe_file_id(conflict_file_id,
704
return HandledConflict._cmp_list(self) + [self.conflict_path,
705
self.conflict_file_id]
708
s = HandledConflict.as_stanza(self)
709
s.add('conflict_path', self.conflict_path)
710
if self.conflict_file_id is not None:
711
s.add('conflict_file_id', self.conflict_file_id.decode('utf8'))
716
class DuplicateID(HandledPathConflict):
717
"""Two files want the same file_id."""
719
typestring = 'duplicate id'
721
format = 'Conflict adding id to %(conflict_path)s. %(action)s %(path)s.'
724
class DuplicateEntry(HandledPathConflict):
725
"""Two directory entries want to have the same name."""
727
typestring = 'duplicate'
729
format = 'Conflict adding file %(conflict_path)s. %(action)s %(path)s.'
731
def action_take_this(self, tree):
732
tree.remove([self.conflict_path], force=True, keep_files=False)
733
tree.rename_one(self.path, self.conflict_path)
735
def action_take_other(self, tree):
736
tree.remove([self.path], force=True, keep_files=False)
739
class ParentLoop(HandledPathConflict):
740
"""An attempt to create an infinitely-looping directory structure.
741
This is rare, but can be produced like so:
750
typestring = 'parent loop'
752
format = 'Conflict moving %(path)s into %(conflict_path)s. %(action)s.'
754
def action_take_this(self, tree):
755
# just acccept bzr proposal
758
def action_take_other(self, tree):
759
tt = transform.TreeTransform(tree)
761
p_tid = tt.trans_id_file_id(self.file_id)
762
parent_tid = tt.get_tree_parent(p_tid)
763
cp_tid = tt.trans_id_file_id(self.conflict_file_id)
764
cparent_tid = tt.get_tree_parent(cp_tid)
765
tt.adjust_path(osutils.basename(self.path), cparent_tid, cp_tid)
766
tt.adjust_path(osutils.basename(self.conflict_path),
773
class UnversionedParent(HandledConflict):
774
"""An attempt to version a file whose parent directory is not versioned.
775
Typically, the result of a merge where one tree unversioned the directory
776
and the other added a versioned file to it.
779
typestring = 'unversioned parent'
781
format = 'Conflict because %(path)s is not versioned, but has versioned'\
782
' children. %(action)s.'
784
# FIXME: We silently do nothing to make tests pass, but most probably the
785
# conflict shouldn't exist (the long story is that the conflict is
786
# generated with another one that can be resolved properly) -- vila 091224
787
def action_take_this(self, tree):
790
def action_take_other(self, tree):
794
class MissingParent(HandledConflict):
795
"""An attempt to add files to a directory that is not present.
796
Typically, the result of a merge where THIS deleted the directory and
797
the OTHER added a file to it.
798
See also: DeletingParent (same situation, THIS and OTHER reversed)
801
typestring = 'missing parent'
803
format = 'Conflict adding files to %(path)s. %(action)s.'
805
def action_take_this(self, tree):
806
tree.remove([self.path], force=True, keep_files=False)
808
def action_take_other(self, tree):
809
# just acccept bzr proposal
813
class DeletingParent(HandledConflict):
814
"""An attempt to add files to a directory that is not present.
815
Typically, the result of a merge where one OTHER deleted the directory and
816
the THIS added a file to it.
819
typestring = 'deleting parent'
821
format = "Conflict: can't delete %(path)s because it is not empty. "\
824
# FIXME: It's a bit strange that the default action is not coherent with
825
# MissingParent from the *user* pov.
827
def action_take_this(self, tree):
828
# just acccept bzr proposal
831
def action_take_other(self, tree):
832
tree.remove([self.path], force=True, keep_files=False)
835
class NonDirectoryParent(HandledConflict):
836
"""An attempt to add files to a directory that is not a directory or
837
an attempt to change the kind of a directory with files.
840
typestring = 'non-directory parent'
842
format = "Conflict: %(path)s is not a directory, but has files in it."\
845
# FIXME: .OTHER should be used instead of .new when the conflict is created
847
def action_take_this(self, tree):
848
# FIXME: we should preserve that path when the conflict is generated !
849
if self.path.endswith('.new'):
850
conflict_path = self.path[:-(len('.new'))]
851
tree.remove([self.path], force=True, keep_files=False)
852
tree.add(conflict_path)
854
raise NotImplementedError(self.action_take_this)
856
def action_take_other(self, tree):
857
# FIXME: we should preserve that path when the conflict is generated !
858
if self.path.endswith('.new'):
859
conflict_path = self.path[:-(len('.new'))]
860
tree.remove([conflict_path], force=True, keep_files=False)
861
tree.rename_one(self.path, conflict_path)
863
raise NotImplementedError(self.action_take_other)
869
def register_types(*conflict_types):
870
"""Register a Conflict subclass for serialization purposes"""
872
for conflict_type in conflict_types:
873
ctype[conflict_type.typestring] = conflict_type
875
register_types(ContentsConflict, TextConflict, PathConflict, DuplicateID,
876
DuplicateEntry, ParentLoop, UnversionedParent, MissingParent,
877
DeletingParent, NonDirectoryParent)
added
removed
bzrlib/conflicts.py
