« back to all changes in this revision
Viewing changes to bzrlib/changeset.py
- browse files at revision 675
- compare with another revision
- download diff
- download tarball
- view history from revision 675
- Committer: Martin Pool
- Date: 2005-06-11 01:55:29 UTC
- Revision ID: mbp@sourcefrog.net-20050611015529-26a9c988699de34f
- help formatting fix from ndim
- files added:
- bzrlib/remotebranch.py
- files removed:
- HACKING
- bzrlib/plugins
- bzrlib/selftest
- bzrlib/store
- bzrlib/transport
- bzrlib/util
- bzrlib/util/effbot
- bzrlib/util/effbot/org
- contrib/emacs
- tools
- files renamed:
- contrib/newinventory.py => bzrlib/newinventory.py
- bzrlib/selftest/__init__.py => bzrlib/selftest.py
- bzrlib/store/__init__.py => bzrlib/store.py
- bzrlib/selftest/whitebox.py => bzrlib/whitebox.py
- bzrlib/util/elementtree/ => elementtree/
- 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"
39
26
40
class OldFailedTreeOp(Exception):
41
def __init__(self):
42
Exception.__init__(self, "bzr-tree-change contains files from a"
43
" previous failed merge operation.")
27
44
28
def invert_dict(dict):
45
29
newdict = {}
46
30
for (key,value) in dict.iteritems():
47
31
newdict[value] = key
48
32
return newdict
49
33
50
51
class ChangeExecFlag(object):
34
35
class PatchApply(object):
36
"""Patch application as a kind of content change"""
37
def __init__(self, contents):
38
"""Constructor.
39
40
:param contents: The text of the patch to apply
41
:type contents: str"""
42
self.contents = contents
43
44
def __eq__(self, other):
45
if not isinstance(other, PatchApply):
46
return False
47
elif self.contents != other.contents:
48
return False
49
else:
50
return True
51
52
def __ne__(self, other):
53
return not (self == other)
54
55
def apply(self, filename, conflict_handler, reverse=False):
56
"""Applies the patch to the specified file.
57
58
:param filename: the file to apply the patch to
59
:type filename: str
60
:param reverse: If true, apply the patch in reverse
61
:type reverse: bool
62
"""
63
input_name = filename+".orig"
64
try:
65
os.rename(filename, input_name)
66
except OSError, e:
67
if e.errno != errno.ENOENT:
68
raise
69
if conflict_handler.patch_target_missing(filename, self.contents)\
70
== "skip":
71
return
72
os.rename(filename, input_name)
73
74
75
status = patch.patch(self.contents, input_name, filename,
76
reverse)
77
os.chmod(filename, os.stat(input_name).st_mode)
78
if status == 0:
79
os.unlink(input_name)
80
elif status == 1:
81
conflict_handler.failed_hunks(filename)
82
83
84
class ChangeUnixPermissions(object):
52
85
"""This is two-way change, suitable for file modification, creation,
53
86
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
87
def __init__(self, old_mode, new_mode):
88
self.old_mode = old_mode
89
self.new_mode = new_mode
57
90
58
91
def apply(self, filename, conflict_handler, reverse=False):
59
92
if not reverse:
60
from_exec_flag = self.old_exec_flag
61
to_exec_flag = self.new_exec_flag
93
from_mode = self.old_mode
94
to_mode = self.new_mode
62
95
else:
63
from_exec_flag = self.new_exec_flag
64
to_exec_flag = self.old_exec_flag
96
from_mode = self.new_mode
97
to_mode = self.old_mode
65
98
try:
66
current_exec_flag = bool(os.stat(filename).st_mode & 0111)
99
current_mode = os.stat(filename).st_mode &0777
67
100
except OSError, e:
68
101
if e.errno == errno.ENOENT:
69
if conflict_handler.missing_for_exec_flag(filename) == "skip":
102
if conflict_handler.missing_for_chmod(filename) == "skip":
70
103
return
71
104
else:
72
current_exec_flag = from_exec_flag
105
current_mode = from_mode
73
106
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":
107
if from_mode is not None and current_mode != from_mode:
108
if conflict_handler.wrong_old_perms(filename, from_mode,
109
current_mode) != "continue":
77
110
return
78
111
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
112
if to_mode is not None:
92
113
try:
93
114
os.chmod(filename, to_mode)
94
115
except IOError, e:
95
116
if e.errno == errno.ENOENT:
96
conflict_handler.missing_for_exec_flag(filename)
117
conflict_handler.missing_for_chmod(filename)
97
118
98
119
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)
120
if not isinstance(other, ChangeUnixPermissions):
121
return False
122
elif self.old_mode != other.old_mode:
123
return False
124
elif self.new_mode != other.new_mode:
125
return False
126
else:
127
return True
102
128
103
129
def __ne__(self, other):
104
130
return not (self == other)
105
131
106
107
132
def dir_create(filename, conflict_handler, reverse):
108
133
"""Creates the directory, or deletes it if reverse is true. Intended to be
109
134
used with ReplaceContents.
129
154
try:
130
155
os.rmdir(filename)
131
156
except OSError, e:
132
if e.errno != errno.ENOTEMPTY:
157
if e.errno != 39:
133
158
raise
134
159
if conflict_handler.rmdir_non_empty(filename) == "skip":
135
160
return
136
161
os.rmdir(filename)
137
162
163
164
138
165
139
166
class SymlinkCreate(object):
140
167
"""Creates or deletes a symlink (for use with ReplaceContents)"""
146
173
"""
147
174
self.target = contents
148
175
149
def __repr__(self):
150
return "SymlinkCreate(%s)" % self.target
151
152
176
def __call__(self, filename, conflict_handler, reverse):
153
177
"""Creates or destroys the symlink.
154
178
236
260
237
261
238
262
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
263
def reversed(sequence):
306
264
max = len(sequence) - 1
307
265
for i in range(len(sequence)):
374
332
if mode is not None:
375
333
os.chmod(filename, mode)
376
334
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
335
class ApplySequence(object):
384
336
def __init__(self, changes=None):
385
337
self.changes = []
411
363
412
364
413
365
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
366
def __init__(self, base_file, other_file):
367
self.base_file = base_file
368
self.other_file = other_file
424
369
425
370
def __eq__(self, other):
426
371
if not isinstance(other, Diff3Merge):
427
372
return False
428
return (self.base == other.base and
429
self.other == other.other and self.file_id == other.file_id)
373
return (self.base_file == other.base_file and
374
self.other_file == other.other_file)
430
375
431
376
def __ne__(self, other):
432
377
return not (self == other)
433
378
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
379
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)
380
new_file = filename+".new"
381
if not reverse:
382
base = self.base_file
383
other = self.other_file
384
else:
385
base = self.other_file
386
other = self.base_file
387
status = patch.diff3(new_file, filename, base, other)
388
if status == 0:
389
os.chmod(new_file, os.stat(filename).st_mode)
390
os.rename(new_file, filename)
391
return
392
else:
393
assert(status == 1)
394
conflict_handler.merge_conflict(new_file, filename, base, other)
472
395
473
396
474
397
def CreateDir():
507
430
"""
508
431
return ReplaceContents(FileCreate(contents), None)
509
432
510
def ReplaceFileContents(old_tree, new_tree, file_id):
433
def ReplaceFileContents(old_contents, new_contents):
511
434
"""Convenience fucntion to replace the contents of a file.
512
435
513
436
:param old_contents: The contents of the file to replace
517
440
:return: A ReplaceContents that will replace the contents of a file a file
518
441
:rtype: `ReplaceContents`
519
442
"""
520
return ReplaceContents(TreeFileCreate(old_tree, file_id),
521
TreeFileCreate(new_tree, file_id))
443
return ReplaceContents(FileCreate(old_contents), FileCreate(new_contents))
522
444
523
445
def CreateSymlink(target):
524
446
"""Convenience fucntion to create a symlink.
687
609
:param reverse: if true, the changeset is being applied in reverse
688
610
:rtype: bool
689
611
"""
690
return self.is_creation(not reverse)
612
return ((self.new_parent is None and not reverse) or
613
(self.parent is None and reverse))
691
614
692
615
def is_creation(self, reverse):
693
616
"""Return true if applying the entry would create a file/directory.
695
618
:param reverse: if true, the changeset is being applied in reverse
696
619
:rtype: bool
697
620
"""
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()
621
return ((self.parent is None and not reverse) or
622
(self.new_parent is None and reverse))
704
623
705
624
def is_creation_or_deletion(self):
706
625
"""Return true if applying the entry would create or delete a
708
627
709
628
:rtype: bool
710
629
"""
711
return self.is_creation(False) or self.is_deletion(False)
630
return self.parent is None or self.new_parent is None
712
631
713
632
def get_cset_path(self, mod=False):
714
633
"""Determine the path of the entry according to the changeset.
734
653
return None
735
654
return self.path
736
655
737
def summarize_name(self, reverse=False):
656
def summarize_name(self, changeset, reverse=False):
738
657
"""Produce a one-line summary of the filename. Indicates renames as
739
658
old => new, indicates creation as None => new, indicates deletion as
740
659
old => None.
771
690
:type reverse: bool
772
691
:rtype: str
773
692
"""
774
mutter("Finding new path for %s" % self.summarize_name())
775
693
if reverse:
776
694
parent = self.parent
777
695
to_dir = self.dir
796
714
if from_dir == to_dir:
797
715
dir = os.path.dirname(id_map[self.id])
798
716
else:
799
mutter("path, new_path: %r %r" % (self.path, self.new_path))
800
717
parent_entry = changeset.entries[parent]
801
718
dir = parent_entry.get_new_path(id_map, changeset, reverse)
802
719
if from_name == to_name:
886
803
:rtype: (List, List)
887
804
"""
888
805
source_entries = [x for x in changeset.entries.itervalues()
889
if x.needs_rename() or x.is_creation_or_deletion()]
806
if x.needs_rename()]
890
807
# these are done from longest path to shortest, to avoid deleting a
891
808
# parent before its children are deleted/renamed
892
809
def longest_to_shortest(entry):
909
826
my_sort(target_entries, shortest_to_longest)
910
827
return (source_entries, target_entries)
911
828
912
def rename_to_temp_delete(source_entries, inventory, dir, temp_dir,
913
conflict_handler, reverse):
829
def rename_to_temp_delete(source_entries, inventory, dir, conflict_handler,
830
reverse):
914
831
"""Delete and rename entries as appropriate. Entries are renamed to temp
915
names. A map of id -> temp name (or None, for deletions) is returned.
832
names. A map of id -> temp name is returned.
916
833
917
834
:param source_entries: The entries to rename and delete
918
835
:type source_entries: List of `ChangesetEntry`
925
842
:return: a mapping of id to temporary name
926
843
:rtype: Dictionary
927
844
"""
845
temp_dir = os.path.join(dir, "temp")
928
846
temp_name = {}
929
847
for i in range(len(source_entries)):
930
848
entry = source_entries[i]
931
849
if entry.is_deletion(reverse):
932
850
path = os.path.join(dir, inventory[entry.id])
933
851
entry.apply(path, conflict_handler, reverse)
934
temp_name[entry.id] = None
935
852
936
elif entry.needs_rename():
937
to_name = os.path.join(temp_dir, str(i))
853
else:
854
to_name = temp_dir+"/"+str(i)
938
855
src_path = inventory.get(entry.id)
939
856
if src_path is not None:
940
857
src_path = os.path.join(dir, src_path)
941
858
try:
942
rename(src_path, to_name)
859
os.rename(src_path, to_name)
943
860
temp_name[entry.id] = to_name
944
861
except OSError, e:
945
862
if e.errno != errno.ENOENT:
946
863
raise
947
if conflict_handler.missing_for_rename(src_path, to_name) \
948
== "skip":
864
if conflict_handler.missing_for_rename(src_path) == "skip":
949
865
continue
950
866
951
867
return temp_name
952
868
953
869
954
def rename_to_new_create(changed_inventory, target_entries, inventory,
955
changeset, dir, conflict_handler, reverse):
870
def rename_to_new_create(temp_name, target_entries, inventory, changeset, dir,
871
conflict_handler, reverse):
956
872
"""Rename entries with temp names to their final names, create new files.
957
873
958
:param changed_inventory: A mapping of id to temporary name
959
:type changed_inventory: Dictionary
874
:param temp_name: A mapping of id to temporary name
875
:type temp_name: Dictionary
960
876
:param target_entries: The entries to apply changes to
961
877
:type target_entries: List of `ChangesetEntry`
962
878
:param changeset: The changeset to apply
967
883
:type reverse: bool
968
884
"""
969
885
for entry in target_entries:
970
new_tree_path = entry.get_new_path(inventory, changeset, reverse)
971
if new_tree_path is None:
886
new_path = entry.get_new_path(inventory, changeset, reverse)
887
if new_path is None:
972
888
continue
973
new_path = os.path.join(dir, new_tree_path)
974
old_path = changed_inventory.get(entry.id)
975
if bzrlib.osutils.lexists(new_path):
889
new_path = os.path.join(dir, new_path)
890
old_path = temp_name.get(entry.id)
891
if os.path.exists(new_path):
976
892
if conflict_handler.target_exists(entry, new_path, old_path) == \
977
893
"skip":
978
894
continue
979
895
if entry.is_creation(reverse):
980
896
entry.apply(new_path, conflict_handler, reverse)
981
changed_inventory[entry.id] = new_tree_path
982
elif entry.needs_rename():
897
else:
983
898
if old_path is None:
984
899
continue
985
900
try:
986
rename(old_path, new_path)
987
changed_inventory[entry.id] = new_tree_path
901
os.rename(old_path, new_path)
988
902
except OSError, e:
989
903
raise Exception ("%s is missing" % new_path)
990
904
1024
938
Exception.__init__(self, "Conflict applying changes to %s" % this_path)
1025
939
self.this_path = this_path
1026
940
941
class MergePermissionConflict(Exception):
942
def __init__(self, this_path, base_path, other_path):
943
this_perms = os.stat(this_path).st_mode & 0755
944
base_perms = os.stat(base_path).st_mode & 0755
945
other_perms = os.stat(other_path).st_mode & 0755
946
msg = """Conflicting permission for %s
947
this: %o
948
base: %o
949
other: %o
950
""" % (this_path, this_perms, base_perms, other_perms)
951
self.this_path = this_path
952
self.base_path = base_path
953
self.other_path = other_path
954
Exception.__init__(self, msg)
955
1027
956
class WrongOldContents(Exception):
1028
957
def __init__(self, filename):
1029
958
msg = "Contents mismatch deleting %s" % filename
1030
959
self.filename = filename
1031
960
Exception.__init__(self, msg)
1032
961
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)
962
class WrongOldPermissions(Exception):
963
def __init__(self, filename, old_perms, new_perms):
964
msg = "Permission missmatch on %s:\n" \
965
"Expected 0%o, got 0%o." % (filename, old_perms, new_perms)
1037
966
self.filename = filename
1038
967
Exception.__init__(self, msg)
1039
968
1057
986
Exception.__init__(self, msg)
1058
987
self.filename = filename
1059
988
1060
class MissingForSetExec(Exception):
989
class MissingPermsFile(Exception):
1061
990
def __init__(self, filename):
1062
991
msg = "Attempt to change permissions on %s, which does not exist" %\
1063
992
filename
1072
1001
1073
1002
1074
1003
class MissingForRename(Exception):
1075
def __init__(self, filename, to_path):
1076
msg = "Attempt to move missing path %s to %s" % (filename, to_path)
1004
def __init__(self, filename):
1005
msg = "Attempt to move missing path %s" % (filename)
1077
1006
Exception.__init__(self, msg)
1078
1007
self.filename = filename
1079
1008
1080
class NewContentsConflict(Exception):
1081
def __init__(self, filename):
1082
msg = "Conflicting contents for new file %s" % (filename)
1083
Exception.__init__(self, msg)
1084
1085
class ThreewayContentsConflict(Exception):
1086
def __init__(self, filename):
1087
msg = "Conflicting contents for file %s" % (filename)
1088
Exception.__init__(self, msg)
1089
1090
1091
class MissingForMerge(Exception):
1092
def __init__(self, filename):
1093
msg = "The file %s was modified, but does not exist in this tree"\
1094
% (filename)
1095
Exception.__init__(self, msg)
1096
1097
1098
1009
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
"""
1010
def __init__(self, dir):
1011
self.dir = dir
1012
1105
1013
def missing_parent(self, pathname):
1106
1014
parent = os.path.dirname(pathname)
1107
1015
raise Exception("Parent directory missing for %s" % pathname)
1118
1026
def rename_conflict(self, id, this_name, base_name, other_name):
1119
1027
raise RenameConflict(id, this_name, base_name, other_name)
1120
1028
1121
def move_conflict(self, id, this_dir, base_dir, other_dir):
1029
def move_conflict(self, id, inventory):
1030
this_dir = inventory.this.get_dir(id)
1031
base_dir = inventory.base.get_dir(id)
1032
other_dir = inventory.other.get_dir(id)
1122
1033
raise MoveConflict(id, this_dir, base_dir, other_dir)
1123
1034
1124
def merge_conflict(self, new_file, this_path, base_lines, other_lines):
1035
def merge_conflict(self, new_file, this_path, base_path, other_path):
1125
1036
os.unlink(new_file)
1126
1037
raise MergeConflict(this_path)
1127
1038
1039
def permission_conflict(self, this_path, base_path, other_path):
1040
raise MergePermissionConflict(this_path, base_path, other_path)
1041
1128
1042
def wrong_old_contents(self, filename, expected_contents):
1129
1043
raise WrongOldContents(filename)
1130
1044
1131
1045
def rem_contents_conflict(self, filename, this_contents, base_contents):
1132
1046
raise RemoveContentsConflict(filename)
1133
1047
1134
def wrong_old_exec_flag(self, filename, old_exec_flag, new_exec_flag):
1135
raise WrongOldExecFlag(filename, old_exec_flag, new_exec_flag)
1048
def wrong_old_perms(self, filename, old_perms, new_perms):
1049
raise WrongOldPermissions(filename, old_perms, new_perms)
1136
1050
1137
1051
def rmdir_non_empty(self, filename):
1138
1052
raise DeletingNonEmptyDirectory(filename)
1143
1057
def patch_target_missing(self, filename, contents):
1144
1058
raise PatchTargetMissing(filename)
1145
1059
1146
def missing_for_exec_flag(self, filename):
1147
raise MissingForExecFlag(filename)
1060
def missing_for_chmod(self, filename):
1061
raise MissingPermsFile(filename)
1148
1062
1149
1063
def missing_for_rm(self, filename, change):
1150
1064
raise MissingForRm(filename)
1151
1065
1152
def missing_for_rename(self, filename, to_path):
1153
raise MissingForRename(filename, to_path)
1154
1155
def missing_for_merge(self, file_id, other_path):
1156
raise MissingForMerge(other_path)
1157
1158
def new_contents_conflict(self, filename, other_contents):
1159
raise NewContentsConflict(filename)
1160
1161
def threeway_contents_conflict(self, filename, this_contents,
1162
base_contents, other_contents):
1163
raise ThreewayContentsConflict(filename)
1164
1165
def finalize(self):
1066
def missing_for_rename(self, filename):
1067
raise MissingForRename(filename)
1068
1069
def finalize():
1166
1070
pass
1167
1071
1168
1072
def apply_changeset(changeset, inventory, dir, conflict_handler=None,
1181
1085
:rtype: Dictionary
1182
1086
"""
1183
1087
if conflict_handler is None:
1184
conflict_handler = ExceptionConflictHandler()
1185
temp_dir = os.path.join(dir, "bzr-tree-change")
1186
try:
1187
os.mkdir(temp_dir)
1188
except OSError, e:
1189
if e.errno == errno.EEXIST:
1190
try:
1191
os.rmdir(temp_dir)
1192
except OSError, e:
1193
if e.errno == errno.ENOTEMPTY:
1194
raise OldFailedTreeOp()
1195
os.mkdir(temp_dir)
1196
else:
1197
raise
1088
conflict_handler = ExceptionConflictHandler(dir)
1089
temp_dir = dir+"/temp"
1090
os.mkdir(temp_dir)
1198
1091
1199
1092
#apply changes that don't affect filenames
1200
1093
for entry in changeset.entries.itervalues():
1201
if not entry.is_creation_or_deletion() and not entry.is_boring():
1094
if not entry.is_creation_or_deletion():
1202
1095
path = os.path.join(dir, inventory[entry.id])
1203
1096
entry.apply(path, conflict_handler, reverse)
1204
1097
1209
1102
(source_entries, target_entries) = get_rename_entries(changeset, inventory,
1210
1103
reverse)
1211
1104
1212
changed_inventory = rename_to_temp_delete(source_entries, inventory, dir,
1213
temp_dir, conflict_handler,
1214
reverse)
1105
temp_name = rename_to_temp_delete(source_entries, inventory, dir,
1106
conflict_handler, reverse)
1215
1107
1216
rename_to_new_create(changed_inventory, target_entries, inventory,
1217
changeset, dir, conflict_handler, reverse)
1108
rename_to_new_create(temp_name, target_entries, inventory, changeset, dir,
1109
conflict_handler, reverse)
1218
1110
os.rmdir(temp_dir)
1219
return changed_inventory
1111
r_inventory = invert_dict(inventory)
1112
new_entries, removed_entries = get_inventory_change(inventory,
1113
r_inventory, changeset, reverse)
1114
new_inventory = {}
1115
for path, file_id in new_entries.iteritems():
1116
new_inventory[file_id] = path
1117
for file_id in removed_entries:
1118
new_inventory[file_id] = None
1119
return new_inventory
1220
1120
1221
1121
1222
1122
def apply_changeset_tree(cset, tree, reverse=False):
1223
1123
r_inventory = {}
1224
1124
for entry in tree.source_inventory().itervalues():
1225
1125
inventory[entry.id] = entry.path
1226
new_inventory = apply_changeset(cset, r_inventory, tree.basedir,
1126
new_inventory = apply_changeset(cset, r_inventory, tree.root,
1227
1127
reverse=reverse)
1228
1128
new_entries, remove_entries = \
1229
1129
get_inventory_change(inventory, new_inventory, cset, reverse)
1233
1133
def get_inventory_change(inventory, new_inventory, cset, reverse=False):
1234
1134
new_entries = {}
1235
1135
remove_entries = []
1136
r_inventory = invert_dict(inventory)
1137
r_new_inventory = invert_dict(new_inventory)
1236
1138
for entry in cset.entries.itervalues():
1237
1139
if entry.needs_rename():
1238
new_path = entry.get_new_path(inventory, cset)
1239
if new_path is None:
1240
remove_entries.append(entry.id)
1140
old_path = r_inventory.get(entry.id)
1141
if old_path is not None:
1142
remove_entries.append(old_path)
1241
1143
else:
1242
new_entries[new_path] = entry.id
1144
new_path = entry.get_new_path(inventory, cset)
1145
if new_path is not None:
1146
new_entries[new_path] = entry.id
1243
1147
return new_entries, remove_entries
1244
1148
1245
1149
1364
1268
return new_meta
1365
1269
elif new_meta is None:
1366
1270
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)
1271
elif isinstance(old_meta, ChangeUnixPermissions) and \
1272
isinstance(new_meta, ChangeUnixPermissions):
1273
return ChangeUnixPermissions(old_meta.old_mode, new_meta.new_mode)
1370
1274
else:
1371
1275
return ApplySequence(old_meta, new_meta)
1372
1276
1377
1281
return False
1378
1282
return True
1379
1283
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)
1284
class UnsuppportedFiletype(Exception):
1285
def __init__(self, full_path, stat_result):
1286
msg = "The file \"%s\" is not a supported filetype." % full_path
1384
1287
Exception.__init__(self, msg)
1385
1288
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
1289
self.stat_result = stat_result
1290
1291
def generate_changeset(tree_a, tree_b, inventory_a=None, inventory_b=None):
1292
return ChangesetGenerator(tree_a, tree_b, inventory_a, inventory_b)()
1391
1293
1392
1294
class ChangesetGenerator(object):
1393
def __init__(self, tree_a, tree_b, interesting_ids=None):
1295
def __init__(self, tree_a, tree_b, inventory_a=None, inventory_b=None):
1394
1296
object.__init__(self)
1395
1297
self.tree_a = tree_a
1396
1298
self.tree_b = tree_b
1397
self._interesting_ids = interesting_ids
1299
if inventory_a is not None:
1300
self.inventory_a = inventory_a
1301
else:
1302
self.inventory_a = tree_a.inventory()
1303
if inventory_b is not None:
1304
self.inventory_b = inventory_b
1305
else:
1306
self.inventory_b = tree_b.inventory()
1307
self.r_inventory_a = self.reverse_inventory(self.inventory_a)
1308
self.r_inventory_b = self.reverse_inventory(self.inventory_b)
1398
1309
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
1310
def reverse_inventory(self, inventory):
1311
r_inventory = {}
1312
for entry in inventory.itervalues():
1313
if entry.id is None:
1314
continue
1315
r_inventory[entry.id] = entry
1316
return r_inventory
1405
1317
1406
1318
def __call__(self):
1407
1319
cset = Changeset()
1408
for file_id in self.iter_both_tree_ids():
1409
cs_entry = self.make_entry(file_id)
1320
for entry in self.inventory_a.itervalues():
1321
if entry.id is None:
1322
continue
1323
cs_entry = self.make_entry(entry.id)
1410
1324
if cs_entry is not None and not cs_entry.is_boring():
1411
1325
cset.add_entry(cs_entry)
1412
1326
1327
for entry in self.inventory_b.itervalues():
1328
if entry.id is None:
1329
continue
1330
if not self.r_inventory_a.has_key(entry.id):
1331
cs_entry = self.make_entry(entry.id)
1332
if cs_entry is not None and not cs_entry.is_boring():
1333
cset.add_entry(cs_entry)
1413
1334
for entry in list(cset.entries.itervalues()):
1414
1335
if entry.parent != entry.new_parent:
1415
1336
if not cset.entries.has_key(entry.parent) and\
1423
1344
cset.add_entry(parent_entry)
1424
1345
return cset
1425
1346
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)
1347
def get_entry_parent(self, entry, inventory):
1348
if entry is None:
1349
return None
1350
if entry.path == "./.":
1351
return NULL_ID
1352
dirname = os.path.dirname(entry.path)
1353
if dirname == ".":
1354
dirname = "./."
1355
parent = inventory[dirname]
1356
return parent.id
1357
1358
def get_paths(self, entry, tree):
1359
if entry is None:
1360
return (None, None)
1361
full_path = tree.readonly_path(entry.id)
1362
if entry.path == ".":
1363
return ("", full_path)
1364
return (entry.path, full_path)
1365
1366
def make_basic_entry(self, id, only_interesting):
1367
entry_a = self.r_inventory_a.get(id)
1368
entry_b = self.r_inventory_b.get(id)
1452
1369
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)
1370
return (None, None, None)
1371
parent = self.get_entry_parent(entry_a, self.inventory_a)
1372
(path, full_path_a) = self.get_paths(entry_a, self.tree_a)
1373
cs_entry = ChangesetEntry(id, parent, path)
1374
new_parent = self.get_entry_parent(entry_b, self.inventory_b)
1375
1376
1377
(new_path, full_path_b) = self.get_paths(entry_b, self.tree_b)
1460
1378
1461
1379
cs_entry.new_path = new_path
1462
1380
cs_entry.new_parent = new_parent
1463
return cs_entry
1381
return (cs_entry, full_path_a, full_path_b)
1464
1382
1465
1383
def is_interesting(self, entry_a, entry_b):
1466
if self._interesting_ids is None:
1467
return True
1468
1384
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
1385
if entry_a.interesting:
1386
return True
1387
if entry_b is not None:
1388
if entry_b.interesting:
1389
return True
1390
return False
1475
1391
1476
1392
def make_boring_entry(self, id):
1477
cs_entry = self.make_basic_entry(id, only_interesting=False)
1393
(cs_entry, full_path_a, full_path_b) = \
1394
self.make_basic_entry(id, only_interesting=False)
1478
1395
if cs_entry.is_creation_or_deletion():
1479
1396
return self.make_entry(id, only_interesting=False)
1480
1397
else:
1482
1399
1483
1400
1484
1401
def make_entry(self, id, only_interesting=True):
1485
cs_entry = self.make_basic_entry(id, only_interesting)
1402
(cs_entry, full_path_a, full_path_b) = \
1403
self.make_basic_entry(id, only_interesting)
1486
1404
1487
1405
if cs_entry is None:
1488
1406
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)
1407
1408
stat_a = self.lstat(full_path_a)
1409
stat_b = self.lstat(full_path_b)
1410
if stat_b is None:
1411
cs_entry.new_parent = None
1412
cs_entry.new_path = None
1413
1414
cs_entry.metadata_change = self.make_mode_change(stat_a, stat_b)
1415
cs_entry.contents_change = self.make_contents_change(full_path_a,
1416
stat_a,
1417
full_path_b,
1418
stat_b)
1499
1419
return cs_entry
1500
1420
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)
1421
def make_mode_change(self, stat_a, stat_b):
1422
mode_a = None
1423
if stat_a is not None and not stat.S_ISLNK(stat_a.st_mode):
1424
mode_a = stat_a.st_mode & 0777
1425
mode_b = None
1426
if stat_b is not None and not stat.S_ISLNK(stat_b.st_mode):
1427
mode_b = stat_b.st_mode & 0777
1428
if mode_a == mode_b:
1429
return None
1430
return ChangeUnixPermissions(mode_a, mode_b)
1431
1432
def make_contents_change(self, full_path_a, stat_a, full_path_b, stat_b):
1433
if stat_a is None and stat_b is None:
1434
return None
1435
if None not in (stat_a, stat_b) and stat.S_ISDIR(stat_a.st_mode) and\
1436
stat.S_ISDIR(stat_b.st_mode):
1437
return None
1438
if None not in (stat_a, stat_b) and stat.S_ISREG(stat_a.st_mode) and\
1439
stat.S_ISREG(stat_b.st_mode):
1440
if stat_a.st_ino == stat_b.st_ino and \
1441
stat_a.st_dev == stat_b.st_dev:
1442
return None
1443
if file(full_path_a, "rb").read() == \
1444
file(full_path_b, "rb").read():
1445
return None
1446
1447
patch_contents = patch.diff(full_path_a,
1448
file(full_path_b, "rb").read())
1449
if patch_contents is None:
1450
return None
1451
return PatchApply(patch_contents)
1452
1453
a_contents = self.get_contents(stat_a, full_path_a)
1454
b_contents = self.get_contents(stat_b, full_path_b)
1516
1455
if a_contents == b_contents:
1517
1456
return None
1518
1457
return ReplaceContents(a_contents, b_contents)
1519
1458
1459
def get_contents(self, stat_result, full_path):
1460
if stat_result is None:
1461
return None
1462
elif stat.S_ISREG(stat_result.st_mode):
1463
return FileCreate(file(full_path, "rb").read())
1464
elif stat.S_ISDIR(stat_result.st_mode):
1465
return dir_create
1466
elif stat.S_ISLNK(stat_result.st_mode):
1467
return SymlinkCreate(os.readlink(full_path))
1468
else:
1469
raise UnsupportedFiletype(full_path, stat_result)
1520
1470
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))
1471
def lstat(self, full_path):
1472
stat_result = None
1473
if full_path is not None:
1474
try:
1475
stat_result = os.lstat(full_path)
1476
except OSError, e:
1477
if e.errno != errno.ENOENT:
1478
raise
1479
return stat_result
1534
1480
1535
1481
1536
1482
def full_path(entry, tree):
1537
return os.path.join(tree.basedir, entry.path)
1483
return os.path.join(tree.root, entry.path)
1538
1484
1539
1485
def new_delete_entry(entry, tree, inventory, delete):
1540
1486
if entry.path == "":
1556
1502
1557
1503
1558
1504
1559
# XXX: Can't we unify this with the regular inventory object
1505
1560
1506
class Inventory(object):
1561
1507
def __init__(self, inventory):
1562
1508
self.inventory = inventory
1571
1517
return self.inventory.get(id)
1572
1518
1573
1519
def get_name(self, id):
1574
path = self.get_path(id)
1575
if path is None:
1576
return None
1577
else:
1578
return os.path.basename(path)
1520
return os.path.basename(self.get_path(id))
1579
1521
1580
1522
def get_dir(self, id):
1581
1523
path = self.get_path(id)
1582
1524
if path == "":
1583
1525
return None
1584
if path is None:
1585
return None
1586
1526
return os.path.dirname(path)
1587
1527
1588
1528
def get_parent(self, id):
1589
if self.get_path(id) is None:
1590
return None
1591
1529
directory = self.get_dir(id)
1592
1530
if directory == '.':
1593
1531
directory = './.'
Loggerhead is a web-based interface for Breezy
Version: 2.0.1