« back to all changes in this revision
Viewing changes to bzrlib/changeset.py
- browse files at revision 856
- compare with another revision
- download diff
- download tarball
- view history from revision 856
- Committer: Martin Pool
- Date: 2005-07-07 10:31:36 UTC
- Revision ID: mbp@sourcefrog.net-20050707103135-9b4d911d8df6e880
- fix pwk help
- files added:
- bzrlib/meta_store.py
- plugins/changeset
- files removed:
- HACKING
- bzrlib/store
- bzrlib/transport
- bzrlib/util
- contrib/emacs
- files renamed:
- contrib/newinventory.py => bzrlib/newinventory.py
- bzrlib/store/__init__.py => bzrlib/store.py
- bzrlib/util/effbot/ => effbot/
- bzrlib/util/elementtree/ => elementtree/
- bzrlib/plugins/ => plugins/
- bzrlib/selftest/test_weave.py => tools/testweave.py
- bzrlib/util/urlgrabber/ => urlgrabber/
- files modified:
- .bzrignore
- bzr *
added
removed
bzrlib/changeset.py
17
17
import errno
18
18
import patch
19
19
import stat
20
from tempfile import mkdtemp
21
from shutil import rmtree
22
from bzrlib.trace import mutter
23
from bzrlib.osutils import rename, sha_file
24
import bzrlib
25
from itertools import izip
26
27
# XXX: mbp: I'm not totally convinced that we should handle conflicts
28
# as part of changeset application, rather than only in the merge
29
# operation.
30
31
"""Represent and apply a changeset
32
33
Conflicts in applying a changeset are represented as exceptions.
34
"""
35
20
"""
21
Represent and apply a changeset
22
"""
36
23
__docformat__ = "restructuredtext"
37
24
38
25
NULL_ID = "!NULL"
47
34
newdict[value] = key
48
35
return newdict
49
36
50
51
class ChangeExecFlag(object):
37
38
class PatchApply(object):
39
"""Patch application as a kind of content change"""
40
def __init__(self, contents):
41
"""Constructor.
42
43
:param contents: The text of the patch to apply
44
:type contents: str"""
45
self.contents = contents
46
47
def __eq__(self, other):
48
if not isinstance(other, PatchApply):
49
return False
50
elif self.contents != other.contents:
51
return False
52
else:
53
return True
54
55
def __ne__(self, other):
56
return not (self == other)
57
58
def apply(self, filename, conflict_handler, reverse=False):
59
"""Applies the patch to the specified file.
60
61
:param filename: the file to apply the patch to
62
:type filename: str
63
:param reverse: If true, apply the patch in reverse
64
:type reverse: bool
65
"""
66
input_name = filename+".orig"
67
try:
68
os.rename(filename, input_name)
69
except OSError, e:
70
if e.errno != errno.ENOENT:
71
raise
72
if conflict_handler.patch_target_missing(filename, self.contents)\
73
== "skip":
74
return
75
os.rename(filename, input_name)
76
77
78
status = patch.patch(self.contents, input_name, filename,
79
reverse)
80
os.chmod(filename, os.stat(input_name).st_mode)
81
if status == 0:
82
os.unlink(input_name)
83
elif status == 1:
84
conflict_handler.failed_hunks(filename)
85
86
87
class ChangeUnixPermissions(object):
52
88
"""This is two-way change, suitable for file modification, creation,
53
89
deletion"""
54
def __init__(self, old_exec_flag, new_exec_flag):
55
self.old_exec_flag = old_exec_flag
56
self.new_exec_flag = new_exec_flag
90
def __init__(self, old_mode, new_mode):
91
self.old_mode = old_mode
92
self.new_mode = new_mode
57
93
58
94
def apply(self, filename, conflict_handler, reverse=False):
59
95
if not reverse:
60
from_exec_flag = self.old_exec_flag
61
to_exec_flag = self.new_exec_flag
96
from_mode = self.old_mode
97
to_mode = self.new_mode
62
98
else:
63
from_exec_flag = self.new_exec_flag
64
to_exec_flag = self.old_exec_flag
99
from_mode = self.new_mode
100
to_mode = self.old_mode
65
101
try:
66
current_exec_flag = bool(os.stat(filename).st_mode & 0111)
102
current_mode = os.stat(filename).st_mode &0777
67
103
except OSError, e:
68
104
if e.errno == errno.ENOENT:
69
if conflict_handler.missing_for_exec_flag(filename) == "skip":
105
if conflict_handler.missing_for_chmod(filename) == "skip":
70
106
return
71
107
else:
72
current_exec_flag = from_exec_flag
108
current_mode = from_mode
73
109
74
if from_exec_flag is not None and current_exec_flag != from_exec_flag:
75
if conflict_handler.wrong_old_exec_flag(filename,
76
from_exec_flag, current_exec_flag) != "continue":
110
if from_mode is not None and current_mode != from_mode:
111
if conflict_handler.wrong_old_perms(filename, from_mode,
112
current_mode) != "continue":
77
113
return
78
114
79
if to_exec_flag is not None:
80
current_mode = os.stat(filename).st_mode
81
if to_exec_flag:
82
umask = os.umask(0)
83
os.umask(umask)
84
to_mode = current_mode | (0100 & ~umask)
85
# Enable x-bit for others only if they can read it.
86
if current_mode & 0004:
87
to_mode |= 0001 & ~umask
88
if current_mode & 0040:
89
to_mode |= 0010 & ~umask
90
else:
91
to_mode = current_mode & ~0111
115
if to_mode is not None:
92
116
try:
93
117
os.chmod(filename, to_mode)
94
118
except IOError, e:
95
119
if e.errno == errno.ENOENT:
96
conflict_handler.missing_for_exec_flag(filename)
120
conflict_handler.missing_for_chmod(filename)
97
121
98
122
def __eq__(self, other):
99
return (isinstance(other, ChangeExecFlag) and
100
self.old_exec_flag == other.old_exec_flag and
101
self.new_exec_flag == other.new_exec_flag)
123
if not isinstance(other, ChangeUnixPermissions):
124
return False
125
elif self.old_mode != other.old_mode:
126
return False
127
elif self.new_mode != other.new_mode:
128
return False
129
else:
130
return True
102
131
103
132
def __ne__(self, other):
104
133
return not (self == other)
105
134
106
107
135
def dir_create(filename, conflict_handler, reverse):
108
136
"""Creates the directory, or deletes it if reverse is true. Intended to be
109
137
used with ReplaceContents.
129
157
try:
130
158
os.rmdir(filename)
131
159
except OSError, e:
132
if e.errno != errno.ENOTEMPTY:
160
if e.errno != 39:
133
161
raise
134
162
if conflict_handler.rmdir_non_empty(filename) == "skip":
135
163
return
136
164
os.rmdir(filename)
137
165
166
167
138
168
139
169
class SymlinkCreate(object):
140
170
"""Creates or deletes a symlink (for use with ReplaceContents)"""
146
176
"""
147
177
self.target = contents
148
178
149
def __repr__(self):
150
return "SymlinkCreate(%s)" % self.target
151
152
179
def __call__(self, filename, conflict_handler, reverse):
153
180
"""Creates or destroys the symlink.
154
181
236
263
237
264
238
265
239
class TreeFileCreate(object):
240
"""Create or delete a file (for use with ReplaceContents)"""
241
def __init__(self, tree, file_id):
242
"""Constructor
243
244
:param contents: The contents of the file to write
245
:type contents: str
246
"""
247
self.tree = tree
248
self.file_id = file_id
249
250
def __repr__(self):
251
return "TreeFileCreate(%s)" % self.file_id
252
253
def __eq__(self, other):
254
if not isinstance(other, TreeFileCreate):
255
return False
256
return self.tree.get_file_sha1(self.file_id) == \
257
other.tree.get_file_sha1(other.file_id)
258
259
def __ne__(self, other):
260
return not (self == other)
261
262
def write_file(self, filename):
263
outfile = file(filename, "wb")
264
for line in self.tree.get_file(self.file_id):
265
outfile.write(line)
266
267
def same_text(self, filename):
268
in_file = file(filename, "rb")
269
return sha_file(in_file) == self.tree.get_file_sha1(self.file_id)
270
271
def __call__(self, filename, conflict_handler, reverse):
272
"""Create or delete a file
273
274
:param filename: The name of the file to create
275
:type filename: str
276
:param reverse: Delete the file instead of creating it
277
:type reverse: bool
278
"""
279
if not reverse:
280
try:
281
self.write_file(filename)
282
except IOError, e:
283
if e.errno == errno.ENOENT:
284
if conflict_handler.missing_parent(filename)=="continue":
285
self.write_file(filename)
286
else:
287
raise
288
289
else:
290
try:
291
if not self.same_text(filename):
292
direction = conflict_handler.wrong_old_contents(filename,
293
self.tree.get_file(self.file_id).read())
294
if direction != "continue":
295
return
296
os.unlink(filename)
297
except IOError, e:
298
if e.errno != errno.ENOENT:
299
raise
300
if conflict_handler.missing_for_rm(filename, undo) == "skip":
301
return
302
303
304
305
266
def reversed(sequence):
306
267
max = len(sequence) - 1
307
268
for i in range(len(sequence)):
374
335
if mode is not None:
375
336
os.chmod(filename, mode)
376
337
377
def is_creation(self):
378
return self.new_contents is not None and self.old_contents is None
379
380
def is_deletion(self):
381
return self.old_contents is not None and self.new_contents is None
382
383
338
class ApplySequence(object):
384
339
def __init__(self, changes=None):
385
340
self.changes = []
411
366
412
367
413
368
class Diff3Merge(object):
414
def __init__(self, file_id, base, other):
415
self.file_id = file_id
416
self.base = base
417
self.other = other
418
419
def is_creation(self):
420
return False
421
422
def is_deletion(self):
423
return False
369
def __init__(self, base_file, other_file):
370
self.base_file = base_file
371
self.other_file = other_file
424
372
425
373
def __eq__(self, other):
426
374
if not isinstance(other, Diff3Merge):
427
375
return False
428
return (self.base == other.base and
429
self.other == other.other and self.file_id == other.file_id)
376
return (self.base_file == other.base_file and
377
self.other_file == other.other_file)
430
378
431
379
def __ne__(self, other):
432
380
return not (self == other)
433
381
434
def dump_file(self, temp_dir, name, tree):
435
out_path = os.path.join(temp_dir, name)
436
out_file = file(out_path, "wb")
437
in_file = tree.get_file(self.file_id)
438
for line in in_file:
439
out_file.write(line)
440
return out_path
441
442
382
def apply(self, filename, conflict_handler, reverse=False):
443
temp_dir = mkdtemp(prefix="bzr-")
444
try:
445
new_file = filename+".new"
446
base_file = self.dump_file(temp_dir, "base", self.base)
447
other_file = self.dump_file(temp_dir, "other", self.other)
448
if not reverse:
449
base = base_file
450
other = other_file
451
else:
452
base = other_file
453
other = base_file
454
status = patch.diff3(new_file, filename, base, other)
455
if status == 0:
456
os.chmod(new_file, os.stat(filename).st_mode)
457
rename(new_file, filename)
458
return
459
else:
460
assert(status == 1)
461
def get_lines(filename):
462
my_file = file(filename, "rb")
463
lines = my_file.readlines()
464
my_file.close()
465
return lines
466
base_lines = get_lines(base)
467
other_lines = get_lines(other)
468
conflict_handler.merge_conflict(new_file, filename, base_lines,
469
other_lines)
470
finally:
471
rmtree(temp_dir)
383
new_file = filename+".new"
384
if not reverse:
385
base = self.base_file
386
other = self.other_file
387
else:
388
base = self.other_file
389
other = self.base_file
390
status = patch.diff3(new_file, filename, base, other)
391
if status == 0:
392
os.chmod(new_file, os.stat(filename).st_mode)
393
os.rename(new_file, filename)
394
return
395
else:
396
assert(status == 1)
397
conflict_handler.merge_conflict(new_file, filename, base, other)
472
398
473
399
474
400
def CreateDir():
507
433
"""
508
434
return ReplaceContents(FileCreate(contents), None)
509
435
510
def ReplaceFileContents(old_tree, new_tree, file_id):
436
def ReplaceFileContents(old_contents, new_contents):
511
437
"""Convenience fucntion to replace the contents of a file.
512
438
513
439
:param old_contents: The contents of the file to replace
517
443
:return: A ReplaceContents that will replace the contents of a file a file
518
444
:rtype: `ReplaceContents`
519
445
"""
520
return ReplaceContents(TreeFileCreate(old_tree, file_id),
521
TreeFileCreate(new_tree, file_id))
446
return ReplaceContents(FileCreate(old_contents), FileCreate(new_contents))
522
447
523
448
def CreateSymlink(target):
524
449
"""Convenience fucntion to create a symlink.
687
612
:param reverse: if true, the changeset is being applied in reverse
688
613
:rtype: bool
689
614
"""
690
return self.is_creation(not reverse)
615
return ((self.new_parent is None and not reverse) or
616
(self.parent is None and reverse))
691
617
692
618
def is_creation(self, reverse):
693
619
"""Return true if applying the entry would create a file/directory.
695
621
:param reverse: if true, the changeset is being applied in reverse
696
622
:rtype: bool
697
623
"""
698
if self.contents_change is None:
699
return False
700
if reverse:
701
return self.contents_change.is_deletion()
702
else:
703
return self.contents_change.is_creation()
624
return ((self.parent is None and not reverse) or
625
(self.new_parent is None and reverse))
704
626
705
627
def is_creation_or_deletion(self):
706
628
"""Return true if applying the entry would create or delete a
708
630
709
631
:rtype: bool
710
632
"""
711
return self.is_creation(False) or self.is_deletion(False)
633
return self.parent is None or self.new_parent is None
712
634
713
635
def get_cset_path(self, mod=False):
714
636
"""Determine the path of the entry according to the changeset.
734
656
return None
735
657
return self.path
736
658
737
def summarize_name(self, reverse=False):
659
def summarize_name(self, changeset, reverse=False):
738
660
"""Produce a one-line summary of the filename. Indicates renames as
739
661
old => new, indicates creation as None => new, indicates deletion as
740
662
old => None.
771
693
:type reverse: bool
772
694
:rtype: str
773
695
"""
774
mutter("Finding new path for %s" % self.summarize_name())
775
696
if reverse:
776
697
parent = self.parent
777
698
to_dir = self.dir
796
717
if from_dir == to_dir:
797
718
dir = os.path.dirname(id_map[self.id])
798
719
else:
799
mutter("path, new_path: %r %r" % (self.path, self.new_path))
800
720
parent_entry = changeset.entries[parent]
801
721
dir = parent_entry.get_new_path(id_map, changeset, reverse)
802
722
if from_name == to_name:
886
806
:rtype: (List, List)
887
807
"""
888
808
source_entries = [x for x in changeset.entries.itervalues()
889
if x.needs_rename() or x.is_creation_or_deletion()]
809
if x.needs_rename()]
890
810
# these are done from longest path to shortest, to avoid deleting a
891
811
# parent before its children are deleted/renamed
892
812
def longest_to_shortest(entry):
933
853
entry.apply(path, conflict_handler, reverse)
934
854
temp_name[entry.id] = None
935
855
936
elif entry.needs_rename():
856
else:
937
857
to_name = os.path.join(temp_dir, str(i))
938
858
src_path = inventory.get(entry.id)
939
859
if src_path is not None:
940
860
src_path = os.path.join(dir, src_path)
941
861
try:
942
rename(src_path, to_name)
862
os.rename(src_path, to_name)
943
863
temp_name[entry.id] = to_name
944
864
except OSError, e:
945
865
if e.errno != errno.ENOENT:
946
866
raise
947
if conflict_handler.missing_for_rename(src_path, to_name) \
948
== "skip":
867
if conflict_handler.missing_for_rename(src_path) == "skip":
949
868
continue
950
869
951
870
return temp_name
972
891
continue
973
892
new_path = os.path.join(dir, new_tree_path)
974
893
old_path = changed_inventory.get(entry.id)
975
if bzrlib.osutils.lexists(new_path):
894
if os.path.exists(new_path):
976
895
if conflict_handler.target_exists(entry, new_path, old_path) == \
977
896
"skip":
978
897
continue
979
898
if entry.is_creation(reverse):
980
899
entry.apply(new_path, conflict_handler, reverse)
981
900
changed_inventory[entry.id] = new_tree_path
982
elif entry.needs_rename():
901
else:
983
902
if old_path is None:
984
903
continue
985
904
try:
986
rename(old_path, new_path)
905
os.rename(old_path, new_path)
987
906
changed_inventory[entry.id] = new_tree_path
988
907
except OSError, e:
989
908
raise Exception ("%s is missing" % new_path)
1024
943
Exception.__init__(self, "Conflict applying changes to %s" % this_path)
1025
944
self.this_path = this_path
1026
945
946
class MergePermissionConflict(Exception):
947
def __init__(self, this_path, base_path, other_path):
948
this_perms = os.stat(this_path).st_mode & 0755
949
base_perms = os.stat(base_path).st_mode & 0755
950
other_perms = os.stat(other_path).st_mode & 0755
951
msg = """Conflicting permission for %s
952
this: %o
953
base: %o
954
other: %o
955
""" % (this_path, this_perms, base_perms, other_perms)
956
self.this_path = this_path
957
self.base_path = base_path
958
self.other_path = other_path
959
Exception.__init__(self, msg)
960
1027
961
class WrongOldContents(Exception):
1028
962
def __init__(self, filename):
1029
963
msg = "Contents mismatch deleting %s" % filename
1030
964
self.filename = filename
1031
965
Exception.__init__(self, msg)
1032
966
1033
class WrongOldExecFlag(Exception):
1034
def __init__(self, filename, old_exec_flag, new_exec_flag):
1035
msg = "Executable flag missmatch on %s:\n" \
1036
"Expected %s, got %s." % (filename, old_exec_flag, new_exec_flag)
967
class WrongOldPermissions(Exception):
968
def __init__(self, filename, old_perms, new_perms):
969
msg = "Permission missmatch on %s:\n" \
970
"Expected 0%o, got 0%o." % (filename, old_perms, new_perms)
1037
971
self.filename = filename
1038
972
Exception.__init__(self, msg)
1039
973
1057
991
Exception.__init__(self, msg)
1058
992
self.filename = filename
1059
993
1060
class MissingForSetExec(Exception):
994
class MissingPermsFile(Exception):
1061
995
def __init__(self, filename):
1062
996
msg = "Attempt to change permissions on %s, which does not exist" %\
1063
997
filename
1072
1006
1073
1007
1074
1008
class MissingForRename(Exception):
1075
def __init__(self, filename, to_path):
1076
msg = "Attempt to move missing path %s to %s" % (filename, to_path)
1009
def __init__(self, filename):
1010
msg = "Attempt to move missing path %s" % (filename)
1077
1011
Exception.__init__(self, msg)
1078
1012
self.filename = filename
1079
1013
1082
1016
msg = "Conflicting contents for new file %s" % (filename)
1083
1017
Exception.__init__(self, msg)
1084
1018
1085
class ThreewayContentsConflict(Exception):
1086
def __init__(self, filename):
1087
msg = "Conflicting contents for file %s" % (filename)
1088
Exception.__init__(self, msg)
1089
1090
1019
1091
1020
class MissingForMerge(Exception):
1092
1021
def __init__(self, filename):
1096
1025
1097
1026
1098
1027
class ExceptionConflictHandler(object):
1099
"""Default handler for merge exceptions.
1100
1101
This throws an error on any kind of conflict. Conflict handlers can
1102
descend from this class if they have a better way to handle some or
1103
all types of conflict.
1104
"""
1028
def __init__(self, dir):
1029
self.dir = dir
1030
1105
1031
def missing_parent(self, pathname):
1106
1032
parent = os.path.dirname(pathname)
1107
1033
raise Exception("Parent directory missing for %s" % pathname)
1118
1044
def rename_conflict(self, id, this_name, base_name, other_name):
1119
1045
raise RenameConflict(id, this_name, base_name, other_name)
1120
1046
1121
def move_conflict(self, id, this_dir, base_dir, other_dir):
1047
def move_conflict(self, id, inventory):
1048
this_dir = inventory.this.get_dir(id)
1049
base_dir = inventory.base.get_dir(id)
1050
other_dir = inventory.other.get_dir(id)
1122
1051
raise MoveConflict(id, this_dir, base_dir, other_dir)
1123
1052
1124
def merge_conflict(self, new_file, this_path, base_lines, other_lines):
1053
def merge_conflict(self, new_file, this_path, base_path, other_path):
1125
1054
os.unlink(new_file)
1126
1055
raise MergeConflict(this_path)
1127
1056
1057
def permission_conflict(self, this_path, base_path, other_path):
1058
raise MergePermissionConflict(this_path, base_path, other_path)
1059
1128
1060
def wrong_old_contents(self, filename, expected_contents):
1129
1061
raise WrongOldContents(filename)
1130
1062
1131
1063
def rem_contents_conflict(self, filename, this_contents, base_contents):
1132
1064
raise RemoveContentsConflict(filename)
1133
1065
1134
def wrong_old_exec_flag(self, filename, old_exec_flag, new_exec_flag):
1135
raise WrongOldExecFlag(filename, old_exec_flag, new_exec_flag)
1066
def wrong_old_perms(self, filename, old_perms, new_perms):
1067
raise WrongOldPermissions(filename, old_perms, new_perms)
1136
1068
1137
1069
def rmdir_non_empty(self, filename):
1138
1070
raise DeletingNonEmptyDirectory(filename)
1143
1075
def patch_target_missing(self, filename, contents):
1144
1076
raise PatchTargetMissing(filename)
1145
1077
1146
def missing_for_exec_flag(self, filename):
1147
raise MissingForExecFlag(filename)
1078
def missing_for_chmod(self, filename):
1079
raise MissingPermsFile(filename)
1148
1080
1149
1081
def missing_for_rm(self, filename, change):
1150
1082
raise MissingForRm(filename)
1151
1083
1152
def missing_for_rename(self, filename, to_path):
1153
raise MissingForRename(filename, to_path)
1084
def missing_for_rename(self, filename):
1085
raise MissingForRename(filename)
1154
1086
1155
def missing_for_merge(self, file_id, other_path):
1156
raise MissingForMerge(other_path)
1087
def missing_for_merge(self, file_id, inventory):
1088
raise MissingForMerge(inventory.other.get_path(file_id))
1157
1089
1158
1090
def new_contents_conflict(self, filename, other_contents):
1159
1091
raise NewContentsConflict(filename)
1160
1092
1161
def threeway_contents_conflict(self, filename, this_contents,
1162
base_contents, other_contents):
1163
raise ThreewayContentsConflict(filename)
1164
1165
def finalize(self):
1093
def finalize():
1166
1094
pass
1167
1095
1168
1096
def apply_changeset(changeset, inventory, dir, conflict_handler=None,
1181
1109
:rtype: Dictionary
1182
1110
"""
1183
1111
if conflict_handler is None:
1184
conflict_handler = ExceptionConflictHandler()
1112
conflict_handler = ExceptionConflictHandler(dir)
1185
1113
temp_dir = os.path.join(dir, "bzr-tree-change")
1186
1114
try:
1187
1115
os.mkdir(temp_dir)
1198
1126
1199
1127
#apply changes that don't affect filenames
1200
1128
for entry in changeset.entries.itervalues():
1201
if not entry.is_creation_or_deletion() and not entry.is_boring():
1129
if not entry.is_creation_or_deletion():
1202
1130
path = os.path.join(dir, inventory[entry.id])
1203
1131
entry.apply(path, conflict_handler, reverse)
1204
1132
1223
1151
r_inventory = {}
1224
1152
for entry in tree.source_inventory().itervalues():
1225
1153
inventory[entry.id] = entry.path
1226
new_inventory = apply_changeset(cset, r_inventory, tree.basedir,
1154
new_inventory = apply_changeset(cset, r_inventory, tree.root,
1227
1155
reverse=reverse)
1228
1156
new_entries, remove_entries = \
1229
1157
get_inventory_change(inventory, new_inventory, cset, reverse)
1364
1292
return new_meta
1365
1293
elif new_meta is None:
1366
1294
return old_meta
1367
elif (isinstance(old_meta, ChangeExecFlag) and
1368
isinstance(new_meta, ChangeExecFlag)):
1369
return ChangeExecFlag(old_meta.old_exec_flag, new_meta.new_exec_flag)
1295
elif isinstance(old_meta, ChangeUnixPermissions) and \
1296
isinstance(new_meta, ChangeUnixPermissions):
1297
return ChangeUnixPermissions(old_meta.old_mode, new_meta.new_mode)
1370
1298
else:
1371
1299
return ApplySequence(old_meta, new_meta)
1372
1300
1377
1305
return False
1378
1306
return True
1379
1307
1380
class UnsupportedFiletype(Exception):
1381
def __init__(self, kind, full_path):
1382
msg = "The file \"%s\" is a %s, which is not a supported filetype." \
1383
% (full_path, kind)
1308
class UnsuppportedFiletype(Exception):
1309
def __init__(self, full_path, stat_result):
1310
msg = "The file \"%s\" is not a supported filetype." % full_path
1384
1311
Exception.__init__(self, msg)
1385
1312
self.full_path = full_path
1386
self.kind = kind
1387
1388
def generate_changeset(tree_a, tree_b, interesting_ids=None):
1389
return ChangesetGenerator(tree_a, tree_b, interesting_ids)()
1390
1313
self.stat_result = stat_result
1314
1315
def generate_changeset(tree_a, tree_b, inventory_a=None, inventory_b=None):
1316
return ChangesetGenerator(tree_a, tree_b, inventory_a, inventory_b)()
1391
1317
1392
1318
class ChangesetGenerator(object):
1393
def __init__(self, tree_a, tree_b, interesting_ids=None):
1319
def __init__(self, tree_a, tree_b, inventory_a=None, inventory_b=None):
1394
1320
object.__init__(self)
1395
1321
self.tree_a = tree_a
1396
1322
self.tree_b = tree_b
1397
self._interesting_ids = interesting_ids
1323
if inventory_a is not None:
1324
self.inventory_a = inventory_a
1325
else:
1326
self.inventory_a = tree_a.inventory()
1327
if inventory_b is not None:
1328
self.inventory_b = inventory_b
1329
else:
1330
self.inventory_b = tree_b.inventory()
1331
self.r_inventory_a = self.reverse_inventory(self.inventory_a)
1332
self.r_inventory_b = self.reverse_inventory(self.inventory_b)
1398
1333
1399
def iter_both_tree_ids(self):
1400
for file_id in self.tree_a:
1401
yield file_id
1402
for file_id in self.tree_b:
1403
if file_id not in self.tree_a:
1404
yield file_id
1334
def reverse_inventory(self, inventory):
1335
r_inventory = {}
1336
for entry in inventory.itervalues():
1337
if entry.id is None:
1338
continue
1339
r_inventory[entry.id] = entry
1340
return r_inventory
1405
1341
1406
1342
def __call__(self):
1407
1343
cset = Changeset()
1408
for file_id in self.iter_both_tree_ids():
1409
cs_entry = self.make_entry(file_id)
1344
for entry in self.inventory_a.itervalues():
1345
if entry.id is None:
1346
continue
1347
cs_entry = self.make_entry(entry.id)
1410
1348
if cs_entry is not None and not cs_entry.is_boring():
1411
1349
cset.add_entry(cs_entry)
1412
1350
1351
for entry in self.inventory_b.itervalues():
1352
if entry.id is None:
1353
continue
1354
if not self.r_inventory_a.has_key(entry.id):
1355
cs_entry = self.make_entry(entry.id)
1356
if cs_entry is not None and not cs_entry.is_boring():
1357
cset.add_entry(cs_entry)
1413
1358
for entry in list(cset.entries.itervalues()):
1414
1359
if entry.parent != entry.new_parent:
1415
1360
if not cset.entries.has_key(entry.parent) and\
1423
1368
cset.add_entry(parent_entry)
1424
1369
return cset
1425
1370
1426
def iter_inventory(self, tree):
1427
for file_id in tree:
1428
yield self.get_entry(file_id, tree)
1429
1430
def get_entry(self, file_id, tree):
1431
if not tree.has_or_had_id(file_id):
1432
return None
1433
return tree.inventory[file_id]
1434
1435
def get_entry_parent(self, entry):
1436
if entry is None:
1437
return None
1438
return entry.parent_id
1439
1440
def get_path(self, file_id, tree):
1441
if not tree.has_or_had_id(file_id):
1442
return None
1443
path = tree.id2path(file_id)
1444
if path == '':
1445
return './.'
1446
else:
1447
return path
1448
1449
def make_basic_entry(self, file_id, only_interesting):
1450
entry_a = self.get_entry(file_id, self.tree_a)
1451
entry_b = self.get_entry(file_id, self.tree_b)
1371
def get_entry_parent(self, entry, inventory):
1372
if entry is None:
1373
return None
1374
if entry.path == "./.":
1375
return NULL_ID
1376
dirname = os.path.dirname(entry.path)
1377
if dirname == ".":
1378
dirname = "./."
1379
parent = inventory[dirname]
1380
return parent.id
1381
1382
def get_paths(self, entry, tree):
1383
if entry is None:
1384
return (None, None)
1385
full_path = tree.readonly_path(entry.id)
1386
if entry.path == ".":
1387
return ("", full_path)
1388
return (entry.path, full_path)
1389
1390
def make_basic_entry(self, id, only_interesting):
1391
entry_a = self.r_inventory_a.get(id)
1392
entry_b = self.r_inventory_b.get(id)
1452
1393
if only_interesting and not self.is_interesting(entry_a, entry_b):
1453
return None
1454
parent = self.get_entry_parent(entry_a)
1455
path = self.get_path(file_id, self.tree_a)
1456
cs_entry = ChangesetEntry(file_id, parent, path)
1457
new_parent = self.get_entry_parent(entry_b)
1458
1459
new_path = self.get_path(file_id, self.tree_b)
1394
return (None, None, None)
1395
parent = self.get_entry_parent(entry_a, self.inventory_a)
1396
(path, full_path_a) = self.get_paths(entry_a, self.tree_a)
1397
cs_entry = ChangesetEntry(id, parent, path)
1398
new_parent = self.get_entry_parent(entry_b, self.inventory_b)
1399
1400
1401
(new_path, full_path_b) = self.get_paths(entry_b, self.tree_b)
1460
1402
1461
1403
cs_entry.new_path = new_path
1462
1404
cs_entry.new_parent = new_parent
1463
return cs_entry
1405
return (cs_entry, full_path_a, full_path_b)
1464
1406
1465
1407
def is_interesting(self, entry_a, entry_b):
1466
if self._interesting_ids is None:
1467
return True
1468
1408
if entry_a is not None:
1469
file_id = entry_a.file_id
1470
elif entry_b is not None:
1471
file_id = entry_b.file_id
1472
else:
1473
return False
1474
return file_id in self._interesting_ids
1409
if entry_a.interesting:
1410
return True
1411
if entry_b is not None:
1412
if entry_b.interesting:
1413
return True
1414
return False
1475
1415
1476
1416
def make_boring_entry(self, id):
1477
cs_entry = self.make_basic_entry(id, only_interesting=False)
1417
(cs_entry, full_path_a, full_path_b) = \
1418
self.make_basic_entry(id, only_interesting=False)
1478
1419
if cs_entry.is_creation_or_deletion():
1479
1420
return self.make_entry(id, only_interesting=False)
1480
1421
else:
1482
1423
1483
1424
1484
1425
def make_entry(self, id, only_interesting=True):
1485
cs_entry = self.make_basic_entry(id, only_interesting)
1426
(cs_entry, full_path_a, full_path_b) = \
1427
self.make_basic_entry(id, only_interesting)
1486
1428
1487
1429
if cs_entry is None:
1488
1430
return None
1489
1490
cs_entry.metadata_change = self.make_exec_flag_change(id)
1491
1492
if id in self.tree_a and id in self.tree_b:
1493
a_sha1 = self.tree_a.get_file_sha1(id)
1494
b_sha1 = self.tree_b.get_file_sha1(id)
1495
if None not in (a_sha1, b_sha1) and a_sha1 == b_sha1:
1496
return cs_entry
1497
1498
cs_entry.contents_change = self.make_contents_change(id)
1431
1432
stat_a = self.lstat(full_path_a)
1433
stat_b = self.lstat(full_path_b)
1434
if stat_b is None:
1435
cs_entry.new_parent = None
1436
cs_entry.new_path = None
1437
1438
cs_entry.metadata_change = self.make_mode_change(stat_a, stat_b)
1439
cs_entry.contents_change = self.make_contents_change(full_path_a,
1440
stat_a,
1441
full_path_b,
1442
stat_b)
1499
1443
return cs_entry
1500
1444
1501
def make_exec_flag_change(self, file_id):
1502
exec_flag_a = exec_flag_b = None
1503
if file_id in self.tree_a and self.tree_a.kind(file_id) == "file":
1504
exec_flag_a = self.tree_a.is_executable(file_id)
1505
1506
if file_id in self.tree_b and self.tree_b.kind(file_id) == "file":
1507
exec_flag_b = self.tree_b.is_executable(file_id)
1508
1509
if exec_flag_a == exec_flag_b:
1510
return None
1511
return ChangeExecFlag(exec_flag_a, exec_flag_b)
1512
1513
def make_contents_change(self, file_id):
1514
a_contents = get_contents(self.tree_a, file_id)
1515
b_contents = get_contents(self.tree_b, file_id)
1445
def make_mode_change(self, stat_a, stat_b):
1446
mode_a = None
1447
if stat_a is not None and not stat.S_ISLNK(stat_a.st_mode):
1448
mode_a = stat_a.st_mode & 0777
1449
mode_b = None
1450
if stat_b is not None and not stat.S_ISLNK(stat_b.st_mode):
1451
mode_b = stat_b.st_mode & 0777
1452
if mode_a == mode_b:
1453
return None
1454
return ChangeUnixPermissions(mode_a, mode_b)
1455
1456
def make_contents_change(self, full_path_a, stat_a, full_path_b, stat_b):
1457
if stat_a is None and stat_b is None:
1458
return None
1459
if None not in (stat_a, stat_b) and stat.S_ISDIR(stat_a.st_mode) and\
1460
stat.S_ISDIR(stat_b.st_mode):
1461
return None
1462
if None not in (stat_a, stat_b) and stat.S_ISREG(stat_a.st_mode) and\
1463
stat.S_ISREG(stat_b.st_mode):
1464
if stat_a.st_ino == stat_b.st_ino and \
1465
stat_a.st_dev == stat_b.st_dev:
1466
return None
1467
if file(full_path_a, "rb").read() == \
1468
file(full_path_b, "rb").read():
1469
return None
1470
1471
patch_contents = patch.diff(full_path_a,
1472
file(full_path_b, "rb").read())
1473
if patch_contents is None:
1474
return None
1475
return PatchApply(patch_contents)
1476
1477
a_contents = self.get_contents(stat_a, full_path_a)
1478
b_contents = self.get_contents(stat_b, full_path_b)
1516
1479
if a_contents == b_contents:
1517
1480
return None
1518
1481
return ReplaceContents(a_contents, b_contents)
1519
1482
1483
def get_contents(self, stat_result, full_path):
1484
if stat_result is None:
1485
return None
1486
elif stat.S_ISREG(stat_result.st_mode):
1487
return FileCreate(file(full_path, "rb").read())
1488
elif stat.S_ISDIR(stat_result.st_mode):
1489
return dir_create
1490
elif stat.S_ISLNK(stat_result.st_mode):
1491
return SymlinkCreate(os.readlink(full_path))
1492
else:
1493
raise UnsupportedFiletype(full_path, stat_result)
1520
1494
1521
def get_contents(tree, file_id):
1522
"""Return the appropriate contents to create a copy of file_id from tree"""
1523
if file_id not in tree:
1524
return None
1525
kind = tree.kind(file_id)
1526
if kind == "file":
1527
return TreeFileCreate(tree, file_id)
1528
elif kind in ("directory", "root_directory"):
1529
return dir_create
1530
elif kind == "symlink":
1531
return SymlinkCreate(tree.get_symlink_target(file_id))
1532
else:
1533
raise UnsupportedFiletype(kind, tree.id2path(file_id))
1495
def lstat(self, full_path):
1496
stat_result = None
1497
if full_path is not None:
1498
try:
1499
stat_result = os.lstat(full_path)
1500
except OSError, e:
1501
if e.errno != errno.ENOENT:
1502
raise
1503
return stat_result
1534
1504
1535
1505
1536
1506
def full_path(entry, tree):
1537
return os.path.join(tree.basedir, entry.path)
1507
return os.path.join(tree.root, entry.path)
1538
1508
1539
1509
def new_delete_entry(entry, tree, inventory, delete):
1540
1510
if entry.path == "":
1556
1526
1557
1527
1558
1528
1559
# XXX: Can't we unify this with the regular inventory object
1529
1560
1530
class Inventory(object):
1561
1531
def __init__(self, inventory):
1562
1532
self.inventory = inventory
Loggerhead is a web-based interface for Breezy
Version: 2.0.1