« back to all changes in this revision
Viewing changes to bzrlib/changeset.py
- browse files at revision 1185.72.5
- compare with another revision
- download diff
- download tarball
- view history from revision 1185.72.5
- Committer: Daniel Silverstone
- Date: 2006-01-09 10:51:47 UTC
- mfrom: (1540 bzr.dev (Main development branch))
- mto: (1185.50.62 bzr-jam-integration)
- mto: This revision was merged to the branch mainline in revision 1554.
- Revision ID: dsilvers@digital-scurf.org-20060109105147-17dd71ee850f7a60
Merge from martin
- files added:
- BRANCH.TODO
- files renamed:
- bzrlib/tests/test_revision_info.py => bzrlib/tests/blackbox/test_revision_info.py
- bzrlib/tests/test_sftp.py => bzrlib/tests/test_sftp_transport.py
- files modified:
- HACKING
added
removed
bzrlib/changeset.py
25
25
import os.path
26
26
import errno
27
27
import stat
28
from tempfile import mkdtemp
29
28
from shutil import rmtree
30
29
from itertools import izip
31
30
32
31
from bzrlib.trace import mutter, warning
33
from bzrlib.osutils import rename, sha_file
32
from bzrlib.osutils import rename, sha_file, pathjoin, mkdtemp
34
33
import bzrlib
35
34
from bzrlib.errors import BzrCheckError
36
35
37
36
__docformat__ = "restructuredtext"
38
37
38
39
39
NULL_ID = "!NULL"
40
40
41
41
42
class OldFailedTreeOp(Exception):
42
43
def __init__(self):
43
44
Exception.__init__(self, "bzr-tree-change contains files from a"
44
45
" previous failed merge operation.")
46
47
45
48
def invert_dict(dict):
46
49
newdict = {}
47
50
for (key,value) in dict.iteritems():
56
59
self.old_exec_flag = old_exec_flag
57
60
self.new_exec_flag = new_exec_flag
58
61
59
def apply(self, filename, conflict_handler, reverse=False):
60
if not reverse:
61
from_exec_flag = self.old_exec_flag
62
to_exec_flag = self.new_exec_flag
63
else:
64
from_exec_flag = self.new_exec_flag
65
to_exec_flag = self.old_exec_flag
62
def apply(self, filename, conflict_handler):
63
from_exec_flag = self.old_exec_flag
64
to_exec_flag = self.new_exec_flag
66
65
try:
67
66
current_exec_flag = bool(os.stat(filename).st_mode & 0111)
68
67
except OSError, e:
105
104
return not (self == other)
106
105
107
106
108
def dir_create(filename, conflict_handler, reverse):
107
def dir_create(filename, conflict_handler, reverse=False):
109
108
"""Creates the directory, or deletes it if reverse is true. Intended to be
110
109
used with ReplaceContents.
111
110
150
149
def __repr__(self):
151
150
return "SymlinkCreate(%s)" % self.target
152
151
153
def __call__(self, filename, conflict_handler, reverse):
152
def __call__(self, filename, conflict_handler, reverse=False):
154
153
"""Creates or destroys the symlink.
155
154
156
155
:param filename: The name of the symlink to create
179
178
def __ne__(self, other):
180
179
return not (self == other)
181
180
181
182
182
class FileCreate(object):
183
183
"""Create or delete a file (for use with ReplaceContents)"""
184
184
def __init__(self, contents):
203
203
def __ne__(self, other):
204
204
return not (self == other)
205
205
206
def __call__(self, filename, conflict_handler, reverse):
206
def __call__(self, filename, conflict_handler, reverse=False):
207
207
"""Create or delete a file
208
208
209
209
:param filename: The name of the file to create
235
235
if conflict_handler.missing_for_rm(filename, undo) == "skip":
236
236
return
237
237
238
239
238
240
239
class TreeFileCreate(object):
241
240
"""Create or delete a file (for use with ReplaceContents)"""
269
268
in_file = file(filename, "rb")
270
269
return sha_file(in_file) == self.tree.get_file_sha1(self.file_id)
271
270
272
def __call__(self, filename, conflict_handler, reverse):
271
def __call__(self, filename, conflict_handler, reverse=False):
273
272
"""Create or delete a file
274
273
275
274
:param filename: The name of the file to create
301
300
if conflict_handler.missing_for_rm(filename, undo) == "skip":
302
301
return
303
302
304
305
306
def reversed(sequence):
307
max = len(sequence) - 1
308
for i in range(len(sequence)):
309
yield sequence[max - i]
310
303
311
304
class ReplaceContents(object):
312
305
"""A contents-replacement framework. It allows a file/directory/symlink to
344
337
def __ne__(self, other):
345
338
return not (self == other)
346
339
347
def apply(self, filename, conflict_handler, reverse=False):
340
def apply(self, filename, conflict_handler):
348
341
"""Applies the FileReplacement to the specified filename
349
342
350
343
:param filename: The name of the file to apply changes to
351
344
:type filename: str
352
:param reverse: If true, apply the change in reverse
353
:type reverse: bool
354
345
"""
355
if not reverse:
356
undo = self.old_contents
357
perform = self.new_contents
358
else:
359
undo = self.new_contents
360
perform = self.old_contents
346
undo = self.old_contents
347
perform = self.new_contents
361
348
mode = None
362
349
if undo is not None:
363
350
try:
371
358
return
372
359
undo(filename, conflict_handler, reverse=True)
373
360
if perform is not None:
374
perform(filename, conflict_handler, reverse=False)
361
perform(filename, conflict_handler)
375
362
if mode is not None:
376
363
os.chmod(filename, mode)
377
364
381
368
def is_deletion(self):
382
369
return self.old_contents is not None and self.new_contents is None
383
370
384
class ApplySequence(object):
385
def __init__(self, changes=None):
386
self.changes = []
387
if changes is not None:
388
self.changes.extend(changes)
389
390
def __eq__(self, other):
391
if not isinstance(other, ApplySequence):
392
return False
393
elif len(other.changes) != len(self.changes):
394
return False
395
else:
396
for i in range(len(self.changes)):
397
if self.changes[i] != other.changes[i]:
398
return False
399
return True
400
401
def __ne__(self, other):
402
return not (self == other)
403
404
405
def apply(self, filename, conflict_handler, reverse=False):
406
if not reverse:
407
iter = self.changes
408
else:
409
iter = reversed(self.changes)
410
for change in iter:
411
change.apply(filename, conflict_handler, reverse)
412
413
371
414
372
class Diff3Merge(object):
415
373
history_based = False
434
392
return not (self == other)
435
393
436
394
def dump_file(self, temp_dir, name, tree):
437
out_path = os.path.join(temp_dir, name)
395
out_path = pathjoin(temp_dir, name)
438
396
out_file = file(out_path, "wb")
439
397
in_file = tree.get_file(self.file_id)
440
398
for line in in_file:
441
399
out_file.write(line)
442
400
return out_path
443
401
444
def apply(self, filename, conflict_handler, reverse=False):
402
def apply(self, filename, conflict_handler):
445
403
import bzrlib.patch
446
404
temp_dir = mkdtemp(prefix="bzr-")
447
405
try:
448
406
new_file = filename+".new"
449
407
base_file = self.dump_file(temp_dir, "base", self.base)
450
408
other_file = self.dump_file(temp_dir, "other", self.other)
451
if not reverse:
452
base = base_file
453
other = other_file
454
else:
455
base = other_file
456
other = base_file
409
base = base_file
410
other = other_file
457
411
status = bzrlib.patch.diff3(new_file, filename, base, other)
458
412
if status == 0:
459
413
os.chmod(new_file, os.stat(filename).st_mode)
482
436
"""
483
437
return ReplaceContents(None, dir_create)
484
438
439
485
440
def DeleteDir():
486
441
"""Convenience function to delete a directory.
487
442
490
445
"""
491
446
return ReplaceContents(dir_create, None)
492
447
448
493
449
def CreateFile(contents):
494
450
"""Convenience fucntion to create a file.
495
451
500
456
"""
501
457
return ReplaceContents(None, FileCreate(contents))
502
458
459
503
460
def DeleteFile(contents):
504
461
"""Convenience fucntion to delete a file.
505
462
510
467
"""
511
468
return ReplaceContents(FileCreate(contents), None)
512
469
470
513
471
def ReplaceFileContents(old_tree, new_tree, file_id):
514
472
"""Convenience fucntion to replace the contents of a file.
515
473
523
481
return ReplaceContents(TreeFileCreate(old_tree, file_id),
524
482
TreeFileCreate(new_tree, file_id))
525
483
484
526
485
def CreateSymlink(target):
527
486
"""Convenience fucntion to create a symlink.
528
487
533
492
"""
534
493
return ReplaceContents(None, SymlinkCreate(target))
535
494
495
536
496
def DeleteSymlink(target):
537
497
"""Convenience fucntion to delete a symlink.
538
498
543
503
"""
544
504
return ReplaceContents(SymlinkCreate(target), None)
545
505
506
546
507
def ChangeTarget(old_target, new_target):
547
508
"""Convenience fucntion to change the target of a symlink.
548
509
586
547
msg = 'Child of !NULL is named "%s", not "./.".' % name
587
548
InvalidEntry.__init__(self, entry, msg)
588
549
550
589
551
class NullIDAssigned(InvalidEntry):
590
552
"""The id !NULL was assigned to a real entry"""
591
553
def __init__(self, entry):
597
559
msg = '"!NULL" id assigned to a file "%s".' % entry.path
598
560
InvalidEntry.__init__(self, entry, msg)
599
561
562
600
563
class ParentIDIsSelf(InvalidEntry):
601
564
"""An entry is marked as its own parent"""
602
565
def __init__(self, entry):
609
572
(entry.path, entry.id)
610
573
InvalidEntry.__init__(self, entry, msg)
611
574
575
612
576
class ChangesetEntry(object):
613
577
"""An entry the changeset"""
614
578
def __init__(self, id, parent, path):
644
608
return os.path.dirname(self.path)
645
609
646
610
def __set_dir(self, dir):
647
self.path = os.path.join(dir, os.path.basename(self.path))
611
self.path = pathjoin(dir, os.path.basename(self.path))
648
612
649
613
dir = property(__get_dir, __set_dir)
650
614
654
618
return os.path.basename(self.path)
655
619
656
620
def __set_name(self, name):
657
self.path = os.path.join(os.path.dirname(self.path), name)
621
self.path = pathjoin(os.path.dirname(self.path), name)
658
622
659
623
name = property(__get_name, __set_name)
660
624
664
628
return os.path.dirname(self.new_path)
665
629
666
630
def __set_new_dir(self, dir):
667
self.new_path = os.path.join(dir, os.path.basename(self.new_path))
631
self.new_path = pathjoin(dir, os.path.basename(self.new_path))
668
632
669
633
new_dir = property(__get_new_dir, __set_new_dir)
670
634
674
638
return os.path.basename(self.new_path)
675
639
676
640
def __set_new_name(self, name):
677
self.new_path = os.path.join(os.path.dirname(self.new_path), name)
641
self.new_path = pathjoin(os.path.dirname(self.new_path), name)
678
642
679
643
new_name = property(__get_new_name, __set_new_name)
680
644
687
651
return False
688
652
return (self.parent != self.new_parent or self.name != self.new_name)
689
653
690
def is_deletion(self, reverse):
654
def is_deletion(self, reverse=False):
691
655
"""Return true if applying the entry would delete a file/directory.
692
656
693
657
:param reverse: if true, the changeset is being applied in reverse
695
659
"""
696
660
return self.is_creation(not reverse)
697
661
698
def is_creation(self, reverse):
662
def is_creation(self, reverse=False):
699
663
"""Return true if applying the entry would create a file/directory.
700
664
701
665
:param reverse: if true, the changeset is being applied in reverse
714
678
715
679
:rtype: bool
716
680
"""
717
return self.is_creation(False) or self.is_deletion(False)
681
return self.is_creation() or self.is_deletion()
718
682
719
683
def get_cset_path(self, mod=False):
720
684
"""Determine the path of the entry according to the changeset.
740
704
return None
741
705
return self.path
742
706
743
def summarize_name(self, reverse=False):
707
def summarize_name(self):
744
708
"""Produce a one-line summary of the filename. Indicates renames as
745
709
old => new, indicates creation as None => new, indicates deletion as
746
710
old => None.
747
711
748
:param changeset: The changeset to get paths from
749
:type changeset: `Changeset`
750
:param reverse: If true, reverse the names in the output
751
:type reverse: bool
752
712
:rtype: str
753
713
"""
754
714
orig_path = self.get_cset_path(False)
760
720
if orig_path == mod_path:
761
721
return orig_path
762
722
else:
763
if not reverse:
764
return "%s => %s" % (orig_path, mod_path)
765
else:
766
return "%s => %s" % (mod_path, orig_path)
767
768
769
def get_new_path(self, id_map, changeset, reverse=False):
723
return "%s => %s" % (orig_path, mod_path)
724
725
def get_new_path(self, id_map, changeset):
770
726
"""Determine the full pathname to rename to
771
727
772
728
:param id_map: The map of ids to filenames for the tree
773
729
:type id_map: Dictionary
774
730
:param changeset: The changeset to get data from
775
731
:type changeset: `Changeset`
776
:param reverse: If true, we're applying the changeset in reverse
777
:type reverse: bool
778
732
:rtype: str
779
733
"""
780
734
mutter("Finding new path for %s", self.summarize_name())
781
if reverse:
782
parent = self.parent
783
to_dir = self.dir
784
from_dir = self.new_dir
785
to_name = self.name
786
from_name = self.new_name
787
else:
788
parent = self.new_parent
789
to_dir = self.new_dir
790
from_dir = self.dir
791
to_name = self.new_name
792
from_name = self.name
735
parent = self.new_parent
736
to_dir = self.new_dir
737
from_dir = self.dir
738
to_name = self.new_name
739
from_name = self.name
793
740
794
741
if to_name is None:
795
742
return None
804
751
dir = os.path.dirname(id_map[self.id])
805
752
else:
806
753
mutter("path, new_path: %r %r", self.path, self.new_path)
807
dir = parent_entry.get_new_path(id_map, changeset, reverse)
754
dir = parent_entry.get_new_path(id_map, changeset)
808
755
if from_name == to_name:
809
756
name = os.path.basename(id_map[self.id])
810
757
else:
811
758
name = to_name
812
759
assert(from_name is None or from_name == os.path.basename(id_map[self.id]))
813
return os.path.join(dir, name)
760
return pathjoin(dir, name)
814
761
815
762
def is_boring(self):
816
763
"""Determines whether the entry does nothing
829
776
else:
830
777
return True
831
778
832
def apply(self, filename, conflict_handler, reverse=False):
779
def apply(self, filename, conflict_handler):
833
780
"""Applies the file content and/or metadata changes.
834
781
835
782
:param filename: the filename of the entry
836
783
:type filename: str
837
:param reverse: If true, apply the changes in reverse
838
:type reverse: bool
839
784
"""
840
if self.is_deletion(reverse) and self.metadata_change is not None:
841
self.metadata_change.apply(filename, conflict_handler, reverse)
785
if self.is_deletion() and self.metadata_change is not None:
786
self.metadata_change.apply(filename, conflict_handler)
842
787
if self.contents_change is not None:
843
self.contents_change.apply(filename, conflict_handler, reverse)
844
if not self.is_deletion(reverse) and self.metadata_change is not None:
845
self.metadata_change.apply(filename, conflict_handler, reverse)
788
self.contents_change.apply(filename, conflict_handler)
789
if not self.is_deletion() and self.metadata_change is not None:
790
self.metadata_change.apply(filename, conflict_handler)
791
846
792
847
793
class IDPresent(Exception):
848
794
def __init__(self, id):
851
797
Exception.__init__(self, msg)
852
798
self.id = id
853
799
800
854
801
class Changeset(object):
855
802
"""A set of changes to apply"""
856
803
def __init__(self):
862
809
raise IDPresent(entry.id)
863
810
self.entries[entry.id] = entry
864
811
865
def my_sort(sequence, key, reverse=False):
866
"""A sort function that supports supplying a key for comparison
867
868
:param sequence: The sequence to sort
869
:param key: A callable object that returns the values to be compared
870
:param reverse: If true, sort in reverse order
871
:type reverse: bool
872
"""
873
def cmp_by_key(entry_a, entry_b):
874
if reverse:
875
tmp=entry_a
876
entry_a = entry_b
877
entry_b = tmp
878
return cmp(key(entry_a), key(entry_b))
879
sequence.sort(cmp_by_key)
880
812
881
def get_rename_entries(changeset, inventory, reverse):
813
def get_rename_entries(changeset, inventory):
882
814
"""Return a list of entries that will be renamed. Entries are sorted from
883
815
longest to shortest source path and from shortest to longest target path.
884
816
886
818
:type changeset: `Changeset`
887
819
:param inventory: The source of current tree paths for the given ids
888
820
:type inventory: Dictionary
889
:param reverse: If true, the changeset is being applied in reverse
890
:type reverse: bool
891
821
:return: source entries and target entries as a tuple
892
822
:rtype: (List, List)
893
823
"""
901
831
return 0
902
832
else:
903
833
return len(path)
904
my_sort(source_entries, longest_to_shortest, reverse=True)
834
source_entries.sort(None, longest_to_shortest, True)
905
835
906
836
target_entries = source_entries[:]
907
837
# These are done from shortest to longest path, to avoid creating a
908
838
# child before its parent has been created/renamed
909
839
def shortest_to_longest(entry):
910
path = entry.get_new_path(inventory, changeset, reverse)
840
path = entry.get_new_path(inventory, changeset)
911
841
if path is None:
912
842
return 0
913
843
else:
914
844
return len(path)
915
my_sort(target_entries, shortest_to_longest)
845
target_entries.sort(None, shortest_to_longest)
916
846
return (source_entries, target_entries)
917
847
848
918
849
def rename_to_temp_delete(source_entries, inventory, dir, temp_dir,
919
conflict_handler, reverse):
850
conflict_handler):
920
851
"""Delete and rename entries as appropriate. Entries are renamed to temp
921
852
names. A map of id -> temp name (or None, for deletions) is returned.
922
853
926
857
:type inventory: Dictionary
927
858
:param dir: The directory to apply changes to
928
859
:type dir: str
929
:param reverse: Apply changes in reverse
930
:type reverse: bool
931
860
:return: a mapping of id to temporary name
932
861
:rtype: Dictionary
933
862
"""
934
863
temp_name = {}
935
864
for i in range(len(source_entries)):
936
865
entry = source_entries[i]
937
if entry.is_deletion(reverse):
938
path = os.path.join(dir, inventory[entry.id])
939
entry.apply(path, conflict_handler, reverse)
866
if entry.is_deletion():
867
path = pathjoin(dir, inventory[entry.id])
868
entry.apply(path, conflict_handler)
940
869
temp_name[entry.id] = None
941
870
942
871
elif entry.needs_rename():
943
if entry.is_creation(reverse):
872
if entry.is_creation():
944
873
continue
945
to_name = os.path.join(temp_dir, str(i))
874
to_name = pathjoin(temp_dir, str(i))
946
875
src_path = inventory.get(entry.id)
947
876
if src_path is not None:
948
src_path = os.path.join(dir, src_path)
877
src_path = pathjoin(dir, src_path)
949
878
try:
950
879
rename(src_path, to_name)
951
880
temp_name[entry.id] = to_name
960
889
961
890
962
891
def rename_to_new_create(changed_inventory, target_entries, inventory,
963
changeset, dir, conflict_handler, reverse):
892
changeset, dir, conflict_handler):
964
893
"""Rename entries with temp names to their final names, create new files.
965
894
966
895
:param changed_inventory: A mapping of id to temporary name
971
900
:type changeset: `Changeset`
972
901
:param dir: The directory to apply changes to
973
902
:type dir: str
974
:param reverse: If true, apply changes in reverse
975
:type reverse: bool
976
903
"""
977
904
for entry in target_entries:
978
new_tree_path = entry.get_new_path(inventory, changeset, reverse)
905
new_tree_path = entry.get_new_path(inventory, changeset)
979
906
if new_tree_path is None:
980
907
continue
981
new_path = os.path.join(dir, new_tree_path)
908
new_path = pathjoin(dir, new_tree_path)
982
909
old_path = changed_inventory.get(entry.id)
983
910
if bzrlib.osutils.lexists(new_path):
984
911
if conflict_handler.target_exists(entry, new_path, old_path) == \
985
912
"skip":
986
913
continue
987
if entry.is_creation(reverse):
988
entry.apply(new_path, conflict_handler, reverse)
914
if entry.is_creation():
915
entry.apply(new_path, conflict_handler)
989
916
changed_inventory[entry.id] = new_tree_path
990
917
elif entry.needs_rename():
991
if entry.is_deletion(reverse):
918
if entry.is_deletion():
992
919
continue
993
920
if old_path is None:
994
921
continue
1000
927
raise BzrCheckError('failed to rename %s to %s for changeset entry %s: %s'
1001
928
% (old_path, new_path, entry, e))
1002
929
930
1003
931
class TargetExists(Exception):
1004
932
def __init__(self, entry, target):
1005
933
msg = "The path %s already exists" % target
1007
935
self.entry = entry
1008
936
self.target = target
1009
937
938
1010
939
class RenameConflict(Exception):
1011
940
def __init__(self, id, this_name, base_name, other_name):
1012
941
msg = """Trees all have different names for a file
1019
948
self.base_name = base_name
1020
949
self_other_name = other_name
1021
950
951
1022
952
class MoveConflict(Exception):
1023
953
def __init__(self, id, this_parent, base_parent, other_parent):
1024
954
msg = """The file is in different directories in every tree
1031
961
self.base_parent = base_parent
1032
962
self_other_parent = other_parent
1033
963
964
1034
965
class MergeConflict(Exception):
1035
966
def __init__(self, this_path):
1036
967
Exception.__init__(self, "Conflict applying changes to %s" % this_path)
1037
968
self.this_path = this_path
1038
969
970
1039
971
class WrongOldContents(Exception):
1040
972
def __init__(self, filename):
1041
973
msg = "Contents mismatch deleting %s" % filename
1042
974
self.filename = filename
1043
975
Exception.__init__(self, msg)
1044
976
977
1045
978
class WrongOldExecFlag(Exception):
1046
979
def __init__(self, filename, old_exec_flag, new_exec_flag):
1047
980
msg = "Executable flag missmatch on %s:\n" \
1049
982
self.filename = filename
1050
983
Exception.__init__(self, msg)
1051
984
985
1052
986
class RemoveContentsConflict(Exception):
1053
987
def __init__(self, filename):
1054
988
msg = "Conflict deleting %s, which has different contents in BASE"\
1056
990
self.filename = filename
1057
991
Exception.__init__(self, msg)
1058
992
993
1059
994
class DeletingNonEmptyDirectory(Exception):
1060
995
def __init__(self, filename):
1061
996
msg = "Trying to remove dir %s while it still had files" % filename
1069
1004
Exception.__init__(self, msg)
1070
1005
self.filename = filename
1071
1006
1007
1072
1008
class MissingForSetExec(Exception):
1073
1009
def __init__(self, filename):
1074
1010
msg = "Attempt to change permissions on %s, which does not exist" %\
1076
1012
Exception.__init__(self, msg)
1077
1013
self.filename = filename
1078
1014
1015
1079
1016
class MissingForRm(Exception):
1080
1017
def __init__(self, filename):
1081
1018
msg = "Attempt to remove missing path %s" % filename
1089
1026
Exception.__init__(self, msg)
1090
1027
self.filename = filename
1091
1028
1029
1092
1030
class NewContentsConflict(Exception):
1093
1031
def __init__(self, filename):
1094
1032
msg = "Conflicting contents for new file %s" % (filename)
1095
1033
Exception.__init__(self, msg)
1096
1034
1035
1097
1036
class WeaveMergeConflict(Exception):
1098
1037
def __init__(self, filename):
1099
1038
msg = "Conflicting contents for file %s" % (filename)
1100
1039
Exception.__init__(self, msg)
1101
1040
1041
1102
1042
class ThreewayContentsConflict(Exception):
1103
1043
def __init__(self, filename):
1104
1044
msg = "Conflicting contents for file %s" % (filename)
1185
1125
def finalize(self):
1186
1126
pass
1187
1127
1188
def apply_changeset(changeset, inventory, dir, conflict_handler=None,
1189
reverse=False):
1128
1129
def apply_changeset(changeset, inventory, dir, conflict_handler=None):
1190
1130
"""Apply a changeset to a directory.
1191
1131
1192
1132
:param changeset: The changes to perform
1195
1135
:type inventory: Dictionary
1196
1136
:param dir: The path of the directory to apply the changes to
1197
1137
:type dir: str
1198
:param reverse: If true, apply the changes in reverse
1199
:type reverse: bool
1200
1138
:return: The mapping of the changed entries
1201
1139
:rtype: Dictionary
1202
1140
"""
1203
1141
if conflict_handler is None:
1204
1142
conflict_handler = ExceptionConflictHandler()
1205
temp_dir = os.path.join(dir, "bzr-tree-change")
1143
temp_dir = pathjoin(dir, "bzr-tree-change")
1206
1144
try:
1207
1145
os.mkdir(temp_dir)
1208
1146
except OSError, e:
1223
1161
warning("entry {%s} no longer present, can't be updated",
1224
1162
entry.id)
1225
1163
continue
1226
path = os.path.join(dir, inventory[entry.id])
1227
entry.apply(path, conflict_handler, reverse)
1164
path = pathjoin(dir, inventory[entry.id])
1165
entry.apply(path, conflict_handler)
1228
1166
1229
1167
# Apply renames in stages, to minimize conflicts:
1230
1168
# Only files whose name or parent change are interesting, because their
1231
1169
# target name may exist in the source tree. If a directory's name changes,
1232
1170
# that doesn't make its children interesting.
1233
(source_entries, target_entries) = get_rename_entries(changeset, inventory,
1234
reverse)
1171
(source_entries, target_entries) = get_rename_entries(changeset, inventory)
1235
1172
1236
1173
changed_inventory = rename_to_temp_delete(source_entries, inventory, dir,
1237
temp_dir, conflict_handler,
1238
reverse)
1174
temp_dir, conflict_handler)
1239
1175
1240
1176
rename_to_new_create(changed_inventory, target_entries, inventory,
1241
changeset, dir, conflict_handler, reverse)
1177
changeset, dir, conflict_handler)
1242
1178
os.rmdir(temp_dir)
1243
1179
return changed_inventory
1244
1180
1245
1181
1246
def apply_changeset_tree(cset, tree, reverse=False):
1182
def apply_changeset_tree(cset, tree):
1247
1183
r_inventory = {}
1248
1184
for entry in tree.source_inventory().itervalues():
1249
1185
inventory[entry.id] = entry.path
1250
new_inventory = apply_changeset(cset, r_inventory, tree.basedir,
1251
reverse=reverse)
1186
new_inventory = apply_changeset(cset, r_inventory, tree.basedir)
1252
1187
new_entries, remove_entries = \
1253
get_inventory_change(inventory, new_inventory, cset, reverse)
1188
get_inventory_change(inventory, new_inventory, cset)
1254
1189
tree.update_source_inventory(new_entries, remove_entries)
1255
1190
1256
1191
1257
def get_inventory_change(inventory, new_inventory, cset, reverse=False):
1192
def get_inventory_change(inventory, new_inventory, cset):
1258
1193
new_entries = {}
1259
1194
remove_entries = []
1260
1195
for entry in cset.entries.itervalues():
1279
1214
print entry.id
1280
1215
print entry.summarize_name(cset)
1281
1216
1282
class CompositionFailure(Exception):
1283
def __init__(self, old_entry, new_entry, problem):
1284
msg = "Unable to conpose entries.\n %s" % problem
1285
Exception.__init__(self, msg)
1286
1287
class IDMismatch(CompositionFailure):
1288
def __init__(self, old_entry, new_entry):
1289
problem = "Attempt to compose entries with different ids: %s and %s" %\
1290
(old_entry.id, new_entry.id)
1291
CompositionFailure.__init__(self, old_entry, new_entry, problem)
1292
1293
def compose_changesets(old_cset, new_cset):
1294
"""Combine two changesets into one. This works well for exact patching.
1295
Otherwise, not so well.
1296
1297
:param old_cset: The first changeset that would be applied
1298
:type old_cset: `Changeset`
1299
:param new_cset: The second changeset that would be applied
1300
:type new_cset: `Changeset`
1301
:return: A changeset that combines the changes in both changesets
1302
:rtype: `Changeset`
1303
"""
1304
composed = Changeset()
1305
for old_entry in old_cset.entries.itervalues():
1306
new_entry = new_cset.entries.get(old_entry.id)
1307
if new_entry is None:
1308
composed.add_entry(old_entry)
1309
else:
1310
composed_entry = compose_entries(old_entry, new_entry)
1311
if composed_entry.parent is not None or\
1312
composed_entry.new_parent is not None:
1313
composed.add_entry(composed_entry)
1314
for new_entry in new_cset.entries.itervalues():
1315
if not old_cset.entries.has_key(new_entry.id):
1316
composed.add_entry(new_entry)
1317
return composed
1318
1319
def compose_entries(old_entry, new_entry):
1320
"""Combine two entries into one.
1321
1322
:param old_entry: The first entry that would be applied
1323
:type old_entry: ChangesetEntry
1324
:param old_entry: The second entry that would be applied
1325
:type old_entry: ChangesetEntry
1326
:return: A changeset entry combining both entries
1327
:rtype: `ChangesetEntry`
1328
"""
1329
if old_entry.id != new_entry.id:
1330
raise IDMismatch(old_entry, new_entry)
1331
output = ChangesetEntry(old_entry.id, old_entry.parent, old_entry.path)
1332
1333
if (old_entry.parent != old_entry.new_parent or
1334
new_entry.parent != new_entry.new_parent):
1335
output.new_parent = new_entry.new_parent
1336
1337
if (old_entry.path != old_entry.new_path or
1338
new_entry.path != new_entry.new_path):
1339
output.new_path = new_entry.new_path
1340
1341
output.contents_change = compose_contents(old_entry, new_entry)
1342
output.metadata_change = compose_metadata(old_entry, new_entry)
1343
return output
1344
1345
def compose_contents(old_entry, new_entry):
1346
"""Combine the contents of two changeset entries. Entries are combined
1347
intelligently where possible, but the fallback behavior returns an
1348
ApplySequence.
1349
1350
:param old_entry: The first entry that would be applied
1351
:type old_entry: `ChangesetEntry`
1352
:param new_entry: The second entry that would be applied
1353
:type new_entry: `ChangesetEntry`
1354
:return: A combined contents change
1355
:rtype: anything supporting the apply(reverse=False) method
1356
"""
1357
old_contents = old_entry.contents_change
1358
new_contents = new_entry.contents_change
1359
if old_entry.contents_change is None:
1360
return new_entry.contents_change
1361
elif new_entry.contents_change is None:
1362
return old_entry.contents_change
1363
elif isinstance(old_contents, ReplaceContents) and \
1364
isinstance(new_contents, ReplaceContents):
1365
if old_contents.old_contents == new_contents.new_contents:
1366
return None
1367
else:
1368
return ReplaceContents(old_contents.old_contents,
1369
new_contents.new_contents)
1370
elif isinstance(old_contents, ApplySequence):
1371
output = ApplySequence(old_contents.changes)
1372
if isinstance(new_contents, ApplySequence):
1373
output.changes.extend(new_contents.changes)
1374
else:
1375
output.changes.append(new_contents)
1376
return output
1377
elif isinstance(new_contents, ApplySequence):
1378
output = ApplySequence((old_contents.changes,))
1379
output.extend(new_contents.changes)
1380
return output
1381
else:
1382
return ApplySequence((old_contents, new_contents))
1383
1384
def compose_metadata(old_entry, new_entry):
1385
old_meta = old_entry.metadata_change
1386
new_meta = new_entry.metadata_change
1387
if old_meta is None:
1388
return new_meta
1389
elif new_meta is None:
1390
return old_meta
1391
elif (isinstance(old_meta, ChangeExecFlag) and
1392
isinstance(new_meta, ChangeExecFlag)):
1393
return ChangeExecFlag(old_meta.old_exec_flag, new_meta.new_exec_flag)
1394
else:
1395
return ApplySequence(old_meta, new_meta)
1396
1397
1398
def changeset_is_null(changeset):
1399
for entry in changeset.entries.itervalues():
1400
if not entry.is_boring():
1401
return False
1402
return True
1403
1217
1404
1218
class UnsupportedFiletype(Exception):
1405
1219
def __init__(self, kind, full_path):
1409
1223
self.full_path = full_path
1410
1224
self.kind = kind
1411
1225
1226
1412
1227
def generate_changeset(tree_a, tree_b, interesting_ids=None):
1413
1228
return ChangesetGenerator(tree_a, tree_b, interesting_ids)()
1414
1229
1503
1318
return self.make_entry(id, only_interesting=False)
1504
1319
else:
1505
1320
return cs_entry
1506
1507
1321
1508
1322
def make_entry(self, id, only_interesting=True):
1509
1323
cs_entry = self.make_basic_entry(id, only_interesting)
1558
1372
1559
1373
1560
1374
def full_path(entry, tree):
1561
return os.path.join(tree.basedir, entry.path)
1375
return pathjoin(tree.basedir, entry.path)
1376
1562
1377
1563
1378
def new_delete_entry(entry, tree, inventory, delete):
1564
1379
if entry.path == "":
1576
1391
status = os.lstat(full_path)
1577
1392
if stat.S_ISDIR(file_stat.st_mode):
1578
1393
action = dir_create
1579
1580
1581
1582
1394
1395
1583
1396
# XXX: Can't we unify this with the regular inventory object
1584
1397
class Inventory(object):
1585
1398
def __init__(self, inventory):
1618
1431
if directory is None:
1619
1432
return NULL_ID
1620
1433
return self.get_rinventory().get(directory)
1434
1435
Loggerhead is a web-based interface for Breezy
Version: 2.0.1