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: 'brz resolve' should accept a directory name and work from that
20
from __future__ import absolute_import
24
from .lazy_import import lazy_import
25
lazy_import(globals(), """
37
from breezy.i18n import gettext, ngettext
47
CONFLICT_SUFFIXES = ('.THIS', '.BASE', '.OTHER')
50
class cmd_conflicts(commands.Command):
51
__doc__ = """List files with conflicts.
53
Merge will do its best to combine the changes in two branches, but there
54
are some kinds of problems only a human can fix. When it encounters those,
55
it will mark a conflict. A conflict means that you need to fix something,
56
before you can commit.
58
Conflicts normally are listed as short, human-readable messages. If --text
59
is supplied, the pathnames of files with text conflicts are listed,
60
instead. (This is useful for editing all files with text conflicts.)
62
Use brz resolve when you have fixed a problem.
67
help='List paths of files with text conflicts.'),
69
_see_also = ['resolve', 'conflict-types']
71
def run(self, text=False, directory=u'.'):
72
wt = workingtree.WorkingTree.open_containing(directory)[0]
73
for conflict in wt.conflicts():
75
if conflict.typestring != 'text conflict':
77
self.outf.write(conflict.path + '\n')
79
self.outf.write(unicode(conflict) + '\n')
82
resolve_action_registry = registry.Registry()
85
resolve_action_registry.register(
86
'done', 'done', 'Marks the conflict as resolved.')
87
resolve_action_registry.register(
88
'take-this', 'take_this',
89
'Resolve the conflict preserving the version in the working tree.')
90
resolve_action_registry.register(
91
'take-other', 'take_other',
92
'Resolve the conflict taking the merged version into account.')
93
resolve_action_registry.default_key = 'done'
95
class ResolveActionOption(option.RegistryOption):
98
super(ResolveActionOption, self).__init__(
99
'action', 'How to resolve the conflict.',
101
registry=resolve_action_registry)
104
class cmd_resolve(commands.Command):
105
__doc__ = """Mark a conflict as resolved.
107
Merge will do its best to combine the changes in two branches, but there
108
are some kinds of problems only a human can fix. When it encounters those,
109
it will mark a conflict. A conflict means that you need to fix something,
110
before you can commit.
112
Once you have fixed a problem, use "brz resolve" to automatically mark
113
text conflicts as fixed, "brz resolve FILE" to mark a specific conflict as
114
resolved, or "brz resolve --all" to mark all conflicts as resolved.
116
aliases = ['resolved']
117
takes_args = ['file*']
120
option.Option('all', help='Resolve all conflicts in this tree.'),
121
ResolveActionOption(),
123
_see_also = ['conflicts']
124
def run(self, file_list=None, all=False, action=None, directory=None):
127
raise errors.BzrCommandError(gettext("If --all is specified,"
128
" no FILE may be provided"))
129
if directory is None:
131
tree = workingtree.WorkingTree.open_containing(directory)[0]
135
tree, file_list = workingtree.WorkingTree.open_containing_paths(
136
file_list, directory)
137
if file_list is None:
139
# FIXME: There is a special case here related to the option
140
# handling that could be clearer and easier to discover by
141
# providing an --auto action (bug #344013 and #383396) and
142
# make it mandatory instead of implicit and active only
143
# when no file_list is provided -- vila 091229
149
if file_list is None:
150
un_resolved, resolved = tree.auto_resolve()
151
if len(un_resolved) > 0:
152
trace.note(ngettext('%d conflict auto-resolved.',
153
'%d conflicts auto-resolved.', len(resolved)),
155
trace.note(gettext('Remaining conflicts:'))
156
for conflict in un_resolved:
157
trace.note(unicode(conflict))
160
trace.note(gettext('All conflicts resolved.'))
163
# FIXME: This can never occur but the block above needs some
164
# refactoring to transfer tree.auto_resolve() to
165
# conflict.auto(tree) --vila 091242
168
before, after = resolve(tree, file_list, action=action)
169
trace.note(ngettext('{0} conflict resolved, {1} remaining',
170
'{0} conflicts resolved, {1} remaining',
171
before-after).format(before - after, after))
174
def resolve(tree, paths=None, ignore_misses=False, recursive=False,
176
"""Resolve some or all of the conflicts in a working tree.
178
:param paths: If None, resolve all conflicts. Otherwise, select only
180
:param recursive: If True, then elements of paths which are directories
181
have all their children resolved, etc. When invoked as part of
182
recursive commands like revert, this should be True. For commands
183
or applications wishing finer-grained control, like the resolve
184
command, this should be False.
185
:param ignore_misses: If False, warnings will be printed if the supplied
186
paths do not have conflicts.
187
:param action: How the conflict should be resolved,
189
tree.lock_tree_write()
190
nb_conflicts_after = None
192
tree_conflicts = tree.conflicts()
193
nb_conflicts_before = len(tree_conflicts)
195
new_conflicts = ConflictList()
196
to_process = tree_conflicts
198
new_conflicts, to_process = tree_conflicts.select_conflicts(
199
tree, paths, ignore_misses, recursive)
200
for conflict in to_process:
202
conflict._do(action, tree)
203
conflict.cleanup(tree)
204
except NotImplementedError:
205
new_conflicts.append(conflict)
207
nb_conflicts_after = len(new_conflicts)
208
tree.set_conflicts(new_conflicts)
209
except errors.UnsupportedOperation:
213
if nb_conflicts_after is None:
214
nb_conflicts_after = nb_conflicts_before
215
return nb_conflicts_before, nb_conflicts_after
218
def restore(filename):
219
"""Restore a conflicted file to the state it was in before merging.
221
Only text restoration is supported at present.
225
osutils.rename(filename + ".THIS", filename)
228
if e.errno != errno.ENOENT:
231
os.unlink(filename + ".BASE")
234
if e.errno != errno.ENOENT:
237
os.unlink(filename + ".OTHER")
240
if e.errno != errno.ENOENT:
243
raise errors.NotConflicted(filename)
246
class ConflictList(object):
247
"""List of conflicts.
249
Typically obtained from WorkingTree.conflicts()
251
Can be instantiated from stanzas or from Conflict subclasses.
254
def __init__(self, conflicts=None):
255
object.__init__(self)
256
if conflicts is None:
259
self.__list = conflicts
262
return len(self.__list) == 0
265
return len(self.__list)
268
return iter(self.__list)
270
def __getitem__(self, key):
271
return self.__list[key]
273
def append(self, conflict):
274
return self.__list.append(conflict)
276
def __eq__(self, other_list):
277
return list(self) == list(other_list)
279
def __ne__(self, other_list):
280
return not (self == other_list)
283
return "ConflictList(%r)" % self.__list
286
def from_stanzas(stanzas):
287
"""Produce a new ConflictList from an iterable of stanzas"""
288
conflicts = ConflictList()
289
for stanza in stanzas:
290
conflicts.append(Conflict.factory(**stanza.as_dict()))
293
def to_stanzas(self):
294
"""Generator of stanzas"""
295
for conflict in self:
296
yield conflict.as_stanza()
298
def to_strings(self):
299
"""Generate strings for the provided conflicts"""
300
for conflict in self:
301
yield unicode(conflict)
303
def remove_files(self, tree):
304
"""Remove the THIS, BASE and OTHER files for listed conflicts"""
305
for conflict in self:
306
if not conflict.has_files:
308
conflict.cleanup(tree)
310
def select_conflicts(self, tree, paths, ignore_misses=False,
312
"""Select the conflicts associated with paths in a tree.
314
File-ids are also used for this.
315
:return: a pair of ConflictLists: (not_selected, selected)
317
path_set = set(paths)
319
selected_paths = set()
320
new_conflicts = ConflictList()
321
selected_conflicts = ConflictList()
323
file_id = tree.path2id(path)
324
if file_id is not None:
327
for conflict in self:
329
for key in ('path', 'conflict_path'):
330
cpath = getattr(conflict, key, None)
333
if cpath in path_set:
335
selected_paths.add(cpath)
337
if osutils.is_inside_any(path_set, cpath):
339
selected_paths.add(cpath)
341
for key in ('file_id', 'conflict_file_id'):
342
cfile_id = getattr(conflict, key, None)
346
cpath = ids[cfile_id]
350
selected_paths.add(cpath)
352
selected_conflicts.append(conflict)
354
new_conflicts.append(conflict)
355
if ignore_misses is not True:
356
for path in [p for p in paths if p not in selected_paths]:
357
if not os.path.exists(tree.abspath(path)):
358
print("%s does not exist" % path)
360
print("%s is not conflicted" % path)
361
return new_conflicts, selected_conflicts
364
class Conflict(object):
365
"""Base class for all types of conflict"""
367
# FIXME: cleanup should take care of that ? -- vila 091229
370
def __init__(self, path, file_id=None):
372
# the factory blindly transfers the Stanza values to __init__ and
373
# Stanza is purely a Unicode api.
374
if isinstance(file_id, unicode):
375
file_id = cache_utf8.encode(file_id)
376
self.file_id = osutils.safe_file_id(file_id)
379
s = rio.Stanza(type=self.typestring, path=self.path)
380
if self.file_id is not None:
381
# Stanza requires Unicode apis
382
s.add('file_id', self.file_id.decode('utf8'))
386
return [type(self), self.path, self.file_id]
388
def __cmp__(self, other):
389
if getattr(other, "_cmp_list", None) is None:
391
return cmp(self._cmp_list(), other._cmp_list())
394
return hash((type(self), self.path, self.file_id))
396
def __eq__(self, other):
397
return self.__cmp__(other) == 0
399
def __ne__(self, other):
400
return not self.__eq__(other)
402
def __unicode__(self):
403
return self.format % self.__dict__
406
rdict = dict(self.__dict__)
407
rdict['class'] = self.__class__.__name__
408
return self.rformat % rdict
411
def factory(type, **kwargs):
413
return ctype[type](**kwargs)
416
def sort_key(conflict):
417
if conflict.path is not None:
418
return conflict.path, conflict.typestring
419
elif getattr(conflict, "conflict_path", None) is not None:
420
return conflict.conflict_path, conflict.typestring
422
return None, conflict.typestring
424
def _do(self, action, tree):
425
"""Apply the specified action to the conflict.
427
:param action: The method name to call.
429
:param tree: The tree passed as a parameter to the method.
431
meth = getattr(self, 'action_%s' % action, None)
433
raise NotImplementedError(self.__class__.__name__ + '.' + action)
436
def associated_filenames(self):
437
"""The names of the files generated to help resolve the conflict."""
438
raise NotImplementedError(self.associated_filenames)
440
def cleanup(self, tree):
441
for fname in self.associated_filenames():
443
osutils.delete_any(tree.abspath(fname))
445
if e.errno != errno.ENOENT:
448
def action_done(self, tree):
449
"""Mark the conflict as solved once it has been handled."""
450
# This method does nothing but simplifies the design of upper levels.
453
def action_take_this(self, tree):
454
raise NotImplementedError(self.action_take_this)
456
def action_take_other(self, tree):
457
raise NotImplementedError(self.action_take_other)
459
def _resolve_with_cleanups(self, tree, *args, **kwargs):
460
tt = transform.TreeTransform(tree)
461
op = cleanup.OperationWithCleanups(self._resolve)
462
op.add_cleanup(tt.finalize)
463
op.run_simple(tt, *args, **kwargs)
466
class PathConflict(Conflict):
467
"""A conflict was encountered merging file paths"""
469
typestring = 'path conflict'
471
format = 'Path conflict: %(path)s / %(conflict_path)s'
473
rformat = '%(class)s(%(path)r, %(conflict_path)r, %(file_id)r)'
475
def __init__(self, path, conflict_path=None, file_id=None):
476
Conflict.__init__(self, path, file_id)
477
self.conflict_path = conflict_path
480
s = Conflict.as_stanza(self)
481
if self.conflict_path is not None:
482
s.add('conflict_path', self.conflict_path)
485
def associated_filenames(self):
486
# No additional files have been generated here
489
def _resolve(self, tt, file_id, path, winner):
490
"""Resolve the conflict.
492
:param tt: The TreeTransform where the conflict is resolved.
493
:param file_id: The retained file id.
494
:param path: The retained path.
495
:param winner: 'this' or 'other' indicates which side is the winner.
497
path_to_create = None
499
if self.path == '<deleted>':
500
return # Nothing to do
501
if self.conflict_path == '<deleted>':
502
path_to_create = self.path
503
revid = tt._tree.get_parent_ids()[0]
504
elif winner == 'other':
505
if self.conflict_path == '<deleted>':
506
return # Nothing to do
507
if self.path == '<deleted>':
508
path_to_create = self.conflict_path
509
# FIXME: If there are more than two parents we may need to
510
# iterate. Taking the last parent is the safer bet in the mean
511
# time. -- vila 20100309
512
revid = tt._tree.get_parent_ids()[-1]
515
raise AssertionError('bad winner: %r' % (winner,))
516
if path_to_create is not None:
517
tid = tt.trans_id_tree_path(path_to_create)
518
transform.create_from_tree(
519
tt, tid, self._revision_tree(tt._tree, revid), file_id)
520
tt.version_file(file_id, tid)
522
tid = tt.trans_id_file_id(file_id)
523
# Adjust the path for the retained file id
524
parent_tid = tt.get_tree_parent(tid)
525
tt.adjust_path(osutils.basename(path), parent_tid, tid)
528
def _revision_tree(self, tree, revid):
529
return tree.branch.repository.revision_tree(revid)
531
def _infer_file_id(self, tree):
532
# Prior to bug #531967, file_id wasn't always set, there may still be
533
# conflict files in the wild so we need to cope with them
534
# Establish which path we should use to find back the file-id
536
for p in (self.path, self.conflict_path):
538
# special hard-coded path
541
possible_paths.append(p)
542
# Search the file-id in the parents with any path available
544
for revid in tree.get_parent_ids():
545
revtree = self._revision_tree(tree, revid)
546
for p in possible_paths:
547
file_id = revtree.path2id(p)
548
if file_id is not None:
549
return revtree, file_id
552
def action_take_this(self, tree):
553
if self.file_id is not None:
554
self._resolve_with_cleanups(tree, self.file_id, self.path,
557
# Prior to bug #531967 we need to find back the file_id and restore
558
# the content from there
559
revtree, file_id = self._infer_file_id(tree)
560
tree.revert([revtree.id2path(file_id)],
561
old_tree=revtree, backups=False)
563
def action_take_other(self, tree):
564
if self.file_id is not None:
565
self._resolve_with_cleanups(tree, self.file_id,
569
# Prior to bug #531967 we need to find back the file_id and restore
570
# the content from there
571
revtree, file_id = self._infer_file_id(tree)
572
tree.revert([revtree.id2path(file_id)],
573
old_tree=revtree, backups=False)
576
class ContentsConflict(PathConflict):
577
"""The files are of different types (or both binary), or not present"""
581
typestring = 'contents conflict'
583
format = 'Contents conflict in %(path)s'
585
def associated_filenames(self):
586
return [self.path + suffix for suffix in ('.BASE', '.OTHER')]
588
def _resolve(self, tt, suffix_to_remove):
589
"""Resolve the conflict.
591
:param tt: The TreeTransform where the conflict is resolved.
592
:param suffix_to_remove: Either 'THIS' or 'OTHER'
594
The resolution is symmetric: when taking THIS, OTHER is deleted and
595
item.THIS is renamed into item and vice-versa.
598
# Delete 'item.THIS' or 'item.OTHER' depending on
601
tt.trans_id_tree_path(self.path + '.' + suffix_to_remove))
602
except errors.NoSuchFile:
603
# There are valid cases where 'item.suffix_to_remove' either
604
# never existed or was already deleted (including the case
605
# where the user deleted it)
608
this_path = tt._tree.id2path(self.file_id)
609
except errors.NoSuchId:
610
# The file is not present anymore. This may happen if the user
611
# deleted the file either manually or when resolving a conflict on
612
# the parent. We may raise some exception to indicate that the
613
# conflict doesn't exist anymore and as such doesn't need to be
614
# resolved ? -- vila 20110615
617
this_tid = tt.trans_id_tree_path(this_path)
618
if this_tid is not None:
619
# Rename 'item.suffix_to_remove' (note that if
620
# 'item.suffix_to_remove' has been deleted, this is a no-op)
621
parent_tid = tt.get_tree_parent(this_tid)
622
tt.adjust_path(osutils.basename(self.path), parent_tid, this_tid)
625
def action_take_this(self, tree):
626
self._resolve_with_cleanups(tree, 'OTHER')
628
def action_take_other(self, tree):
629
self._resolve_with_cleanups(tree, 'THIS')
632
# TODO: There should be a base revid attribute to better inform the user about
633
# how the conflicts were generated.
634
class TextConflict(Conflict):
635
"""The merge algorithm could not resolve all differences encountered."""
639
typestring = 'text conflict'
641
format = 'Text conflict in %(path)s'
643
rformat = '%(class)s(%(path)r, %(file_id)r)'
645
def associated_filenames(self):
646
return [self.path + suffix for suffix in CONFLICT_SUFFIXES]
648
def _resolve(self, tt, winner_suffix):
649
"""Resolve the conflict by copying one of .THIS or .OTHER into file.
651
:param tt: The TreeTransform where the conflict is resolved.
652
:param winner_suffix: Either 'THIS' or 'OTHER'
654
The resolution is symmetric, when taking THIS, item.THIS is renamed
655
into item and vice-versa. This takes one of the files as a whole
656
ignoring every difference that could have been merged cleanly.
658
# To avoid useless copies, we switch item and item.winner_suffix, only
659
# item will exist after the conflict has been resolved anyway.
660
item_tid = tt.trans_id_file_id(self.file_id)
661
item_parent_tid = tt.get_tree_parent(item_tid)
662
winner_path = self.path + '.' + winner_suffix
663
winner_tid = tt.trans_id_tree_path(winner_path)
664
winner_parent_tid = tt.get_tree_parent(winner_tid)
665
# Switch the paths to preserve the content
666
tt.adjust_path(osutils.basename(self.path),
667
winner_parent_tid, winner_tid)
668
tt.adjust_path(osutils.basename(winner_path), item_parent_tid, item_tid)
669
# Associate the file_id to the right content
670
tt.unversion_file(item_tid)
671
tt.version_file(self.file_id, winner_tid)
674
def action_take_this(self, tree):
675
self._resolve_with_cleanups(tree, 'THIS')
677
def action_take_other(self, tree):
678
self._resolve_with_cleanups(tree, 'OTHER')
681
class HandledConflict(Conflict):
682
"""A path problem that has been provisionally resolved.
683
This is intended to be a base class.
686
rformat = "%(class)s(%(action)r, %(path)r, %(file_id)r)"
688
def __init__(self, action, path, file_id=None):
689
Conflict.__init__(self, path, file_id)
693
return Conflict._cmp_list(self) + [self.action]
696
s = Conflict.as_stanza(self)
697
s.add('action', self.action)
700
def associated_filenames(self):
701
# Nothing has been generated here
705
class HandledPathConflict(HandledConflict):
706
"""A provisionally-resolved path problem involving two paths.
707
This is intended to be a base class.
710
rformat = "%(class)s(%(action)r, %(path)r, %(conflict_path)r,"\
711
" %(file_id)r, %(conflict_file_id)r)"
713
def __init__(self, action, path, conflict_path, file_id=None,
714
conflict_file_id=None):
715
HandledConflict.__init__(self, action, path, file_id)
716
self.conflict_path = conflict_path
717
# the factory blindly transfers the Stanza values to __init__,
718
# so they can be unicode.
719
if isinstance(conflict_file_id, unicode):
720
conflict_file_id = cache_utf8.encode(conflict_file_id)
721
self.conflict_file_id = osutils.safe_file_id(conflict_file_id)
724
return HandledConflict._cmp_list(self) + [self.conflict_path,
725
self.conflict_file_id]
728
s = HandledConflict.as_stanza(self)
729
s.add('conflict_path', self.conflict_path)
730
if self.conflict_file_id is not None:
731
s.add('conflict_file_id', self.conflict_file_id.decode('utf8'))
736
class DuplicateID(HandledPathConflict):
737
"""Two files want the same file_id."""
739
typestring = 'duplicate id'
741
format = 'Conflict adding id to %(conflict_path)s. %(action)s %(path)s.'
744
class DuplicateEntry(HandledPathConflict):
745
"""Two directory entries want to have the same name."""
747
typestring = 'duplicate'
749
format = 'Conflict adding file %(conflict_path)s. %(action)s %(path)s.'
751
def action_take_this(self, tree):
752
tree.remove([self.conflict_path], force=True, keep_files=False)
753
tree.rename_one(self.path, self.conflict_path)
755
def action_take_other(self, tree):
756
tree.remove([self.path], force=True, keep_files=False)
759
class ParentLoop(HandledPathConflict):
760
"""An attempt to create an infinitely-looping directory structure.
761
This is rare, but can be produced like so:
770
typestring = 'parent loop'
772
format = 'Conflict moving %(path)s into %(conflict_path)s. %(action)s.'
774
def action_take_this(self, tree):
775
# just acccept brz proposal
778
def action_take_other(self, tree):
779
tt = transform.TreeTransform(tree)
781
p_tid = tt.trans_id_file_id(self.file_id)
782
parent_tid = tt.get_tree_parent(p_tid)
783
cp_tid = tt.trans_id_file_id(self.conflict_file_id)
784
cparent_tid = tt.get_tree_parent(cp_tid)
785
tt.adjust_path(osutils.basename(self.path), cparent_tid, cp_tid)
786
tt.adjust_path(osutils.basename(self.conflict_path),
793
class UnversionedParent(HandledConflict):
794
"""An attempt to version a file whose parent directory is not versioned.
795
Typically, the result of a merge where one tree unversioned the directory
796
and the other added a versioned file to it.
799
typestring = 'unversioned parent'
801
format = 'Conflict because %(path)s is not versioned, but has versioned'\
802
' children. %(action)s.'
804
# FIXME: We silently do nothing to make tests pass, but most probably the
805
# conflict shouldn't exist (the long story is that the conflict is
806
# generated with another one that can be resolved properly) -- vila 091224
807
def action_take_this(self, tree):
810
def action_take_other(self, tree):
814
class MissingParent(HandledConflict):
815
"""An attempt to add files to a directory that is not present.
816
Typically, the result of a merge where THIS deleted the directory and
817
the OTHER added a file to it.
818
See also: DeletingParent (same situation, THIS and OTHER reversed)
821
typestring = 'missing parent'
823
format = 'Conflict adding files to %(path)s. %(action)s.'
825
def action_take_this(self, tree):
826
tree.remove([self.path], force=True, keep_files=False)
828
def action_take_other(self, tree):
829
# just acccept brz proposal
833
class DeletingParent(HandledConflict):
834
"""An attempt to add files to a directory that is not present.
835
Typically, the result of a merge where one OTHER deleted the directory and
836
the THIS added a file to it.
839
typestring = 'deleting parent'
841
format = "Conflict: can't delete %(path)s because it is not empty. "\
844
# FIXME: It's a bit strange that the default action is not coherent with
845
# MissingParent from the *user* pov.
847
def action_take_this(self, tree):
848
# just acccept brz proposal
851
def action_take_other(self, tree):
852
tree.remove([self.path], force=True, keep_files=False)
855
class NonDirectoryParent(HandledConflict):
856
"""An attempt to add files to a directory that is not a directory or
857
an attempt to change the kind of a directory with files.
860
typestring = 'non-directory parent'
862
format = "Conflict: %(path)s is not a directory, but has files in it."\
865
# FIXME: .OTHER should be used instead of .new when the conflict is created
867
def action_take_this(self, tree):
868
# FIXME: we should preserve that path when the conflict is generated !
869
if self.path.endswith('.new'):
870
conflict_path = self.path[:-(len('.new'))]
871
tree.remove([self.path], force=True, keep_files=False)
872
tree.add(conflict_path)
874
raise NotImplementedError(self.action_take_this)
876
def action_take_other(self, tree):
877
# FIXME: we should preserve that path when the conflict is generated !
878
if self.path.endswith('.new'):
879
conflict_path = self.path[:-(len('.new'))]
880
tree.remove([conflict_path], force=True, keep_files=False)
881
tree.rename_one(self.path, conflict_path)
883
raise NotImplementedError(self.action_take_other)
889
def register_types(*conflict_types):
890
"""Register a Conflict subclass for serialization purposes"""
892
for conflict_type in conflict_types:
893
ctype[conflict_type.typestring] = conflict_type
895
register_types(ContentsConflict, TextConflict, PathConflict, DuplicateID,
896
DuplicateEntry, ParentLoop, UnversionedParent, MissingParent,
897
DeletingParent, NonDirectoryParent)
added
removed
breezy/conflicts.py
