« back to all changes in this revision
Viewing changes to bzrlib/changeset.py
- browse files at revision 854
- compare with another revision
- download diff
- download tarball
- view history from revision 854
- Committer: Martin Pool
- Date: 2005-07-07 10:22:02 UTC
- Revision ID: mbp@sourcefrog.net-20050707102201-2d2a13a25098b101
- rearrange and clear up merged weave
- files added:
- bzrlib/meta_store.py
- plugins/changeset
- files removed:
- HACKING
- bzrlib/store
- bzrlib/transport
- bzrlib/util
- bzrlib/util/configobj
- bzrlib/util/configobj/docs
- contrib/emacs
- files renamed:
- contrib/newinventory.py => bzrlib/newinventory.py
- bzrlib/selftest/testplugins.py => bzrlib/selftest/plugins.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 *
- setup.py *
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
history_based = False
415
def __init__(self, file_id, base, other):
416
self.file_id = file_id
417
self.base = base
418
self.other = other
419
420
def is_creation(self):
421
return False
422
423
def is_deletion(self):
424
return False
369
def __init__(self, base_file, other_file):
370
self.base_file = base_file
371
self.other_file = other_file
425
372
426
373
def __eq__(self, other):
427
374
if not isinstance(other, Diff3Merge):
428
375
return False
429
return (self.base == other.base and
430
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)
431
378
432
379
def __ne__(self, other):
433
380
return not (self == other)
434
381
435
def dump_file(self, temp_dir, name, tree):
436
out_path = os.path.join(temp_dir, name)
437
out_file = file(out_path, "wb")
438
in_file = tree.get_file(self.file_id)
439
for line in in_file:
440
out_file.write(line)
441
return out_path
442
443
382
def apply(self, filename, conflict_handler, reverse=False):
444
temp_dir = mkdtemp(prefix="bzr-")
445
try:
446
new_file = filename+".new"
447
base_file = self.dump_file(temp_dir, "base", self.base)
448
other_file = self.dump_file(temp_dir, "other", self.other)
449
if not reverse:
450
base = base_file
451
other = other_file
452
else:
453
base = other_file
454
other = base_file
455
status = patch.diff3(new_file, filename, base, other)
456
if status == 0:
457
os.chmod(new_file, os.stat(filename).st_mode)
458
rename(new_file, filename)
459
return
460
else:
461
assert(status == 1)
462
def get_lines(filename):
463
my_file = file(filename, "rb")
464
lines = my_file.readlines()
465
my_file.close()
466
return lines
467
base_lines = get_lines(base)
468
other_lines = get_lines(other)
469
conflict_handler.merge_conflict(new_file, filename, base_lines,
470
other_lines)
471
finally:
472
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)
473
398
474
399
475
400
def CreateDir():
508
433
"""
509
434
return ReplaceContents(FileCreate(contents), None)
510
435
511
def ReplaceFileContents(old_tree, new_tree, file_id):
436
def ReplaceFileContents(old_contents, new_contents):
512
437
"""Convenience fucntion to replace the contents of a file.
513
438
514
439
:param old_contents: The contents of the file to replace
518
443
:return: A ReplaceContents that will replace the contents of a file a file
519
444
:rtype: `ReplaceContents`
520
445
"""
521
return ReplaceContents(TreeFileCreate(old_tree, file_id),
522
TreeFileCreate(new_tree, file_id))
446
return ReplaceContents(FileCreate(old_contents), FileCreate(new_contents))
523
447
524
448
def CreateSymlink(target):
525
449
"""Convenience fucntion to create a symlink.
688
612
:param reverse: if true, the changeset is being applied in reverse
689
613
:rtype: bool
690
614
"""
691
return self.is_creation(not reverse)
615
return ((self.new_parent is None and not reverse) or
616
(self.parent is None and reverse))
692
617
693
618
def is_creation(self, reverse):
694
619
"""Return true if applying the entry would create a file/directory.
696
621
:param reverse: if true, the changeset is being applied in reverse
697
622
:rtype: bool
698
623
"""
699
if self.contents_change is None:
700
return False
701
if reverse:
702
return self.contents_change.is_deletion()
703
else:
704
return self.contents_change.is_creation()
624
return ((self.parent is None and not reverse) or
625
(self.new_parent is None and reverse))
705
626
706
627
def is_creation_or_deletion(self):
707
628
"""Return true if applying the entry would create or delete a
709
630
710
631
:rtype: bool
711
632
"""
712
return self.is_creation(False) or self.is_deletion(False)
633
return self.parent is None or self.new_parent is None
713
634
714
635
def get_cset_path(self, mod=False):
715
636
"""Determine the path of the entry according to the changeset.
735
656
return None
736
657
return self.path
737
658
738
def summarize_name(self, reverse=False):
659
def summarize_name(self, changeset, reverse=False):
739
660
"""Produce a one-line summary of the filename. Indicates renames as
740
661
old => new, indicates creation as None => new, indicates deletion as
741
662
old => None.
772
693
:type reverse: bool
773
694
:rtype: str
774
695
"""
775
mutter("Finding new path for %s" % self.summarize_name())
776
696
if reverse:
777
697
parent = self.parent
778
698
to_dir = self.dir
797
717
if from_dir == to_dir:
798
718
dir = os.path.dirname(id_map[self.id])
799
719
else:
800
mutter("path, new_path: %r %r" % (self.path, self.new_path))
801
720
parent_entry = changeset.entries[parent]
802
721
dir = parent_entry.get_new_path(id_map, changeset, reverse)
803
722
if from_name == to_name:
887
806
:rtype: (List, List)
888
807
"""
889
808
source_entries = [x for x in changeset.entries.itervalues()
890
if x.needs_rename() or x.is_creation_or_deletion()]
809
if x.needs_rename()]
891
810
# these are done from longest path to shortest, to avoid deleting a
892
811
# parent before its children are deleted/renamed
893
812
def longest_to_shortest(entry):
934
853
entry.apply(path, conflict_handler, reverse)
935
854
temp_name[entry.id] = None
936
855
937
elif entry.needs_rename():
856
else:
938
857
to_name = os.path.join(temp_dir, str(i))
939
858
src_path = inventory.get(entry.id)
940
859
if src_path is not None:
941
860
src_path = os.path.join(dir, src_path)
942
861
try:
943
rename(src_path, to_name)
862
os.rename(src_path, to_name)
944
863
temp_name[entry.id] = to_name
945
864
except OSError, e:
946
865
if e.errno != errno.ENOENT:
947
866
raise
948
if conflict_handler.missing_for_rename(src_path, to_name) \
949
== "skip":
867
if conflict_handler.missing_for_rename(src_path) == "skip":
950
868
continue
951
869
952
870
return temp_name
973
891
continue
974
892
new_path = os.path.join(dir, new_tree_path)
975
893
old_path = changed_inventory.get(entry.id)
976
if bzrlib.osutils.lexists(new_path):
894
if os.path.exists(new_path):
977
895
if conflict_handler.target_exists(entry, new_path, old_path) == \
978
896
"skip":
979
897
continue
980
898
if entry.is_creation(reverse):
981
899
entry.apply(new_path, conflict_handler, reverse)
982
900
changed_inventory[entry.id] = new_tree_path
983
elif entry.needs_rename():
901
else:
984
902
if old_path is None:
985
903
continue
986
904
try:
987
rename(old_path, new_path)
905
os.rename(old_path, new_path)
988
906
changed_inventory[entry.id] = new_tree_path
989
907
except OSError, e:
990
908
raise Exception ("%s is missing" % new_path)
1025
943
Exception.__init__(self, "Conflict applying changes to %s" % this_path)
1026
944
self.this_path = this_path
1027
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
1028
961
class WrongOldContents(Exception):
1029
962
def __init__(self, filename):
1030
963
msg = "Contents mismatch deleting %s" % filename
1031
964
self.filename = filename
1032
965
Exception.__init__(self, msg)
1033
966
1034
class WrongOldExecFlag(Exception):
1035
def __init__(self, filename, old_exec_flag, new_exec_flag):
1036
msg = "Executable flag missmatch on %s:\n" \
1037
"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)
1038
971
self.filename = filename
1039
972
Exception.__init__(self, msg)
1040
973
1058
991
Exception.__init__(self, msg)
1059
992
self.filename = filename
1060
993
1061
class MissingForSetExec(Exception):
994
class MissingPermsFile(Exception):
1062
995
def __init__(self, filename):
1063
996
msg = "Attempt to change permissions on %s, which does not exist" %\
1064
997
filename
1073
1006
1074
1007
1075
1008
class MissingForRename(Exception):
1076
def __init__(self, filename, to_path):
1077
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)
1078
1011
Exception.__init__(self, msg)
1079
1012
self.filename = filename
1080
1013
1083
1016
msg = "Conflicting contents for new file %s" % (filename)
1084
1017
Exception.__init__(self, msg)
1085
1018
1086
class WeaveMergeConflict(Exception):
1087
def __init__(self, filename):
1088
msg = "Conflicting contents for file %s" % (filename)
1089
Exception.__init__(self, msg)
1090
1091
class ThreewayContentsConflict(Exception):
1092
def __init__(self, filename):
1093
msg = "Conflicting contents for file %s" % (filename)
1094
Exception.__init__(self, msg)
1095
1096
1019
1097
1020
class MissingForMerge(Exception):
1098
1021
def __init__(self, filename):
1102
1025
1103
1026
1104
1027
class ExceptionConflictHandler(object):
1105
"""Default handler for merge exceptions.
1106
1107
This throws an error on any kind of conflict. Conflict handlers can
1108
descend from this class if they have a better way to handle some or
1109
all types of conflict.
1110
"""
1028
def __init__(self, dir):
1029
self.dir = dir
1030
1111
1031
def missing_parent(self, pathname):
1112
1032
parent = os.path.dirname(pathname)
1113
1033
raise Exception("Parent directory missing for %s" % pathname)
1124
1044
def rename_conflict(self, id, this_name, base_name, other_name):
1125
1045
raise RenameConflict(id, this_name, base_name, other_name)
1126
1046
1127
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)
1128
1051
raise MoveConflict(id, this_dir, base_dir, other_dir)
1129
1052
1130
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):
1131
1054
os.unlink(new_file)
1132
1055
raise MergeConflict(this_path)
1133
1056
1057
def permission_conflict(self, this_path, base_path, other_path):
1058
raise MergePermissionConflict(this_path, base_path, other_path)
1059
1134
1060
def wrong_old_contents(self, filename, expected_contents):
1135
1061
raise WrongOldContents(filename)
1136
1062
1137
1063
def rem_contents_conflict(self, filename, this_contents, base_contents):
1138
1064
raise RemoveContentsConflict(filename)
1139
1065
1140
def wrong_old_exec_flag(self, filename, old_exec_flag, new_exec_flag):
1141
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)
1142
1068
1143
1069
def rmdir_non_empty(self, filename):
1144
1070
raise DeletingNonEmptyDirectory(filename)
1149
1075
def patch_target_missing(self, filename, contents):
1150
1076
raise PatchTargetMissing(filename)
1151
1077
1152
def missing_for_exec_flag(self, filename):
1153
raise MissingForExecFlag(filename)
1078
def missing_for_chmod(self, filename):
1079
raise MissingPermsFile(filename)
1154
1080
1155
1081
def missing_for_rm(self, filename, change):
1156
1082
raise MissingForRm(filename)
1157
1083
1158
def missing_for_rename(self, filename, to_path):
1159
raise MissingForRename(filename, to_path)
1084
def missing_for_rename(self, filename):
1085
raise MissingForRename(filename)
1160
1086
1161
def missing_for_merge(self, file_id, other_path):
1162
raise MissingForMerge(other_path)
1087
def missing_for_merge(self, file_id, inventory):
1088
raise MissingForMerge(inventory.other.get_path(file_id))
1163
1089
1164
1090
def new_contents_conflict(self, filename, other_contents):
1165
1091
raise NewContentsConflict(filename)
1166
1092
1167
def weave_merge_conflict(self, filename, weave, other_i, out_file):
1168
raise WeaveMergeConflict(filename)
1169
1170
def threeway_contents_conflict(self, filename, this_contents,
1171
base_contents, other_contents):
1172
raise ThreewayContentsConflict(filename)
1173
1174
def finalize(self):
1093
def finalize():
1175
1094
pass
1176
1095
1177
1096
def apply_changeset(changeset, inventory, dir, conflict_handler=None,
1190
1109
:rtype: Dictionary
1191
1110
"""
1192
1111
if conflict_handler is None:
1193
conflict_handler = ExceptionConflictHandler()
1112
conflict_handler = ExceptionConflictHandler(dir)
1194
1113
temp_dir = os.path.join(dir, "bzr-tree-change")
1195
1114
try:
1196
1115
os.mkdir(temp_dir)
1207
1126
1208
1127
#apply changes that don't affect filenames
1209
1128
for entry in changeset.entries.itervalues():
1210
if not entry.is_creation_or_deletion() and not entry.is_boring():
1129
if not entry.is_creation_or_deletion():
1211
1130
path = os.path.join(dir, inventory[entry.id])
1212
1131
entry.apply(path, conflict_handler, reverse)
1213
1132
1232
1151
r_inventory = {}
1233
1152
for entry in tree.source_inventory().itervalues():
1234
1153
inventory[entry.id] = entry.path
1235
new_inventory = apply_changeset(cset, r_inventory, tree.basedir,
1154
new_inventory = apply_changeset(cset, r_inventory, tree.root,
1236
1155
reverse=reverse)
1237
1156
new_entries, remove_entries = \
1238
1157
get_inventory_change(inventory, new_inventory, cset, reverse)
1373
1292
return new_meta
1374
1293
elif new_meta is None:
1375
1294
return old_meta
1376
elif (isinstance(old_meta, ChangeExecFlag) and
1377
isinstance(new_meta, ChangeExecFlag)):
1378
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)
1379
1298
else:
1380
1299
return ApplySequence(old_meta, new_meta)
1381
1300
1386
1305
return False
1387
1306
return True
1388
1307
1389
class UnsupportedFiletype(Exception):
1390
def __init__(self, kind, full_path):
1391
msg = "The file \"%s\" is a %s, which is not a supported filetype." \
1392
% (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
1393
1311
Exception.__init__(self, msg)
1394
1312
self.full_path = full_path
1395
self.kind = kind
1396
1397
def generate_changeset(tree_a, tree_b, interesting_ids=None):
1398
return ChangesetGenerator(tree_a, tree_b, interesting_ids)()
1399
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)()
1400
1317
1401
1318
class ChangesetGenerator(object):
1402
def __init__(self, tree_a, tree_b, interesting_ids=None):
1319
def __init__(self, tree_a, tree_b, inventory_a=None, inventory_b=None):
1403
1320
object.__init__(self)
1404
1321
self.tree_a = tree_a
1405
1322
self.tree_b = tree_b
1406
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)
1407
1333
1408
def iter_both_tree_ids(self):
1409
for file_id in self.tree_a:
1410
yield file_id
1411
for file_id in self.tree_b:
1412
if file_id not in self.tree_a:
1413
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
1414
1341
1415
1342
def __call__(self):
1416
1343
cset = Changeset()
1417
for file_id in self.iter_both_tree_ids():
1418
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)
1419
1348
if cs_entry is not None and not cs_entry.is_boring():
1420
1349
cset.add_entry(cs_entry)
1421
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)
1422
1358
for entry in list(cset.entries.itervalues()):
1423
1359
if entry.parent != entry.new_parent:
1424
1360
if not cset.entries.has_key(entry.parent) and\
1432
1368
cset.add_entry(parent_entry)
1433
1369
return cset
1434
1370
1435
def iter_inventory(self, tree):
1436
for file_id in tree:
1437
yield self.get_entry(file_id, tree)
1438
1439
def get_entry(self, file_id, tree):
1440
if not tree.has_or_had_id(file_id):
1441
return None
1442
return tree.inventory[file_id]
1443
1444
def get_entry_parent(self, entry):
1445
if entry is None:
1446
return None
1447
return entry.parent_id
1448
1449
def get_path(self, file_id, tree):
1450
if not tree.has_or_had_id(file_id):
1451
return None
1452
path = tree.id2path(file_id)
1453
if path == '':
1454
return './.'
1455
else:
1456
return path
1457
1458
def make_basic_entry(self, file_id, only_interesting):
1459
entry_a = self.get_entry(file_id, self.tree_a)
1460
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)
1461
1393
if only_interesting and not self.is_interesting(entry_a, entry_b):
1462
return None
1463
parent = self.get_entry_parent(entry_a)
1464
path = self.get_path(file_id, self.tree_a)
1465
cs_entry = ChangesetEntry(file_id, parent, path)
1466
new_parent = self.get_entry_parent(entry_b)
1467
1468
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)
1469
1402
1470
1403
cs_entry.new_path = new_path
1471
1404
cs_entry.new_parent = new_parent
1472
return cs_entry
1405
return (cs_entry, full_path_a, full_path_b)
1473
1406
1474
1407
def is_interesting(self, entry_a, entry_b):
1475
if self._interesting_ids is None:
1476
return True
1477
1408
if entry_a is not None:
1478
file_id = entry_a.file_id
1479
elif entry_b is not None:
1480
file_id = entry_b.file_id
1481
else:
1482
return False
1483
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
1484
1415
1485
1416
def make_boring_entry(self, id):
1486
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)
1487
1419
if cs_entry.is_creation_or_deletion():
1488
1420
return self.make_entry(id, only_interesting=False)
1489
1421
else:
1491
1423
1492
1424
1493
1425
def make_entry(self, id, only_interesting=True):
1494
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)
1495
1428
1496
1429
if cs_entry is None:
1497
1430
return None
1498
1499
cs_entry.metadata_change = self.make_exec_flag_change(id)
1500
1501
if id in self.tree_a and id in self.tree_b:
1502
a_sha1 = self.tree_a.get_file_sha1(id)
1503
b_sha1 = self.tree_b.get_file_sha1(id)
1504
if None not in (a_sha1, b_sha1) and a_sha1 == b_sha1:
1505
return cs_entry
1506
1507
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)
1508
1443
return cs_entry
1509
1444
1510
def make_exec_flag_change(self, file_id):
1511
exec_flag_a = exec_flag_b = None
1512
if file_id in self.tree_a and self.tree_a.kind(file_id) == "file":
1513
exec_flag_a = self.tree_a.is_executable(file_id)
1514
1515
if file_id in self.tree_b and self.tree_b.kind(file_id) == "file":
1516
exec_flag_b = self.tree_b.is_executable(file_id)
1517
1518
if exec_flag_a == exec_flag_b:
1519
return None
1520
return ChangeExecFlag(exec_flag_a, exec_flag_b)
1521
1522
def make_contents_change(self, file_id):
1523
a_contents = get_contents(self.tree_a, file_id)
1524
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)
1525
1479
if a_contents == b_contents:
1526
1480
return None
1527
1481
return ReplaceContents(a_contents, b_contents)
1528
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)
1529
1494
1530
def get_contents(tree, file_id):
1531
"""Return the appropriate contents to create a copy of file_id from tree"""
1532
if file_id not in tree:
1533
return None
1534
kind = tree.kind(file_id)
1535
if kind == "file":
1536
return TreeFileCreate(tree, file_id)
1537
elif kind in ("directory", "root_directory"):
1538
return dir_create
1539
elif kind == "symlink":
1540
return SymlinkCreate(tree.get_symlink_target(file_id))
1541
else:
1542
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
1543
1504
1544
1505
1545
1506
def full_path(entry, tree):
1546
return os.path.join(tree.basedir, entry.path)
1507
return os.path.join(tree.root, entry.path)
1547
1508
1548
1509
def new_delete_entry(entry, tree, inventory, delete):
1549
1510
if entry.path == "":
1565
1526
1566
1527
1567
1528
1568
# XXX: Can't we unify this with the regular inventory object
1529
1569
1530
class Inventory(object):
1570
1531
def __init__(self, inventory):
1571
1532
self.inventory = inventory
Loggerhead is a web-based interface for Breezy
Version: 2.0.1