To get this branch, use:
bzr branch
http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar
« back to all changes in this revision
Viewing changes to bzrlib/transform.py
- browse files at revision 3173.1.14
- compare with another revision
- compare with revision 5200.2.4
- download diff
- download tarball
- view history from revision 3173.1.14
- Committer: Martin Pool
- Date: 2008-02-06 00:41:04 UTC
- mfrom: (3215 +trunk)
- mto: This revision was merged to the branch mainline in revision 3219.
- Revision ID: mbp@sourcefrog.net-20080206004104-mxtn32habuhjq6b8
Merge trunk
- files removed:
- bzrlib/plugins/multiparent.py
- files modified:
- NEWS
added
removed
bzrlib/transform.py
1
# Copyright (C) 2006, 2007 Canonical Ltd
1
# Copyright (C) 2006, 2007, 2008 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
17
17
import os
18
18
import errno
19
19
from stat import S_ISREG
20
import tempfile
20
21
21
22
from bzrlib.lazy_import import lazy_import
22
23
lazy_import(globals(), """
62
63
self.rename_count = rename_count
63
64
64
65
65
class TreeTransform(object):
66
"""Represent a tree transformation.
67
68
This object is designed to support incremental generation of the transform,
69
in any order.
70
71
However, it gives optimum performance when parent directories are created
72
before their contents. The transform is then able to put child files
73
directly in their parent directory, avoiding later renames.
74
75
It is easy to produce malformed transforms, but they are generally
76
harmless. Attempting to apply a malformed transform will cause an
77
exception to be raised before any modifications are made to the tree.
78
79
Many kinds of malformed transforms can be corrected with the
80
resolve_conflicts function. The remaining ones indicate programming error,
81
such as trying to create a file with no path.
82
83
Two sets of file creation methods are supplied. Convenience methods are:
84
* new_file
85
* new_directory
86
* new_symlink
87
88
These are composed of the low-level methods:
89
* create_path
90
* create_file or create_directory or create_symlink
91
* version_file
92
* set_executability
93
94
Transform/Transaction ids
95
-------------------------
96
trans_ids are temporary ids assigned to all files involved in a transform.
97
It's possible, even common, that not all files in the Tree have trans_ids.
98
99
trans_ids are used because filenames and file_ids are not good enough
100
identifiers; filenames change, and not all files have file_ids. File-ids
101
are also associated with trans-ids, so that moving a file moves its
102
file-id.
103
104
trans_ids are only valid for the TreeTransform that generated them.
105
106
Limbo
107
-----
108
Limbo is a temporary directory use to hold new versions of files.
109
Files are added to limbo by create_file, create_directory, create_symlink,
110
and their convenience variants (new_*). Files may be removed from limbo
111
using cancel_creation. Files are renamed from limbo into their final
112
location as part of TreeTransform.apply
113
114
Limbo must be cleaned up, by either calling TreeTransform.apply or
115
calling TreeTransform.finalize.
116
117
Files are placed into limbo inside their parent directories, where
118
possible. This reduces subsequent renames, and makes operations involving
119
lots of files faster. This optimization is only possible if the parent
120
directory is created *before* creating any of its children, so avoid
121
creating children before parents, where possible.
122
123
Pending-deletion
124
----------------
125
This temporary directory is used by _FileMover for storing files that are
126
about to be deleted. In case of rollback, the files will be restored.
127
FileMover does not delete files until it is sure that a rollback will not
128
happen.
129
"""
130
def __init__(self, tree, pb=DummyProgress()):
131
"""Note: a tree_write lock is taken on the tree.
132
133
Use TreeTransform.finalize() to release the lock (can be omitted if
134
TreeTransform.apply() called).
66
class TreeTransformBase(object):
67
"""The base class for TreeTransform and TreeTransformBase"""
68
69
def __init__(self, tree, limbodir, pb=DummyProgress(),
70
case_sensitive=True):
71
"""Constructor.
72
73
:param tree: The tree that will be transformed, but not necessarily
74
the output tree.
75
:param limbodir: A directory where new files can be stored until
76
they are installed in their proper places
77
:param pb: A ProgressBar indicating how much progress is being made
78
:param case_sensitive: If True, the target of the transform is
79
case sensitive, not just case preserving.
135
80
"""
136
81
object.__init__(self)
137
82
self._tree = tree
138
self._tree.lock_tree_write()
139
try:
140
control_files = self._tree._control_files
141
self._limbodir = urlutils.local_path_from_url(
142
control_files.controlfilename('limbo'))
143
try:
144
os.mkdir(self._limbodir)
145
except OSError, e:
146
if e.errno == errno.EEXIST:
147
raise ExistingLimbo(self._limbodir)
148
self._deletiondir = urlutils.local_path_from_url(
149
control_files.controlfilename('pending-deletion'))
150
try:
151
os.mkdir(self._deletiondir)
152
except OSError, e:
153
if e.errno == errno.EEXIST:
154
raise errors.ExistingPendingDeletion(self._deletiondir)
155
156
except:
157
self._tree.unlock()
158
raise
159
160
# counter used to generate trans-ids (which are locally unique)
83
self._limbodir = limbodir
84
self._deletiondir = None
161
85
self._id_number = 0
162
86
# mapping of trans_id -> new basename
163
87
self._new_name = {}
199
123
# The trans_id that will be used as the tree root
200
124
self._new_root = self.trans_id_tree_file_id(tree.get_root_id())
201
125
# Indictor of whether the transform has been applied
202
self.__done = False
126
self._done = False
203
127
# A progress bar
204
128
self._pb = pb
129
# Whether the target is case sensitive
130
self._case_sensitive_target = case_sensitive
205
131
# A counter of how many files have been renamed
206
132
self.rename_count = 0
207
133
233
159
# We don't especially care *why* the dir is immortal.
234
160
raise ImmortalLimbo(self._limbodir)
235
161
try:
236
os.rmdir(self._deletiondir)
162
if self._deletiondir is not None:
163
os.rmdir(self._deletiondir)
237
164
except OSError:
238
165
raise errors.ImmortalPendingDeletion(self._deletiondir)
239
166
finally:
630
557
631
558
def find_conflicts(self):
632
559
"""Find any violations of inventory or filesystem invariants"""
633
if self.__done is True:
560
if self._done is True:
634
561
raise ReusingTransform()
635
562
conflicts = []
636
563
# ensure all children of all existent parents are known
801
728
return conflicts
802
729
for children in by_parent.itervalues():
803
730
name_ids = [(self.final_name(t), t) for t in children]
804
if not self._tree.case_sensitive:
731
if not self._case_sensitive_target:
805
732
name_ids = [(n.lower(), t) for n, t in name_ids]
806
733
name_ids.sort()
807
734
last_name = None
866
793
continue
867
794
return True
868
795
return False
869
870
def apply(self, no_conflicts=False, _mover=None):
871
"""Apply all changes to the inventory and filesystem.
872
873
If filesystem or inventory conflicts are present, MalformedTransform
874
will be thrown.
875
876
If apply succeeds, finalize is not necessary.
877
878
:param no_conflicts: if True, the caller guarantees there are no
879
conflicts, so no check is made.
880
:param _mover: Supply an alternate FileMover, for testing
881
"""
882
if not no_conflicts:
883
conflicts = self.find_conflicts()
884
if len(conflicts) != 0:
885
raise MalformedTransform(conflicts=conflicts)
886
inv = self._tree.inventory
887
inventory_delta = []
888
child_pb = bzrlib.ui.ui_factory.nested_progress_bar()
889
try:
890
if _mover is None:
891
mover = _FileMover()
892
else:
893
mover = _mover
894
try:
895
child_pb.update('Apply phase', 0, 2)
896
self._apply_removals(inv, inventory_delta, mover)
897
child_pb.update('Apply phase', 1, 2)
898
modified_paths = self._apply_insertions(inv, inventory_delta,
899
mover)
900
except:
901
mover.rollback()
902
raise
903
else:
904
mover.apply_deletions()
905
finally:
906
child_pb.finished()
907
self._tree.apply_inventory_delta(inventory_delta)
908
self.__done = True
909
self.finalize()
910
return _TransformResults(modified_paths, self.rename_count)
911
796
912
797
def _limbo_name(self, trans_id):
913
798
"""Generate the limbo name of a file"""
929
814
# the direct path can only be used if no other file has
930
815
# already taken this pathname, i.e. if the name is unused, or
931
816
# if it is already associated with this trans_id.
932
elif self._tree.case_sensitive:
817
elif self._case_sensitive_target:
933
818
if (self._limbo_children_names[parent].get(filename)
934
819
in (trans_id, None)):
935
820
use_direct_path = True
953
838
self._limbo_files[trans_id] = limbo_name
954
839
return limbo_name
955
840
956
def _apply_removals(self, inv, inventory_delta, mover):
957
"""Perform tree operations that remove directory/inventory names.
958
959
That is, delete files that are to be deleted, and put any files that
960
need renaming into limbo. This must be done in strict child-to-parent
961
order.
962
"""
963
tree_paths = list(self._tree_path_ids.iteritems())
964
tree_paths.sort(reverse=True)
965
child_pb = bzrlib.ui.ui_factory.nested_progress_bar()
966
try:
967
for num, data in enumerate(tree_paths):
968
path, trans_id = data
969
child_pb.update('removing file', num, len(tree_paths))
970
full_path = self._tree.abspath(path)
971
if trans_id in self._removed_contents:
972
mover.pre_delete(full_path, os.path.join(self._deletiondir,
973
trans_id))
974
elif trans_id in self._new_name or trans_id in \
975
self._new_parent:
976
try:
977
mover.rename(full_path, self._limbo_name(trans_id))
978
except OSError, e:
979
if e.errno != errno.ENOENT:
980
raise
981
else:
982
self.rename_count += 1
983
if trans_id in self._removed_id:
984
if trans_id == self._new_root:
985
file_id = self._tree.get_root_id()
986
else:
987
file_id = self.tree_file_id(trans_id)
988
if file_id is not None:
989
inventory_delta.append((path, None, file_id, None))
990
finally:
991
child_pb.finished()
992
993
def _apply_insertions(self, inv, inventory_delta, mover):
994
"""Perform tree operations that insert directory/inventory names.
995
996
That is, create any files that need to be created, and restore from
997
limbo any files that needed renaming. This must be done in strict
998
parent-to-child order.
999
"""
1000
new_paths = self.new_paths()
1001
modified_paths = []
1002
child_pb = bzrlib.ui.ui_factory.nested_progress_bar()
1003
completed_new = []
1004
try:
1005
for num, (path, trans_id) in enumerate(new_paths):
1006
new_entry = None
1007
child_pb.update('adding file', num, len(new_paths))
1008
try:
1009
kind = self._new_contents[trans_id]
1010
except KeyError:
1011
kind = contents = None
1012
if trans_id in self._new_contents or \
1013
self.path_changed(trans_id):
1014
full_path = self._tree.abspath(path)
1015
if trans_id in self._needs_rename:
1016
try:
1017
mover.rename(self._limbo_name(trans_id), full_path)
1018
except OSError, e:
1019
# We may be renaming a dangling inventory id
1020
if e.errno != errno.ENOENT:
1021
raise
1022
else:
1023
self.rename_count += 1
1024
if trans_id in self._new_contents:
1025
modified_paths.append(full_path)
1026
completed_new.append(trans_id)
1027
1028
if trans_id in self._new_id:
1029
if kind is None:
1030
kind = file_kind(self._tree.abspath(path))
1031
if trans_id in self._new_reference_revision:
1032
new_entry = inventory.TreeReference(
1033
self._new_id[trans_id],
1034
self._new_name[trans_id],
1035
self.final_file_id(self._new_parent[trans_id]),
1036
None, self._new_reference_revision[trans_id])
1037
else:
1038
new_entry = inventory.make_entry(kind,
1039
self.final_name(trans_id),
1040
self.final_file_id(self.final_parent(trans_id)),
1041
self._new_id[trans_id])
1042
else:
1043
if trans_id in self._new_name or trans_id in\
1044
self._new_parent or\
1045
trans_id in self._new_executability:
1046
file_id = self.final_file_id(trans_id)
1047
if file_id is not None:
1048
entry = inv[file_id]
1049
new_entry = entry.copy()
1050
1051
if trans_id in self._new_name or trans_id in\
1052
self._new_parent:
1053
if new_entry is not None:
1054
new_entry.name = self.final_name(trans_id)
1055
parent = self.final_parent(trans_id)
1056
parent_id = self.final_file_id(parent)
1057
new_entry.parent_id = parent_id
1058
1059
if trans_id in self._new_executability:
1060
self._set_executability(path, new_entry, trans_id)
1061
if new_entry is not None:
1062
if new_entry.file_id in inv:
1063
old_path = inv.id2path(new_entry.file_id)
1064
else:
1065
old_path = None
1066
inventory_delta.append((old_path, path,
1067
new_entry.file_id,
1068
new_entry))
1069
finally:
1070
child_pb.finished()
1071
for trans_id in completed_new:
1072
del self._new_contents[trans_id]
1073
return modified_paths
1074
1075
841
def _set_executability(self, path, entry, trans_id):
1076
842
"""Set the executability of versioned files """
1077
843
new_executability = self._new_executability[trans_id]
1281
1047
(from_executable, to_executable)))
1282
1048
return iter(sorted(results, key=lambda x:x[1]))
1283
1049
1050
def get_preview_tree(self):
1051
"""Return a tree representing the result of the transform.
1052
1053
This tree only supports the subset of Tree functionality required
1054
by show_diff_trees. It must only be compared to tt._tree.
1055
"""
1056
return _PreviewTree(self)
1057
1058
1059
class TreeTransform(TreeTransformBase):
1060
"""Represent a tree transformation.
1061
1062
This object is designed to support incremental generation of the transform,
1063
in any order.
1064
1065
However, it gives optimum performance when parent directories are created
1066
before their contents. The transform is then able to put child files
1067
directly in their parent directory, avoiding later renames.
1068
1069
It is easy to produce malformed transforms, but they are generally
1070
harmless. Attempting to apply a malformed transform will cause an
1071
exception to be raised before any modifications are made to the tree.
1072
1073
Many kinds of malformed transforms can be corrected with the
1074
resolve_conflicts function. The remaining ones indicate programming error,
1075
such as trying to create a file with no path.
1076
1077
Two sets of file creation methods are supplied. Convenience methods are:
1078
* new_file
1079
* new_directory
1080
* new_symlink
1081
1082
These are composed of the low-level methods:
1083
* create_path
1084
* create_file or create_directory or create_symlink
1085
* version_file
1086
* set_executability
1087
1088
Transform/Transaction ids
1089
-------------------------
1090
trans_ids are temporary ids assigned to all files involved in a transform.
1091
It's possible, even common, that not all files in the Tree have trans_ids.
1092
1093
trans_ids are used because filenames and file_ids are not good enough
1094
identifiers; filenames change, and not all files have file_ids. File-ids
1095
are also associated with trans-ids, so that moving a file moves its
1096
file-id.
1097
1098
trans_ids are only valid for the TreeTransform that generated them.
1099
1100
Limbo
1101
-----
1102
Limbo is a temporary directory use to hold new versions of files.
1103
Files are added to limbo by create_file, create_directory, create_symlink,
1104
and their convenience variants (new_*). Files may be removed from limbo
1105
using cancel_creation. Files are renamed from limbo into their final
1106
location as part of TreeTransform.apply
1107
1108
Limbo must be cleaned up, by either calling TreeTransform.apply or
1109
calling TreeTransform.finalize.
1110
1111
Files are placed into limbo inside their parent directories, where
1112
possible. This reduces subsequent renames, and makes operations involving
1113
lots of files faster. This optimization is only possible if the parent
1114
directory is created *before* creating any of its children, so avoid
1115
creating children before parents, where possible.
1116
1117
Pending-deletion
1118
----------------
1119
This temporary directory is used by _FileMover for storing files that are
1120
about to be deleted. In case of rollback, the files will be restored.
1121
FileMover does not delete files until it is sure that a rollback will not
1122
happen.
1123
"""
1124
def __init__(self, tree, pb=DummyProgress()):
1125
"""Note: a tree_write lock is taken on the tree.
1126
1127
Use TreeTransform.finalize() to release the lock (can be omitted if
1128
TreeTransform.apply() called).
1129
"""
1130
tree.lock_tree_write()
1131
1132
try:
1133
control_files = tree._control_files
1134
limbodir = urlutils.local_path_from_url(
1135
control_files.controlfilename('limbo'))
1136
try:
1137
os.mkdir(limbodir)
1138
except OSError, e:
1139
if e.errno == errno.EEXIST:
1140
raise ExistingLimbo(limbodir)
1141
deletiondir = urlutils.local_path_from_url(
1142
control_files.controlfilename('pending-deletion'))
1143
try:
1144
os.mkdir(deletiondir)
1145
except OSError, e:
1146
if e.errno == errno.EEXIST:
1147
raise errors.ExistingPendingDeletion(deletiondir)
1148
except:
1149
tree.unlock()
1150
raise
1151
1152
TreeTransformBase.__init__(self, tree, limbodir, pb,
1153
tree.case_sensitive)
1154
self._deletiondir = deletiondir
1155
1156
def apply(self, no_conflicts=False, _mover=None):
1157
"""Apply all changes to the inventory and filesystem.
1158
1159
If filesystem or inventory conflicts are present, MalformedTransform
1160
will be thrown.
1161
1162
If apply succeeds, finalize is not necessary.
1163
1164
:param no_conflicts: if True, the caller guarantees there are no
1165
conflicts, so no check is made.
1166
:param _mover: Supply an alternate FileMover, for testing
1167
"""
1168
if not no_conflicts:
1169
conflicts = self.find_conflicts()
1170
if len(conflicts) != 0:
1171
raise MalformedTransform(conflicts=conflicts)
1172
inv = self._tree.inventory
1173
inventory_delta = []
1174
child_pb = bzrlib.ui.ui_factory.nested_progress_bar()
1175
try:
1176
if _mover is None:
1177
mover = _FileMover()
1178
else:
1179
mover = _mover
1180
try:
1181
child_pb.update('Apply phase', 0, 2)
1182
self._apply_removals(inv, inventory_delta, mover)
1183
child_pb.update('Apply phase', 1, 2)
1184
modified_paths = self._apply_insertions(inv, inventory_delta,
1185
mover)
1186
except:
1187
mover.rollback()
1188
raise
1189
else:
1190
mover.apply_deletions()
1191
finally:
1192
child_pb.finished()
1193
self._tree.apply_inventory_delta(inventory_delta)
1194
self._done = True
1195
self.finalize()
1196
return _TransformResults(modified_paths, self.rename_count)
1197
1198
def _apply_removals(self, inv, inventory_delta, mover):
1199
"""Perform tree operations that remove directory/inventory names.
1200
1201
That is, delete files that are to be deleted, and put any files that
1202
need renaming into limbo. This must be done in strict child-to-parent
1203
order.
1204
"""
1205
tree_paths = list(self._tree_path_ids.iteritems())
1206
tree_paths.sort(reverse=True)
1207
child_pb = bzrlib.ui.ui_factory.nested_progress_bar()
1208
try:
1209
for num, data in enumerate(tree_paths):
1210
path, trans_id = data
1211
child_pb.update('removing file', num, len(tree_paths))
1212
full_path = self._tree.abspath(path)
1213
if trans_id in self._removed_contents:
1214
mover.pre_delete(full_path, os.path.join(self._deletiondir,
1215
trans_id))
1216
elif trans_id in self._new_name or trans_id in \
1217
self._new_parent:
1218
try:
1219
mover.rename(full_path, self._limbo_name(trans_id))
1220
except OSError, e:
1221
if e.errno != errno.ENOENT:
1222
raise
1223
else:
1224
self.rename_count += 1
1225
if trans_id in self._removed_id:
1226
if trans_id == self._new_root:
1227
file_id = self._tree.get_root_id()
1228
else:
1229
file_id = self.tree_file_id(trans_id)
1230
if file_id is not None:
1231
inventory_delta.append((path, None, file_id, None))
1232
finally:
1233
child_pb.finished()
1234
1235
def _apply_insertions(self, inv, inventory_delta, mover):
1236
"""Perform tree operations that insert directory/inventory names.
1237
1238
That is, create any files that need to be created, and restore from
1239
limbo any files that needed renaming. This must be done in strict
1240
parent-to-child order.
1241
"""
1242
new_paths = self.new_paths()
1243
modified_paths = []
1244
child_pb = bzrlib.ui.ui_factory.nested_progress_bar()
1245
completed_new = []
1246
try:
1247
for num, (path, trans_id) in enumerate(new_paths):
1248
new_entry = None
1249
child_pb.update('adding file', num, len(new_paths))
1250
try:
1251
kind = self._new_contents[trans_id]
1252
except KeyError:
1253
kind = contents = None
1254
if trans_id in self._new_contents or \
1255
self.path_changed(trans_id):
1256
full_path = self._tree.abspath(path)
1257
if trans_id in self._needs_rename:
1258
try:
1259
mover.rename(self._limbo_name(trans_id), full_path)
1260
except OSError, e:
1261
# We may be renaming a dangling inventory id
1262
if e.errno != errno.ENOENT:
1263
raise
1264
else:
1265
self.rename_count += 1
1266
if trans_id in self._new_contents:
1267
modified_paths.append(full_path)
1268
completed_new.append(trans_id)
1269
1270
if trans_id in self._new_id:
1271
if kind is None:
1272
kind = file_kind(self._tree.abspath(path))
1273
if trans_id in self._new_reference_revision:
1274
new_entry = inventory.TreeReference(
1275
self._new_id[trans_id],
1276
self._new_name[trans_id],
1277
self.final_file_id(self._new_parent[trans_id]),
1278
None, self._new_reference_revision[trans_id])
1279
else:
1280
new_entry = inventory.make_entry(kind,
1281
self.final_name(trans_id),
1282
self.final_file_id(self.final_parent(trans_id)),
1283
self._new_id[trans_id])
1284
else:
1285
if trans_id in self._new_name or trans_id in\
1286
self._new_parent or\
1287
trans_id in self._new_executability:
1288
file_id = self.final_file_id(trans_id)
1289
if file_id is not None:
1290
entry = inv[file_id]
1291
new_entry = entry.copy()
1292
1293
if trans_id in self._new_name or trans_id in\
1294
self._new_parent:
1295
if new_entry is not None:
1296
new_entry.name = self.final_name(trans_id)
1297
parent = self.final_parent(trans_id)
1298
parent_id = self.final_file_id(parent)
1299
new_entry.parent_id = parent_id
1300
1301
if trans_id in self._new_executability:
1302
self._set_executability(path, new_entry, trans_id)
1303
if new_entry is not None:
1304
if new_entry.file_id in inv:
1305
old_path = inv.id2path(new_entry.file_id)
1306
else:
1307
old_path = None
1308
inventory_delta.append((old_path, path,
1309
new_entry.file_id,
1310
new_entry))
1311
finally:
1312
child_pb.finished()
1313
for trans_id in completed_new:
1314
del self._new_contents[trans_id]
1315
return modified_paths
1316
1317
1318
class TransformPreview(TreeTransformBase):
1319
"""A TreeTransform for generating preview trees.
1320
1321
Unlike TreeTransform, this version works when the input tree is a
1322
RevisionTree, rather than a WorkingTree. As a result, it tends to ignore
1323
unversioned files in the input tree.
1324
"""
1325
1326
def __init__(self, tree, pb=DummyProgress(), case_sensitive=True):
1327
tree.lock_read()
1328
limbodir = tempfile.mkdtemp(prefix='bzr-limbo-')
1329
TreeTransformBase.__init__(self, tree, limbodir, pb, case_sensitive)
1330
1331
def canonical_path(self, path):
1332
return path
1333
1334
def tree_kind(self, trans_id):
1335
path = self._tree_id_paths.get(trans_id)
1336
if path is None:
1337
raise NoSuchFile(None)
1338
file_id = self._tree.path2id(path)
1339
return self._tree.kind(file_id)
1340
1341
def _set_mode(self, trans_id, mode_id, typefunc):
1342
"""Set the mode of new file contents.
1343
The mode_id is the existing file to get the mode from (often the same
1344
as trans_id). The operation is only performed if there's a mode match
1345
according to typefunc.
1346
"""
1347
# is it ok to ignore this? probably
1348
pass
1349
1350
def iter_tree_children(self, parent_id):
1351
"""Iterate through the entry's tree children, if any"""
1352
try:
1353
path = self._tree_id_paths[parent_id]
1354
except KeyError:
1355
return
1356
file_id = self.tree_file_id(parent_id)
1357
for child in self._tree.inventory[file_id].children.iterkeys():
1358
childpath = joinpath(path, child)
1359
yield self.trans_id_tree_path(childpath)
1360
1361
1362
class _PreviewTree(object):
1363
"""Partial implementation of Tree to support show_diff_trees"""
1364
1365
def __init__(self, transform):
1366
self._transform = transform
1367
1368
def lock_read(self):
1369
# Perhaps in theory, this should lock the TreeTransform?
1370
pass
1371
1372
def unlock(self):
1373
pass
1374
1375
def _iter_changes(self, from_tree, include_unchanged=False,
1376
specific_files=None, pb=None, extra_trees=None,
1377
require_versioned=True, want_unversioned=False):
1378
"""See InterTree._iter_changes.
1379
1380
This implementation does not support include_unchanged, specific_files,
1381
or want_unversioned. extra_trees, require_versioned, and pb are
1382
ignored.
1383
"""
1384
if from_tree is not self._transform._tree:
1385
raise ValueError('from_tree must be transform source tree.')
1386
if include_unchanged:
1387
raise ValueError('include_unchanged is not supported')
1388
if specific_files is not None:
1389
raise ValueError('specific_files is not supported')
1390
if want_unversioned:
1391
raise ValueError('want_unversioned is not supported')
1392
return self._transform._iter_changes()
1393
1394
def kind(self, file_id):
1395
trans_id = self._transform.trans_id_file_id(file_id)
1396
return self._transform.final_kind(trans_id)
1397
1398
def get_file_mtime(self, file_id, path=None):
1399
"""See Tree.get_file_mtime"""
1400
trans_id = self._transform.trans_id_file_id(file_id)
1401
name = self._transform._limbo_name(trans_id)
1402
return os.stat(name).st_mtime
1403
1404
def get_file(self, file_id):
1405
"""See Tree.get_file"""
1406
trans_id = self._transform.trans_id_file_id(file_id)
1407
name = self._transform._limbo_name(trans_id)
1408
return open(name, 'rb')
1409
1410
def paths2ids(self, specific_files, trees=None, require_versioned=False):
1411
"""See Tree.paths2ids"""
1412
return 'not_empty'
1413
1284
1414
1285
1415
def joinpath(parent, child):
1286
1416
"""Join tree-relative paths, handling the tree root specially"""
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0