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
23
from bzrlib.lazy_import import lazy_import
24
lazy_import(globals(), """
26
from bzrlib.commands import register_command
27
from bzrlib.errors import BzrCommandError, NotConflicted, UnsupportedOperation
28
from bzrlib.option import Option
29
from bzrlib.osutils import rename, delete_any
30
from bzrlib.rio import Stanza
33
44
CONFLICT_SUFFIXES = ('.THIS', '.BASE', '.OTHER')
36
class cmd_conflicts(bzrlib.commands.Command):
47
class cmd_conflicts(commands.Command):
37
48
"""List files with conflicts.
39
50
Merge will do its best to combine the changes in two branches, but there
41
52
it will mark a conflict. A conflict means that you need to fix something,
42
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.)
44
59
Use bzr resolve when you have fixed a problem.
46
(conflicts are determined by the presence of .BASE .TREE, and .OTHER
52
from bzrlib.workingtree import WorkingTree
53
wt = WorkingTree.open_containing(u'.')[0]
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]
54
69
for conflict in wt.conflicts():
58
class cmd_resolve(bzrlib.commands.Command):
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):
59
101
"""Mark a conflict as resolved.
61
103
Merge will do its best to combine the changes in two branches, but there
63
105
it will mark a conflict. A conflict means that you need to fix something,
64
106
before you should commit.
66
Once you have fixed a problem, use "bzr resolve FILE.." to mark
67
individual files as fixed, or "bzr resolve --all" to mark all conflicts as
70
See also bzr conflicts.
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.
72
112
aliases = ['resolved']
73
113
takes_args = ['file*']
74
takes_options = [Option('all', help='Resolve all conflicts in this tree')]
75
def run(self, file_list=None, all=False):
76
from bzrlib.workingtree import WorkingTree
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):
79
raise BzrCommandError("If --all is specified, no FILE may be provided")
80
tree = WorkingTree.open_containing('.')[0]
84
raise BzrCommandError("command 'resolve' needs one or more FILE, or --all")
85
tree = WorkingTree.open_containing(file_list[0])[0]
86
to_resolve = [tree.relpath(p) for p in file_list]
87
resolve(tree, to_resolve)
90
def resolve(tree, paths=None, ignore_misses=False):
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()
93
178
tree_conflicts = tree.conflicts()
95
180
new_conflicts = ConflictList()
96
selected_conflicts = tree_conflicts
181
to_process = tree_conflicts
98
new_conflicts, selected_conflicts = \
99
tree_conflicts.select_conflicts(tree, paths, ignore_misses)
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)
101
192
tree.set_conflicts(new_conflicts)
102
except UnsupportedOperation:
193
except errors.UnsupportedOperation:
104
selected_conflicts.remove_files(tree)
109
199
def restore(filename):
111
Restore a conflicted file to the state it was in before merging.
112
Only text restoration supported at present.
200
"""Restore a conflicted file to the state it was in before merging.
202
Only text restoration is supported at present.
114
204
conflicted = False
116
rename(filename + ".THIS", filename)
206
osutils.rename(filename + ".THIS", filename)
117
207
conflicted = True
118
208
except OSError, e:
119
209
if e.errno != errno.ENOENT:
250
341
print "%s is not conflicted" % path
251
342
return new_conflicts, selected_conflicts
254
345
class Conflict(object):
255
346
"""Base class for all types of conflict"""
348
# FIXME: cleanup should take care of that ? -- vila 091229
257
349
has_files = False
259
351
def __init__(self, path, file_id=None):
261
self.file_id = file_id
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)
263
357
def as_stanza(self):
264
s = Stanza(type=self.typestring, path=self.path)
358
s = rio.Stanza(type=self.typestring, path=self.path)
265
359
if self.file_id is not None:
266
s.add('file_id', self.file_id)
360
# Stanza requires Unicode apis
361
s.add('file_id', self.file_id.decode('utf8'))
269
364
def _cmp_list(self):
306
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_%s' % action, None)
412
raise NotImplementedError(self.__class__.__name__ + '.' + action)
415
def cleanup(self, tree):
416
raise NotImplementedError(self.cleanup)
418
def action_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 action_take_this(self, tree):
424
raise NotImplementedError(self.action_take_this)
426
def action_take_other(self, tree):
427
raise NotImplementedError(self.action_take_other)
309
430
class PathConflict(Conflict):
310
431
"""A conflict was encountered merging file paths"""
335
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 action_take_this nor action_take_other reflect that...
482
def action_take_this(self, tree):
483
tree.remove([self.path + '.OTHER'], force=True, keep_files=False)
485
def action_take_other(self, tree):
486
tree.remove([self.path], force=True, keep_files=False)
490
# FIXME: TextConflict is about a single file-id, there never is a conflict_path
491
# attribute so we shouldn't inherit from PathConflict but simply from Conflict
493
# TODO: There should be a base revid attribute to better inform the user about
494
# how the conflicts were generated.
338
495
class TextConflict(PathConflict):
339
496
"""The merge algorithm could not resolve all differences encountered."""
376
545
def __init__(self, action, path, conflict_path, file_id=None,
377
546
conflict_file_id=None):
378
547
HandledConflict.__init__(self, action, path, file_id)
379
self.conflict_path = conflict_path
380
self.conflict_file_id = conflict_file_id
548
self.conflict_path = conflict_path
549
# warn turned off, because the factory blindly transfers the Stanza
550
# values to __init__.
551
self.conflict_file_id = osutils.safe_file_id(conflict_file_id,
382
554
def _cmp_list(self):
383
return HandledConflict._cmp_list(self) + [self.conflict_path,
555
return HandledConflict._cmp_list(self) + [self.conflict_path,
384
556
self.conflict_file_id]
386
558
def as_stanza(self):
387
559
s = HandledConflict.as_stanza(self)
388
560
s.add('conflict_path', self.conflict_path)
389
561
if self.conflict_file_id is not None:
390
s.add('conflict_file_id', self.conflict_file_id)
562
s.add('conflict_file_id', self.conflict_file_id.decode('utf8'))
424
603
format = 'Conflict moving %(conflict_path)s into %(path)s. %(action)s.'
605
def action_take_this(self, tree):
606
# just acccept bzr proposal
609
def action_take_other(self, tree):
610
# FIXME: We shouldn't have to manipulate so many paths here (and there
611
# is probably a bug or two...)
612
base_path = osutils.basename(self.path)
613
conflict_base_path = osutils.basename(self.conflict_path)
614
tt = transform.TreeTransform(tree)
616
p_tid = tt.trans_id_file_id(self.file_id)
617
parent_tid = tt.get_tree_parent(p_tid)
618
cp_tid = tt.trans_id_file_id(self.conflict_file_id)
619
cparent_tid = tt.get_tree_parent(cp_tid)
620
tt.adjust_path(base_path, cparent_tid, cp_tid)
621
tt.adjust_path(conflict_base_path, parent_tid, p_tid)
427
627
class UnversionedParent(HandledConflict):
428
"""An attempt to version an file whose parent directory is not versioned.
628
"""An attempt to version a file whose parent directory is not versioned.
429
629
Typically, the result of a merge where one tree unversioned the directory
430
630
and the other added a versioned file to it.
433
633
typestring = 'unversioned parent'
435
format = 'Conflict adding versioned files to %(path)s. %(action)s.'
635
format = 'Conflict because %(path)s is not versioned, but has versioned'\
636
' children. %(action)s.'
638
# FIXME: We silently do nothing to make tests pass, but most probably the
639
# conflict shouldn't exist (the long story is that the conflict is
640
# generated with another one that can be resolved properly) -- vila 091224
641
def action_take_this(self, tree):
644
def action_take_other(self, tree):
438
648
class MissingParent(HandledConflict):
439
649
"""An attempt to add files to a directory that is not present.
440
Typically, the result of a merge where one tree deleted the directory and
441
the other added a file to it.
650
Typically, the result of a merge where THIS deleted the directory and
651
the OTHER added a file to it.
652
See also: DeletingParent (same situation, THIS and OTHER reversed)
444
655
typestring = 'missing parent'
446
657
format = 'Conflict adding files to %(path)s. %(action)s.'
659
def action_take_this(self, tree):
660
tree.remove([self.path], force=True, keep_files=False)
662
def action_take_other(self, tree):
663
# just acccept bzr proposal
667
class DeletingParent(HandledConflict):
668
"""An attempt to add files to a directory that is not present.
669
Typically, the result of a merge where one OTHER deleted the directory and
670
the THIS added a file to it.
673
typestring = 'deleting parent'
675
format = "Conflict: can't delete %(path)s because it is not empty. "\
678
# FIXME: It's a bit strange that the default action is not coherent with
679
# MissingParent from the *user* pov.
681
def action_take_this(self, tree):
682
# just acccept bzr proposal
685
def action_take_other(self, tree):
686
tree.remove([self.path], force=True, keep_files=False)
689
class NonDirectoryParent(HandledConflict):
690
"""An attempt to add files to a directory that is not a directory or
691
an attempt to change the kind of a directory with files.
694
typestring = 'non-directory parent'
696
format = "Conflict: %(path)s is not a directory, but has files in it."\
699
# FIXME: .OTHER should be used instead of .new when the conflict is created
701
def action_take_this(self, tree):
702
# FIXME: we should preserve that path when the conflict is generated !
703
if self.path.endswith('.new'):
704
conflict_path = self.path[:-(len('.new'))]
705
tree.remove([self.path], force=True, keep_files=False)
706
tree.add(conflict_path)
708
raise NotImplementedError(self.action_take_this)
710
def action_take_other(self, tree):
711
# FIXME: we should preserve that path when the conflict is generated !
712
if self.path.endswith('.new'):
713
conflict_path = self.path[:-(len('.new'))]
714
tree.remove([conflict_path], force=True, keep_files=False)
715
tree.rename_one(self.path, conflict_path)
717
raise NotImplementedError(self.action_take_other)
added
removed
bzrlib/conflicts.py
