To get this branch, use:
bzr branch
http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar
« back to all changes in this revision
Viewing changes to breezy/conflicts.py
- browse files at revision 7520.1.1
- compare with another revision
- download diff
- download tarball
- view history from revision 7520.1.1
- Committer: Jelmer Vernooij
- Date: 2020-08-10 15:00:17 UTC
- mfrom: (7490.40.99 work)
- mto: This revision was merged to the branch mainline in revision 7521.
- Revision ID: jelmer@jelmer.uk-20200810150017-vs7xnrd1vat4iktg
Merge lp:brz/3.1.
- files added:
- breezy/bzr/conflicts.py
- files modified:
- breezy/builtins.py
added
removed
breezy/conflicts.py
17
17
# TODO: 'brz resolve' should accept a directory name and work from that
18
18
# point down
19
19
20
import errno
20
21
import os
21
22
import re
22
23
23
24
from .lazy_import import lazy_import
24
25
lazy_import(globals(), """
25
import errno
26
26
27
27
from breezy import (
28
osutils,
29
rio,
30
trace,
31
transform,
32
28
workingtree,
33
29
)
34
30
from breezy.i18n import gettext, ngettext
38
34
errors,
39
35
commands,
40
36
option,
37
osutils,
41
38
registry,
39
trace,
42
40
)
43
41
44
42
45
CONFLICT_SUFFIXES = ('.THIS', '.BASE', '.OTHER')
46
47
48
43
class cmd_conflicts(commands.Command):
49
44
__doc__ = """List files with conflicts.
50
45
127
122
if all:
128
123
if file_list:
129
124
raise errors.CommandError(gettext("If --all is specified,"
130
" no FILE may be provided"))
125
" no FILE may be provided"))
131
126
if directory is None:
132
127
directory = u'.'
133
128
tree = workingtree.WorkingTree.open_containing(directory)[0]
182
177
tree_conflicts = tree.conflicts()
183
178
nb_conflicts_before = len(tree_conflicts)
184
179
if paths is None:
185
new_conflicts = ConflictList()
180
new_conflicts = []
186
181
to_process = tree_conflicts
187
182
else:
188
183
new_conflicts, to_process = tree_conflicts.select_conflicts(
189
184
tree, paths, ignore_misses, recursive)
190
185
for conflict in to_process:
191
186
try:
192
conflict._do(action, tree)
187
conflict.do(action, tree)
193
188
conflict.cleanup(tree)
194
189
except NotImplementedError:
195
190
new_conflicts.append(conflict)
235
230
"""List of conflicts.
236
231
237
232
Typically obtained from WorkingTree.conflicts()
238
239
Can be instantiated from stanzas or from Conflict subclasses.
240
233
"""
241
234
242
235
def __init__(self, conflicts=None):
270
263
def __repr__(self):
271
264
return "ConflictList(%r)" % self.__list
272
265
273
@staticmethod
274
def from_stanzas(stanzas):
275
"""Produce a new ConflictList from an iterable of stanzas"""
276
conflicts = ConflictList()
277
for stanza in stanzas:
278
conflicts.append(Conflict.factory(**stanza.as_dict()))
279
return conflicts
280
281
def to_stanzas(self):
282
"""Generator of stanzas"""
283
for conflict in self:
284
yield conflict.as_stanza()
285
286
266
def to_strings(self):
287
267
"""Generate strings for the provided conflicts"""
288
268
for conflict in self:
299
279
recurse=False):
300
280
"""Select the conflicts associated with paths in a tree.
301
281
302
File-ids are also used for this.
303
282
:return: a pair of ConflictLists: (not_selected, selected)
304
283
"""
305
284
path_set = set(paths)
306
ids = {}
307
285
selected_paths = set()
308
286
new_conflicts = ConflictList()
309
287
selected_conflicts = ConflictList()
310
for path in paths:
311
file_id = tree.path2id(path)
312
if file_id is not None:
313
ids[file_id] = path
314
288
315
289
for conflict in self:
316
290
selected = False
317
for key in ('path', 'conflict_path'):
318
cpath = getattr(conflict, key, None)
319
if cpath is None:
320
continue
321
if cpath in path_set:
291
if conflict.path in path_set:
292
selected = True
293
selected_paths.add(conflict.path)
294
if recurse:
295
if osutils.is_inside_any(path_set, conflict.path):
322
296
selected = True
323
selected_paths.add(cpath)
324
if recurse:
325
if osutils.is_inside_any(path_set, cpath):
326
selected = True
327
selected_paths.add(cpath)
297
selected_paths.add(conflict.path)
328
298
329
for key in ('file_id', 'conflict_file_id'):
330
cfile_id = getattr(conflict, key, None)
331
if cfile_id is None:
332
continue
333
try:
334
cpath = ids[cfile_id]
335
except KeyError:
336
continue
337
selected = True
338
selected_paths.add(cpath)
339
299
if selected:
340
300
selected_conflicts.append(conflict)
341
301
else:
350
310
351
311
352
312
class Conflict(object):
353
"""Base class for all types of conflict"""
354
355
# FIXME: cleanup should take care of that ? -- vila 091229
356
has_files = False
357
358
def __init__(self, path, file_id=None):
313
"""Base class for conflicts."""
314
315
typestring = None
316
317
def __init__(self, path):
359
318
self.path = path
360
# the factory blindly transfers the Stanza values to __init__ and
361
# Stanza is purely a Unicode api.
362
if isinstance(file_id, str):
363
file_id = cache_utf8.encode(file_id)
364
self.file_id = file_id
365
366
def as_stanza(self):
367
s = rio.Stanza(type=self.typestring, path=self.path)
368
if self.file_id is not None:
369
# Stanza requires Unicode apis
370
s.add('file_id', self.file_id.decode('utf8'))
371
return s
372
373
def _cmp_list(self):
374
return [type(self), self.path, self.file_id]
375
376
def __cmp__(self, other):
377
if getattr(other, "_cmp_list", None) is None:
378
return -1
379
x = self._cmp_list()
380
y = other._cmp_list()
381
return (x > y) - (x < y)
382
383
def __hash__(self):
384
return hash((type(self), self.path, self.file_id))
385
386
def __eq__(self, other):
387
return self.__cmp__(other) == 0
388
389
def __ne__(self, other):
390
return not self.__eq__(other)
391
392
def __unicode__(self):
393
return self.describe()
394
395
def __str__(self):
396
return self.describe()
397
398
def describe(self):
399
return self.format % self.__dict__
400
401
def __repr__(self):
402
rdict = dict(self.__dict__)
403
rdict['class'] = self.__class__.__name__
404
return self.rformat % rdict
405
406
@staticmethod
407
def factory(type, **kwargs):
408
global ctype
409
return ctype[type](**kwargs)
410
411
@staticmethod
412
def sort_key(conflict):
413
if conflict.path is not None:
414
return conflict.path, conflict.typestring
415
elif getattr(conflict, "conflict_path", None) is not None:
416
return conflict.conflict_path, conflict.typestring
417
else:
418
return None, conflict.typestring
419
420
def _do(self, action, tree):
421
"""Apply the specified action to the conflict.
422
423
:param action: The method name to call.
424
425
:param tree: The tree passed as a parameter to the method.
426
"""
427
meth = getattr(self, 'action_%s' % action, None)
428
if meth is None:
429
raise NotImplementedError(self.__class__.__name__ + '.' + action)
430
meth(tree)
431
319
432
320
def associated_filenames(self):
433
321
"""The names of the files generated to help resolve the conflict."""
441
329
if e.errno != errno.ENOENT:
442
330
raise
443
331
444
def action_auto(self, tree):
445
raise NotImplementedError(self.action_auto)
446
447
def action_done(self, tree):
448
"""Mark the conflict as solved once it has been handled."""
449
# This method does nothing but simplifies the design of upper levels.
450
pass
451
452
def action_take_this(self, tree):
453
raise NotImplementedError(self.action_take_this)
454
455
def action_take_other(self, tree):
456
raise NotImplementedError(self.action_take_other)
457
458
def _resolve_with_cleanups(self, tree, *args, **kwargs):
459
with tree.transform() as tt:
460
self._resolve(tt, *args, **kwargs)
461
462
463
class PathConflict(Conflict):
464
"""A conflict was encountered merging file paths"""
465
466
typestring = 'path conflict'
467
468
format = 'Path conflict: %(path)s / %(conflict_path)s'
469
470
rformat = '%(class)s(%(path)r, %(conflict_path)r, %(file_id)r)'
471
472
def __init__(self, path, conflict_path=None, file_id=None):
473
Conflict.__init__(self, path, file_id)
474
self.conflict_path = conflict_path
475
476
def as_stanza(self):
477
s = Conflict.as_stanza(self)
478
if self.conflict_path is not None:
479
s.add('conflict_path', self.conflict_path)
480
return s
481
482
def associated_filenames(self):
483
# No additional files have been generated here
484
return []
485
486
def _resolve(self, tt, file_id, path, winner):
487
"""Resolve the conflict.
488
489
:param tt: The TreeTransform where the conflict is resolved.
490
:param file_id: The retained file id.
491
:param path: The retained path.
492
:param winner: 'this' or 'other' indicates which side is the winner.
493
"""
494
path_to_create = None
495
if winner == 'this':
496
if self.path == '<deleted>':
497
return # Nothing to do
498
if self.conflict_path == '<deleted>':
499
path_to_create = self.path
500
revid = tt._tree.get_parent_ids()[0]
501
elif winner == 'other':
502
if self.conflict_path == '<deleted>':
503
return # Nothing to do
504
if self.path == '<deleted>':
505
path_to_create = self.conflict_path
506
# FIXME: If there are more than two parents we may need to
507
# iterate. Taking the last parent is the safer bet in the mean
508
# time. -- vila 20100309
509
revid = tt._tree.get_parent_ids()[-1]
510
else:
511
# Programmer error
512
raise AssertionError('bad winner: %r' % (winner,))
513
if path_to_create is not None:
514
tid = tt.trans_id_tree_path(path_to_create)
515
tree = self._revision_tree(tt._tree, revid)
516
transform.create_from_tree(
517
tt, tid, tree, tree.id2path(file_id))
518
tt.version_file(tid, file_id=file_id)
519
else:
520
tid = tt.trans_id_file_id(file_id)
521
# Adjust the path for the retained file id
522
parent_tid = tt.get_tree_parent(tid)
523
tt.adjust_path(osutils.basename(path), parent_tid, tid)
524
tt.apply()
525
526
def _revision_tree(self, tree, revid):
527
return tree.branch.repository.revision_tree(revid)
528
529
def _infer_file_id(self, tree):
530
# Prior to bug #531967, file_id wasn't always set, there may still be
531
# conflict files in the wild so we need to cope with them
532
# Establish which path we should use to find back the file-id
533
possible_paths = []
534
for p in (self.path, self.conflict_path):
535
if p == '<deleted>':
536
# special hard-coded path
537
continue
538
if p is not None:
539
possible_paths.append(p)
540
# Search the file-id in the parents with any path available
541
file_id = None
542
for revid in tree.get_parent_ids():
543
revtree = self._revision_tree(tree, revid)
544
for p in possible_paths:
545
file_id = revtree.path2id(p)
546
if file_id is not None:
547
return revtree, file_id
548
return None, None
549
550
def action_take_this(self, tree):
551
if self.file_id is not None:
552
self._resolve_with_cleanups(tree, self.file_id, self.path,
553
winner='this')
554
else:
555
# Prior to bug #531967 we need to find back the file_id and restore
556
# the content from there
557
revtree, file_id = self._infer_file_id(tree)
558
tree.revert([revtree.id2path(file_id)],
559
old_tree=revtree, backups=False)
560
561
def action_take_other(self, tree):
562
if self.file_id is not None:
563
self._resolve_with_cleanups(tree, self.file_id,
564
self.conflict_path,
565
winner='other')
566
else:
567
# Prior to bug #531967 we need to find back the file_id and restore
568
# the content from there
569
revtree, file_id = self._infer_file_id(tree)
570
tree.revert([revtree.id2path(file_id)],
571
old_tree=revtree, backups=False)
572
573
574
class ContentsConflict(PathConflict):
575
"""The files are of different types (or both binary), or not present"""
576
577
has_files = True
578
579
typestring = 'contents conflict'
580
581
format = 'Contents conflict in %(path)s'
582
583
def associated_filenames(self):
584
return [self.path + suffix for suffix in ('.BASE', '.OTHER')]
585
586
def _resolve(self, tt, suffix_to_remove):
587
"""Resolve the conflict.
588
589
:param tt: The TreeTransform where the conflict is resolved.
590
:param suffix_to_remove: Either 'THIS' or 'OTHER'
591
592
The resolution is symmetric: when taking THIS, OTHER is deleted and
593
item.THIS is renamed into item and vice-versa.
594
"""
595
try:
596
# Delete 'item.THIS' or 'item.OTHER' depending on
597
# suffix_to_remove
598
tt.delete_contents(
599
tt.trans_id_tree_path(self.path + '.' + suffix_to_remove))
600
except errors.NoSuchFile:
601
# There are valid cases where 'item.suffix_to_remove' either
602
# never existed or was already deleted (including the case
603
# where the user deleted it)
604
pass
605
try:
606
this_path = tt._tree.id2path(self.file_id)
607
except errors.NoSuchId:
608
# The file is not present anymore. This may happen if the user
609
# deleted the file either manually or when resolving a conflict on
610
# the parent. We may raise some exception to indicate that the
611
# conflict doesn't exist anymore and as such doesn't need to be
612
# resolved ? -- vila 20110615
613
this_tid = None
614
else:
615
this_tid = tt.trans_id_tree_path(this_path)
616
if this_tid is not None:
617
# Rename 'item.suffix_to_remove' (note that if
618
# 'item.suffix_to_remove' has been deleted, this is a no-op)
619
parent_tid = tt.get_tree_parent(this_tid)
620
tt.adjust_path(osutils.basename(self.path), parent_tid, this_tid)
621
tt.apply()
622
623
def action_take_this(self, tree):
624
self._resolve_with_cleanups(tree, 'OTHER')
625
626
def action_take_other(self, tree):
627
self._resolve_with_cleanups(tree, 'THIS')
628
629
630
# TODO: There should be a base revid attribute to better inform the user about
631
# how the conflicts were generated.
632
class TextConflict(Conflict):
633
"""The merge algorithm could not resolve all differences encountered."""
634
635
has_files = True
636
637
typestring = 'text conflict'
638
639
format = 'Text conflict in %(path)s'
640
641
rformat = '%(class)s(%(path)r, %(file_id)r)'
642
643
_conflict_re = re.compile(b'^(<{7}|={7}|>{7})')
644
645
def associated_filenames(self):
646
return [self.path + suffix for suffix in CONFLICT_SUFFIXES]
647
648
def _resolve(self, tt, winner_suffix):
649
"""Resolve the conflict by copying one of .THIS or .OTHER into file.
650
651
:param tt: The TreeTransform where the conflict is resolved.
652
:param winner_suffix: Either 'THIS' or 'OTHER'
653
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.
657
"""
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),
669
item_parent_tid, item_tid)
670
# Associate the file_id to the right content
671
tt.unversion_file(item_tid)
672
tt.version_file(winner_tid, file_id=self.file_id)
673
tt.apply()
674
675
def action_auto(self, tree):
676
# GZ 2012-07-27: Using NotImplementedError to signal that a conflict
677
# can't be auto resolved does not seem ideal.
678
try:
679
kind = tree.kind(self.path)
680
except errors.NoSuchFile:
681
return
682
if kind != 'file':
683
raise NotImplementedError("Conflict is not a file")
684
conflict_markers_in_line = self._conflict_re.search
685
# GZ 2012-07-27: What if not tree.has_id(self.file_id) due to removal?
686
with tree.get_file(self.path) as f:
687
for line in f:
688
if conflict_markers_in_line(line):
689
raise NotImplementedError("Conflict markers present")
690
691
def action_take_this(self, tree):
692
self._resolve_with_cleanups(tree, 'THIS')
693
694
def action_take_other(self, tree):
695
self._resolve_with_cleanups(tree, 'OTHER')
696
697
698
class HandledConflict(Conflict):
699
"""A path problem that has been provisionally resolved.
700
This is intended to be a base class.
701
"""
702
703
rformat = "%(class)s(%(action)r, %(path)r, %(file_id)r)"
704
705
def __init__(self, action, path, file_id=None):
706
Conflict.__init__(self, path, file_id)
707
self.action = action
708
709
def _cmp_list(self):
710
return Conflict._cmp_list(self) + [self.action]
711
712
def as_stanza(self):
713
s = Conflict.as_stanza(self)
714
s.add('action', self.action)
715
return s
716
717
def associated_filenames(self):
718
# Nothing has been generated here
719
return []
720
721
722
class HandledPathConflict(HandledConflict):
723
"""A provisionally-resolved path problem involving two paths.
724
This is intended to be a base class.
725
"""
726
727
rformat = "%(class)s(%(action)r, %(path)r, %(conflict_path)r,"\
728
" %(file_id)r, %(conflict_file_id)r)"
729
730
def __init__(self, action, path, conflict_path, file_id=None,
731
conflict_file_id=None):
732
HandledConflict.__init__(self, action, path, file_id)
733
self.conflict_path = conflict_path
734
# the factory blindly transfers the Stanza values to __init__,
735
# so they can be unicode.
736
if isinstance(conflict_file_id, str):
737
conflict_file_id = cache_utf8.encode(conflict_file_id)
738
self.conflict_file_id = conflict_file_id
739
740
def _cmp_list(self):
741
return HandledConflict._cmp_list(self) + [self.conflict_path,
742
self.conflict_file_id]
743
744
def as_stanza(self):
745
s = HandledConflict.as_stanza(self)
746
s.add('conflict_path', self.conflict_path)
747
if self.conflict_file_id is not None:
748
s.add('conflict_file_id', self.conflict_file_id.decode('utf8'))
749
750
return s
751
752
753
class DuplicateID(HandledPathConflict):
754
"""Two files want the same file_id."""
755
756
typestring = 'duplicate id'
757
758
format = 'Conflict adding id to %(conflict_path)s. %(action)s %(path)s.'
759
760
761
class DuplicateEntry(HandledPathConflict):
762
"""Two directory entries want to have the same name."""
763
764
typestring = 'duplicate'
765
766
format = 'Conflict adding file %(conflict_path)s. %(action)s %(path)s.'
767
768
def action_take_this(self, tree):
769
tree.remove([self.conflict_path], force=True, keep_files=False)
770
tree.rename_one(self.path, self.conflict_path)
771
772
def action_take_other(self, tree):
773
tree.remove([self.path], force=True, keep_files=False)
774
775
776
class ParentLoop(HandledPathConflict):
777
"""An attempt to create an infinitely-looping directory structure.
778
This is rare, but can be produced like so:
779
780
tree A:
781
mv foo bar
782
tree B:
783
mv bar foo
784
merge A and B
785
"""
786
787
typestring = 'parent loop'
788
789
format = 'Conflict moving %(path)s into %(conflict_path)s. %(action)s.'
790
791
def action_take_this(self, tree):
792
# just acccept brz proposal
793
pass
794
795
def action_take_other(self, tree):
796
with tree.transform() as tt:
797
p_tid = tt.trans_id_file_id(self.file_id)
798
parent_tid = tt.get_tree_parent(p_tid)
799
cp_tid = tt.trans_id_file_id(self.conflict_file_id)
800
cparent_tid = tt.get_tree_parent(cp_tid)
801
tt.adjust_path(osutils.basename(self.path), cparent_tid, cp_tid)
802
tt.adjust_path(osutils.basename(self.conflict_path),
803
parent_tid, p_tid)
804
tt.apply()
805
806
807
class UnversionedParent(HandledConflict):
808
"""An attempt to version a file whose parent directory is not versioned.
809
Typically, the result of a merge where one tree unversioned the directory
810
and the other added a versioned file to it.
811
"""
812
813
typestring = 'unversioned parent'
814
815
format = 'Conflict because %(path)s is not versioned, but has versioned'\
816
' children. %(action)s.'
817
818
# FIXME: We silently do nothing to make tests pass, but most probably the
819
# conflict shouldn't exist (the long story is that the conflict is
820
# generated with another one that can be resolved properly) -- vila 091224
821
def action_take_this(self, tree):
822
pass
823
824
def action_take_other(self, tree):
825
pass
826
827
828
class MissingParent(HandledConflict):
829
"""An attempt to add files to a directory that is not present.
830
Typically, the result of a merge where THIS deleted the directory and
831
the OTHER added a file to it.
832
See also: DeletingParent (same situation, THIS and OTHER reversed)
833
"""
834
835
typestring = 'missing parent'
836
837
format = 'Conflict adding files to %(path)s. %(action)s.'
838
839
def action_take_this(self, tree):
840
tree.remove([self.path], force=True, keep_files=False)
841
842
def action_take_other(self, tree):
843
# just acccept brz proposal
844
pass
845
846
847
class DeletingParent(HandledConflict):
848
"""An attempt to add files to a directory that is not present.
849
Typically, the result of a merge where one OTHER deleted the directory and
850
the THIS added a file to it.
851
"""
852
853
typestring = 'deleting parent'
854
855
format = "Conflict: can't delete %(path)s because it is not empty. "\
856
"%(action)s."
857
858
# FIXME: It's a bit strange that the default action is not coherent with
859
# MissingParent from the *user* pov.
860
861
def action_take_this(self, tree):
862
# just acccept brz proposal
863
pass
864
865
def action_take_other(self, tree):
866
tree.remove([self.path], force=True, keep_files=False)
867
868
869
class NonDirectoryParent(HandledConflict):
870
"""An attempt to add files to a directory that is not a directory or
871
an attempt to change the kind of a directory with files.
872
"""
873
874
typestring = 'non-directory parent'
875
876
format = "Conflict: %(path)s is not a directory, but has files in it."\
877
" %(action)s."
878
879
# FIXME: .OTHER should be used instead of .new when the conflict is created
880
881
def action_take_this(self, tree):
882
# FIXME: we should preserve that path when the conflict is generated !
883
if self.path.endswith('.new'):
884
conflict_path = self.path[:-(len('.new'))]
885
tree.remove([self.path], force=True, keep_files=False)
886
tree.add(conflict_path)
887
else:
888
raise NotImplementedError(self.action_take_this)
889
890
def action_take_other(self, tree):
891
# FIXME: we should preserve that path when the conflict is generated !
892
if self.path.endswith('.new'):
893
conflict_path = self.path[:-(len('.new'))]
894
tree.remove([conflict_path], force=True, keep_files=False)
895
tree.rename_one(self.path, conflict_path)
896
else:
897
raise NotImplementedError(self.action_take_other)
898
899
900
ctype = {}
901
902
903
def register_types(*conflict_types):
904
"""Register a Conflict subclass for serialization purposes"""
905
global ctype
906
for conflict_type in conflict_types:
907
ctype[conflict_type.typestring] = conflict_type
908
909
910
register_types(ContentsConflict, TextConflict, PathConflict, DuplicateID,
911
DuplicateEntry, ParentLoop, UnversionedParent, MissingParent,
912
DeletingParent, NonDirectoryParent)
332
def do(self, action, tree):
333
"""Apply the specified action to the conflict.
334
335
:param action: The method name to call.
336
337
:param tree: The tree passed as a parameter to the method.
338
"""
339
raise NotImplementedError(self.do)
340
341
def describe(self):
342
raise NotImplementedError(self.describe)
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0