1
# Copyright (C) 2005 by Aaron Bentley
1
# Copyright (C) 2005, 2006, 2007, 2009, 2010, 2011 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
17
# TODO: Move this into builtins
19
# TODO: 'bzr resolve' should accept a directory name and work from that
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
# TODO: bzr revert should resolve; even when reverting the whole tree
23
# or particular directories
22
from bzrlib.lazy_import import lazy_import
23
lazy_import(globals(), """
29
from bzrlib.branch import Branch
30
from bzrlib.errors import BzrCommandError, NotConflicted
31
from bzrlib.commands import register_command
32
from bzrlib.workingtree import CONFLICT_SUFFIXES
34
class cmd_conflicts(bzrlib.commands.Command):
35
"""List files with conflicts.
36
(conflicts are determined by the presence of .BASE .TREE, and .OTHER
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.
40
for path in Branch.open_containing(u'.')[0].working_tree().iter_conflicts():
43
class cmd_resolve(bzrlib.commands.Command):
44
"""Mark a conflict as resolved.
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.
46
112
aliases = ['resolved']
47
113
takes_args = ['file*']
48
takes_options = ['all']
49
def run(self, file_list=None, all=False):
52
raise BzrCommandError(
53
"command 'resolve' needs one or more FILE, or --all")
54
tree = Branch.open_containing(u'.')[0].working_tree()
55
file_list = list(tree.abspath(f) for f in tree.iter_conflicts())
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]
58
raise BzrCommandError(
59
"If --all is specified, no FILE may be provided")
60
for filename in file_list:
62
for suffix in CONFLICT_SUFFIXES:
64
os.unlink(filename+suffix)
66
if e.errno != errno.ENOENT:
70
if failures == len(CONFLICT_SUFFIXES):
71
if not os.path.exists(filename):
72
print "%s does not exist" % filename
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:
74
print "%s is not conflicted" % filename
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
76
211
def restore(filename):
78
Restore a conflicted file to the state it was in before merging.
79
Only text restoration supported at present.
212
"""Restore a conflicted file to the state it was in before merging.
214
Only text restoration is supported at present.
81
216
conflicted = False
83
os.rename(filename + ".THIS", filename)
218
osutils.rename(filename + ".THIS", filename)
85
220
except OSError, e:
86
221
if e.errno != errno.ENOENT:
98
233
if e.errno != errno.ENOENT:
100
235
if not conflicted:
101
raise NotConflicted(filename)
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(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(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(self.path, winner_parent_tid, winner_tid)
648
tt.adjust_path(winner_path, item_parent_tid, item_tid)
649
# Associate the file_id to the right content
650
tt.unversion_file(item_tid)
651
tt.version_file(self.file_id, winner_tid)
654
def action_take_this(self, tree):
655
self._resolve_with_cleanups(tree, 'THIS')
657
def action_take_other(self, tree):
658
self._resolve_with_cleanups(tree, 'OTHER')
661
class HandledConflict(Conflict):
662
"""A path problem that has been provisionally resolved.
663
This is intended to be a base class.
666
rformat = "%(class)s(%(action)r, %(path)r, %(file_id)r)"
668
def __init__(self, action, path, file_id=None):
669
Conflict.__init__(self, path, file_id)
673
return Conflict._cmp_list(self) + [self.action]
676
s = Conflict.as_stanza(self)
677
s.add('action', self.action)
680
def associated_filenames(self):
681
# Nothing has been generated here
685
class HandledPathConflict(HandledConflict):
686
"""A provisionally-resolved path problem involving two paths.
687
This is intended to be a base class.
690
rformat = "%(class)s(%(action)r, %(path)r, %(conflict_path)r,"\
691
" %(file_id)r, %(conflict_file_id)r)"
693
def __init__(self, action, path, conflict_path, file_id=None,
694
conflict_file_id=None):
695
HandledConflict.__init__(self, action, path, file_id)
696
self.conflict_path = conflict_path
697
# warn turned off, because the factory blindly transfers the Stanza
698
# values to __init__.
699
self.conflict_file_id = osutils.safe_file_id(conflict_file_id,
703
return HandledConflict._cmp_list(self) + [self.conflict_path,
704
self.conflict_file_id]
707
s = HandledConflict.as_stanza(self)
708
s.add('conflict_path', self.conflict_path)
709
if self.conflict_file_id is not None:
710
s.add('conflict_file_id', self.conflict_file_id.decode('utf8'))
715
class DuplicateID(HandledPathConflict):
716
"""Two files want the same file_id."""
718
typestring = 'duplicate id'
720
format = 'Conflict adding id to %(conflict_path)s. %(action)s %(path)s.'
723
class DuplicateEntry(HandledPathConflict):
724
"""Two directory entries want to have the same name."""
726
typestring = 'duplicate'
728
format = 'Conflict adding file %(conflict_path)s. %(action)s %(path)s.'
730
def action_take_this(self, tree):
731
tree.remove([self.conflict_path], force=True, keep_files=False)
732
tree.rename_one(self.path, self.conflict_path)
734
def action_take_other(self, tree):
735
tree.remove([self.path], force=True, keep_files=False)
738
class ParentLoop(HandledPathConflict):
739
"""An attempt to create an infinitely-looping directory structure.
740
This is rare, but can be produced like so:
749
typestring = 'parent loop'
751
format = 'Conflict moving %(path)s into %(conflict_path)s. %(action)s.'
753
def action_take_this(self, tree):
754
# just acccept bzr proposal
757
def action_take_other(self, tree):
758
# FIXME: We shouldn't have to manipulate so many paths here (and there
759
# is probably a bug or two...)
760
base_path = osutils.basename(self.path)
761
conflict_base_path = osutils.basename(self.conflict_path)
762
tt = transform.TreeTransform(tree)
764
p_tid = tt.trans_id_file_id(self.file_id)
765
parent_tid = tt.get_tree_parent(p_tid)
766
cp_tid = tt.trans_id_file_id(self.conflict_file_id)
767
cparent_tid = tt.get_tree_parent(cp_tid)
768
tt.adjust_path(base_path, cparent_tid, cp_tid)
769
tt.adjust_path(conflict_base_path, parent_tid, p_tid)
775
class UnversionedParent(HandledConflict):
776
"""An attempt to version a file whose parent directory is not versioned.
777
Typically, the result of a merge where one tree unversioned the directory
778
and the other added a versioned file to it.
781
typestring = 'unversioned parent'
783
format = 'Conflict because %(path)s is not versioned, but has versioned'\
784
' children. %(action)s.'
786
# FIXME: We silently do nothing to make tests pass, but most probably the
787
# conflict shouldn't exist (the long story is that the conflict is
788
# generated with another one that can be resolved properly) -- vila 091224
789
def action_take_this(self, tree):
792
def action_take_other(self, tree):
796
class MissingParent(HandledConflict):
797
"""An attempt to add files to a directory that is not present.
798
Typically, the result of a merge where THIS deleted the directory and
799
the OTHER added a file to it.
800
See also: DeletingParent (same situation, THIS and OTHER reversed)
803
typestring = 'missing parent'
805
format = 'Conflict adding files to %(path)s. %(action)s.'
807
def action_take_this(self, tree):
808
tree.remove([self.path], force=True, keep_files=False)
810
def action_take_other(self, tree):
811
# just acccept bzr proposal
815
class DeletingParent(HandledConflict):
816
"""An attempt to add files to a directory that is not present.
817
Typically, the result of a merge where one OTHER deleted the directory and
818
the THIS added a file to it.
821
typestring = 'deleting parent'
823
format = "Conflict: can't delete %(path)s because it is not empty. "\
826
# FIXME: It's a bit strange that the default action is not coherent with
827
# MissingParent from the *user* pov.
829
def action_take_this(self, tree):
830
# just acccept bzr proposal
833
def action_take_other(self, tree):
834
tree.remove([self.path], force=True, keep_files=False)
837
class NonDirectoryParent(HandledConflict):
838
"""An attempt to add files to a directory that is not a directory or
839
an attempt to change the kind of a directory with files.
842
typestring = 'non-directory parent'
844
format = "Conflict: %(path)s is not a directory, but has files in it."\
847
# FIXME: .OTHER should be used instead of .new when the conflict is created
849
def action_take_this(self, tree):
850
# FIXME: we should preserve that path when the conflict is generated !
851
if self.path.endswith('.new'):
852
conflict_path = self.path[:-(len('.new'))]
853
tree.remove([self.path], force=True, keep_files=False)
854
tree.add(conflict_path)
856
raise NotImplementedError(self.action_take_this)
858
def action_take_other(self, tree):
859
# FIXME: we should preserve that path when the conflict is generated !
860
if self.path.endswith('.new'):
861
conflict_path = self.path[:-(len('.new'))]
862
tree.remove([conflict_path], force=True, keep_files=False)
863
tree.rename_one(self.path, conflict_path)
865
raise NotImplementedError(self.action_take_other)
871
def register_types(*conflict_types):
872
"""Register a Conflict subclass for serialization purposes"""
874
for conflict_type in conflict_types:
875
ctype[conflict_type.typestring] = conflict_type
877
register_types(ContentsConflict, TextConflict, PathConflict, DuplicateID,
878
DuplicateEntry, ParentLoop, UnversionedParent, MissingParent,
879
DeletingParent, NonDirectoryParent)
added
removed
bzrlib/conflicts.py
