« back to all changes in this revision
Viewing changes to bzrlib/workingtree.py
- browse files at revision 5787
- compare with another revision
- compare with revision 6017.1.2
- download diff
- download tarball
- view history from revision 5787
- Committer: Canonical.com Patch Queue Manager
- Date: 2011-04-15 12:07:39 UTC
- mfrom: (5777.5.3 inventoryworkingtree)
- Revision ID: pqm@pqm.ubuntu.com-20110415120739-7ftrzs0qmz98ar5e
(jelmer) Split inventory-specific implementation out of MutableTree into
MutableInventoryTree. (Jelmer Vernooij)
MutableInventoryTree. (Jelmer Vernooij)
added
removed
bzrlib/workingtree.py
166
166
return ''
167
167
168
168
169
class WorkingTree(bzrlib.mutabletree.MutableInventoryTree,
169
class WorkingTree(bzrlib.mutabletree.MutableTree,
170
170
controldir.ControlComponent):
171
171
"""Working copy tree.
172
172
173
The inventory is held in the `Branch` working-inventory, and the
174
files are in a directory on disk.
175
176
It is possible for a `WorkingTree` to have a filename which is
177
not listed in the Inventory and vice versa.
178
179
173
:ivar basedir: The root of the tree on disk. This is a unicode path object
180
174
(as opposed to a URL).
181
175
"""
186
180
187
181
def __init__(self, basedir='.',
188
182
branch=DEPRECATED_PARAMETER,
189
_inventory=None,
190
183
_control_files=None,
191
184
_internal=False,
192
185
_format=None,
229
222
mutter("write hc")
230
223
hc.write()
231
224
232
if _inventory is None:
233
# This will be acquired on lock_read() or lock_write()
234
self._inventory_is_modified = False
235
self._inventory = None
236
else:
237
# the caller of __init__ has provided an inventory,
238
# we assume they know what they are doing - as its only
239
# the Format factory and creation methods that are
240
# permitted to do this.
241
self._set_inventory(_inventory, dirty=False)
242
225
self._detect_case_handling()
243
226
self._rules_searcher = None
244
227
self.views = self._make_views()
315
298
def supports_views(self):
316
299
return self.views.supports_views()
317
300
318
def _set_inventory(self, inv, dirty):
319
"""Set the internal cached inventory.
320
321
:param inv: The inventory to set.
322
:param dirty: A boolean indicating whether the inventory is the same
323
logical inventory as whats on disk. If True the inventory is not
324
the same and should be written to disk or data will be lost, if
325
False then the inventory is the same as that on disk and any
326
serialisation would be unneeded overhead.
327
"""
328
self._inventory = inv
329
self._inventory_is_modified = dirty
330
331
301
@staticmethod
332
302
def open(path=None, _unsupported=False):
333
303
"""Open an existing working tree at path.
446
416
list_current=list_current)
447
417
return [tr for tr in iterator if tr is not None]
448
418
449
# should be deprecated - this is slow and in any case treating them as a
450
# container is (we now know) bad style -- mbp 20070302
451
## @deprecated_method(zero_fifteen)
452
def __iter__(self):
453
"""Iterate through file_ids for this tree.
454
455
file_ids are in a WorkingTree if they are in the working inventory
456
and the working file exists.
457
"""
458
inv = self._inventory
459
for path, ie in inv.iter_entries():
460
if osutils.lexists(self.abspath(path)):
461
yield ie.file_id
462
463
419
def all_file_ids(self):
464
420
"""See Tree.iter_all_file_ids"""
465
return set(self.inventory)
421
raise NotImplementedError(self.all_file_ids)
466
422
467
423
def __repr__(self):
468
424
return "<%s of %s>" % (self.__class__.__name__,
558
514
finally:
559
515
file.close()
560
516
561
@needs_read_lock
562
def annotate_iter(self, file_id, default_revision=CURRENT_REVISION):
563
"""See Tree.annotate_iter
564
565
This implementation will use the basis tree implementation if possible.
566
Lines not in the basis are attributed to CURRENT_REVISION
567
568
If there are pending merges, lines added by those merges will be
569
incorrectly attributed to CURRENT_REVISION (but after committing, the
570
attribution will be correct).
571
"""
572
maybe_file_parent_keys = []
573
for parent_id in self.get_parent_ids():
574
try:
575
parent_tree = self.revision_tree(parent_id)
576
except errors.NoSuchRevisionInTree:
577
parent_tree = self.branch.repository.revision_tree(parent_id)
578
parent_tree.lock_read()
579
try:
580
if file_id not in parent_tree:
581
continue
582
ie = parent_tree.inventory[file_id]
583
if ie.kind != 'file':
584
# Note: this is slightly unnecessary, because symlinks and
585
# directories have a "text" which is the empty text, and we
586
# know that won't mess up annotations. But it seems cleaner
587
continue
588
parent_text_key = (file_id, ie.revision)
589
if parent_text_key not in maybe_file_parent_keys:
590
maybe_file_parent_keys.append(parent_text_key)
591
finally:
592
parent_tree.unlock()
593
graph = _mod_graph.Graph(self.branch.repository.texts)
594
heads = graph.heads(maybe_file_parent_keys)
595
file_parent_keys = []
596
for key in maybe_file_parent_keys:
597
if key in heads:
598
file_parent_keys.append(key)
599
600
# Now we have the parents of this content
601
annotator = self.branch.repository.texts.get_annotator()
602
text = self.get_file_text(file_id)
603
this_key =(file_id, default_revision)
604
annotator.add_special_text(this_key, file_parent_keys, text)
605
annotations = [(key[-1], line)
606
for key, line in annotator.annotate_flat(this_key)]
607
return annotations
608
609
517
def _get_ancestors(self, default_revision):
610
518
ancestors = set([default_revision])
611
519
for parent_id in self.get_parent_ids():
634
542
parents.append(revision_id)
635
543
return parents
636
544
637
@needs_read_lock
638
545
def get_root_id(self):
639
546
"""Return the id of this trees root"""
640
return self._inventory.root.file_id
547
raise NotImplementedError(self.get_root_id)
641
548
642
549
@needs_read_lock
643
550
def clone(self, to_bzrdir, revision_id=None):
673
580
def id2abspath(self, file_id):
674
581
return self.abspath(self.id2path(file_id))
675
582
676
def has_id(self, file_id):
677
# files that have been deleted are excluded
678
inv = self.inventory
679
if not inv.has_id(file_id):
680
return False
681
path = inv.id2path(file_id)
682
return osutils.lexists(self.abspath(path))
683
684
def has_or_had_id(self, file_id):
685
if file_id == self.inventory.root.file_id:
686
return True
687
return self.inventory.has_id(file_id)
688
689
__contains__ = has_id
690
691
583
def get_file_size(self, file_id):
692
584
"""See Tree.get_file_size"""
693
585
# XXX: this returns the on-disk size; it should probably return the
700
592
else:
701
593
return None
702
594
703
@needs_read_lock
704
595
def get_file_sha1(self, file_id, path=None, stat_value=None):
705
if not path:
706
path = self._inventory.id2path(file_id)
707
return self._hashcache.get_sha1(path, stat_value)
708
709
def get_file_mtime(self, file_id, path=None):
710
if not path:
711
path = self.inventory.id2path(file_id)
712
return os.lstat(self.abspath(path)).st_mtime
713
714
def _is_executable_from_path_and_stat_from_basis(self, path, stat_result):
715
file_id = self.path2id(path)
716
if file_id is None:
717
# For unversioned files on win32, we just assume they are not
718
# executable
719
return False
720
return self._inventory[file_id].executable
721
722
def _is_executable_from_path_and_stat_from_stat(self, path, stat_result):
723
mode = stat_result.st_mode
724
return bool(stat.S_ISREG(mode) and stat.S_IEXEC & mode)
725
726
if not supports_executable():
727
def is_executable(self, file_id, path=None):
728
return self._inventory[file_id].executable
729
730
_is_executable_from_path_and_stat = \
731
_is_executable_from_path_and_stat_from_basis
732
else:
733
def is_executable(self, file_id, path=None):
734
if not path:
735
path = self.id2path(file_id)
736
mode = os.lstat(self.abspath(path)).st_mode
737
return bool(stat.S_ISREG(mode) and stat.S_IEXEC & mode)
738
739
_is_executable_from_path_and_stat = \
740
_is_executable_from_path_and_stat_from_stat
741
742
@needs_tree_write_lock
743
def _add(self, files, ids, kinds):
744
"""See MutableTree._add."""
745
# TODO: Re-adding a file that is removed in the working copy
746
# should probably put it back with the previous ID.
747
# the read and write working inventory should not occur in this
748
# function - they should be part of lock_write and unlock.
749
inv = self.inventory
750
for f, file_id, kind in zip(files, ids, kinds):
751
if file_id is None:
752
inv.add_path(f, kind=kind)
753
else:
754
inv.add_path(f, kind=kind, file_id=file_id)
755
self._inventory_is_modified = True
596
# FIXME: Shouldn't this be in Tree?
597
raise NotImplementedError(self.get_file_sha1)
756
598
757
599
@needs_tree_write_lock
758
600
def _gather_kinds(self, files, kinds):
1020
862
merger.set_pending()
1021
863
return conflicts
1022
864
1023
@needs_read_lock
1024
865
def merge_modified(self):
1025
866
"""Return a dictionary of files modified by a merge.
1026
867
1031
872
This returns a map of file_id->sha1, containing only files which are
1032
873
still in the working inventory and have that text hash.
1033
874
"""
1034
try:
1035
hashfile = self._transport.get('merge-hashes')
1036
except errors.NoSuchFile:
1037
return {}
1038
try:
1039
merge_hashes = {}
1040
try:
1041
if hashfile.next() != MERGE_MODIFIED_HEADER_1 + '\n':
1042
raise errors.MergeModifiedFormatError()
1043
except StopIteration:
1044
raise errors.MergeModifiedFormatError()
1045
for s in _mod_rio.RioReader(hashfile):
1046
# RioReader reads in Unicode, so convert file_ids back to utf8
1047
file_id = osutils.safe_file_id(s.get("file_id"), warn=False)
1048
if file_id not in self.inventory:
1049
continue
1050
text_hash = s.get("hash")
1051
if text_hash == self.get_file_sha1(file_id):
1052
merge_hashes[file_id] = text_hash
1053
return merge_hashes
1054
finally:
1055
hashfile.close()
875
raise NotImplementedError(self.merge_modified)
1056
876
1057
877
@needs_write_lock
1058
878
def mkdir(self, path, file_id=None):
1068
888
target = osutils.readlink(abspath)
1069
889
return target
1070
890
1071
@needs_write_lock
1072
891
def subsume(self, other_tree):
1073
def add_children(inventory, entry):
1074
for child_entry in entry.children.values():
1075
inventory._byid[child_entry.file_id] = child_entry
1076
if child_entry.kind == 'directory':
1077
add_children(inventory, child_entry)
1078
if other_tree.get_root_id() == self.get_root_id():
1079
raise errors.BadSubsumeSource(self, other_tree,
1080
'Trees have the same root')
1081
try:
1082
other_tree_path = self.relpath(other_tree.basedir)
1083
except errors.PathNotChild:
1084
raise errors.BadSubsumeSource(self, other_tree,
1085
'Tree is not contained by the other')
1086
new_root_parent = self.path2id(osutils.dirname(other_tree_path))
1087
if new_root_parent is None:
1088
raise errors.BadSubsumeSource(self, other_tree,
1089
'Parent directory is not versioned.')
1090
# We need to ensure that the result of a fetch will have a
1091
# versionedfile for the other_tree root, and only fetching into
1092
# RepositoryKnit2 guarantees that.
1093
if not self.branch.repository.supports_rich_root():
1094
raise errors.SubsumeTargetNeedsUpgrade(other_tree)
1095
other_tree.lock_tree_write()
1096
try:
1097
new_parents = other_tree.get_parent_ids()
1098
other_root = other_tree.inventory.root
1099
other_root.parent_id = new_root_parent
1100
other_root.name = osutils.basename(other_tree_path)
1101
self.inventory.add(other_root)
1102
add_children(self.inventory, other_root)
1103
self._write_inventory(self.inventory)
1104
# normally we don't want to fetch whole repositories, but i think
1105
# here we really do want to consolidate the whole thing.
1106
for parent_id in other_tree.get_parent_ids():
1107
self.branch.fetch(other_tree.branch, parent_id)
1108
self.add_parent_tree_id(parent_id)
1109
finally:
1110
other_tree.unlock()
1111
other_tree.bzrdir.retire_bzrdir()
892
raise NotImplementedError(self.subsume)
1112
893
1113
894
def _setup_directory_is_tree_reference(self):
1114
895
if self._branch.repository._format.supports_tree_reference:
1136
917
# checkout in a subdirectory. This can be avoided by not adding
1137
918
# it. mbp 20070306
1138
919
1139
@needs_tree_write_lock
1140
920
def extract(self, file_id, format=None):
1141
921
"""Extract a subtree from this tree.
1142
922
1143
923
A new branch will be created, relative to the path for this tree.
1144
924
"""
1145
self.flush()
1146
def mkdirs(path):
1147
segments = osutils.splitpath(path)
1148
transport = self.branch.bzrdir.root_transport
1149
for name in segments:
1150
transport = transport.clone(name)
1151
transport.ensure_base()
1152
return transport
1153
1154
sub_path = self.id2path(file_id)
1155
branch_transport = mkdirs(sub_path)
1156
if format is None:
1157
format = self.bzrdir.cloning_metadir()
1158
branch_transport.ensure_base()
1159
branch_bzrdir = format.initialize_on_transport(branch_transport)
1160
try:
1161
repo = branch_bzrdir.find_repository()
1162
except errors.NoRepositoryPresent:
1163
repo = branch_bzrdir.create_repository()
1164
if not repo.supports_rich_root():
1165
raise errors.RootNotRich()
1166
new_branch = branch_bzrdir.create_branch()
1167
new_branch.pull(self.branch)
1168
for parent_id in self.get_parent_ids():
1169
new_branch.fetch(self.branch, parent_id)
1170
tree_transport = self.bzrdir.root_transport.clone(sub_path)
1171
if tree_transport.base != branch_transport.base:
1172
tree_bzrdir = format.initialize_on_transport(tree_transport)
1173
branch.BranchReferenceFormat().initialize(tree_bzrdir,
1174
target_branch=new_branch)
1175
else:
1176
tree_bzrdir = branch_bzrdir
1177
wt = tree_bzrdir.create_workingtree(_mod_revision.NULL_REVISION)
1178
wt.set_parent_ids(self.get_parent_ids())
1179
my_inv = self.inventory
1180
child_inv = inventory.Inventory(root_id=None)
1181
new_root = my_inv[file_id]
1182
my_inv.remove_recursive_id(file_id)
1183
new_root.parent_id = None
1184
child_inv.add(new_root)
1185
self._write_inventory(my_inv)
1186
wt._write_inventory(child_inv)
1187
return wt
1188
1189
def _serialize(self, inventory, out_file):
1190
xml5.serializer_v5.write_inventory(self._inventory, out_file,
1191
working=True)
1192
1193
def _deserialize(selt, in_file):
1194
return xml5.serializer_v5.read_inventory(in_file)
925
raise NotImplementedError(self.extract)
1195
926
1196
927
def flush(self):
1197
"""Write the in memory inventory to disk."""
1198
# TODO: Maybe this should only write on dirty ?
1199
if self._control_files._lock_mode != 'w':
1200
raise errors.NotWriteLocked(self)
1201
sio = StringIO()
1202
self._serialize(self._inventory, sio)
1203
sio.seek(0)
1204
self._transport.put_file('inventory', sio,
1205
mode=self.bzrdir._get_file_mode())
1206
self._inventory_is_modified = False
928
"""Write the in memory meta data to disk."""
929
raise NotImplementedError(self.flush)
1207
930
1208
931
def _kind(self, relpath):
1209
932
return osutils.file_kind(self.abspath(relpath))
1219
942
:param from_dir: start from this directory or None for the root
1220
943
:param recursive: whether to recurse into subdirectories or not
1221
944
"""
1222
# list_files is an iterator, so @needs_read_lock doesn't work properly
1223
# with it. So callers should be careful to always read_lock the tree.
1224
if not self.is_locked():
1225
raise errors.ObjectNotLocked(self)
1226
1227
inv = self.inventory
1228
if from_dir is None and include_root is True:
1229
yield ('', 'V', 'directory', inv.root.file_id, inv.root)
1230
# Convert these into local objects to save lookup times
1231
pathjoin = osutils.pathjoin
1232
file_kind = self._kind
1233
1234
# transport.base ends in a slash, we want the piece
1235
# between the last two slashes
1236
transport_base_dir = self.bzrdir.transport.base.rsplit('/', 2)[1]
1237
1238
fk_entries = {'directory':TreeDirectory, 'file':TreeFile, 'symlink':TreeLink}
1239
1240
# directory file_id, relative path, absolute path, reverse sorted children
1241
if from_dir is not None:
1242
from_dir_id = inv.path2id(from_dir)
1243
if from_dir_id is None:
1244
# Directory not versioned
1245
return
1246
from_dir_abspath = pathjoin(self.basedir, from_dir)
1247
else:
1248
from_dir_id = inv.root.file_id
1249
from_dir_abspath = self.basedir
1250
children = os.listdir(from_dir_abspath)
1251
children.sort()
1252
# jam 20060527 The kernel sized tree seems equivalent whether we
1253
# use a deque and popleft to keep them sorted, or if we use a plain
1254
# list and just reverse() them.
1255
children = collections.deque(children)
1256
stack = [(from_dir_id, u'', from_dir_abspath, children)]
1257
while stack:
1258
from_dir_id, from_dir_relpath, from_dir_abspath, children = stack[-1]
1259
1260
while children:
1261
f = children.popleft()
1262
## TODO: If we find a subdirectory with its own .bzr
1263
## directory, then that is a separate tree and we
1264
## should exclude it.
1265
1266
# the bzrdir for this tree
1267
if transport_base_dir == f:
1268
continue
1269
1270
# we know that from_dir_relpath and from_dir_abspath never end in a slash
1271
# and 'f' doesn't begin with one, we can do a string op, rather
1272
# than the checks of pathjoin(), all relative paths will have an extra slash
1273
# at the beginning
1274
fp = from_dir_relpath + '/' + f
1275
1276
# absolute path
1277
fap = from_dir_abspath + '/' + f
1278
1279
dir_ie = inv[from_dir_id]
1280
if dir_ie.kind == 'directory':
1281
f_ie = dir_ie.children.get(f)
1282
else:
1283
f_ie = None
1284
if f_ie:
1285
c = 'V'
1286
elif self.is_ignored(fp[1:]):
1287
c = 'I'
1288
else:
1289
# we may not have found this file, because of a unicode
1290
# issue, or because the directory was actually a symlink.
1291
f_norm, can_access = osutils.normalized_filename(f)
1292
if f == f_norm or not can_access:
1293
# No change, so treat this file normally
1294
c = '?'
1295
else:
1296
# this file can be accessed by a normalized path
1297
# check again if it is versioned
1298
# these lines are repeated here for performance
1299
f = f_norm
1300
fp = from_dir_relpath + '/' + f
1301
fap = from_dir_abspath + '/' + f
1302
f_ie = inv.get_child(from_dir_id, f)
1303
if f_ie:
1304
c = 'V'
1305
elif self.is_ignored(fp[1:]):
1306
c = 'I'
1307
else:
1308
c = '?'
1309
1310
fk = file_kind(fap)
1311
1312
# make a last minute entry
1313
if f_ie:
1314
yield fp[1:], c, fk, f_ie.file_id, f_ie
1315
else:
1316
try:
1317
yield fp[1:], c, fk, None, fk_entries[fk]()
1318
except KeyError:
1319
yield fp[1:], c, fk, None, TreeEntry()
1320
continue
1321
1322
if fk != 'directory':
1323
continue
1324
1325
# But do this child first if recursing down
1326
if recursive:
1327
new_children = os.listdir(fap)
1328
new_children.sort()
1329
new_children = collections.deque(new_children)
1330
stack.append((f_ie.file_id, fp, fap, new_children))
1331
# Break out of inner loop,
1332
# so that we start outer loop with child
1333
break
1334
else:
1335
# if we finished all children, pop it off the stack
1336
stack.pop()
1337
1338
@needs_tree_write_lock
945
raise NotImplementedError(self.list_files)
946
1339
947
def move(self, from_paths, to_dir=None, after=False):
1340
948
"""Rename files.
1341
949
1342
to_dir must exist in the inventory.
950
to_dir must be known to the working tree.
1343
951
1344
952
If to_dir exists and is a directory, the files are moved into
1345
953
it, keeping their old names.
1351
959
independently.
1352
960
1353
961
The first mode moves the file in the filesystem and updates the
1354
inventory. The second mode only updates the inventory without
1355
touching the file on the filesystem. This is the new mode introduced
1356
in version 0.15.
962
working tree metadata. The second mode only updates the working tree
963
metadata without touching the file on the filesystem.
1357
964
1358
965
move uses the second mode if 'after == True' and the target is not
1359
966
versioned but present in the working tree.
1371
978
This returns a list of (from_path, to_path) pairs for each
1372
979
entry that is moved.
1373
980
"""
1374
rename_entries = []
1375
rename_tuples = []
1376
1377
# check for deprecated use of signature
1378
if to_dir is None:
1379
raise TypeError('You must supply a target directory')
1380
# check destination directory
1381
if isinstance(from_paths, basestring):
1382
raise ValueError()
1383
inv = self.inventory
1384
to_abs = self.abspath(to_dir)
1385
if not isdir(to_abs):
1386
raise errors.BzrMoveFailedError('',to_dir,
1387
errors.NotADirectory(to_abs))
1388
if not self.has_filename(to_dir):
1389
raise errors.BzrMoveFailedError('',to_dir,
1390
errors.NotInWorkingDirectory(to_dir))
1391
to_dir_id = inv.path2id(to_dir)
1392
if to_dir_id is None:
1393
raise errors.BzrMoveFailedError('',to_dir,
1394
errors.NotVersionedError(path=to_dir))
1395
1396
to_dir_ie = inv[to_dir_id]
1397
if to_dir_ie.kind != 'directory':
1398
raise errors.BzrMoveFailedError('',to_dir,
1399
errors.NotADirectory(to_abs))
1400
1401
# create rename entries and tuples
1402
for from_rel in from_paths:
1403
from_tail = splitpath(from_rel)[-1]
1404
from_id = inv.path2id(from_rel)
1405
if from_id is None:
1406
raise errors.BzrMoveFailedError(from_rel,to_dir,
1407
errors.NotVersionedError(path=from_rel))
1408
1409
from_entry = inv[from_id]
1410
from_parent_id = from_entry.parent_id
1411
to_rel = pathjoin(to_dir, from_tail)
1412
rename_entry = WorkingTree._RenameEntry(from_rel=from_rel,
1413
from_id=from_id,
1414
from_tail=from_tail,
1415
from_parent_id=from_parent_id,
1416
to_rel=to_rel, to_tail=from_tail,
1417
to_parent_id=to_dir_id)
1418
rename_entries.append(rename_entry)
1419
rename_tuples.append((from_rel, to_rel))
1420
1421
# determine which move mode to use. checks also for movability
1422
rename_entries = self._determine_mv_mode(rename_entries, after)
1423
1424
original_modified = self._inventory_is_modified
1425
try:
1426
if len(from_paths):
1427
self._inventory_is_modified = True
1428
self._move(rename_entries)
1429
except:
1430
# restore the inventory on error
1431
self._inventory_is_modified = original_modified
1432
raise
1433
self._write_inventory(inv)
1434
return rename_tuples
1435
1436
def _determine_mv_mode(self, rename_entries, after=False):
1437
"""Determines for each from-to pair if both inventory and working tree
1438
or only the inventory has to be changed.
1439
1440
Also does basic plausability tests.
1441
"""
1442
inv = self.inventory
1443
1444
for rename_entry in rename_entries:
1445
# store to local variables for easier reference
1446
from_rel = rename_entry.from_rel
1447
from_id = rename_entry.from_id
1448
to_rel = rename_entry.to_rel
1449
to_id = inv.path2id(to_rel)
1450
only_change_inv = False
1451
1452
# check the inventory for source and destination
1453
if from_id is None:
1454
raise errors.BzrMoveFailedError(from_rel,to_rel,
1455
errors.NotVersionedError(path=from_rel))
1456
if to_id is not None:
1457
raise errors.BzrMoveFailedError(from_rel,to_rel,
1458
errors.AlreadyVersionedError(path=to_rel))
1459
1460
# try to determine the mode for rename (only change inv or change
1461
# inv and file system)
1462
if after:
1463
if not self.has_filename(to_rel):
1464
raise errors.BzrMoveFailedError(from_id,to_rel,
1465
errors.NoSuchFile(path=to_rel,
1466
extra="New file has not been created yet"))
1467
only_change_inv = True
1468
elif not self.has_filename(from_rel) and self.has_filename(to_rel):
1469
only_change_inv = True
1470
elif self.has_filename(from_rel) and not self.has_filename(to_rel):
1471
only_change_inv = False
1472
elif (not self.case_sensitive
1473
and from_rel.lower() == to_rel.lower()
1474
and self.has_filename(from_rel)):
1475
only_change_inv = False
1476
else:
1477
# something is wrong, so lets determine what exactly
1478
if not self.has_filename(from_rel) and \
1479
not self.has_filename(to_rel):
1480
raise errors.BzrRenameFailedError(from_rel,to_rel,
1481
errors.PathsDoNotExist(paths=(str(from_rel),
1482
str(to_rel))))
1483
else:
1484
raise errors.RenameFailedFilesExist(from_rel, to_rel)
1485
rename_entry.only_change_inv = only_change_inv
1486
return rename_entries
1487
1488
def _move(self, rename_entries):
1489
"""Moves a list of files.
1490
1491
Depending on the value of the flag 'only_change_inv', the
1492
file will be moved on the file system or not.
1493
"""
1494
inv = self.inventory
1495
moved = []
1496
1497
for entry in rename_entries:
1498
try:
1499
self._move_entry(entry)
1500
except:
1501
self._rollback_move(moved)
1502
raise
1503
moved.append(entry)
1504
1505
def _rollback_move(self, moved):
1506
"""Try to rollback a previous move in case of an filesystem error."""
1507
inv = self.inventory
1508
for entry in moved:
1509
try:
1510
self._move_entry(WorkingTree._RenameEntry(
1511
entry.to_rel, entry.from_id,
1512
entry.to_tail, entry.to_parent_id, entry.from_rel,
1513
entry.from_tail, entry.from_parent_id,
1514
entry.only_change_inv))
1515
except errors.BzrMoveFailedError, e:
1516
raise errors.BzrMoveFailedError( '', '', "Rollback failed."
1517
" The working tree is in an inconsistent state."
1518
" Please consider doing a 'bzr revert'."
1519
" Error message is: %s" % e)
1520
1521
def _move_entry(self, entry):
1522
inv = self.inventory
1523
from_rel_abs = self.abspath(entry.from_rel)
1524
to_rel_abs = self.abspath(entry.to_rel)
1525
if from_rel_abs == to_rel_abs:
1526
raise errors.BzrMoveFailedError(entry.from_rel, entry.to_rel,
1527
"Source and target are identical.")
1528
1529
if not entry.only_change_inv:
1530
try:
1531
osutils.rename(from_rel_abs, to_rel_abs)
1532
except OSError, e:
1533
raise errors.BzrMoveFailedError(entry.from_rel,
1534
entry.to_rel, e[1])
1535
inv.rename(entry.from_id, entry.to_parent_id, entry.to_tail)
981
raise NotImplementedError(self.move)
1536
982
1537
983
@needs_tree_write_lock
1538
984
def rename_one(self, from_rel, to_rel, after=False):
1542
988
1543
989
rename_one has several 'modes' to work. First, it can rename a physical
1544
990
file and change the file_id. That is the normal mode. Second, it can
1545
only change the file_id without touching any physical file. This is
1546
the new mode introduced in version 0.15.
991
only change the file_id without touching any physical file.
1547
992
1548
993
rename_one uses the second mode if 'after == True' and 'to_rel' is not
1549
994
versioned but present in the working tree.
1558
1003
1559
1004
Everything else results in an error.
1560
1005
"""
1561
inv = self.inventory
1562
rename_entries = []
1563
1564
# create rename entries and tuples
1565
from_tail = splitpath(from_rel)[-1]
1566
from_id = inv.path2id(from_rel)
1567
if from_id is None:
1568
# if file is missing in the inventory maybe it's in the basis_tree
1569
basis_tree = self.branch.basis_tree()
1570
from_id = basis_tree.path2id(from_rel)
1571
if from_id is None:
1572
raise errors.BzrRenameFailedError(from_rel,to_rel,
1573
errors.NotVersionedError(path=from_rel))
1574
# put entry back in the inventory so we can rename it
1575
from_entry = basis_tree.inventory[from_id].copy()
1576
inv.add(from_entry)
1577
else:
1578
from_entry = inv[from_id]
1579
from_parent_id = from_entry.parent_id
1580
to_dir, to_tail = os.path.split(to_rel)
1581
to_dir_id = inv.path2id(to_dir)
1582
rename_entry = WorkingTree._RenameEntry(from_rel=from_rel,
1583
from_id=from_id,
1584
from_tail=from_tail,
1585
from_parent_id=from_parent_id,
1586
to_rel=to_rel, to_tail=to_tail,
1587
to_parent_id=to_dir_id)
1588
rename_entries.append(rename_entry)
1589
1590
# determine which move mode to use. checks also for movability
1591
rename_entries = self._determine_mv_mode(rename_entries, after)
1592
1593
# check if the target changed directory and if the target directory is
1594
# versioned
1595
if to_dir_id is None:
1596
raise errors.BzrMoveFailedError(from_rel,to_rel,
1597
errors.NotVersionedError(path=to_dir))
1598
1599
# all checks done. now we can continue with our actual work
1600
mutter('rename_one:\n'
1601
' from_id {%s}\n'
1602
' from_rel: %r\n'
1603
' to_rel: %r\n'
1604
' to_dir %r\n'
1605
' to_dir_id {%s}\n',
1606
from_id, from_rel, to_rel, to_dir, to_dir_id)
1607
1608
self._move(rename_entries)
1609
self._write_inventory(inv)
1610
1611
class _RenameEntry(object):
1612
def __init__(self, from_rel, from_id, from_tail, from_parent_id,
1613
to_rel, to_tail, to_parent_id, only_change_inv=False):
1614
self.from_rel = from_rel
1615
self.from_id = from_id
1616
self.from_tail = from_tail
1617
self.from_parent_id = from_parent_id
1618
self.to_rel = to_rel
1619
self.to_tail = to_tail
1620
self.to_parent_id = to_parent_id
1621
self.only_change_inv = only_change_inv
1006
raise NotImplementedError(self.rename_one)
1622
1007
1623
1008
@needs_read_lock
1624
1009
def unknowns(self):
1632
1017
return iter(
1633
1018
[subp for subp in self.extras() if not self.is_ignored(subp)])
1634
1019
1635
@needs_tree_write_lock
1636
1020
def unversion(self, file_ids):
1637
1021
"""Remove the file ids in file_ids from the current versioned set.
1638
1022
1642
1026
:param file_ids: The file ids to stop versioning.
1643
1027
:raises: NoSuchId if any fileid is not currently versioned.
1644
1028
"""
1645
for file_id in file_ids:
1646
if file_id not in self._inventory:
1647
raise errors.NoSuchId(self, file_id)
1648
for file_id in file_ids:
1649
if self._inventory.has_id(file_id):
1650
self._inventory.remove_recursive_id(file_id)
1651
if len(file_ids):
1652
# in the future this should just set a dirty bit to wait for the
1653
# final unlock. However, until all methods of workingtree start
1654
# with the current in -memory inventory rather than triggering
1655
# a read, it is more complex - we need to teach read_inventory
1656
# to know when to read, and when to not read first... and possibly
1657
# to save first when the in memory one may be corrupted.
1658
# so for now, we just only write it if it is indeed dirty.
1659
# - RBC 20060907
1660
self._write_inventory(self._inventory)
1029
raise NotImplementedError(self.unversion)
1661
1030
1662
1031
@needs_write_lock
1663
1032
def pull(self, source, overwrite=False, stop_revision=None,
1728
1097
Currently returned depth-first, sorted by name within directories.
1729
1098
This is the same order used by 'osutils.walkdirs'.
1730
1099
"""
1731
## TODO: Work from given directory downwards
1732
for path, dir_entry in self.inventory.directories():
1733
# mutter("search for unknowns in %r", path)
1734
dirabs = self.abspath(path)
1735
if not isdir(dirabs):
1736
# e.g. directory deleted
1737
continue
1738
1739
fl = []
1740
for subf in os.listdir(dirabs):
1741
if self.bzrdir.is_control_filename(subf):
1742
continue
1743
if subf not in dir_entry.children:
1744
try:
1745
(subf_norm,
1746
can_access) = osutils.normalized_filename(subf)
1747
except UnicodeDecodeError:
1748
path_os_enc = path.encode(osutils._fs_enc)
1749
relpath = path_os_enc + '/' + subf
1750
raise errors.BadFilenameEncoding(relpath,
1751
osutils._fs_enc)
1752
if subf_norm != subf and can_access:
1753
if subf_norm not in dir_entry.children:
1754
fl.append(subf_norm)
1755
else:
1756
fl.append(subf)
1757
1758
fl.sort()
1759
for subf in fl:
1760
subp = pathjoin(path, subf)
1761
yield subp
1100
raise NotImplementedError(self.extras)
1762
1101
1763
1102
def ignored_files(self):
1764
1103
"""Yield list of PATH, IGNORE_PATTERN"""
1813
1152
1814
1153
def stored_kind(self, file_id):
1815
1154
"""See Tree.stored_kind"""
1816
return self.inventory[file_id].kind
1155
raise NotImplementedError(self.stored_kind)
1817
1156
1818
1157
def _comparison_data(self, entry, path):
1819
1158
abspath = self.abspath(path)
1910
1249
def get_physical_lock_status(self):
1911
1250
return self._control_files.get_physical_lock_status()
1912
1251
1913
def _basis_inventory_name(self):
1914
return 'basis-inventory-cache'
1915
1916
1252
def _reset_data(self):
1917
1253
"""Reset transient data that cannot be revalidated."""
1918
self._inventory_is_modified = False
1919
f = self._transport.get('inventory')
1920
try:
1921
result = self._deserialize(f)
1922
finally:
1923
f.close()
1924
self._set_inventory(result, dirty=False)
1254
raise NotImplementedError(self._reset_data)
1925
1255
1926
@needs_tree_write_lock
1927
1256
def set_last_revision(self, new_revision):
1928
1257
"""Change the last revision in the working tree."""
1929
if self._change_last_revision(new_revision):
1930
self._cache_basis_inventory(new_revision)
1258
raise NotImplementedError(self.set_last_revision)
1931
1259
1932
1260
def _change_last_revision(self, new_revision):
1933
1261
"""Template method part of set_last_revision to perform the change.
1945
1273
self.branch.set_revision_history([new_revision])
1946
1274
return True
1947
1275
1948
def _write_basis_inventory(self, xml):
1949
"""Write the basis inventory XML to the basis-inventory file"""
1950
path = self._basis_inventory_name()
1951
sio = StringIO(xml)
1952
self._transport.put_file(path, sio,
1953
mode=self.bzrdir._get_file_mode())
1954
1955
def _create_basis_xml_from_inventory(self, revision_id, inventory):
1956
"""Create the text that will be saved in basis-inventory"""
1957
inventory.revision_id = revision_id
1958
return xml7.serializer_v7.write_inventory_to_string(inventory)
1959
1960
def _cache_basis_inventory(self, new_revision):
1961
"""Cache new_revision as the basis inventory."""
1962
# TODO: this should allow the ready-to-use inventory to be passed in,
1963
# as commit already has that ready-to-use [while the format is the
1964
# same, that is].
1965
try:
1966
# this double handles the inventory - unpack and repack -
1967
# but is easier to understand. We can/should put a conditional
1968
# in here based on whether the inventory is in the latest format
1969
# - perhaps we should repack all inventories on a repository
1970
# upgrade ?
1971
# the fast path is to copy the raw xml from the repository. If the
1972
# xml contains 'revision_id="', then we assume the right
1973
# revision_id is set. We must check for this full string, because a
1974
# root node id can legitimately look like 'revision_id' but cannot
1975
# contain a '"'.
1976
xml = self.branch.repository._get_inventory_xml(new_revision)
1977
firstline = xml.split('\n', 1)[0]
1978
if (not 'revision_id="' in firstline or
1979
'format="7"' not in firstline):
1980
inv = self.branch.repository._serializer.read_inventory_from_string(
1981
xml, new_revision)
1982
xml = self._create_basis_xml_from_inventory(new_revision, inv)
1983
self._write_basis_inventory(xml)
1984
except (errors.NoSuchRevision, errors.RevisionNotPresent):
1985
pass
1986
1987
def read_basis_inventory(self):
1988
"""Read the cached basis inventory."""
1989
path = self._basis_inventory_name()
1990
return self._transport.get_bytes(path)
1991
1992
@needs_read_lock
1993
def read_working_inventory(self):
1994
"""Read the working inventory.
1995
1996
:raises errors.InventoryModified: read_working_inventory will fail
1997
when the current in memory inventory has been modified.
1998
"""
1999
# conceptually this should be an implementation detail of the tree.
2000
# XXX: Deprecate this.
2001
# ElementTree does its own conversion from UTF-8, so open in
2002
# binary.
2003
if self._inventory_is_modified:
2004
raise errors.InventoryModified(self)
2005
f = self._transport.get('inventory')
2006
try:
2007
result = self._deserialize(f)
2008
finally:
2009
f.close()
2010
self._set_inventory(result, dirty=False)
2011
return result
2012
2013
1276
@needs_tree_write_lock
2014
1277
def remove(self, files, verbose=False, to_file=None, keep_files=True,
2015
1278
force=False):
2016
"""Remove nominated files from the working inventory.
1279
"""Remove nominated files from the working tree metadata.
2017
1280
2018
1281
:files: File paths relative to the basedir.
2019
1282
:keep_files: If true, the files will also be kept.
2084
1347
backup_name)
2085
1348
2086
1349
# Build inv_delta and delete files where applicable,
2087
# do this before any modifications to inventory.
1350
# do this before any modifications to meta data.
2088
1351
for f in files:
2089
1352
fid = self.path2id(f)
2090
1353
message = None
2170
1433
WorkingTree can supply revision_trees for the basis revision only
2171
1434
because there is only one cached inventory in the bzr directory.
2172
1435
"""
2173
if revision_id == self.last_revision():
2174
try:
2175
xml = self.read_basis_inventory()
2176
except errors.NoSuchFile:
2177
pass
2178
else:
2179
try:
2180
inv = xml7.serializer_v7.read_inventory_from_string(xml)
2181
# dont use the repository revision_tree api because we want
2182
# to supply the inventory.
2183
if inv.revision_id == revision_id:
2184
return revisiontree.RevisionTree(self.branch.repository,
2185
inv, revision_id)
2186
except errors.BadInventoryFormat:
2187
pass
2188
# raise if there was no inventory, or if we read the wrong inventory.
2189
raise errors.NoSuchRevisionInTree(self, revision_id)
2190
2191
# XXX: This method should be deprecated in favour of taking in a proper
2192
# new Inventory object.
2193
@needs_tree_write_lock
2194
def set_inventory(self, new_inventory_list):
2195
from bzrlib.inventory import (Inventory,
2196
InventoryDirectory,
2197
InventoryFile,
2198
InventoryLink)
2199
inv = Inventory(self.get_root_id())
2200
for path, file_id, parent, kind in new_inventory_list:
2201
name = os.path.basename(path)
2202
if name == "":
2203
continue
2204
# fixme, there should be a factory function inv,add_??
2205
if kind == 'directory':
2206
inv.add(InventoryDirectory(file_id, name, parent))
2207
elif kind == 'file':
2208
inv.add(InventoryFile(file_id, name, parent))
2209
elif kind == 'symlink':
2210
inv.add(InventoryLink(file_id, name, parent))
2211
else:
2212
raise errors.BzrError("unknown kind %r" % kind)
2213
self._write_inventory(inv)
1436
raise NotImplementedError(self.revision_tree)
2214
1437
2215
1438
@needs_tree_write_lock
2216
1439
def set_root_id(self, file_id):
2229
1452
present in the current inventory or an error will occur. It must
2230
1453
not be None, but rather a valid file id.
2231
1454
"""
2232
inv = self._inventory
2233
orig_root_id = inv.root.file_id
2234
# TODO: it might be nice to exit early if there was nothing
2235
# to do, saving us from trigger a sync on unlock.
2236
self._inventory_is_modified = True
2237
# we preserve the root inventory entry object, but
2238
# unlinkit from the byid index
2239
del inv._byid[inv.root.file_id]
2240
inv.root.file_id = file_id
2241
# and link it into the index with the new changed id.
2242
inv._byid[inv.root.file_id] = inv.root
2243
# and finally update all children to reference the new id.
2244
# XXX: this should be safe to just look at the root.children
2245
# list, not the WHOLE INVENTORY.
2246
for fid in inv:
2247
entry = inv[fid]
2248
if entry.parent_id == orig_root_id:
2249
entry.parent_id = inv.root.file_id
1455
raise NotImplementedError(self._set_root_id)
2250
1456
2251
1457
def unlock(self):
2252
1458
"""See Branch.unlock.
2360
1566
basis = self.basis_tree()
2361
1567
basis.lock_read()
2362
1568
try:
2363
if (basis.inventory.root is None
2364
or basis.inventory.root.file_id != to_root_id):
1569
if (basis.get_root_id() is None or basis.get_root_id() != to_root_id):
2365
1570
self.set_root_id(to_root_id)
2366
1571
self.flush()
2367
1572
finally:
2409
1614
# warning might be sufficient to let the user know what
2410
1615
# is going on.
2411
1616
mutter('Could not write hashcache for %s\nError: %s',
2412
self._hashcache.cache_file_name(), e)
2413
2414
@needs_tree_write_lock
2415
def _write_inventory(self, inv):
2416
"""Write inventory as the current inventory."""
2417
self._set_inventory(inv, dirty=True)
2418
self.flush()
1617
self._hashcache.cache_file_name(), e)
2419
1618
2420
1619
def set_conflicts(self, arg):
2421
1620
raise errors.UnsupportedOperation(self.set_conflicts, self)
2556
1755
[(file1_path, file1_name, file1_kind, None, file1_id,
2557
1756
file1_kind), ... ])
2558
1757
"""
2559
_directory = 'directory'
2560
# get the root in the inventory
2561
inv = self.inventory
2562
top_id = inv.path2id(prefix)
2563
if top_id is None:
2564
pending = []
2565
else:
2566
pending = [(prefix, '', _directory, None, top_id, None)]
2567
while pending:
2568
dirblock = []
2569
currentdir = pending.pop()
2570
# 0 - relpath, 1- basename, 2- kind, 3- stat, 4-id, 5-kind
2571
top_id = currentdir[4]
2572
if currentdir[0]:
2573
relroot = currentdir[0] + '/'
2574
else:
2575
relroot = ""
2576
# FIXME: stash the node in pending
2577
entry = inv[top_id]
2578
if entry.kind == 'directory':
2579
for name, child in entry.sorted_children():
2580
dirblock.append((relroot + name, name, child.kind, None,
2581
child.file_id, child.kind
2582
))
2583
yield (currentdir[0], entry.file_id), dirblock
2584
# push the user specified dirs from dirblock
2585
for dir in reversed(dirblock):
2586
if dir[2] == _directory:
2587
pending.append(dir)
1758
raise NotImplementedError(self._walkdirs)
2588
1759
2589
1760
@needs_tree_write_lock
2590
1761
def auto_resolve(self):
2659
1830
refs[ref] = self.branch.repository.revision_tree(value)
2660
1831
self._check(refs)
2661
1832
2662
@needs_tree_write_lock
2663
1833
def reset_state(self, revision_ids=None):
2664
1834
"""Reset the state of the working tree.
2665
1835
2666
1836
This does a hard-reset to a last-known-good state. This is a way to
2667
1837
fix if something got corrupted (like the .bzr/checkout/dirstate file)
2668
1838
"""
2669
if revision_ids is None:
2670
revision_ids = self.get_parent_ids()
2671
if not revision_ids:
2672
rt = self.branch.repository.revision_tree(
2673
_mod_revision.NULL_REVISION)
2674
else:
2675
rt = self.branch.repository.revision_tree(revision_ids[0])
2676
self._write_inventory(rt.inventory)
2677
self.set_parent_ids(revision_ids)
1839
raise NotImplementedError(self.reset_state)
2678
1840
2679
1841
def _get_rules_searcher(self, default_searcher):
2680
1842
"""See Tree._get_rules_searcher."""
2689
1851
return ShelfManager(self, self._transport)
2690
1852
2691
1853
2692
class WorkingTree3(WorkingTree):
1854
class InventoryWorkingTree(WorkingTree,
1855
bzrlib.mutabletree.MutableInventoryTree):
1856
"""Base class for working trees that are inventory-oriented.
1857
1858
The inventory is held in the `Branch` working-inventory, and the
1859
files are in a directory on disk.
1860
1861
It is possible for a `WorkingTree` to have a filename which is
1862
not listed in the Inventory and vice versa.
1863
"""
1864
1865
def __init__(self, basedir='.',
1866
branch=DEPRECATED_PARAMETER,
1867
_inventory=None,
1868
_control_files=None,
1869
_internal=False,
1870
_format=None,
1871
_bzrdir=None):
1872
"""Construct a InventoryWorkingTree instance. This is not a public API.
1873
1874
:param branch: A branch to override probing for the branch.
1875
"""
1876
super(InventoryWorkingTree, self).__init__(basedir=basedir,
1877
branch=branch, _control_files=_control_files, _internal=_internal,
1878
_format=_format, _bzrdir=_bzrdir)
1879
1880
if _inventory is None:
1881
# This will be acquired on lock_read() or lock_write()
1882
self._inventory_is_modified = False
1883
self._inventory = None
1884
else:
1885
# the caller of __init__ has provided an inventory,
1886
# we assume they know what they are doing - as its only
1887
# the Format factory and creation methods that are
1888
# permitted to do this.
1889
self._set_inventory(_inventory, dirty=False)
1890
1891
def _set_inventory(self, inv, dirty):
1892
"""Set the internal cached inventory.
1893
1894
:param inv: The inventory to set.
1895
:param dirty: A boolean indicating whether the inventory is the same
1896
logical inventory as whats on disk. If True the inventory is not
1897
the same and should be written to disk or data will be lost, if
1898
False then the inventory is the same as that on disk and any
1899
serialisation would be unneeded overhead.
1900
"""
1901
self._inventory = inv
1902
self._inventory_is_modified = dirty
1903
1904
def _serialize(self, inventory, out_file):
1905
xml5.serializer_v5.write_inventory(self._inventory, out_file,
1906
working=True)
1907
1908
def _deserialize(selt, in_file):
1909
return xml5.serializer_v5.read_inventory(in_file)
1910
1911
@needs_tree_write_lock
1912
def _write_inventory(self, inv):
1913
"""Write inventory as the current inventory."""
1914
self._set_inventory(inv, dirty=True)
1915
self.flush()
1916
1917
# XXX: This method should be deprecated in favour of taking in a proper
1918
# new Inventory object.
1919
@needs_tree_write_lock
1920
def set_inventory(self, new_inventory_list):
1921
from bzrlib.inventory import (Inventory,
1922
InventoryDirectory,
1923
InventoryFile,
1924
InventoryLink)
1925
inv = Inventory(self.get_root_id())
1926
for path, file_id, parent, kind in new_inventory_list:
1927
name = os.path.basename(path)
1928
if name == "":
1929
continue
1930
# fixme, there should be a factory function inv,add_??
1931
if kind == 'directory':
1932
inv.add(InventoryDirectory(file_id, name, parent))
1933
elif kind == 'file':
1934
inv.add(InventoryFile(file_id, name, parent))
1935
elif kind == 'symlink':
1936
inv.add(InventoryLink(file_id, name, parent))
1937
else:
1938
raise errors.BzrError("unknown kind %r" % kind)
1939
self._write_inventory(inv)
1940
1941
def _write_basis_inventory(self, xml):
1942
"""Write the basis inventory XML to the basis-inventory file"""
1943
path = self._basis_inventory_name()
1944
sio = StringIO(xml)
1945
self._transport.put_file(path, sio,
1946
mode=self.bzrdir._get_file_mode())
1947
1948
def _reset_data(self):
1949
"""Reset transient data that cannot be revalidated."""
1950
self._inventory_is_modified = False
1951
f = self._transport.get('inventory')
1952
try:
1953
result = self._deserialize(f)
1954
finally:
1955
f.close()
1956
self._set_inventory(result, dirty=False)
1957
1958
def _set_root_id(self, file_id):
1959
"""Set the root id for this tree, in a format specific manner.
1960
1961
:param file_id: The file id to assign to the root. It must not be
1962
present in the current inventory or an error will occur. It must
1963
not be None, but rather a valid file id.
1964
"""
1965
inv = self._inventory
1966
orig_root_id = inv.root.file_id
1967
# TODO: it might be nice to exit early if there was nothing
1968
# to do, saving us from trigger a sync on unlock.
1969
self._inventory_is_modified = True
1970
# we preserve the root inventory entry object, but
1971
# unlinkit from the byid index
1972
del inv._byid[inv.root.file_id]
1973
inv.root.file_id = file_id
1974
# and link it into the index with the new changed id.
1975
inv._byid[inv.root.file_id] = inv.root
1976
# and finally update all children to reference the new id.
1977
# XXX: this should be safe to just look at the root.children
1978
# list, not the WHOLE INVENTORY.
1979
for fid in inv:
1980
entry = inv[fid]
1981
if entry.parent_id == orig_root_id:
1982
entry.parent_id = inv.root.file_id
1983
1984
def all_file_ids(self):
1985
"""See Tree.iter_all_file_ids"""
1986
return set(self.inventory)
1987
1988
def _cache_basis_inventory(self, new_revision):
1989
"""Cache new_revision as the basis inventory."""
1990
# TODO: this should allow the ready-to-use inventory to be passed in,
1991
# as commit already has that ready-to-use [while the format is the
1992
# same, that is].
1993
try:
1994
# this double handles the inventory - unpack and repack -
1995
# but is easier to understand. We can/should put a conditional
1996
# in here based on whether the inventory is in the latest format
1997
# - perhaps we should repack all inventories on a repository
1998
# upgrade ?
1999
# the fast path is to copy the raw xml from the repository. If the
2000
# xml contains 'revision_id="', then we assume the right
2001
# revision_id is set. We must check for this full string, because a
2002
# root node id can legitimately look like 'revision_id' but cannot
2003
# contain a '"'.
2004
xml = self.branch.repository._get_inventory_xml(new_revision)
2005
firstline = xml.split('\n', 1)[0]
2006
if (not 'revision_id="' in firstline or
2007
'format="7"' not in firstline):
2008
inv = self.branch.repository._serializer.read_inventory_from_string(
2009
xml, new_revision)
2010
xml = self._create_basis_xml_from_inventory(new_revision, inv)
2011
self._write_basis_inventory(xml)
2012
except (errors.NoSuchRevision, errors.RevisionNotPresent):
2013
pass
2014
2015
def _basis_inventory_name(self):
2016
return 'basis-inventory-cache'
2017
2018
def _create_basis_xml_from_inventory(self, revision_id, inventory):
2019
"""Create the text that will be saved in basis-inventory"""
2020
inventory.revision_id = revision_id
2021
return xml7.serializer_v7.write_inventory_to_string(inventory)
2022
2023
def read_basis_inventory(self):
2024
"""Read the cached basis inventory."""
2025
path = self._basis_inventory_name()
2026
return self._transport.get_bytes(path)
2027
2028
@needs_read_lock
2029
def read_working_inventory(self):
2030
"""Read the working inventory.
2031
2032
:raises errors.InventoryModified: read_working_inventory will fail
2033
when the current in memory inventory has been modified.
2034
"""
2035
# conceptually this should be an implementation detail of the tree.
2036
# XXX: Deprecate this.
2037
# ElementTree does its own conversion from UTF-8, so open in
2038
# binary.
2039
if self._inventory_is_modified:
2040
raise errors.InventoryModified(self)
2041
f = self._transport.get('inventory')
2042
try:
2043
result = self._deserialize(f)
2044
finally:
2045
f.close()
2046
self._set_inventory(result, dirty=False)
2047
return result
2048
2049
@needs_read_lock
2050
def get_root_id(self):
2051
"""Return the id of this trees root"""
2052
return self._inventory.root.file_id
2053
2054
def has_id(self, file_id):
2055
# files that have been deleted are excluded
2056
inv = self.inventory
2057
if not inv.has_id(file_id):
2058
return False
2059
path = inv.id2path(file_id)
2060
return osutils.lexists(self.abspath(path))
2061
2062
def has_or_had_id(self, file_id):
2063
if file_id == self.inventory.root.file_id:
2064
return True
2065
return self.inventory.has_id(file_id)
2066
2067
__contains__ = has_id
2068
2069
# should be deprecated - this is slow and in any case treating them as a
2070
# container is (we now know) bad style -- mbp 20070302
2071
## @deprecated_method(zero_fifteen)
2072
def __iter__(self):
2073
"""Iterate through file_ids for this tree.
2074
2075
file_ids are in a WorkingTree if they are in the working inventory
2076
and the working file exists.
2077
"""
2078
inv = self._inventory
2079
for path, ie in inv.iter_entries():
2080
if osutils.lexists(self.abspath(path)):
2081
yield ie.file_id
2082
2083
@needs_tree_write_lock
2084
def set_last_revision(self, new_revision):
2085
"""Change the last revision in the working tree."""
2086
if self._change_last_revision(new_revision):
2087
self._cache_basis_inventory(new_revision)
2088
2089
@needs_tree_write_lock
2090
def reset_state(self, revision_ids=None):
2091
"""Reset the state of the working tree.
2092
2093
This does a hard-reset to a last-known-good state. This is a way to
2094
fix if something got corrupted (like the .bzr/checkout/dirstate file)
2095
"""
2096
if revision_ids is None:
2097
revision_ids = self.get_parent_ids()
2098
if not revision_ids:
2099
rt = self.branch.repository.revision_tree(
2100
_mod_revision.NULL_REVISION)
2101
else:
2102
rt = self.branch.repository.revision_tree(revision_ids[0])
2103
self._write_inventory(rt.inventory)
2104
self.set_parent_ids(revision_ids)
2105
2106
def flush(self):
2107
"""Write the in memory inventory to disk."""
2108
# TODO: Maybe this should only write on dirty ?
2109
if self._control_files._lock_mode != 'w':
2110
raise errors.NotWriteLocked(self)
2111
sio = StringIO()
2112
self._serialize(self._inventory, sio)
2113
sio.seek(0)
2114
self._transport.put_file('inventory', sio,
2115
mode=self.bzrdir._get_file_mode())
2116
self._inventory_is_modified = False
2117
2118
@needs_read_lock
2119
def get_file_sha1(self, file_id, path=None, stat_value=None):
2120
if not path:
2121
path = self._inventory.id2path(file_id)
2122
return self._hashcache.get_sha1(path, stat_value)
2123
2124
def get_file_mtime(self, file_id, path=None):
2125
"""See Tree.get_file_mtime."""
2126
if not path:
2127
path = self.inventory.id2path(file_id)
2128
return os.lstat(self.abspath(path)).st_mtime
2129
2130
def _is_executable_from_path_and_stat_from_basis(self, path, stat_result):
2131
file_id = self.path2id(path)
2132
if file_id is None:
2133
# For unversioned files on win32, we just assume they are not
2134
# executable
2135
return False
2136
return self._inventory[file_id].executable
2137
2138
def _is_executable_from_path_and_stat_from_stat(self, path, stat_result):
2139
mode = stat_result.st_mode
2140
return bool(stat.S_ISREG(mode) and stat.S_IEXEC & mode)
2141
2142
if not supports_executable():
2143
def is_executable(self, file_id, path=None):
2144
return self._inventory[file_id].executable
2145
2146
_is_executable_from_path_and_stat = \
2147
_is_executable_from_path_and_stat_from_basis
2148
else:
2149
def is_executable(self, file_id, path=None):
2150
if not path:
2151
path = self.id2path(file_id)
2152
mode = os.lstat(self.abspath(path)).st_mode
2153
return bool(stat.S_ISREG(mode) and stat.S_IEXEC & mode)
2154
2155
_is_executable_from_path_and_stat = \
2156
_is_executable_from_path_and_stat_from_stat
2157
2158
@needs_tree_write_lock
2159
def _add(self, files, ids, kinds):
2160
"""See MutableTree._add."""
2161
# TODO: Re-adding a file that is removed in the working copy
2162
# should probably put it back with the previous ID.
2163
# the read and write working inventory should not occur in this
2164
# function - they should be part of lock_write and unlock.
2165
inv = self.inventory
2166
for f, file_id, kind in zip(files, ids, kinds):
2167
if file_id is None:
2168
inv.add_path(f, kind=kind)
2169
else:
2170
inv.add_path(f, kind=kind, file_id=file_id)
2171
self._inventory_is_modified = True
2172
2173
def revision_tree(self, revision_id):
2174
"""See WorkingTree.revision_id."""
2175
if revision_id == self.last_revision():
2176
try:
2177
xml = self.read_basis_inventory()
2178
except errors.NoSuchFile:
2179
pass
2180
else:
2181
try:
2182
inv = xml7.serializer_v7.read_inventory_from_string(xml)
2183
# dont use the repository revision_tree api because we want
2184
# to supply the inventory.
2185
if inv.revision_id == revision_id:
2186
return revisiontree.RevisionTree(self.branch.repository,
2187
inv, revision_id)
2188
except errors.BadInventoryFormat:
2189
pass
2190
# raise if there was no inventory, or if we read the wrong inventory.
2191
raise errors.NoSuchRevisionInTree(self, revision_id)
2192
2193
@needs_read_lock
2194
def annotate_iter(self, file_id, default_revision=CURRENT_REVISION):
2195
"""See Tree.annotate_iter
2196
2197
This implementation will use the basis tree implementation if possible.
2198
Lines not in the basis are attributed to CURRENT_REVISION
2199
2200
If there are pending merges, lines added by those merges will be
2201
incorrectly attributed to CURRENT_REVISION (but after committing, the
2202
attribution will be correct).
2203
"""
2204
maybe_file_parent_keys = []
2205
for parent_id in self.get_parent_ids():
2206
try:
2207
parent_tree = self.revision_tree(parent_id)
2208
except errors.NoSuchRevisionInTree:
2209
parent_tree = self.branch.repository.revision_tree(parent_id)
2210
parent_tree.lock_read()
2211
try:
2212
if file_id not in parent_tree:
2213
continue
2214
ie = parent_tree.inventory[file_id]
2215
if ie.kind != 'file':
2216
# Note: this is slightly unnecessary, because symlinks and
2217
# directories have a "text" which is the empty text, and we
2218
# know that won't mess up annotations. But it seems cleaner
2219
continue
2220
parent_text_key = (file_id, ie.revision)
2221
if parent_text_key not in maybe_file_parent_keys:
2222
maybe_file_parent_keys.append(parent_text_key)
2223
finally:
2224
parent_tree.unlock()
2225
graph = _mod_graph.Graph(self.branch.repository.texts)
2226
heads = graph.heads(maybe_file_parent_keys)
2227
file_parent_keys = []
2228
for key in maybe_file_parent_keys:
2229
if key in heads:
2230
file_parent_keys.append(key)
2231
2232
# Now we have the parents of this content
2233
annotator = self.branch.repository.texts.get_annotator()
2234
text = self.get_file_text(file_id)
2235
this_key =(file_id, default_revision)
2236
annotator.add_special_text(this_key, file_parent_keys, text)
2237
annotations = [(key[-1], line)
2238
for key, line in annotator.annotate_flat(this_key)]
2239
return annotations
2240
2241
@needs_read_lock
2242
def merge_modified(self):
2243
"""Return a dictionary of files modified by a merge.
2244
2245
The list is initialized by WorkingTree.set_merge_modified, which is
2246
typically called after we make some automatic updates to the tree
2247
because of a merge.
2248
2249
This returns a map of file_id->sha1, containing only files which are
2250
still in the working inventory and have that text hash.
2251
"""
2252
try:
2253
hashfile = self._transport.get('merge-hashes')
2254
except errors.NoSuchFile:
2255
return {}
2256
try:
2257
merge_hashes = {}
2258
try:
2259
if hashfile.next() != MERGE_MODIFIED_HEADER_1 + '\n':
2260
raise errors.MergeModifiedFormatError()
2261
except StopIteration:
2262
raise errors.MergeModifiedFormatError()
2263
for s in _mod_rio.RioReader(hashfile):
2264
# RioReader reads in Unicode, so convert file_ids back to utf8
2265
file_id = osutils.safe_file_id(s.get("file_id"), warn=False)
2266
if file_id not in self.inventory:
2267
continue
2268
text_hash = s.get("hash")
2269
if text_hash == self.get_file_sha1(file_id):
2270
merge_hashes[file_id] = text_hash
2271
return merge_hashes
2272
finally:
2273
hashfile.close()
2274
2275
@needs_write_lock
2276
def subsume(self, other_tree):
2277
def add_children(inventory, entry):
2278
for child_entry in entry.children.values():
2279
inventory._byid[child_entry.file_id] = child_entry
2280
if child_entry.kind == 'directory':
2281
add_children(inventory, child_entry)
2282
if other_tree.get_root_id() == self.get_root_id():
2283
raise errors.BadSubsumeSource(self, other_tree,
2284
'Trees have the same root')
2285
try:
2286
other_tree_path = self.relpath(other_tree.basedir)
2287
except errors.PathNotChild:
2288
raise errors.BadSubsumeSource(self, other_tree,
2289
'Tree is not contained by the other')
2290
new_root_parent = self.path2id(osutils.dirname(other_tree_path))
2291
if new_root_parent is None:
2292
raise errors.BadSubsumeSource(self, other_tree,
2293
'Parent directory is not versioned.')
2294
# We need to ensure that the result of a fetch will have a
2295
# versionedfile for the other_tree root, and only fetching into
2296
# RepositoryKnit2 guarantees that.
2297
if not self.branch.repository.supports_rich_root():
2298
raise errors.SubsumeTargetNeedsUpgrade(other_tree)
2299
other_tree.lock_tree_write()
2300
try:
2301
new_parents = other_tree.get_parent_ids()
2302
other_root = other_tree.inventory.root
2303
other_root.parent_id = new_root_parent
2304
other_root.name = osutils.basename(other_tree_path)
2305
self.inventory.add(other_root)
2306
add_children(self.inventory, other_root)
2307
self._write_inventory(self.inventory)
2308
# normally we don't want to fetch whole repositories, but i think
2309
# here we really do want to consolidate the whole thing.
2310
for parent_id in other_tree.get_parent_ids():
2311
self.branch.fetch(other_tree.branch, parent_id)
2312
self.add_parent_tree_id(parent_id)
2313
finally:
2314
other_tree.unlock()
2315
other_tree.bzrdir.retire_bzrdir()
2316
2317
@needs_tree_write_lock
2318
def extract(self, file_id, format=None):
2319
"""Extract a subtree from this tree.
2320
2321
A new branch will be created, relative to the path for this tree.
2322
"""
2323
self.flush()
2324
def mkdirs(path):
2325
segments = osutils.splitpath(path)
2326
transport = self.branch.bzrdir.root_transport
2327
for name in segments:
2328
transport = transport.clone(name)
2329
transport.ensure_base()
2330
return transport
2331
2332
sub_path = self.id2path(file_id)
2333
branch_transport = mkdirs(sub_path)
2334
if format is None:
2335
format = self.bzrdir.cloning_metadir()
2336
branch_transport.ensure_base()
2337
branch_bzrdir = format.initialize_on_transport(branch_transport)
2338
try:
2339
repo = branch_bzrdir.find_repository()
2340
except errors.NoRepositoryPresent:
2341
repo = branch_bzrdir.create_repository()
2342
if not repo.supports_rich_root():
2343
raise errors.RootNotRich()
2344
new_branch = branch_bzrdir.create_branch()
2345
new_branch.pull(self.branch)
2346
for parent_id in self.get_parent_ids():
2347
new_branch.fetch(self.branch, parent_id)
2348
tree_transport = self.bzrdir.root_transport.clone(sub_path)
2349
if tree_transport.base != branch_transport.base:
2350
tree_bzrdir = format.initialize_on_transport(tree_transport)
2351
branch.BranchReferenceFormat().initialize(tree_bzrdir,
2352
target_branch=new_branch)
2353
else:
2354
tree_bzrdir = branch_bzrdir
2355
wt = tree_bzrdir.create_workingtree(_mod_revision.NULL_REVISION)
2356
wt.set_parent_ids(self.get_parent_ids())
2357
my_inv = self.inventory
2358
child_inv = inventory.Inventory(root_id=None)
2359
new_root = my_inv[file_id]
2360
my_inv.remove_recursive_id(file_id)
2361
new_root.parent_id = None
2362
child_inv.add(new_root)
2363
self._write_inventory(my_inv)
2364
wt._write_inventory(child_inv)
2365
return wt
2366
2367
def list_files(self, include_root=False, from_dir=None, recursive=True):
2368
"""List all files as (path, class, kind, id, entry).
2369
2370
Lists, but does not descend into unversioned directories.
2371
This does not include files that have been deleted in this
2372
tree. Skips the control directory.
2373
2374
:param include_root: if True, return an entry for the root
2375
:param from_dir: start from this directory or None for the root
2376
:param recursive: whether to recurse into subdirectories or not
2377
"""
2378
# list_files is an iterator, so @needs_read_lock doesn't work properly
2379
# with it. So callers should be careful to always read_lock the tree.
2380
if not self.is_locked():
2381
raise errors.ObjectNotLocked(self)
2382
2383
inv = self.inventory
2384
if from_dir is None and include_root is True:
2385
yield ('', 'V', 'directory', inv.root.file_id, inv.root)
2386
# Convert these into local objects to save lookup times
2387
pathjoin = osutils.pathjoin
2388
file_kind = self._kind
2389
2390
# transport.base ends in a slash, we want the piece
2391
# between the last two slashes
2392
transport_base_dir = self.bzrdir.transport.base.rsplit('/', 2)[1]
2393
2394
fk_entries = {'directory':TreeDirectory, 'file':TreeFile, 'symlink':TreeLink}
2395
2396
# directory file_id, relative path, absolute path, reverse sorted children
2397
if from_dir is not None:
2398
from_dir_id = inv.path2id(from_dir)
2399
if from_dir_id is None:
2400
# Directory not versioned
2401
return
2402
from_dir_abspath = pathjoin(self.basedir, from_dir)
2403
else:
2404
from_dir_id = inv.root.file_id
2405
from_dir_abspath = self.basedir
2406
children = os.listdir(from_dir_abspath)
2407
children.sort()
2408
# jam 20060527 The kernel sized tree seems equivalent whether we
2409
# use a deque and popleft to keep them sorted, or if we use a plain
2410
# list and just reverse() them.
2411
children = collections.deque(children)
2412
stack = [(from_dir_id, u'', from_dir_abspath, children)]
2413
while stack:
2414
from_dir_id, from_dir_relpath, from_dir_abspath, children = stack[-1]
2415
2416
while children:
2417
f = children.popleft()
2418
## TODO: If we find a subdirectory with its own .bzr
2419
## directory, then that is a separate tree and we
2420
## should exclude it.
2421
2422
# the bzrdir for this tree
2423
if transport_base_dir == f:
2424
continue
2425
2426
# we know that from_dir_relpath and from_dir_abspath never end in a slash
2427
# and 'f' doesn't begin with one, we can do a string op, rather
2428
# than the checks of pathjoin(), all relative paths will have an extra slash
2429
# at the beginning
2430
fp = from_dir_relpath + '/' + f
2431
2432
# absolute path
2433
fap = from_dir_abspath + '/' + f
2434
2435
dir_ie = inv[from_dir_id]
2436
if dir_ie.kind == 'directory':
2437
f_ie = dir_ie.children.get(f)
2438
else:
2439
f_ie = None
2440
if f_ie:
2441
c = 'V'
2442
elif self.is_ignored(fp[1:]):
2443
c = 'I'
2444
else:
2445
# we may not have found this file, because of a unicode
2446
# issue, or because the directory was actually a symlink.
2447
f_norm, can_access = osutils.normalized_filename(f)
2448
if f == f_norm or not can_access:
2449
# No change, so treat this file normally
2450
c = '?'
2451
else:
2452
# this file can be accessed by a normalized path
2453
# check again if it is versioned
2454
# these lines are repeated here for performance
2455
f = f_norm
2456
fp = from_dir_relpath + '/' + f
2457
fap = from_dir_abspath + '/' + f
2458
f_ie = inv.get_child(from_dir_id, f)
2459
if f_ie:
2460
c = 'V'
2461
elif self.is_ignored(fp[1:]):
2462
c = 'I'
2463
else:
2464
c = '?'
2465
2466
fk = file_kind(fap)
2467
2468
# make a last minute entry
2469
if f_ie:
2470
yield fp[1:], c, fk, f_ie.file_id, f_ie
2471
else:
2472
try:
2473
yield fp[1:], c, fk, None, fk_entries[fk]()
2474
except KeyError:
2475
yield fp[1:], c, fk, None, TreeEntry()
2476
continue
2477
2478
if fk != 'directory':
2479
continue
2480
2481
# But do this child first if recursing down
2482
if recursive:
2483
new_children = os.listdir(fap)
2484
new_children.sort()
2485
new_children = collections.deque(new_children)
2486
stack.append((f_ie.file_id, fp, fap, new_children))
2487
# Break out of inner loop,
2488
# so that we start outer loop with child
2489
break
2490
else:
2491
# if we finished all children, pop it off the stack
2492
stack.pop()
2493
2494
@needs_tree_write_lock
2495
def move(self, from_paths, to_dir=None, after=False):
2496
"""Rename files.
2497
2498
to_dir must exist in the inventory.
2499
2500
If to_dir exists and is a directory, the files are moved into
2501
it, keeping their old names.
2502
2503
Note that to_dir is only the last component of the new name;
2504
this doesn't change the directory.
2505
2506
For each entry in from_paths the move mode will be determined
2507
independently.
2508
2509
The first mode moves the file in the filesystem and updates the
2510
inventory. The second mode only updates the inventory without
2511
touching the file on the filesystem.
2512
2513
move uses the second mode if 'after == True' and the target is not
2514
versioned but present in the working tree.
2515
2516
move uses the second mode if 'after == False' and the source is
2517
versioned but no longer in the working tree, and the target is not
2518
versioned but present in the working tree.
2519
2520
move uses the first mode if 'after == False' and the source is
2521
versioned and present in the working tree, and the target is not
2522
versioned and not present in the working tree.
2523
2524
Everything else results in an error.
2525
2526
This returns a list of (from_path, to_path) pairs for each
2527
entry that is moved.
2528
"""
2529
rename_entries = []
2530
rename_tuples = []
2531
2532
# check for deprecated use of signature
2533
if to_dir is None:
2534
raise TypeError('You must supply a target directory')
2535
# check destination directory
2536
if isinstance(from_paths, basestring):
2537
raise ValueError()
2538
inv = self.inventory
2539
to_abs = self.abspath(to_dir)
2540
if not isdir(to_abs):
2541
raise errors.BzrMoveFailedError('',to_dir,
2542
errors.NotADirectory(to_abs))
2543
if not self.has_filename(to_dir):
2544
raise errors.BzrMoveFailedError('',to_dir,
2545
errors.NotInWorkingDirectory(to_dir))
2546
to_dir_id = inv.path2id(to_dir)
2547
if to_dir_id is None:
2548
raise errors.BzrMoveFailedError('',to_dir,
2549
errors.NotVersionedError(path=to_dir))
2550
2551
to_dir_ie = inv[to_dir_id]
2552
if to_dir_ie.kind != 'directory':
2553
raise errors.BzrMoveFailedError('',to_dir,
2554
errors.NotADirectory(to_abs))
2555
2556
# create rename entries and tuples
2557
for from_rel in from_paths:
2558
from_tail = splitpath(from_rel)[-1]
2559
from_id = inv.path2id(from_rel)
2560
if from_id is None:
2561
raise errors.BzrMoveFailedError(from_rel,to_dir,
2562
errors.NotVersionedError(path=from_rel))
2563
2564
from_entry = inv[from_id]
2565
from_parent_id = from_entry.parent_id
2566
to_rel = pathjoin(to_dir, from_tail)
2567
rename_entry = InventoryWorkingTree._RenameEntry(
2568
from_rel=from_rel,
2569
from_id=from_id,
2570
from_tail=from_tail,
2571
from_parent_id=from_parent_id,
2572
to_rel=to_rel, to_tail=from_tail,
2573
to_parent_id=to_dir_id)
2574
rename_entries.append(rename_entry)
2575
rename_tuples.append((from_rel, to_rel))
2576
2577
# determine which move mode to use. checks also for movability
2578
rename_entries = self._determine_mv_mode(rename_entries, after)
2579
2580
original_modified = self._inventory_is_modified
2581
try:
2582
if len(from_paths):
2583
self._inventory_is_modified = True
2584
self._move(rename_entries)
2585
except:
2586
# restore the inventory on error
2587
self._inventory_is_modified = original_modified
2588
raise
2589
self._write_inventory(inv)
2590
return rename_tuples
2591
2592
@needs_tree_write_lock
2593
def rename_one(self, from_rel, to_rel, after=False):
2594
"""Rename one file.
2595
2596
This can change the directory or the filename or both.
2597
2598
rename_one has several 'modes' to work. First, it can rename a physical
2599
file and change the file_id. That is the normal mode. Second, it can
2600
only change the file_id without touching any physical file.
2601
2602
rename_one uses the second mode if 'after == True' and 'to_rel' is not
2603
versioned but present in the working tree.
2604
2605
rename_one uses the second mode if 'after == False' and 'from_rel' is
2606
versioned but no longer in the working tree, and 'to_rel' is not
2607
versioned but present in the working tree.
2608
2609
rename_one uses the first mode if 'after == False' and 'from_rel' is
2610
versioned and present in the working tree, and 'to_rel' is not
2611
versioned and not present in the working tree.
2612
2613
Everything else results in an error.
2614
"""
2615
inv = self.inventory
2616
rename_entries = []
2617
2618
# create rename entries and tuples
2619
from_tail = splitpath(from_rel)[-1]
2620
from_id = inv.path2id(from_rel)
2621
if from_id is None:
2622
# if file is missing in the inventory maybe it's in the basis_tree
2623
basis_tree = self.branch.basis_tree()
2624
from_id = basis_tree.path2id(from_rel)
2625
if from_id is None:
2626
raise errors.BzrRenameFailedError(from_rel,to_rel,
2627
errors.NotVersionedError(path=from_rel))
2628
# put entry back in the inventory so we can rename it
2629
from_entry = basis_tree.inventory[from_id].copy()
2630
inv.add(from_entry)
2631
else:
2632
from_entry = inv[from_id]
2633
from_parent_id = from_entry.parent_id
2634
to_dir, to_tail = os.path.split(to_rel)
2635
to_dir_id = inv.path2id(to_dir)
2636
rename_entry = InventoryWorkingTree._RenameEntry(from_rel=from_rel,
2637
from_id=from_id,
2638
from_tail=from_tail,
2639
from_parent_id=from_parent_id,
2640
to_rel=to_rel, to_tail=to_tail,
2641
to_parent_id=to_dir_id)
2642
rename_entries.append(rename_entry)
2643
2644
# determine which move mode to use. checks also for movability
2645
rename_entries = self._determine_mv_mode(rename_entries, after)
2646
2647
# check if the target changed directory and if the target directory is
2648
# versioned
2649
if to_dir_id is None:
2650
raise errors.BzrMoveFailedError(from_rel,to_rel,
2651
errors.NotVersionedError(path=to_dir))
2652
2653
# all checks done. now we can continue with our actual work
2654
mutter('rename_one:\n'
2655
' from_id {%s}\n'
2656
' from_rel: %r\n'
2657
' to_rel: %r\n'
2658
' to_dir %r\n'
2659
' to_dir_id {%s}\n',
2660
from_id, from_rel, to_rel, to_dir, to_dir_id)
2661
2662
self._move(rename_entries)
2663
self._write_inventory(inv)
2664
2665
class _RenameEntry(object):
2666
def __init__(self, from_rel, from_id, from_tail, from_parent_id,
2667
to_rel, to_tail, to_parent_id, only_change_inv=False):
2668
self.from_rel = from_rel
2669
self.from_id = from_id
2670
self.from_tail = from_tail
2671
self.from_parent_id = from_parent_id
2672
self.to_rel = to_rel
2673
self.to_tail = to_tail
2674
self.to_parent_id = to_parent_id
2675
self.only_change_inv = only_change_inv
2676
2677
def _determine_mv_mode(self, rename_entries, after=False):
2678
"""Determines for each from-to pair if both inventory and working tree
2679
or only the inventory has to be changed.
2680
2681
Also does basic plausability tests.
2682
"""
2683
inv = self.inventory
2684
2685
for rename_entry in rename_entries:
2686
# store to local variables for easier reference
2687
from_rel = rename_entry.from_rel
2688
from_id = rename_entry.from_id
2689
to_rel = rename_entry.to_rel
2690
to_id = inv.path2id(to_rel)
2691
only_change_inv = False
2692
2693
# check the inventory for source and destination
2694
if from_id is None:
2695
raise errors.BzrMoveFailedError(from_rel,to_rel,
2696
errors.NotVersionedError(path=from_rel))
2697
if to_id is not None:
2698
raise errors.BzrMoveFailedError(from_rel,to_rel,
2699
errors.AlreadyVersionedError(path=to_rel))
2700
2701
# try to determine the mode for rename (only change inv or change
2702
# inv and file system)
2703
if after:
2704
if not self.has_filename(to_rel):
2705
raise errors.BzrMoveFailedError(from_id,to_rel,
2706
errors.NoSuchFile(path=to_rel,
2707
extra="New file has not been created yet"))
2708
only_change_inv = True
2709
elif not self.has_filename(from_rel) and self.has_filename(to_rel):
2710
only_change_inv = True
2711
elif self.has_filename(from_rel) and not self.has_filename(to_rel):
2712
only_change_inv = False
2713
elif (not self.case_sensitive
2714
and from_rel.lower() == to_rel.lower()
2715
and self.has_filename(from_rel)):
2716
only_change_inv = False
2717
else:
2718
# something is wrong, so lets determine what exactly
2719
if not self.has_filename(from_rel) and \
2720
not self.has_filename(to_rel):
2721
raise errors.BzrRenameFailedError(from_rel,to_rel,
2722
errors.PathsDoNotExist(paths=(str(from_rel),
2723
str(to_rel))))
2724
else:
2725
raise errors.RenameFailedFilesExist(from_rel, to_rel)
2726
rename_entry.only_change_inv = only_change_inv
2727
return rename_entries
2728
2729
def _move(self, rename_entries):
2730
"""Moves a list of files.
2731
2732
Depending on the value of the flag 'only_change_inv', the
2733
file will be moved on the file system or not.
2734
"""
2735
inv = self.inventory
2736
moved = []
2737
2738
for entry in rename_entries:
2739
try:
2740
self._move_entry(entry)
2741
except:
2742
self._rollback_move(moved)
2743
raise
2744
moved.append(entry)
2745
2746
def _rollback_move(self, moved):
2747
"""Try to rollback a previous move in case of an filesystem error."""
2748
inv = self.inventory
2749
for entry in moved:
2750
try:
2751
self._move_entry(WorkingTree._RenameEntry(
2752
entry.to_rel, entry.from_id,
2753
entry.to_tail, entry.to_parent_id, entry.from_rel,
2754
entry.from_tail, entry.from_parent_id,
2755
entry.only_change_inv))
2756
except errors.BzrMoveFailedError, e:
2757
raise errors.BzrMoveFailedError( '', '', "Rollback failed."
2758
" The working tree is in an inconsistent state."
2759
" Please consider doing a 'bzr revert'."
2760
" Error message is: %s" % e)
2761
2762
def _move_entry(self, entry):
2763
inv = self.inventory
2764
from_rel_abs = self.abspath(entry.from_rel)
2765
to_rel_abs = self.abspath(entry.to_rel)
2766
if from_rel_abs == to_rel_abs:
2767
raise errors.BzrMoveFailedError(entry.from_rel, entry.to_rel,
2768
"Source and target are identical.")
2769
2770
if not entry.only_change_inv:
2771
try:
2772
osutils.rename(from_rel_abs, to_rel_abs)
2773
except OSError, e:
2774
raise errors.BzrMoveFailedError(entry.from_rel,
2775
entry.to_rel, e[1])
2776
inv.rename(entry.from_id, entry.to_parent_id, entry.to_tail)
2777
2778
@needs_tree_write_lock
2779
def unversion(self, file_ids):
2780
"""Remove the file ids in file_ids from the current versioned set.
2781
2782
When a file_id is unversioned, all of its children are automatically
2783
unversioned.
2784
2785
:param file_ids: The file ids to stop versioning.
2786
:raises: NoSuchId if any fileid is not currently versioned.
2787
"""
2788
for file_id in file_ids:
2789
if file_id not in self._inventory:
2790
raise errors.NoSuchId(self, file_id)
2791
for file_id in file_ids:
2792
if self._inventory.has_id(file_id):
2793
self._inventory.remove_recursive_id(file_id)
2794
if len(file_ids):
2795
# in the future this should just set a dirty bit to wait for the
2796
# final unlock. However, until all methods of workingtree start
2797
# with the current in -memory inventory rather than triggering
2798
# a read, it is more complex - we need to teach read_inventory
2799
# to know when to read, and when to not read first... and possibly
2800
# to save first when the in memory one may be corrupted.
2801
# so for now, we just only write it if it is indeed dirty.
2802
# - RBC 20060907
2803
self._write_inventory(self._inventory)
2804
2805
def stored_kind(self, file_id):
2806
"""See Tree.stored_kind"""
2807
return self.inventory[file_id].kind
2808
2809
def extras(self):
2810
"""Yield all unversioned files in this WorkingTree.
2811
2812
If there are any unversioned directories then only the directory is
2813
returned, not all its children. But if there are unversioned files
2814
under a versioned subdirectory, they are returned.
2815
2816
Currently returned depth-first, sorted by name within directories.
2817
This is the same order used by 'osutils.walkdirs'.
2818
"""
2819
## TODO: Work from given directory downwards
2820
for path, dir_entry in self.inventory.directories():
2821
# mutter("search for unknowns in %r", path)
2822
dirabs = self.abspath(path)
2823
if not isdir(dirabs):
2824
# e.g. directory deleted
2825
continue
2826
2827
fl = []
2828
for subf in os.listdir(dirabs):
2829
if self.bzrdir.is_control_filename(subf):
2830
continue
2831
if subf not in dir_entry.children:
2832
try:
2833
(subf_norm,
2834
can_access) = osutils.normalized_filename(subf)
2835
except UnicodeDecodeError:
2836
path_os_enc = path.encode(osutils._fs_enc)
2837
relpath = path_os_enc + '/' + subf
2838
raise errors.BadFilenameEncoding(relpath,
2839
osutils._fs_enc)
2840
if subf_norm != subf and can_access:
2841
if subf_norm not in dir_entry.children:
2842
fl.append(subf_norm)
2843
else:
2844
fl.append(subf)
2845
2846
fl.sort()
2847
for subf in fl:
2848
subp = pathjoin(path, subf)
2849
yield subp
2850
2851
def _walkdirs(self, prefix=""):
2852
"""Walk the directories of this tree.
2853
2854
:prefix: is used as the directrory to start with.
2855
returns a generator which yields items in the form:
2856
((curren_directory_path, fileid),
2857
[(file1_path, file1_name, file1_kind, None, file1_id,
2858
file1_kind), ... ])
2859
"""
2860
_directory = 'directory'
2861
# get the root in the inventory
2862
inv = self.inventory
2863
top_id = inv.path2id(prefix)
2864
if top_id is None:
2865
pending = []
2866
else:
2867
pending = [(prefix, '', _directory, None, top_id, None)]
2868
while pending:
2869
dirblock = []
2870
currentdir = pending.pop()
2871
# 0 - relpath, 1- basename, 2- kind, 3- stat, 4-id, 5-kind
2872
top_id = currentdir[4]
2873
if currentdir[0]:
2874
relroot = currentdir[0] + '/'
2875
else:
2876
relroot = ""
2877
# FIXME: stash the node in pending
2878
entry = inv[top_id]
2879
if entry.kind == 'directory':
2880
for name, child in entry.sorted_children():
2881
dirblock.append((relroot + name, name, child.kind, None,
2882
child.file_id, child.kind
2883
))
2884
yield (currentdir[0], entry.file_id), dirblock
2885
# push the user specified dirs from dirblock
2886
for dir in reversed(dirblock):
2887
if dir[2] == _directory:
2888
pending.append(dir)
2889
2890
2891
class WorkingTree3(InventoryWorkingTree):
2693
2892
"""This is the Format 3 working tree.
2694
2893
2695
2894
This differs from the base WorkingTree by:
Loggerhead is a web-based interface for Breezy
Version: 2.0.1