« back to all changes in this revision
Viewing changes to bzrlib/changeset.py
- browse files at revision 757
- compare with another revision
- download diff
- download tarball
- view history from revision 757
- Committer: Martin Pool
- Date: 2005-06-22 09:08:43 UTC
- Revision ID: mbp@sourcefrog.net-20050622090843-78fe9c62da9ed167
- add john's changeset plugin
- files added:
- bzrlib/mdiff.py
- contrib/plugins/changeset
- files removed:
- HACKING
- bzrlib/store
- bzrlib/transport
- bzrlib/util
- bzrlib/util/configobj
- bzrlib/util/configobj/docs
- bzrlib/util/effbot
- bzrlib/util/effbot/org
- contrib/emacs
- tools
- files renamed:
- bzr_man.py => bzr-man.py
- contrib/newinventory.py => bzrlib/newinventory.py
- bzrlib/selftest/testplugins.py => bzrlib/selftest/plugins.py
- bzrlib/store/__init__.py => bzrlib/store.py
- bzrlib/plugins/ => contrib/plugins/
- bzrlib/util/elementtree/ => elementtree/
- bzrlib/util/urlgrabber/ => urlgrabber/
- files modified:
- .bzrignore
- bzr *
- setup.py *
added
removed
bzrlib/changeset.py
13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
16
17
"""Represent and apply a changeset.
18
19
Conflicts in applying a changeset are represented as exceptions.
20
21
This only handles the in-memory objects representing changesets, which are
22
primarily used by the merge code.
23
"""
24
25
16
import os.path
26
17
import errno
18
import patch
27
19
import stat
28
from tempfile import mkdtemp
29
from shutil import rmtree
30
from itertools import izip
31
32
from bzrlib.trace import mutter, warning
33
from bzrlib.osutils import rename, sha_file
34
import bzrlib
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
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
366
def __init__(self, base_file, other_file):
367
self.base_file = base_file
368
self.other_file = other_file
425
369
426
370
def __eq__(self, other):
427
371
if not isinstance(other, Diff3Merge):
428
372
return False
429
return (self.base == other.base and
430
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)
431
375
432
376
def __ne__(self, other):
433
377
return not (self == other)
434
378
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
379
def apply(self, filename, conflict_handler, reverse=False):
444
import bzrlib.patch
445
temp_dir = mkdtemp(prefix="bzr-")
446
try:
447
new_file = filename+".new"
448
base_file = self.dump_file(temp_dir, "base", self.base)
449
other_file = self.dump_file(temp_dir, "other", self.other)
450
if not reverse:
451
base = base_file
452
other = other_file
453
else:
454
base = other_file
455
other = base_file
456
status = bzrlib.patch.diff3(new_file, filename, base, other)
457
if status == 0:
458
os.chmod(new_file, os.stat(filename).st_mode)
459
rename(new_file, filename)
460
return
461
else:
462
assert(status == 1)
463
def get_lines(filename):
464
my_file = file(filename, "rb")
465
lines = my_file.readlines()
466
my_file.close()
467
return lines
468
base_lines = get_lines(base)
469
other_lines = get_lines(other)
470
conflict_handler.merge_conflict(new_file, filename, base_lines,
471
other_lines)
472
finally:
473
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)
474
395
475
396
476
397
def CreateDir():
509
430
"""
510
431
return ReplaceContents(FileCreate(contents), None)
511
432
512
def ReplaceFileContents(old_tree, new_tree, file_id):
433
def ReplaceFileContents(old_contents, new_contents):
513
434
"""Convenience fucntion to replace the contents of a file.
514
435
515
436
:param old_contents: The contents of the file to replace
519
440
:return: A ReplaceContents that will replace the contents of a file a file
520
441
:rtype: `ReplaceContents`
521
442
"""
522
return ReplaceContents(TreeFileCreate(old_tree, file_id),
523
TreeFileCreate(new_tree, file_id))
443
return ReplaceContents(FileCreate(old_contents), FileCreate(new_contents))
524
444
525
445
def CreateSymlink(target):
526
446
"""Convenience fucntion to create a symlink.
689
609
:param reverse: if true, the changeset is being applied in reverse
690
610
:rtype: bool
691
611
"""
692
return self.is_creation(not reverse)
612
return ((self.new_parent is None and not reverse) or
613
(self.parent is None and reverse))
693
614
694
615
def is_creation(self, reverse):
695
616
"""Return true if applying the entry would create a file/directory.
697
618
:param reverse: if true, the changeset is being applied in reverse
698
619
:rtype: bool
699
620
"""
700
if self.contents_change is None:
701
return False
702
if reverse:
703
return self.contents_change.is_deletion()
704
else:
705
return self.contents_change.is_creation()
621
return ((self.parent is None and not reverse) or
622
(self.new_parent is None and reverse))
706
623
707
624
def is_creation_or_deletion(self):
708
625
"""Return true if applying the entry would create or delete a
710
627
711
628
:rtype: bool
712
629
"""
713
return self.is_creation(False) or self.is_deletion(False)
630
return self.parent is None or self.new_parent is None
714
631
715
632
def get_cset_path(self, mod=False):
716
633
"""Determine the path of the entry according to the changeset.
736
653
return None
737
654
return self.path
738
655
739
def summarize_name(self, reverse=False):
656
def summarize_name(self, changeset, reverse=False):
740
657
"""Produce a one-line summary of the filename. Indicates renames as
741
658
old => new, indicates creation as None => new, indicates deletion as
742
659
old => None.
773
690
:type reverse: bool
774
691
:rtype: str
775
692
"""
776
mutter("Finding new path for %s", self.summarize_name())
777
693
if reverse:
778
694
parent = self.parent
779
695
to_dir = self.dir
798
714
if from_dir == to_dir:
799
715
dir = os.path.dirname(id_map[self.id])
800
716
else:
801
mutter("path, new_path: %r %r", self.path, self.new_path)
802
717
parent_entry = changeset.entries[parent]
803
718
dir = parent_entry.get_new_path(id_map, changeset, reverse)
804
719
if from_name == to_name:
888
803
:rtype: (List, List)
889
804
"""
890
805
source_entries = [x for x in changeset.entries.itervalues()
891
if x.needs_rename() or x.is_creation_or_deletion()]
806
if x.needs_rename()]
892
807
# these are done from longest path to shortest, to avoid deleting a
893
808
# parent before its children are deleted/renamed
894
809
def longest_to_shortest(entry):
911
826
my_sort(target_entries, shortest_to_longest)
912
827
return (source_entries, target_entries)
913
828
914
def rename_to_temp_delete(source_entries, inventory, dir, temp_dir,
915
conflict_handler, reverse):
829
def rename_to_temp_delete(source_entries, inventory, dir, conflict_handler,
830
reverse):
916
831
"""Delete and rename entries as appropriate. Entries are renamed to temp
917
names. A map of id -> temp name (or None, for deletions) is returned.
832
names. A map of id -> temp name is returned.
918
833
919
834
:param source_entries: The entries to rename and delete
920
835
:type source_entries: List of `ChangesetEntry`
927
842
:return: a mapping of id to temporary name
928
843
:rtype: Dictionary
929
844
"""
845
temp_dir = os.path.join(dir, "temp")
930
846
temp_name = {}
931
847
for i in range(len(source_entries)):
932
848
entry = source_entries[i]
933
849
if entry.is_deletion(reverse):
934
850
path = os.path.join(dir, inventory[entry.id])
935
851
entry.apply(path, conflict_handler, reverse)
936
temp_name[entry.id] = None
937
852
938
elif entry.needs_rename():
939
to_name = os.path.join(temp_dir, str(i))
853
else:
854
to_name = temp_dir+"/"+str(i)
940
855
src_path = inventory.get(entry.id)
941
856
if src_path is not None:
942
857
src_path = os.path.join(dir, src_path)
943
858
try:
944
rename(src_path, to_name)
859
os.rename(src_path, to_name)
945
860
temp_name[entry.id] = to_name
946
861
except OSError, e:
947
862
if e.errno != errno.ENOENT:
948
863
raise
949
if conflict_handler.missing_for_rename(src_path, to_name) \
950
== "skip":
864
if conflict_handler.missing_for_rename(src_path) == "skip":
951
865
continue
952
866
953
867
return temp_name
954
868
955
869
956
def rename_to_new_create(changed_inventory, target_entries, inventory,
957
changeset, dir, conflict_handler, reverse):
870
def rename_to_new_create(temp_name, target_entries, inventory, changeset, dir,
871
conflict_handler, reverse):
958
872
"""Rename entries with temp names to their final names, create new files.
959
873
960
:param changed_inventory: A mapping of id to temporary name
961
:type changed_inventory: Dictionary
874
:param temp_name: A mapping of id to temporary name
875
:type temp_name: Dictionary
962
876
:param target_entries: The entries to apply changes to
963
877
:type target_entries: List of `ChangesetEntry`
964
878
:param changeset: The changeset to apply
969
883
:type reverse: bool
970
884
"""
971
885
for entry in target_entries:
972
new_tree_path = entry.get_new_path(inventory, changeset, reverse)
973
if new_tree_path is None:
886
new_path = entry.get_new_path(inventory, changeset, reverse)
887
if new_path is None:
974
888
continue
975
new_path = os.path.join(dir, new_tree_path)
976
old_path = changed_inventory.get(entry.id)
977
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):
978
892
if conflict_handler.target_exists(entry, new_path, old_path) == \
979
893
"skip":
980
894
continue
981
895
if entry.is_creation(reverse):
982
896
entry.apply(new_path, conflict_handler, reverse)
983
changed_inventory[entry.id] = new_tree_path
984
elif entry.needs_rename():
897
else:
985
898
if old_path is None:
986
899
continue
987
900
try:
988
rename(old_path, new_path)
989
changed_inventory[entry.id] = new_tree_path
901
os.rename(old_path, new_path)
990
902
except OSError, e:
991
903
raise Exception ("%s is missing" % new_path)
992
904
1026
938
Exception.__init__(self, "Conflict applying changes to %s" % this_path)
1027
939
self.this_path = this_path
1028
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
1029
956
class WrongOldContents(Exception):
1030
957
def __init__(self, filename):
1031
958
msg = "Contents mismatch deleting %s" % filename
1032
959
self.filename = filename
1033
960
Exception.__init__(self, msg)
1034
961
1035
class WrongOldExecFlag(Exception):
1036
def __init__(self, filename, old_exec_flag, new_exec_flag):
1037
msg = "Executable flag missmatch on %s:\n" \
1038
"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)
1039
966
self.filename = filename
1040
967
Exception.__init__(self, msg)
1041
968
1059
986
Exception.__init__(self, msg)
1060
987
self.filename = filename
1061
988
1062
class MissingForSetExec(Exception):
989
class MissingPermsFile(Exception):
1063
990
def __init__(self, filename):
1064
991
msg = "Attempt to change permissions on %s, which does not exist" %\
1065
992
filename
1074
1001
1075
1002
1076
1003
class MissingForRename(Exception):
1077
def __init__(self, filename, to_path):
1078
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)
1079
1006
Exception.__init__(self, msg)
1080
1007
self.filename = filename
1081
1008
1082
class NewContentsConflict(Exception):
1083
def __init__(self, filename):
1084
msg = "Conflicting contents for new file %s" % (filename)
1085
Exception.__init__(self, msg)
1086
1087
class WeaveMergeConflict(Exception):
1088
def __init__(self, filename):
1089
msg = "Conflicting contents for file %s" % (filename)
1090
Exception.__init__(self, msg)
1091
1092
class ThreewayContentsConflict(Exception):
1093
def __init__(self, filename):
1094
msg = "Conflicting contents for file %s" % (filename)
1095
Exception.__init__(self, msg)
1096
1097
1098
class MissingForMerge(Exception):
1099
def __init__(self, filename):
1100
msg = "The file %s was modified, but does not exist in this tree"\
1101
% (filename)
1102
Exception.__init__(self, msg)
1103
1104
1105
1009
class ExceptionConflictHandler(object):
1106
"""Default handler for merge exceptions.
1107
1108
This throws an error on any kind of conflict. Conflict handlers can
1109
descend from this class if they have a better way to handle some or
1110
all types of conflict.
1111
"""
1010
def __init__(self, dir):
1011
self.dir = dir
1012
1112
1013
def missing_parent(self, pathname):
1113
1014
parent = os.path.dirname(pathname)
1114
1015
raise Exception("Parent directory missing for %s" % pathname)
1125
1026
def rename_conflict(self, id, this_name, base_name, other_name):
1126
1027
raise RenameConflict(id, this_name, base_name, other_name)
1127
1028
1128
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)
1129
1033
raise MoveConflict(id, this_dir, base_dir, other_dir)
1130
1034
1131
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):
1132
1036
os.unlink(new_file)
1133
1037
raise MergeConflict(this_path)
1134
1038
1039
def permission_conflict(self, this_path, base_path, other_path):
1040
raise MergePermissionConflict(this_path, base_path, other_path)
1041
1135
1042
def wrong_old_contents(self, filename, expected_contents):
1136
1043
raise WrongOldContents(filename)
1137
1044
1138
1045
def rem_contents_conflict(self, filename, this_contents, base_contents):
1139
1046
raise RemoveContentsConflict(filename)
1140
1047
1141
def wrong_old_exec_flag(self, filename, old_exec_flag, new_exec_flag):
1142
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)
1143
1050
1144
1051
def rmdir_non_empty(self, filename):
1145
1052
raise DeletingNonEmptyDirectory(filename)
1150
1057
def patch_target_missing(self, filename, contents):
1151
1058
raise PatchTargetMissing(filename)
1152
1059
1153
def missing_for_exec_flag(self, filename):
1154
raise MissingForExecFlag(filename)
1060
def missing_for_chmod(self, filename):
1061
raise MissingPermsFile(filename)
1155
1062
1156
1063
def missing_for_rm(self, filename, change):
1157
1064
raise MissingForRm(filename)
1158
1065
1159
def missing_for_rename(self, filename, to_path):
1160
raise MissingForRename(filename, to_path)
1161
1162
def missing_for_merge(self, file_id, other_path):
1163
raise MissingForMerge(other_path)
1164
1165
def new_contents_conflict(self, filename, other_contents):
1166
raise NewContentsConflict(filename)
1167
1168
def weave_merge_conflict(self, filename, weave, other_i, out_file):
1169
raise WeaveMergeConflict(filename)
1170
1171
def threeway_contents_conflict(self, filename, this_contents,
1172
base_contents, other_contents):
1173
raise ThreewayContentsConflict(filename)
1174
1175
def finalize(self):
1066
def missing_for_rename(self, filename):
1067
raise MissingForRename(filename)
1068
1069
def finalize():
1176
1070
pass
1177
1071
1178
1072
def apply_changeset(changeset, inventory, dir, conflict_handler=None,
1191
1085
:rtype: Dictionary
1192
1086
"""
1193
1087
if conflict_handler is None:
1194
conflict_handler = ExceptionConflictHandler()
1195
temp_dir = os.path.join(dir, "bzr-tree-change")
1196
try:
1197
os.mkdir(temp_dir)
1198
except OSError, e:
1199
if e.errno == errno.EEXIST:
1200
try:
1201
os.rmdir(temp_dir)
1202
except OSError, e:
1203
if e.errno == errno.ENOTEMPTY:
1204
raise OldFailedTreeOp()
1205
os.mkdir(temp_dir)
1206
else:
1207
raise
1088
conflict_handler = ExceptionConflictHandler(dir)
1089
temp_dir = dir+"/temp"
1090
os.mkdir(temp_dir)
1208
1091
1209
1092
#apply changes that don't affect filenames
1210
1093
for entry in changeset.entries.itervalues():
1211
if not entry.is_creation_or_deletion() and not entry.is_boring():
1212
if entry.id not in inventory:
1213
warning("entry {%s} no longer present, can't be updated",
1214
entry.id)
1215
continue
1094
if not entry.is_creation_or_deletion():
1216
1095
path = os.path.join(dir, inventory[entry.id])
1217
1096
entry.apply(path, conflict_handler, reverse)
1218
1097
1223
1102
(source_entries, target_entries) = get_rename_entries(changeset, inventory,
1224
1103
reverse)
1225
1104
1226
changed_inventory = rename_to_temp_delete(source_entries, inventory, dir,
1227
temp_dir, conflict_handler,
1228
reverse)
1105
temp_name = rename_to_temp_delete(source_entries, inventory, dir,
1106
conflict_handler, reverse)
1229
1107
1230
rename_to_new_create(changed_inventory, target_entries, inventory,
1231
changeset, dir, conflict_handler, reverse)
1108
rename_to_new_create(temp_name, target_entries, inventory, changeset, dir,
1109
conflict_handler, reverse)
1232
1110
os.rmdir(temp_dir)
1233
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
1234
1120
1235
1121
1236
1122
def apply_changeset_tree(cset, tree, reverse=False):
1237
1123
r_inventory = {}
1238
1124
for entry in tree.source_inventory().itervalues():
1239
1125
inventory[entry.id] = entry.path
1240
new_inventory = apply_changeset(cset, r_inventory, tree.basedir,
1126
new_inventory = apply_changeset(cset, r_inventory, tree.root,
1241
1127
reverse=reverse)
1242
1128
new_entries, remove_entries = \
1243
1129
get_inventory_change(inventory, new_inventory, cset, reverse)
1247
1133
def get_inventory_change(inventory, new_inventory, cset, reverse=False):
1248
1134
new_entries = {}
1249
1135
remove_entries = []
1136
r_inventory = invert_dict(inventory)
1137
r_new_inventory = invert_dict(new_inventory)
1250
1138
for entry in cset.entries.itervalues():
1251
1139
if entry.needs_rename():
1252
new_path = entry.get_new_path(inventory, cset)
1253
if new_path is None:
1254
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)
1255
1143
else:
1256
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
1257
1147
return new_entries, remove_entries
1258
1148
1259
1149
1378
1268
return new_meta
1379
1269
elif new_meta is None:
1380
1270
return old_meta
1381
elif (isinstance(old_meta, ChangeExecFlag) and
1382
isinstance(new_meta, ChangeExecFlag)):
1383
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)
1384
1274
else:
1385
1275
return ApplySequence(old_meta, new_meta)
1386
1276
1391
1281
return False
1392
1282
return True
1393
1283
1394
class UnsupportedFiletype(Exception):
1395
def __init__(self, kind, full_path):
1396
msg = "The file \"%s\" is a %s, which is not a supported filetype." \
1397
% (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
1398
1287
Exception.__init__(self, msg)
1399
1288
self.full_path = full_path
1400
self.kind = kind
1401
1402
def generate_changeset(tree_a, tree_b, interesting_ids=None):
1403
return ChangesetGenerator(tree_a, tree_b, interesting_ids)()
1404
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)()
1405
1293
1406
1294
class ChangesetGenerator(object):
1407
def __init__(self, tree_a, tree_b, interesting_ids=None):
1295
def __init__(self, tree_a, tree_b, inventory_a=None, inventory_b=None):
1408
1296
object.__init__(self)
1409
1297
self.tree_a = tree_a
1410
1298
self.tree_b = tree_b
1411
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)
1412
1309
1413
def iter_both_tree_ids(self):
1414
for file_id in self.tree_a:
1415
yield file_id
1416
for file_id in self.tree_b:
1417
if file_id not in self.tree_a:
1418
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
1419
1317
1420
1318
def __call__(self):
1421
1319
cset = Changeset()
1422
for file_id in self.iter_both_tree_ids():
1423
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)
1424
1324
if cs_entry is not None and not cs_entry.is_boring():
1425
1325
cset.add_entry(cs_entry)
1426
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)
1427
1334
for entry in list(cset.entries.itervalues()):
1428
1335
if entry.parent != entry.new_parent:
1429
1336
if not cset.entries.has_key(entry.parent) and\
1437
1344
cset.add_entry(parent_entry)
1438
1345
return cset
1439
1346
1440
def iter_inventory(self, tree):
1441
for file_id in tree:
1442
yield self.get_entry(file_id, tree)
1443
1444
def get_entry(self, file_id, tree):
1445
if not tree.has_or_had_id(file_id):
1446
return None
1447
return tree.inventory[file_id]
1448
1449
def get_entry_parent(self, entry):
1450
if entry is None:
1451
return None
1452
return entry.parent_id
1453
1454
def get_path(self, file_id, tree):
1455
if not tree.has_or_had_id(file_id):
1456
return None
1457
path = tree.id2path(file_id)
1458
if path == '':
1459
return './.'
1460
else:
1461
return path
1462
1463
def make_basic_entry(self, file_id, only_interesting):
1464
entry_a = self.get_entry(file_id, self.tree_a)
1465
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)
1466
1369
if only_interesting and not self.is_interesting(entry_a, entry_b):
1467
return None
1468
parent = self.get_entry_parent(entry_a)
1469
path = self.get_path(file_id, self.tree_a)
1470
cs_entry = ChangesetEntry(file_id, parent, path)
1471
new_parent = self.get_entry_parent(entry_b)
1472
1473
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)
1474
1378
1475
1379
cs_entry.new_path = new_path
1476
1380
cs_entry.new_parent = new_parent
1477
return cs_entry
1381
return (cs_entry, full_path_a, full_path_b)
1478
1382
1479
1383
def is_interesting(self, entry_a, entry_b):
1480
if self._interesting_ids is None:
1481
return True
1482
1384
if entry_a is not None:
1483
file_id = entry_a.file_id
1484
elif entry_b is not None:
1485
file_id = entry_b.file_id
1486
else:
1487
return False
1488
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
1489
1391
1490
1392
def make_boring_entry(self, id):
1491
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)
1492
1395
if cs_entry.is_creation_or_deletion():
1493
1396
return self.make_entry(id, only_interesting=False)
1494
1397
else:
1496
1399
1497
1400
1498
1401
def make_entry(self, id, only_interesting=True):
1499
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)
1500
1404
1501
1405
if cs_entry is None:
1502
1406
return None
1503
1504
cs_entry.metadata_change = self.make_exec_flag_change(id)
1505
1506
if id in self.tree_a and id in self.tree_b:
1507
a_sha1 = self.tree_a.get_file_sha1(id)
1508
b_sha1 = self.tree_b.get_file_sha1(id)
1509
if None not in (a_sha1, b_sha1) and a_sha1 == b_sha1:
1510
return cs_entry
1511
1512
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)
1513
1419
return cs_entry
1514
1420
1515
def make_exec_flag_change(self, file_id):
1516
exec_flag_a = exec_flag_b = None
1517
if file_id in self.tree_a and self.tree_a.kind(file_id) == "file":
1518
exec_flag_a = self.tree_a.is_executable(file_id)
1519
1520
if file_id in self.tree_b and self.tree_b.kind(file_id) == "file":
1521
exec_flag_b = self.tree_b.is_executable(file_id)
1522
1523
if exec_flag_a == exec_flag_b:
1524
return None
1525
return ChangeExecFlag(exec_flag_a, exec_flag_b)
1526
1527
def make_contents_change(self, file_id):
1528
a_contents = get_contents(self.tree_a, file_id)
1529
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)
1530
1455
if a_contents == b_contents:
1531
1456
return None
1532
1457
return ReplaceContents(a_contents, b_contents)
1533
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)
1534
1470
1535
def get_contents(tree, file_id):
1536
"""Return the appropriate contents to create a copy of file_id from tree"""
1537
if file_id not in tree:
1538
return None
1539
kind = tree.kind(file_id)
1540
if kind == "file":
1541
return TreeFileCreate(tree, file_id)
1542
elif kind in ("directory", "root_directory"):
1543
return dir_create
1544
elif kind == "symlink":
1545
return SymlinkCreate(tree.get_symlink_target(file_id))
1546
else:
1547
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
1548
1480
1549
1481
1550
1482
def full_path(entry, tree):
1551
return os.path.join(tree.basedir, entry.path)
1483
return os.path.join(tree.root, entry.path)
1552
1484
1553
1485
def new_delete_entry(entry, tree, inventory, delete):
1554
1486
if entry.path == "":
1570
1502
1571
1503
1572
1504
1573
# XXX: Can't we unify this with the regular inventory object
1505
1574
1506
class Inventory(object):
1575
1507
def __init__(self, inventory):
1576
1508
self.inventory = inventory
1585
1517
return self.inventory.get(id)
1586
1518
1587
1519
def get_name(self, id):
1588
path = self.get_path(id)
1589
if path is None:
1590
return None
1591
else:
1592
return os.path.basename(path)
1520
return os.path.basename(self.get_path(id))
1593
1521
1594
1522
def get_dir(self, id):
1595
1523
path = self.get_path(id)
1596
1524
if path == "":
1597
1525
return None
1598
if path is None:
1599
return None
1600
1526
return os.path.dirname(path)
1601
1527
1602
1528
def get_parent(self, id):
1603
if self.get_path(id) is None:
1604
return None
1605
1529
directory = self.get_dir(id)
1606
1530
if directory == '.':
1607
1531
directory = './.'
Loggerhead is a web-based interface for Breezy
Version: 2.0.1