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 3169.3.2
- compare with another revision
- download diff
- download tarball
- view history from revision 3169.3.2
- Committer: Andrew Bennetts
- Date: 2008-01-21 00:46:32 UTC
- mfrom: (3193 +trunk)
- mto: This revision was merged to the branch mainline in revision 3194.
- Revision ID: andrew.bennetts@canonical.com-20080121004632-wvpox6g9j7czn4vk
Merge from bzr.dev.
- 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
161
84
self._id_number = 0
162
85
# mapping of trans_id -> new basename
163
86
self._new_name = {}
199
122
# The trans_id that will be used as the tree root
200
123
self._new_root = self.trans_id_tree_file_id(tree.get_root_id())
201
124
# Indictor of whether the transform has been applied
202
self.__done = False
125
self._done = False
203
126
# A progress bar
204
127
self._pb = pb
128
# Whether the target is case sensitive
129
self._case_sensitive_target = case_sensitive
205
130
# A counter of how many files have been renamed
206
131
self.rename_count = 0
207
132
630
555
631
556
def find_conflicts(self):
632
557
"""Find any violations of inventory or filesystem invariants"""
633
if self.__done is True:
558
if self._done is True:
634
559
raise ReusingTransform()
635
560
conflicts = []
636
561
# ensure all children of all existent parents are known
801
726
return conflicts
802
727
for children in by_parent.itervalues():
803
728
name_ids = [(self.final_name(t), t) for t in children]
804
if not self._tree.case_sensitive:
729
if not self._case_sensitive_target:
805
730
name_ids = [(n.lower(), t) for n, t in name_ids]
806
731
name_ids.sort()
807
732
last_name = None
866
791
continue
867
792
return True
868
793
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
794
912
795
def _limbo_name(self, trans_id):
913
796
"""Generate the limbo name of a file"""
929
812
# the direct path can only be used if no other file has
930
813
# already taken this pathname, i.e. if the name is unused, or
931
814
# if it is already associated with this trans_id.
932
elif self._tree.case_sensitive:
815
elif self._case_sensitive_target:
933
816
if (self._limbo_children_names[parent].get(filename)
934
817
in (trans_id, None)):
935
818
use_direct_path = True
953
836
self._limbo_files[trans_id] = limbo_name
954
837
return limbo_name
955
838
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
839
def _set_executability(self, path, entry, trans_id):
1076
840
"""Set the executability of versioned files """
1077
841
new_executability = self._new_executability[trans_id]
1281
1045
(from_executable, to_executable)))
1282
1046
return iter(sorted(results, key=lambda x:x[1]))
1283
1047
1048
def get_preview_tree(self):
1049
"""Return a tree representing the result of the transform.
1050
1051
This tree only supports the subset of Tree functionality required
1052
by show_diff_trees. It must only be compared to tt._tree.
1053
"""
1054
return _PreviewTree(self)
1055
1056
1057
class TreeTransform(TreeTransformBase):
1058
"""Represent a tree transformation.
1059
1060
This object is designed to support incremental generation of the transform,
1061
in any order.
1062
1063
However, it gives optimum performance when parent directories are created
1064
before their contents. The transform is then able to put child files
1065
directly in their parent directory, avoiding later renames.
1066
1067
It is easy to produce malformed transforms, but they are generally
1068
harmless. Attempting to apply a malformed transform will cause an
1069
exception to be raised before any modifications are made to the tree.
1070
1071
Many kinds of malformed transforms can be corrected with the
1072
resolve_conflicts function. The remaining ones indicate programming error,
1073
such as trying to create a file with no path.
1074
1075
Two sets of file creation methods are supplied. Convenience methods are:
1076
* new_file
1077
* new_directory
1078
* new_symlink
1079
1080
These are composed of the low-level methods:
1081
* create_path
1082
* create_file or create_directory or create_symlink
1083
* version_file
1084
* set_executability
1085
1086
Transform/Transaction ids
1087
-------------------------
1088
trans_ids are temporary ids assigned to all files involved in a transform.
1089
It's possible, even common, that not all files in the Tree have trans_ids.
1090
1091
trans_ids are used because filenames and file_ids are not good enough
1092
identifiers; filenames change, and not all files have file_ids. File-ids
1093
are also associated with trans-ids, so that moving a file moves its
1094
file-id.
1095
1096
trans_ids are only valid for the TreeTransform that generated them.
1097
1098
Limbo
1099
-----
1100
Limbo is a temporary directory use to hold new versions of files.
1101
Files are added to limbo by create_file, create_directory, create_symlink,
1102
and their convenience variants (new_*). Files may be removed from limbo
1103
using cancel_creation. Files are renamed from limbo into their final
1104
location as part of TreeTransform.apply
1105
1106
Limbo must be cleaned up, by either calling TreeTransform.apply or
1107
calling TreeTransform.finalize.
1108
1109
Files are placed into limbo inside their parent directories, where
1110
possible. This reduces subsequent renames, and makes operations involving
1111
lots of files faster. This optimization is only possible if the parent
1112
directory is created *before* creating any of its children, so avoid
1113
creating children before parents, where possible.
1114
1115
Pending-deletion
1116
----------------
1117
This temporary directory is used by _FileMover for storing files that are
1118
about to be deleted. In case of rollback, the files will be restored.
1119
FileMover does not delete files until it is sure that a rollback will not
1120
happen.
1121
"""
1122
def __init__(self, tree, pb=DummyProgress()):
1123
"""Note: a tree_write lock is taken on the tree.
1124
1125
Use TreeTransform.finalize() to release the lock (can be omitted if
1126
TreeTransform.apply() called).
1127
"""
1128
tree.lock_tree_write()
1129
1130
try:
1131
control_files = tree._control_files
1132
limbodir = urlutils.local_path_from_url(
1133
control_files.controlfilename('limbo'))
1134
try:
1135
os.mkdir(limbodir)
1136
except OSError, e:
1137
if e.errno == errno.EEXIST:
1138
raise ExistingLimbo(limbodir)
1139
self._deletiondir = urlutils.local_path_from_url(
1140
control_files.controlfilename('pending-deletion'))
1141
try:
1142
os.mkdir(self._deletiondir)
1143
except OSError, e:
1144
if e.errno == errno.EEXIST:
1145
raise errors.ExistingPendingDeletion(self._deletiondir)
1146
except:
1147
tree.unlock()
1148
raise
1149
1150
TreeTransformBase.__init__(self, tree, limbodir, pb,
1151
tree.case_sensitive)
1152
1153
def apply(self, no_conflicts=False, _mover=None):
1154
"""Apply all changes to the inventory and filesystem.
1155
1156
If filesystem or inventory conflicts are present, MalformedTransform
1157
will be thrown.
1158
1159
If apply succeeds, finalize is not necessary.
1160
1161
:param no_conflicts: if True, the caller guarantees there are no
1162
conflicts, so no check is made.
1163
:param _mover: Supply an alternate FileMover, for testing
1164
"""
1165
if not no_conflicts:
1166
conflicts = self.find_conflicts()
1167
if len(conflicts) != 0:
1168
raise MalformedTransform(conflicts=conflicts)
1169
inv = self._tree.inventory
1170
inventory_delta = []
1171
child_pb = bzrlib.ui.ui_factory.nested_progress_bar()
1172
try:
1173
if _mover is None:
1174
mover = _FileMover()
1175
else:
1176
mover = _mover
1177
try:
1178
child_pb.update('Apply phase', 0, 2)
1179
self._apply_removals(inv, inventory_delta, mover)
1180
child_pb.update('Apply phase', 1, 2)
1181
modified_paths = self._apply_insertions(inv, inventory_delta,
1182
mover)
1183
except:
1184
mover.rollback()
1185
raise
1186
else:
1187
mover.apply_deletions()
1188
finally:
1189
child_pb.finished()
1190
self._tree.apply_inventory_delta(inventory_delta)
1191
self._done = True
1192
self.finalize()
1193
return _TransformResults(modified_paths, self.rename_count)
1194
1195
def _apply_removals(self, inv, inventory_delta, mover):
1196
"""Perform tree operations that remove directory/inventory names.
1197
1198
That is, delete files that are to be deleted, and put any files that
1199
need renaming into limbo. This must be done in strict child-to-parent
1200
order.
1201
"""
1202
tree_paths = list(self._tree_path_ids.iteritems())
1203
tree_paths.sort(reverse=True)
1204
child_pb = bzrlib.ui.ui_factory.nested_progress_bar()
1205
try:
1206
for num, data in enumerate(tree_paths):
1207
path, trans_id = data
1208
child_pb.update('removing file', num, len(tree_paths))
1209
full_path = self._tree.abspath(path)
1210
if trans_id in self._removed_contents:
1211
mover.pre_delete(full_path, os.path.join(self._deletiondir,
1212
trans_id))
1213
elif trans_id in self._new_name or trans_id in \
1214
self._new_parent:
1215
try:
1216
mover.rename(full_path, self._limbo_name(trans_id))
1217
except OSError, e:
1218
if e.errno != errno.ENOENT:
1219
raise
1220
else:
1221
self.rename_count += 1
1222
if trans_id in self._removed_id:
1223
if trans_id == self._new_root:
1224
file_id = self._tree.get_root_id()
1225
else:
1226
file_id = self.tree_file_id(trans_id)
1227
if file_id is not None:
1228
inventory_delta.append((path, None, file_id, None))
1229
finally:
1230
child_pb.finished()
1231
1232
def _apply_insertions(self, inv, inventory_delta, mover):
1233
"""Perform tree operations that insert directory/inventory names.
1234
1235
That is, create any files that need to be created, and restore from
1236
limbo any files that needed renaming. This must be done in strict
1237
parent-to-child order.
1238
"""
1239
new_paths = self.new_paths()
1240
modified_paths = []
1241
child_pb = bzrlib.ui.ui_factory.nested_progress_bar()
1242
completed_new = []
1243
try:
1244
for num, (path, trans_id) in enumerate(new_paths):
1245
new_entry = None
1246
child_pb.update('adding file', num, len(new_paths))
1247
try:
1248
kind = self._new_contents[trans_id]
1249
except KeyError:
1250
kind = contents = None
1251
if trans_id in self._new_contents or \
1252
self.path_changed(trans_id):
1253
full_path = self._tree.abspath(path)
1254
if trans_id in self._needs_rename:
1255
try:
1256
mover.rename(self._limbo_name(trans_id), full_path)
1257
except OSError, e:
1258
# We may be renaming a dangling inventory id
1259
if e.errno != errno.ENOENT:
1260
raise
1261
else:
1262
self.rename_count += 1
1263
if trans_id in self._new_contents:
1264
modified_paths.append(full_path)
1265
completed_new.append(trans_id)
1266
1267
if trans_id in self._new_id:
1268
if kind is None:
1269
kind = file_kind(self._tree.abspath(path))
1270
if trans_id in self._new_reference_revision:
1271
new_entry = inventory.TreeReference(
1272
self._new_id[trans_id],
1273
self._new_name[trans_id],
1274
self.final_file_id(self._new_parent[trans_id]),
1275
None, self._new_reference_revision[trans_id])
1276
else:
1277
new_entry = inventory.make_entry(kind,
1278
self.final_name(trans_id),
1279
self.final_file_id(self.final_parent(trans_id)),
1280
self._new_id[trans_id])
1281
else:
1282
if trans_id in self._new_name or trans_id in\
1283
self._new_parent or\
1284
trans_id in self._new_executability:
1285
file_id = self.final_file_id(trans_id)
1286
if file_id is not None:
1287
entry = inv[file_id]
1288
new_entry = entry.copy()
1289
1290
if trans_id in self._new_name or trans_id in\
1291
self._new_parent:
1292
if new_entry is not None:
1293
new_entry.name = self.final_name(trans_id)
1294
parent = self.final_parent(trans_id)
1295
parent_id = self.final_file_id(parent)
1296
new_entry.parent_id = parent_id
1297
1298
if trans_id in self._new_executability:
1299
self._set_executability(path, new_entry, trans_id)
1300
if new_entry is not None:
1301
if new_entry.file_id in inv:
1302
old_path = inv.id2path(new_entry.file_id)
1303
else:
1304
old_path = None
1305
inventory_delta.append((old_path, path,
1306
new_entry.file_id,
1307
new_entry))
1308
finally:
1309
child_pb.finished()
1310
for trans_id in completed_new:
1311
del self._new_contents[trans_id]
1312
return modified_paths
1313
1314
1315
class TransformPreview(TreeTransformBase):
1316
"""A TreeTransform for generating preview trees.
1317
1318
Unlike TreeTransform, this version works when the input tree is a
1319
RevisionTree, rather than a WorkingTree. As a result, it tends to ignore
1320
unversioned files in the input tree.
1321
"""
1322
1323
def __init__(self, tree, pb=DummyProgress(), case_sensitive=True):
1324
limbodir = tempfile.mkdtemp()
1325
TreeTransformBase.__init__(self, tree, limbodir, pb, case_sensitive)
1326
1327
def canonical_path(self, path):
1328
return path
1329
1330
def tree_kind(self, trans_id):
1331
path = self._tree_id_paths.get(trans_id)
1332
if path is None:
1333
raise NoSuchFile(None)
1334
file_id = self._tree.path2id(path)
1335
return self._tree.kind(file_id)
1336
1337
def _set_mode(self, trans_id, mode_id, typefunc):
1338
"""Set the mode of new file contents.
1339
The mode_id is the existing file to get the mode from (often the same
1340
as trans_id). The operation is only performed if there's a mode match
1341
according to typefunc.
1342
"""
1343
# is it ok to ignore this? probably
1344
pass
1345
1346
def iter_tree_children(self, parent_id):
1347
"""Iterate through the entry's tree children, if any"""
1348
try:
1349
path = self._tree_id_paths[parent_id]
1350
except KeyError:
1351
return
1352
file_id = self.tree_file_id(parent_id)
1353
for child in self._tree.inventory[file_id].children.iterkeys():
1354
childpath = joinpath(path, child)
1355
yield self.trans_id_tree_path(childpath)
1356
1357
1358
class _PreviewTree(object):
1359
"""Partial implementation of Tree to support show_diff_trees"""
1360
1361
def __init__(self, transform):
1362
self._transform = transform
1363
1364
def lock_read(self):
1365
# Perhaps in theory, this should lock the TreeTransform?
1366
pass
1367
1368
def unlock(self):
1369
pass
1370
1371
def _iter_changes(self, from_tree, include_unchanged=False,
1372
specific_files=None, pb=None, extra_trees=None,
1373
require_versioned=True, want_unversioned=False):
1374
"""See InterTree._iter_changes.
1375
1376
This implementation does not support include_unchanged, specific_files,
1377
or want_unversioned. extra_trees, require_versioned, and pb are
1378
ignored.
1379
"""
1380
if from_tree is not self._transform._tree:
1381
raise ValueError('from_tree must be transform source tree.')
1382
if include_unchanged:
1383
raise ValueError('include_unchanged is not supported')
1384
if specific_files is not None:
1385
raise ValueError('specific_files is not supported')
1386
if want_unversioned:
1387
raise ValueError('want_unversioned is not supported')
1388
return self._transform._iter_changes()
1389
1390
def kind(self, file_id):
1391
trans_id = self._transform.trans_id_file_id(file_id)
1392
return self._transform.final_kind(trans_id)
1393
1394
def get_file_mtime(self, file_id, path=None):
1395
"""See Tree.get_file_mtime"""
1396
trans_id = self._transform.trans_id_file_id(file_id)
1397
name = self._transform._limbo_name(trans_id)
1398
return os.stat(name).st_mtime
1399
1400
def get_file(self, file_id):
1401
"""See Tree.get_file"""
1402
trans_id = self._transform.trans_id_file_id(file_id)
1403
name = self._transform._limbo_name(trans_id)
1404
return open(name, 'rb')
1405
1406
def paths2ids(self, specific_files, trees=None, require_versioned=False):
1407
"""See Tree.paths2ids"""
1408
return 'not_empty'
1409
1284
1410
1285
1411
def joinpath(parent, child):
1286
1412
"""Join tree-relative paths, handling the tree root specially"""
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0