1
# Copyright (C) 2005, 2007, 2009, 2010 Canonical Ltd
1
# Copyright (C) 2005 by Aaron Bentley
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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
17
# TODO: 'bzr resolve' should accept a directory name and work from that
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
17
# TODO: Move this into builtins
19
# TODO: 'bzr resolve' should accept a directory name and work from that
22
# TODO: bzr revert should resolve; even when reverting the whole tree
23
# or particular directories
23
from bzrlib.lazy_import import lazy_import
24
lazy_import(globals(), """
44
CONFLICT_SUFFIXES = ('.THIS', '.BASE', '.OTHER')
47
class cmd_conflicts(commands.Command):
29
from bzrlib.branch import Branch
30
from bzrlib.errors import BzrCommandError
31
from bzrlib.commands import register_command
32
from bzrlib.workingtree import CONFLICT_SUFFIXES
34
class cmd_conflicts(bzrlib.commands.Command):
48
35
"""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.
36
(conflicts are determined by the presence of .BASE .TREE, and .OTHER
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):
40
for path in Branch.open_containing('.').working_tree().iter_conflicts():
43
class cmd_resolve(bzrlib.commands.Command):
101
44
"""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
46
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)
47
takes_options = ['all']
48
def run(self, file_list=None, all=False):
51
raise BzrCommandError(
52
"command 'resolve' needs one or more FILE, or --all")
53
tree = Branch.open_containing('.').working_tree()
54
file_list = list(tree.abspath(f) for f in tree.iter_conflicts())
57
raise BzrCommandError(
58
"If --all is specified, no FILE may be provided")
59
for filename in file_list:
61
for suffix in CONFLICT_SUFFIXES:
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
63
os.unlink(filename+suffix)
65
if e.errno != errno.ENOENT:
69
if failures == len(CONFLICT_SUFFIXES):
70
if not os.path.exists(filename):
71
print "%s does not exist" % filename
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, None)
412
raise NotImplementedError(self.__class__.__name__ + '.' + action)
415
def cleanup(self, tree):
416
raise NotImplementedError(self.cleanup)
418
def 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 take_this(self, tree):
424
raise NotImplementedError(self.take_this)
426
def take_other(self, tree):
427
raise NotImplementedError(self.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 take_this(self, tree):
454
tree.rename_one(self.conflict_path, self.path)
456
def 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 take_this nor take_other reflect that... -- vila 091224
481
def take_this(self, tree):
482
tree.remove([self.path + '.OTHER'], force=True, keep_files=False)
484
def take_other(self, tree):
485
tree.remove([self.path], force=True, keep_files=False)
489
# FIXME: TextConflict is about a single file-id, there never is a conflict_path
490
# attribute so we shouldn't inherit from PathConflict but simply from Conflict
492
# TODO: There should be a base revid attribute to better inform the user about
493
# how the conflicts were generated.
494
class TextConflict(PathConflict):
495
"""The merge algorithm could not resolve all differences encountered."""
499
typestring = 'text conflict'
501
format = 'Text conflict in %(path)s'
503
def cleanup(self, tree):
504
for suffix in CONFLICT_SUFFIXES:
506
osutils.delete_any(tree.abspath(self.path+suffix))
508
if e.errno != errno.ENOENT:
512
class HandledConflict(Conflict):
513
"""A path problem that has been provisionally resolved.
514
This is intended to be a base class.
517
rformat = "%(class)s(%(action)r, %(path)r, %(file_id)r)"
519
def __init__(self, action, path, file_id=None):
520
Conflict.__init__(self, path, file_id)
524
return Conflict._cmp_list(self) + [self.action]
527
s = Conflict.as_stanza(self)
528
s.add('action', self.action)
531
def cleanup(self, tree):
532
"""Nothing to cleanup."""
536
class HandledPathConflict(HandledConflict):
537
"""A provisionally-resolved path problem involving two paths.
538
This is intended to be a base class.
541
rformat = "%(class)s(%(action)r, %(path)r, %(conflict_path)r,"\
542
" %(file_id)r, %(conflict_file_id)r)"
544
def __init__(self, action, path, conflict_path, file_id=None,
545
conflict_file_id=None):
546
HandledConflict.__init__(self, action, path, file_id)
547
self.conflict_path = conflict_path
548
# warn turned off, because the factory blindly transfers the Stanza
549
# values to __init__.
550
self.conflict_file_id = osutils.safe_file_id(conflict_file_id,
554
return HandledConflict._cmp_list(self) + [self.conflict_path,
555
self.conflict_file_id]
558
s = HandledConflict.as_stanza(self)
559
s.add('conflict_path', self.conflict_path)
560
if self.conflict_file_id is not None:
561
s.add('conflict_file_id', self.conflict_file_id.decode('utf8'))
566
class DuplicateID(HandledPathConflict):
567
"""Two files want the same file_id."""
569
typestring = 'duplicate id'
571
format = 'Conflict adding id to %(conflict_path)s. %(action)s %(path)s.'
574
class DuplicateEntry(HandledPathConflict):
575
"""Two directory entries want to have the same name."""
577
typestring = 'duplicate'
579
format = 'Conflict adding file %(conflict_path)s. %(action)s %(path)s.'
581
def take_this(self, tree):
582
tree.remove([self.conflict_path], force=True, keep_files=False)
583
tree.rename_one(self.path, self.conflict_path)
585
def take_other(self, tree):
586
tree.remove([self.path], force=True, keep_files=False)
589
class ParentLoop(HandledPathConflict):
590
"""An attempt to create an infinitely-looping directory structure.
591
This is rare, but can be produced like so:
600
typestring = 'parent loop'
602
format = 'Conflict moving %(conflict_path)s into %(path)s. %(action)s.'
604
def take_this(self, tree):
605
# just acccept bzr proposal
608
def take_other(self, tree):
609
# FIXME: We shouldn't have to manipulate so many paths here (and there
610
# is probably a bug or two...)
611
base_path = osutils.basename(self.path)
612
conflict_base_path = osutils.basename(self.conflict_path)
613
tt = transform.TreeTransform(tree)
615
p_tid = tt.trans_id_file_id(self.file_id)
616
parent_tid = tt.get_tree_parent(p_tid)
617
cp_tid = tt.trans_id_file_id(self.conflict_file_id)
618
cparent_tid = tt.get_tree_parent(cp_tid)
619
tt.adjust_path(base_path, cparent_tid, cp_tid)
620
tt.adjust_path(conflict_base_path, parent_tid, p_tid)
626
class UnversionedParent(HandledConflict):
627
"""An attempt to version a file whose parent directory is not versioned.
628
Typically, the result of a merge where one tree unversioned the directory
629
and the other added a versioned file to it.
632
typestring = 'unversioned parent'
634
format = 'Conflict because %(path)s is not versioned, but has versioned'\
635
' children. %(action)s.'
637
# FIXME: We silently do nothing to make tests pass, but most probably the
638
# conflict shouldn't exist (the long story is that the conflict is
639
# generated with another one that can be resolved properly) -- vila 091224
640
def take_this(self, tree):
643
def take_other(self, tree):
647
class MissingParent(HandledConflict):
648
"""An attempt to add files to a directory that is not present.
649
Typically, the result of a merge where THIS deleted the directory and
650
the OTHER added a file to it.
651
See also: DeletingParent (same situation, THIS and OTHER reversed)
654
typestring = 'missing parent'
656
format = 'Conflict adding files to %(path)s. %(action)s.'
658
def take_this(self, tree):
659
tree.remove([self.path], force=True, keep_files=False)
661
def take_other(self, tree):
662
# just acccept bzr proposal
666
class DeletingParent(HandledConflict):
667
"""An attempt to add files to a directory that is not present.
668
Typically, the result of a merge where one OTHER deleted the directory and
669
the THIS added a file to it.
672
typestring = 'deleting parent'
674
format = "Conflict: can't delete %(path)s because it is not empty. "\
677
# FIXME: It's a bit strange that the default action is not coherent with
678
# MissingParent from the *user* pov.
680
def take_this(self, tree):
681
# just acccept bzr proposal
684
def take_other(self, tree):
685
tree.remove([self.path], force=True, keep_files=False)
688
class NonDirectoryParent(HandledConflict):
689
"""An attempt to add files to a directory that is not a directory or
690
an attempt to change the kind of a directory with files.
693
typestring = 'non-directory parent'
695
format = "Conflict: %(path)s is not a directory, but has files in it."\
698
# FIXME: .OTHER should be used instead of .new when the conflict is created
700
def take_this(self, tree):
701
# FIXME: we should preserve that path when the conflict is generated !
702
if self.path.endswith('.new'):
703
conflict_path = self.path[:-(len('.new'))]
704
tree.remove([self.path], force=True, keep_files=False)
705
tree.add(conflict_path)
707
raise NotImplementedError(self.take_this)
709
def take_other(self, tree):
710
# FIXME: we should preserve that path when the conflict is generated !
711
if self.path.endswith('.new'):
712
conflict_path = self.path[:-(len('.new'))]
713
tree.remove([conflict_path], force=True, keep_files=False)
714
tree.rename_one(self.path, conflict_path)
716
raise NotImplementedError(self.take_other)
722
def register_types(*conflict_types):
723
"""Register a Conflict subclass for serialization purposes"""
725
for conflict_type in conflict_types:
726
ctype[conflict_type.typestring] = conflict_type
728
register_types(ContentsConflict, TextConflict, PathConflict, DuplicateID,
729
DuplicateEntry, ParentLoop, UnversionedParent, MissingParent,
730
DeletingParent, NonDirectoryParent)
73
print "%s is not conflicted" % filename
added
removed
bzrlib/conflicts.py
