1
# Copyright (C) 2005 by Aaron Bentley
1
# Copyright (C) 2005, 2006, 2007, 2009, 2010 Canonical Ltd
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
5
5
# the Free Software Foundation; either version 2 of the License, or
6
6
# (at your option) any later version.
8
8
# This program is distributed in the hope that it will be useful,
9
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11
11
# GNU General Public License for more details.
13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
18
from bzrlib.branch import Branch
19
from bzrlib.errors import BzrCommandError
20
from bzrlib.commands import register_command
21
from bzrlib.workingtree import CONFLICT_SUFFIXES
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(), """
25
class cmd_conflicts(bzrlib.commands.Command):
45
CONFLICT_SUFFIXES = ('.THIS', '.BASE', '.OTHER')
48
class cmd_conflicts(commands.Command):
26
49
"""List files with conflicts.
27
(conflicts are determined by the presence of .BASE .TREE, and .OTHER
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.
31
for path in Branch.open_containing('.').working_tree().iter_conflicts():
34
register_command(cmd_conflicts)
36
class cmd_resolve(bzrlib.commands.Command):
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):
37
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']
39
114
takes_args = ['file*']
40
takes_options = ['all']
41
def run(self, file_list=None, all=False):
44
raise BzrCommandError(
45
"command 'resolve' needs one or more FILE, or --all")
46
tree = Branch.open_containing('.').working_tree()
47
file_list = list(tree.abspath(f) for f in tree.iter_conflicts())
50
raise BzrCommandError(
51
"If --all is specified, no FILE may be provided")
52
for filename in file_list:
54
for suffix in CONFLICT_SUFFIXES:
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)
56
os.unlink(filename+suffix)
58
if e.errno != errno.ENOENT:
62
if failures == len(CONFLICT_SUFFIXES):
63
if not os.path.exists(filename):
64
print "%s does not exist" % filename
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
66
print "%s is not conflicted" % filename
68
register_command(cmd_resolve)
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)
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)
446
class PathConflict(Conflict):
447
"""A conflict was encountered merging file paths"""
449
typestring = 'path conflict'
451
format = 'Path conflict: %(path)s / %(conflict_path)s'
453
rformat = '%(class)s(%(path)r, %(conflict_path)r, %(file_id)r)'
455
def __init__(self, path, conflict_path=None, file_id=None):
456
Conflict.__init__(self, path, file_id)
457
self.conflict_path = conflict_path
460
s = Conflict.as_stanza(self)
461
if self.conflict_path is not None:
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)
557
class ContentsConflict(PathConflict):
558
"""The files are of different types (or both binary), or not present"""
562
typestring = 'contents conflict'
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.
607
class TextConflict(PathConflict):
608
"""The merge algorithm could not resolve all differences encountered."""
612
typestring = 'text conflict'
614
format = 'Text conflict in %(path)s'
616
def associated_filenames(self):
617
return [self.path + suffix for suffix in CONFLICT_SUFFIXES]
620
class HandledConflict(Conflict):
621
"""A path problem that has been provisionally resolved.
622
This is intended to be a base class.
625
rformat = "%(class)s(%(action)r, %(path)r, %(file_id)r)"
627
def __init__(self, action, path, file_id=None):
628
Conflict.__init__(self, path, file_id)
632
return Conflict._cmp_list(self) + [self.action]
635
s = Conflict.as_stanza(self)
636
s.add('action', self.action)
639
def associated_filenames(self):
640
# Nothing has been generated here
644
class HandledPathConflict(HandledConflict):
645
"""A provisionally-resolved path problem involving two paths.
646
This is intended to be a base class.
649
rformat = "%(class)s(%(action)r, %(path)r, %(conflict_path)r,"\
650
" %(file_id)r, %(conflict_file_id)r)"
652
def __init__(self, action, path, conflict_path, file_id=None,
653
conflict_file_id=None):
654
HandledConflict.__init__(self, action, path, file_id)
655
self.conflict_path = conflict_path
656
# warn turned off, because the factory blindly transfers the Stanza
657
# values to __init__.
658
self.conflict_file_id = osutils.safe_file_id(conflict_file_id,
662
return HandledConflict._cmp_list(self) + [self.conflict_path,
663
self.conflict_file_id]
666
s = HandledConflict.as_stanza(self)
667
s.add('conflict_path', self.conflict_path)
668
if self.conflict_file_id is not None:
669
s.add('conflict_file_id', self.conflict_file_id.decode('utf8'))
674
class DuplicateID(HandledPathConflict):
675
"""Two files want the same file_id."""
677
typestring = 'duplicate id'
679
format = 'Conflict adding id to %(conflict_path)s. %(action)s %(path)s.'
682
class DuplicateEntry(HandledPathConflict):
683
"""Two directory entries want to have the same name."""
685
typestring = 'duplicate'
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)
697
class ParentLoop(HandledPathConflict):
698
"""An attempt to create an infinitely-looping directory structure.
699
This is rare, but can be produced like so:
708
typestring = 'parent loop'
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)
734
class UnversionedParent(HandledConflict):
735
"""An attempt to version a file whose parent directory is not versioned.
736
Typically, the result of a merge where one tree unversioned the directory
737
and the other added a versioned file to it.
740
typestring = 'unversioned parent'
742
format = 'Conflict because %(path)s is not versioned, but has versioned'\
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):
755
class MissingParent(HandledConflict):
756
"""An attempt to add files to a directory that is not present.
757
Typically, the result of a merge where THIS deleted the directory and
758
the OTHER added a file to it.
759
See also: DeletingParent (same situation, THIS and OTHER reversed)
762
typestring = 'missing parent'
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
774
class DeletingParent(HandledConflict):
775
"""An attempt to add files to a directory that is not present.
776
Typically, the result of a merge where one OTHER deleted the directory and
777
the THIS added a file to it.
780
typestring = 'deleting parent'
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)
796
class NonDirectoryParent(HandledConflict):
797
"""An attempt to add files to a directory that is not a directory or
798
an attempt to change the kind of a directory with files.
801
typestring = 'non-directory parent'
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)
830
def register_types(*conflict_types):
831
"""Register a Conflict subclass for serialization purposes"""
833
for conflict_type in conflict_types:
834
ctype[conflict_type.typestring] = conflict_type
836
register_types(ContentsConflict, TextConflict, PathConflict, DuplicateID,
837
DuplicateEntry, ParentLoop, UnversionedParent, MissingParent,
838
DeletingParent, NonDirectoryParent)
added
removed
bzrlib/conflicts.py
