« back to all changes in this revision
Viewing changes to bzrlib/workingtree.py
- browse files at revision 5783.1.1
- compare with another revision
- download diff
- download tarball
- view history from revision 5783.1.1
- Committer: John Arbash Meinel
- Date: 2011-04-12 14:55:57 UTC
- mto: This revision was merged to the branch mainline in revision 5784.
- Revision ID: john@arbash-meinel.com-20110412145557-ltjdd171cbddfbrf
Fix bug #758695, correctly order the 'cfn' vs 'cfi' in callgrind output.
- files removed:
- bzrlib/export_pot.py
- po
- files renamed:
- bzrlib/tests/per_repository_vf/helpers.py => bzrlib/tests/per_repository/helpers.py
- bzrlib/tests/per_repository_vf/test_add_inventory_by_delta.py => bzrlib/tests/per_repository/test_add_inventory_by_delta.py
- files modified:
- Makefile
added
removed
bzrlib/workingtree.py
68
68
xml5,
69
69
xml7,
70
70
)
71
from bzrlib.workingtree_4 import (
72
WorkingTreeFormat4,
73
WorkingTreeFormat5,
74
WorkingTreeFormat6,
75
)
71
76
""")
72
77
73
78
from bzrlib import symbol_versioning
74
79
from bzrlib.decorators import needs_read_lock, needs_write_lock
75
80
from bzrlib.lock import LogicalLockResult
81
from bzrlib.lockable_files import LockableFiles
82
from bzrlib.lockdir import LockDir
76
83
import bzrlib.mutabletree
77
84
from bzrlib.mutabletree import needs_tree_write_lock
78
85
from bzrlib import osutils
87
94
supports_executable,
88
95
)
89
96
from bzrlib.trace import mutter, note
97
from bzrlib.transport.local import LocalTransport
90
98
from bzrlib.revision import CURRENT_REVISION
91
99
from bzrlib.symbol_versioning import (
92
100
deprecated_passed,
158
166
return ''
159
167
160
168
161
class WorkingTree(bzrlib.mutabletree.MutableTree,
169
class WorkingTree(bzrlib.mutabletree.MutableInventoryTree,
162
170
controldir.ControlComponent):
163
171
"""Working copy tree.
164
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
165
179
:ivar basedir: The root of the tree on disk. This is a unicode path object
166
180
(as opposed to a URL).
167
181
"""
172
186
173
187
def __init__(self, basedir='.',
174
188
branch=DEPRECATED_PARAMETER,
189
_inventory=None,
175
190
_control_files=None,
176
191
_internal=False,
177
192
_format=None,
214
229
mutter("write hc")
215
230
hc.write()
216
231
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)
217
242
self._detect_case_handling()
218
243
self._rules_searcher = None
219
244
self.views = self._make_views()
290
315
def supports_views(self):
291
316
return self.views.supports_views()
292
317
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
293
331
@staticmethod
294
332
def open(path=None, _unsupported=False):
295
333
"""Open an existing working tree at path.
408
446
list_current=list_current)
409
447
return [tr for tr in iterator if tr is not None]
410
448
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
411
463
def all_file_ids(self):
412
464
"""See Tree.iter_all_file_ids"""
413
raise NotImplementedError(self.all_file_ids)
465
return set(self.inventory)
414
466
415
467
def __repr__(self):
416
468
return "<%s of %s>" % (self.__class__.__name__,
506
558
finally:
507
559
file.close()
508
560
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
509
609
def _get_ancestors(self, default_revision):
510
610
ancestors = set([default_revision])
511
611
for parent_id in self.get_parent_ids():
534
634
parents.append(revision_id)
535
635
return parents
536
636
637
@needs_read_lock
537
638
def get_root_id(self):
538
639
"""Return the id of this trees root"""
539
raise NotImplementedError(self.get_root_id)
640
return self._inventory.root.file_id
540
641
541
642
@needs_read_lock
542
643
def clone(self, to_bzrdir, revision_id=None):
572
673
def id2abspath(self, file_id):
573
674
return self.abspath(self.id2path(file_id))
574
675
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
575
691
def get_file_size(self, file_id):
576
692
"""See Tree.get_file_size"""
577
693
# XXX: this returns the on-disk size; it should probably return the
584
700
else:
585
701
return None
586
702
703
@needs_read_lock
587
704
def get_file_sha1(self, file_id, path=None, stat_value=None):
588
# FIXME: Shouldn't this be in Tree?
589
raise NotImplementedError(self.get_file_sha1)
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
590
756
591
757
@needs_tree_write_lock
592
758
def _gather_kinds(self, files, kinds):
750
916
self._set_merges_from_parent_ids(revision_ids)
751
917
752
918
@needs_tree_write_lock
919
def set_parent_trees(self, parents_list, allow_leftmost_as_ghost=False):
920
"""See MutableTree.set_parent_trees."""
921
parent_ids = [rev for (rev, tree) in parents_list]
922
for revision_id in parent_ids:
923
_mod_revision.check_not_reserved_id(revision_id)
924
925
self._check_parents_for_ghosts(parent_ids,
926
allow_leftmost_as_ghost=allow_leftmost_as_ghost)
927
928
parent_ids = self._filter_parent_ids_by_ancestry(parent_ids)
929
930
if len(parent_ids) == 0:
931
leftmost_parent_id = _mod_revision.NULL_REVISION
932
leftmost_parent_tree = None
933
else:
934
leftmost_parent_id, leftmost_parent_tree = parents_list[0]
935
936
if self._change_last_revision(leftmost_parent_id):
937
if leftmost_parent_tree is None:
938
# If we don't have a tree, fall back to reading the
939
# parent tree from the repository.
940
self._cache_basis_inventory(leftmost_parent_id)
941
else:
942
inv = leftmost_parent_tree.inventory
943
xml = self._create_basis_xml_from_inventory(
944
leftmost_parent_id, inv)
945
self._write_basis_inventory(xml)
946
self._set_merges_from_parent_ids(parent_ids)
947
948
@needs_tree_write_lock
753
949
def set_pending_merges(self, rev_list):
754
950
parents = self.get_parent_ids()
755
951
leftmost = parents[:1]
824
1020
merger.set_pending()
825
1021
return conflicts
826
1022
1023
@needs_read_lock
827
1024
def merge_modified(self):
828
1025
"""Return a dictionary of files modified by a merge.
829
1026
834
1031
This returns a map of file_id->sha1, containing only files which are
835
1032
still in the working inventory and have that text hash.
836
1033
"""
837
raise NotImplementedError(self.merge_modified)
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()
838
1056
839
1057
@needs_write_lock
840
1058
def mkdir(self, path, file_id=None):
850
1068
target = osutils.readlink(abspath)
851
1069
return target
852
1070
1071
@needs_write_lock
853
1072
def subsume(self, other_tree):
854
raise NotImplementedError(self.subsume)
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()
855
1112
856
1113
def _setup_directory_is_tree_reference(self):
857
1114
if self._branch.repository._format.supports_tree_reference:
879
1136
# checkout in a subdirectory. This can be avoided by not adding
880
1137
# it. mbp 20070306
881
1138
1139
@needs_tree_write_lock
882
1140
def extract(self, file_id, format=None):
883
1141
"""Extract a subtree from this tree.
884
1142
885
1143
A new branch will be created, relative to the path for this tree.
886
1144
"""
887
raise NotImplementedError(self.extract)
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)
888
1195
889
1196
def flush(self):
890
"""Write the in memory meta data to disk."""
891
raise NotImplementedError(self.flush)
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
892
1207
893
1208
def _kind(self, relpath):
894
1209
return osutils.file_kind(self.abspath(relpath))
904
1219
:param from_dir: start from this directory or None for the root
905
1220
:param recursive: whether to recurse into subdirectories or not
906
1221
"""
907
raise NotImplementedError(self.list_files)
908
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
909
1339
def move(self, from_paths, to_dir=None, after=False):
910
1340
"""Rename files.
911
1341
912
to_dir must be known to the working tree.
1342
to_dir must exist in the inventory.
913
1343
914
1344
If to_dir exists and is a directory, the files are moved into
915
1345
it, keeping their old names.
921
1351
independently.
922
1352
923
1353
The first mode moves the file in the filesystem and updates the
924
working tree metadata. The second mode only updates the working tree
925
metadata without touching the file on the filesystem.
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.
926
1357
927
1358
move uses the second mode if 'after == True' and the target is not
928
1359
versioned but present in the working tree.
940
1371
This returns a list of (from_path, to_path) pairs for each
941
1372
entry that is moved.
942
1373
"""
943
raise NotImplementedError(self.move)
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)
944
1536
945
1537
@needs_tree_write_lock
946
1538
def rename_one(self, from_rel, to_rel, after=False):
950
1542
951
1543
rename_one has several 'modes' to work. First, it can rename a physical
952
1544
file and change the file_id. That is the normal mode. Second, it can
953
only change the file_id without touching any physical file.
1545
only change the file_id without touching any physical file. This is
1546
the new mode introduced in version 0.15.
954
1547
955
1548
rename_one uses the second mode if 'after == True' and 'to_rel' is not
956
1549
versioned but present in the working tree.
965
1558
966
1559
Everything else results in an error.
967
1560
"""
968
raise NotImplementedError(self.rename_one)
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
969
1622
970
1623
@needs_read_lock
971
1624
def unknowns(self):
979
1632
return iter(
980
1633
[subp for subp in self.extras() if not self.is_ignored(subp)])
981
1634
1635
@needs_tree_write_lock
982
1636
def unversion(self, file_ids):
983
1637
"""Remove the file ids in file_ids from the current versioned set.
984
1638
988
1642
:param file_ids: The file ids to stop versioning.
989
1643
:raises: NoSuchId if any fileid is not currently versioned.
990
1644
"""
991
raise NotImplementedError(self.unversion)
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)
992
1661
993
1662
@needs_write_lock
994
1663
def pull(self, source, overwrite=False, stop_revision=None,
1059
1728
Currently returned depth-first, sorted by name within directories.
1060
1729
This is the same order used by 'osutils.walkdirs'.
1061
1730
"""
1062
raise NotImplementedError(self.extras)
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
1063
1762
1064
1763
def ignored_files(self):
1065
1764
"""Yield list of PATH, IGNORE_PATTERN"""
1114
1813
1115
1814
def stored_kind(self, file_id):
1116
1815
"""See Tree.stored_kind"""
1117
raise NotImplementedError(self.stored_kind)
1816
return self.inventory[file_id].kind
1118
1817
1119
1818
def _comparison_data(self, entry, path):
1120
1819
abspath = self.abspath(path)
1211
1910
def get_physical_lock_status(self):
1212
1911
return self._control_files.get_physical_lock_status()
1213
1912
1913
def _basis_inventory_name(self):
1914
return 'basis-inventory-cache'
1915
1214
1916
def _reset_data(self):
1215
1917
"""Reset transient data that cannot be revalidated."""
1216
raise NotImplementedError(self._reset_data)
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)
1217
1925
1926
@needs_tree_write_lock
1218
1927
def set_last_revision(self, new_revision):
1219
1928
"""Change the last revision in the working tree."""
1220
raise NotImplementedError(self.set_last_revision)
1929
if self._change_last_revision(new_revision):
1930
self._cache_basis_inventory(new_revision)
1221
1931
1222
1932
def _change_last_revision(self, new_revision):
1223
1933
"""Template method part of set_last_revision to perform the change.
1226
1936
when their last revision is set.
1227
1937
"""
1228
1938
if _mod_revision.is_null(new_revision):
1229
self.branch.set_last_revision_info(0, new_revision)
1939
self.branch.set_revision_history([])
1230
1940
return False
1231
1941
try:
1232
1942
self.branch.generate_revision_history(new_revision)
1233
1943
except errors.NoSuchRevision:
1234
1944
# not present in the repo - dont try to set it deeper than the tip
1235
self.branch._set_revision_history([new_revision])
1945
self.branch.set_revision_history([new_revision])
1236
1946
return True
1237
1947
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
1238
2013
@needs_tree_write_lock
1239
2014
def remove(self, files, verbose=False, to_file=None, keep_files=True,
1240
2015
force=False):
1241
"""Remove nominated files from the working tree metadata.
2016
"""Remove nominated files from the working inventory.
1242
2017
1243
2018
:files: File paths relative to the basedir.
1244
2019
:keep_files: If true, the files will also be kept.
1309
2084
backup_name)
1310
2085
1311
2086
# Build inv_delta and delete files where applicable,
1312
# do this before any modifications to meta data.
2087
# do this before any modifications to inventory.
1313
2088
for f in files:
1314
2089
fid = self.path2id(f)
1315
2090
message = None
1395
2170
WorkingTree can supply revision_trees for the basis revision only
1396
2171
because there is only one cached inventory in the bzr directory.
1397
2172
"""
1398
raise NotImplementedError(self.revision_tree)
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)
1399
2214
1400
2215
@needs_tree_write_lock
1401
2216
def set_root_id(self, file_id):
1414
2229
present in the current inventory or an error will occur. It must
1415
2230
not be None, but rather a valid file id.
1416
2231
"""
1417
raise NotImplementedError(self._set_root_id)
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
1418
2250
1419
2251
def unlock(self):
1420
2252
"""See Branch.unlock.
1528
2360
basis = self.basis_tree()
1529
2361
basis.lock_read()
1530
2362
try:
1531
if (basis.get_root_id() is None or basis.get_root_id() != to_root_id):
2363
if (basis.inventory.root is None
2364
or basis.inventory.root.file_id != to_root_id):
1532
2365
self.set_root_id(to_root_id)
1533
2366
self.flush()
1534
2367
finally:
1576
2409
# warning might be sufficient to let the user know what
1577
2410
# is going on.
1578
2411
mutter('Could not write hashcache for %s\nError: %s',
1579
self._hashcache.cache_file_name(), e)
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()
1580
2419
1581
2420
def set_conflicts(self, arg):
1582
2421
raise errors.UnsupportedOperation(self.set_conflicts, self)
1717
2556
[(file1_path, file1_name, file1_kind, None, file1_id,
1718
2557
file1_kind), ... ])
1719
2558
"""
1720
raise NotImplementedError(self._walkdirs)
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)
1721
2588
1722
2589
@needs_tree_write_lock
1723
2590
def auto_resolve(self):
1792
2659
refs[ref] = self.branch.repository.revision_tree(value)
1793
2660
self._check(refs)
1794
2661
2662
@needs_tree_write_lock
1795
2663
def reset_state(self, revision_ids=None):
1796
2664
"""Reset the state of the working tree.
1797
2665
1798
2666
This does a hard-reset to a last-known-good state. This is a way to
1799
2667
fix if something got corrupted (like the .bzr/checkout/dirstate file)
1800
2668
"""
1801
raise NotImplementedError(self.reset_state)
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)
1802
2678
1803
2679
def _get_rules_searcher(self, default_searcher):
1804
2680
"""See Tree._get_rules_searcher."""
1813
2689
return ShelfManager(self, self._transport)
1814
2690
1815
2691
1816
class InventoryWorkingTree(WorkingTree,
1817
bzrlib.mutabletree.MutableInventoryTree):
1818
"""Base class for working trees that are inventory-oriented.
1819
1820
The inventory is held in the `Branch` working-inventory, and the
1821
files are in a directory on disk.
1822
1823
It is possible for a `WorkingTree` to have a filename which is
1824
not listed in the Inventory and vice versa.
2692
class WorkingTree3(WorkingTree):
2693
"""This is the Format 3 working tree.
2694
2695
This differs from the base WorkingTree by:
2696
- having its own file lock
2697
- having its own last-revision property.
2698
2699
This is new in bzr 0.8
1825
2700
"""
1826
2701
1827
def __init__(self, basedir='.',
1828
branch=DEPRECATED_PARAMETER,
1829
_inventory=None,
1830
_control_files=None,
1831
_internal=False,
1832
_format=None,
1833
_bzrdir=None):
1834
"""Construct a InventoryWorkingTree instance. This is not a public API.
1835
1836
:param branch: A branch to override probing for the branch.
1837
"""
1838
super(InventoryWorkingTree, self).__init__(basedir=basedir,
1839
branch=branch, _control_files=_control_files, _internal=_internal,
1840
_format=_format, _bzrdir=_bzrdir)
1841
1842
if _inventory is None:
1843
# This will be acquired on lock_read() or lock_write()
1844
self._inventory_is_modified = False
1845
self._inventory = None
1846
else:
1847
# the caller of __init__ has provided an inventory,
1848
# we assume they know what they are doing - as its only
1849
# the Format factory and creation methods that are
1850
# permitted to do this.
1851
self._set_inventory(_inventory, dirty=False)
1852
1853
def _set_inventory(self, inv, dirty):
1854
"""Set the internal cached inventory.
1855
1856
:param inv: The inventory to set.
1857
:param dirty: A boolean indicating whether the inventory is the same
1858
logical inventory as whats on disk. If True the inventory is not
1859
the same and should be written to disk or data will be lost, if
1860
False then the inventory is the same as that on disk and any
1861
serialisation would be unneeded overhead.
1862
"""
1863
self._inventory = inv
1864
self._inventory_is_modified = dirty
1865
1866
def _serialize(self, inventory, out_file):
1867
xml5.serializer_v5.write_inventory(self._inventory, out_file,
1868
working=True)
1869
1870
def _deserialize(selt, in_file):
1871
return xml5.serializer_v5.read_inventory(in_file)
1872
1873
@needs_tree_write_lock
1874
def _write_inventory(self, inv):
1875
"""Write inventory as the current inventory."""
1876
self._set_inventory(inv, dirty=True)
1877
self.flush()
1878
1879
# XXX: This method should be deprecated in favour of taking in a proper
1880
# new Inventory object.
1881
@needs_tree_write_lock
1882
def set_inventory(self, new_inventory_list):
1883
from bzrlib.inventory import (Inventory,
1884
InventoryDirectory,
1885
InventoryFile,
1886
InventoryLink)
1887
inv = Inventory(self.get_root_id())
1888
for path, file_id, parent, kind in new_inventory_list:
1889
name = os.path.basename(path)
1890
if name == "":
1891
continue
1892
# fixme, there should be a factory function inv,add_??
1893
if kind == 'directory':
1894
inv.add(InventoryDirectory(file_id, name, parent))
1895
elif kind == 'file':
1896
inv.add(InventoryFile(file_id, name, parent))
1897
elif kind == 'symlink':
1898
inv.add(InventoryLink(file_id, name, parent))
1899
else:
1900
raise errors.BzrError("unknown kind %r" % kind)
1901
self._write_inventory(inv)
1902
1903
def _write_basis_inventory(self, xml):
1904
"""Write the basis inventory XML to the basis-inventory file"""
1905
path = self._basis_inventory_name()
1906
sio = StringIO(xml)
1907
self._transport.put_file(path, sio,
1908
mode=self.bzrdir._get_file_mode())
1909
1910
def _reset_data(self):
1911
"""Reset transient data that cannot be revalidated."""
1912
self._inventory_is_modified = False
1913
f = self._transport.get('inventory')
1914
try:
1915
result = self._deserialize(f)
1916
finally:
1917
f.close()
1918
self._set_inventory(result, dirty=False)
1919
1920
def _set_root_id(self, file_id):
1921
"""Set the root id for this tree, in a format specific manner.
1922
1923
:param file_id: The file id to assign to the root. It must not be
1924
present in the current inventory or an error will occur. It must
1925
not be None, but rather a valid file id.
1926
"""
1927
inv = self._inventory
1928
orig_root_id = inv.root.file_id
1929
# TODO: it might be nice to exit early if there was nothing
1930
# to do, saving us from trigger a sync on unlock.
1931
self._inventory_is_modified = True
1932
# we preserve the root inventory entry object, but
1933
# unlinkit from the byid index
1934
del inv._byid[inv.root.file_id]
1935
inv.root.file_id = file_id
1936
# and link it into the index with the new changed id.
1937
inv._byid[inv.root.file_id] = inv.root
1938
# and finally update all children to reference the new id.
1939
# XXX: this should be safe to just look at the root.children
1940
# list, not the WHOLE INVENTORY.
1941
for fid in inv:
1942
entry = inv[fid]
1943
if entry.parent_id == orig_root_id:
1944
entry.parent_id = inv.root.file_id
1945
1946
def all_file_ids(self):
1947
"""See Tree.iter_all_file_ids"""
1948
return set(self.inventory)
1949
1950
@needs_tree_write_lock
1951
def set_parent_trees(self, parents_list, allow_leftmost_as_ghost=False):
1952
"""See MutableTree.set_parent_trees."""
1953
parent_ids = [rev for (rev, tree) in parents_list]
1954
for revision_id in parent_ids:
1955
_mod_revision.check_not_reserved_id(revision_id)
1956
1957
self._check_parents_for_ghosts(parent_ids,
1958
allow_leftmost_as_ghost=allow_leftmost_as_ghost)
1959
1960
parent_ids = self._filter_parent_ids_by_ancestry(parent_ids)
1961
1962
if len(parent_ids) == 0:
1963
leftmost_parent_id = _mod_revision.NULL_REVISION
1964
leftmost_parent_tree = None
1965
else:
1966
leftmost_parent_id, leftmost_parent_tree = parents_list[0]
1967
1968
if self._change_last_revision(leftmost_parent_id):
1969
if leftmost_parent_tree is None:
1970
# If we don't have a tree, fall back to reading the
1971
# parent tree from the repository.
1972
self._cache_basis_inventory(leftmost_parent_id)
1973
else:
1974
inv = leftmost_parent_tree.inventory
1975
xml = self._create_basis_xml_from_inventory(
1976
leftmost_parent_id, inv)
1977
self._write_basis_inventory(xml)
1978
self._set_merges_from_parent_ids(parent_ids)
1979
1980
def _cache_basis_inventory(self, new_revision):
1981
"""Cache new_revision as the basis inventory."""
1982
# TODO: this should allow the ready-to-use inventory to be passed in,
1983
# as commit already has that ready-to-use [while the format is the
1984
# same, that is].
1985
try:
1986
# this double handles the inventory - unpack and repack -
1987
# but is easier to understand. We can/should put a conditional
1988
# in here based on whether the inventory is in the latest format
1989
# - perhaps we should repack all inventories on a repository
1990
# upgrade ?
1991
# the fast path is to copy the raw xml from the repository. If the
1992
# xml contains 'revision_id="', then we assume the right
1993
# revision_id is set. We must check for this full string, because a
1994
# root node id can legitimately look like 'revision_id' but cannot
1995
# contain a '"'.
1996
xml = self.branch.repository._get_inventory_xml(new_revision)
1997
firstline = xml.split('\n', 1)[0]
1998
if (not 'revision_id="' in firstline or
1999
'format="7"' not in firstline):
2000
inv = self.branch.repository._serializer.read_inventory_from_string(
2001
xml, new_revision)
2002
xml = self._create_basis_xml_from_inventory(new_revision, inv)
2003
self._write_basis_inventory(xml)
2004
except (errors.NoSuchRevision, errors.RevisionNotPresent):
2005
pass
2006
2007
def _basis_inventory_name(self):
2008
return 'basis-inventory-cache'
2009
2010
def _create_basis_xml_from_inventory(self, revision_id, inventory):
2011
"""Create the text that will be saved in basis-inventory"""
2012
inventory.revision_id = revision_id
2013
return xml7.serializer_v7.write_inventory_to_string(inventory)
2702
@needs_read_lock
2703
def _last_revision(self):
2704
"""See Mutable.last_revision."""
2705
try:
2706
return self._transport.get_bytes('last-revision')
2707
except errors.NoSuchFile:
2708
return _mod_revision.NULL_REVISION
2709
2710
def _change_last_revision(self, revision_id):
2711
"""See WorkingTree._change_last_revision."""
2712
if revision_id is None or revision_id == _mod_revision.NULL_REVISION:
2713
try:
2714
self._transport.delete('last-revision')
2715
except errors.NoSuchFile:
2716
pass
2717
return False
2718
else:
2719
self._transport.put_bytes('last-revision', revision_id,
2720
mode=self.bzrdir._get_file_mode())
2721
return True
2722
2723
def _get_check_refs(self):
2724
"""Return the references needed to perform a check of this tree."""
2725
return [('trees', self.last_revision())]
2014
2726
2015
2727
@needs_tree_write_lock
2016
2728
def set_conflicts(self, conflicts):
2041
2753
finally:
2042
2754
confile.close()
2043
2755
2044
def read_basis_inventory(self):
2045
"""Read the cached basis inventory."""
2046
path = self._basis_inventory_name()
2047
return self._transport.get_bytes(path)
2048
2049
@needs_read_lock
2050
def read_working_inventory(self):
2051
"""Read the working inventory.
2052
2053
:raises errors.InventoryModified: read_working_inventory will fail
2054
when the current in memory inventory has been modified.
2055
"""
2056
# conceptually this should be an implementation detail of the tree.
2057
# XXX: Deprecate this.
2058
# ElementTree does its own conversion from UTF-8, so open in
2059
# binary.
2060
if self._inventory_is_modified:
2061
raise errors.InventoryModified(self)
2062
f = self._transport.get('inventory')
2063
try:
2064
result = self._deserialize(f)
2065
finally:
2066
f.close()
2067
self._set_inventory(result, dirty=False)
2068
return result
2069
2070
@needs_read_lock
2071
def get_root_id(self):
2072
"""Return the id of this trees root"""
2073
return self._inventory.root.file_id
2074
2075
def has_id(self, file_id):
2076
# files that have been deleted are excluded
2077
inv = self.inventory
2078
if not inv.has_id(file_id):
2079
return False
2080
path = inv.id2path(file_id)
2081
return osutils.lexists(self.abspath(path))
2082
2083
def has_or_had_id(self, file_id):
2084
if file_id == self.inventory.root.file_id:
2085
return True
2086
return self.inventory.has_id(file_id)
2087
2088
__contains__ = has_id
2089
2090
# should be deprecated - this is slow and in any case treating them as a
2091
# container is (we now know) bad style -- mbp 20070302
2092
## @deprecated_method(zero_fifteen)
2093
def __iter__(self):
2094
"""Iterate through file_ids for this tree.
2095
2096
file_ids are in a WorkingTree if they are in the working inventory
2097
and the working file exists.
2098
"""
2099
inv = self._inventory
2100
for path, ie in inv.iter_entries():
2101
if osutils.lexists(self.abspath(path)):
2102
yield ie.file_id
2103
2104
@needs_tree_write_lock
2105
def set_last_revision(self, new_revision):
2106
"""Change the last revision in the working tree."""
2107
if self._change_last_revision(new_revision):
2108
self._cache_basis_inventory(new_revision)
2109
2110
@needs_tree_write_lock
2111
def reset_state(self, revision_ids=None):
2112
"""Reset the state of the working tree.
2113
2114
This does a hard-reset to a last-known-good state. This is a way to
2115
fix if something got corrupted (like the .bzr/checkout/dirstate file)
2116
"""
2117
if revision_ids is None:
2118
revision_ids = self.get_parent_ids()
2119
if not revision_ids:
2120
rt = self.branch.repository.revision_tree(
2121
_mod_revision.NULL_REVISION)
2122
else:
2123
rt = self.branch.repository.revision_tree(revision_ids[0])
2124
self._write_inventory(rt.inventory)
2125
self.set_parent_ids(revision_ids)
2126
2127
def flush(self):
2128
"""Write the in memory inventory to disk."""
2129
# TODO: Maybe this should only write on dirty ?
2130
if self._control_files._lock_mode != 'w':
2131
raise errors.NotWriteLocked(self)
2132
sio = StringIO()
2133
self._serialize(self._inventory, sio)
2134
sio.seek(0)
2135
self._transport.put_file('inventory', sio,
2136
mode=self.bzrdir._get_file_mode())
2137
self._inventory_is_modified = False
2138
2139
@needs_read_lock
2140
def get_file_sha1(self, file_id, path=None, stat_value=None):
2141
if not path:
2142
path = self._inventory.id2path(file_id)
2143
return self._hashcache.get_sha1(path, stat_value)
2144
2145
def get_file_mtime(self, file_id, path=None):
2146
"""See Tree.get_file_mtime."""
2147
if not path:
2148
path = self.inventory.id2path(file_id)
2149
return os.lstat(self.abspath(path)).st_mtime
2150
2151
def _is_executable_from_path_and_stat_from_basis(self, path, stat_result):
2152
file_id = self.path2id(path)
2153
if file_id is None:
2154
# For unversioned files on win32, we just assume they are not
2155
# executable
2156
return False
2157
return self._inventory[file_id].executable
2158
2159
def _is_executable_from_path_and_stat_from_stat(self, path, stat_result):
2160
mode = stat_result.st_mode
2161
return bool(stat.S_ISREG(mode) and stat.S_IEXEC & mode)
2162
2163
if not supports_executable():
2164
def is_executable(self, file_id, path=None):
2165
return self._inventory[file_id].executable
2166
2167
_is_executable_from_path_and_stat = \
2168
_is_executable_from_path_and_stat_from_basis
2169
else:
2170
def is_executable(self, file_id, path=None):
2171
if not path:
2172
path = self.id2path(file_id)
2173
mode = os.lstat(self.abspath(path)).st_mode
2174
return bool(stat.S_ISREG(mode) and stat.S_IEXEC & mode)
2175
2176
_is_executable_from_path_and_stat = \
2177
_is_executable_from_path_and_stat_from_stat
2178
2179
@needs_tree_write_lock
2180
def _add(self, files, ids, kinds):
2181
"""See MutableTree._add."""
2182
# TODO: Re-adding a file that is removed in the working copy
2183
# should probably put it back with the previous ID.
2184
# the read and write working inventory should not occur in this
2185
# function - they should be part of lock_write and unlock.
2186
inv = self.inventory
2187
for f, file_id, kind in zip(files, ids, kinds):
2188
if file_id is None:
2189
inv.add_path(f, kind=kind)
2190
else:
2191
inv.add_path(f, kind=kind, file_id=file_id)
2192
self._inventory_is_modified = True
2193
2194
def revision_tree(self, revision_id):
2195
"""See WorkingTree.revision_id."""
2196
if revision_id == self.last_revision():
2197
try:
2198
xml = self.read_basis_inventory()
2199
except errors.NoSuchFile:
2200
pass
2201
else:
2202
try:
2203
inv = xml7.serializer_v7.read_inventory_from_string(xml)
2204
# dont use the repository revision_tree api because we want
2205
# to supply the inventory.
2206
if inv.revision_id == revision_id:
2207
return revisiontree.InventoryRevisionTree(
2208
self.branch.repository, inv, revision_id)
2209
except errors.BadInventoryFormat:
2210
pass
2211
# raise if there was no inventory, or if we read the wrong inventory.
2212
raise errors.NoSuchRevisionInTree(self, revision_id)
2213
2214
@needs_read_lock
2215
def annotate_iter(self, file_id, default_revision=CURRENT_REVISION):
2216
"""See Tree.annotate_iter
2217
2218
This implementation will use the basis tree implementation if possible.
2219
Lines not in the basis are attributed to CURRENT_REVISION
2220
2221
If there are pending merges, lines added by those merges will be
2222
incorrectly attributed to CURRENT_REVISION (but after committing, the
2223
attribution will be correct).
2224
"""
2225
maybe_file_parent_keys = []
2226
for parent_id in self.get_parent_ids():
2227
try:
2228
parent_tree = self.revision_tree(parent_id)
2229
except errors.NoSuchRevisionInTree:
2230
parent_tree = self.branch.repository.revision_tree(parent_id)
2231
parent_tree.lock_read()
2232
try:
2233
if file_id not in parent_tree:
2234
continue
2235
ie = parent_tree.inventory[file_id]
2236
if ie.kind != 'file':
2237
# Note: this is slightly unnecessary, because symlinks and
2238
# directories have a "text" which is the empty text, and we
2239
# know that won't mess up annotations. But it seems cleaner
2240
continue
2241
parent_text_key = (file_id, ie.revision)
2242
if parent_text_key not in maybe_file_parent_keys:
2243
maybe_file_parent_keys.append(parent_text_key)
2244
finally:
2245
parent_tree.unlock()
2246
graph = _mod_graph.Graph(self.branch.repository.texts)
2247
heads = graph.heads(maybe_file_parent_keys)
2248
file_parent_keys = []
2249
for key in maybe_file_parent_keys:
2250
if key in heads:
2251
file_parent_keys.append(key)
2252
2253
# Now we have the parents of this content
2254
annotator = self.branch.repository.texts.get_annotator()
2255
text = self.get_file_text(file_id)
2256
this_key =(file_id, default_revision)
2257
annotator.add_special_text(this_key, file_parent_keys, text)
2258
annotations = [(key[-1], line)
2259
for key, line in annotator.annotate_flat(this_key)]
2260
return annotations
2261
2262
@needs_read_lock
2263
def merge_modified(self):
2264
"""Return a dictionary of files modified by a merge.
2265
2266
The list is initialized by WorkingTree.set_merge_modified, which is
2267
typically called after we make some automatic updates to the tree
2268
because of a merge.
2269
2270
This returns a map of file_id->sha1, containing only files which are
2271
still in the working inventory and have that text hash.
2272
"""
2273
try:
2274
hashfile = self._transport.get('merge-hashes')
2275
except errors.NoSuchFile:
2276
return {}
2277
try:
2278
merge_hashes = {}
2279
try:
2280
if hashfile.next() != MERGE_MODIFIED_HEADER_1 + '\n':
2281
raise errors.MergeModifiedFormatError()
2282
except StopIteration:
2283
raise errors.MergeModifiedFormatError()
2284
for s in _mod_rio.RioReader(hashfile):
2285
# RioReader reads in Unicode, so convert file_ids back to utf8
2286
file_id = osutils.safe_file_id(s.get("file_id"), warn=False)
2287
if file_id not in self.inventory:
2288
continue
2289
text_hash = s.get("hash")
2290
if text_hash == self.get_file_sha1(file_id):
2291
merge_hashes[file_id] = text_hash
2292
return merge_hashes
2293
finally:
2294
hashfile.close()
2295
2296
@needs_write_lock
2297
def subsume(self, other_tree):
2298
def add_children(inventory, entry):
2299
for child_entry in entry.children.values():
2300
inventory._byid[child_entry.file_id] = child_entry
2301
if child_entry.kind == 'directory':
2302
add_children(inventory, child_entry)
2303
if other_tree.get_root_id() == self.get_root_id():
2304
raise errors.BadSubsumeSource(self, other_tree,
2305
'Trees have the same root')
2306
try:
2307
other_tree_path = self.relpath(other_tree.basedir)
2308
except errors.PathNotChild:
2309
raise errors.BadSubsumeSource(self, other_tree,
2310
'Tree is not contained by the other')
2311
new_root_parent = self.path2id(osutils.dirname(other_tree_path))
2312
if new_root_parent is None:
2313
raise errors.BadSubsumeSource(self, other_tree,
2314
'Parent directory is not versioned.')
2315
# We need to ensure that the result of a fetch will have a
2316
# versionedfile for the other_tree root, and only fetching into
2317
# RepositoryKnit2 guarantees that.
2318
if not self.branch.repository.supports_rich_root():
2319
raise errors.SubsumeTargetNeedsUpgrade(other_tree)
2320
other_tree.lock_tree_write()
2321
try:
2322
new_parents = other_tree.get_parent_ids()
2323
other_root = other_tree.inventory.root
2324
other_root.parent_id = new_root_parent
2325
other_root.name = osutils.basename(other_tree_path)
2326
self.inventory.add(other_root)
2327
add_children(self.inventory, other_root)
2328
self._write_inventory(self.inventory)
2329
# normally we don't want to fetch whole repositories, but i think
2330
# here we really do want to consolidate the whole thing.
2331
for parent_id in other_tree.get_parent_ids():
2332
self.branch.fetch(other_tree.branch, parent_id)
2333
self.add_parent_tree_id(parent_id)
2334
finally:
2335
other_tree.unlock()
2336
other_tree.bzrdir.retire_bzrdir()
2337
2338
@needs_tree_write_lock
2339
def extract(self, file_id, format=None):
2340
"""Extract a subtree from this tree.
2341
2342
A new branch will be created, relative to the path for this tree.
2343
"""
2344
self.flush()
2345
def mkdirs(path):
2346
segments = osutils.splitpath(path)
2347
transport = self.branch.bzrdir.root_transport
2348
for name in segments:
2349
transport = transport.clone(name)
2350
transport.ensure_base()
2351
return transport
2352
2353
sub_path = self.id2path(file_id)
2354
branch_transport = mkdirs(sub_path)
2355
if format is None:
2356
format = self.bzrdir.cloning_metadir()
2357
branch_transport.ensure_base()
2358
branch_bzrdir = format.initialize_on_transport(branch_transport)
2359
try:
2360
repo = branch_bzrdir.find_repository()
2361
except errors.NoRepositoryPresent:
2362
repo = branch_bzrdir.create_repository()
2363
if not repo.supports_rich_root():
2364
raise errors.RootNotRich()
2365
new_branch = branch_bzrdir.create_branch()
2366
new_branch.pull(self.branch)
2367
for parent_id in self.get_parent_ids():
2368
new_branch.fetch(self.branch, parent_id)
2369
tree_transport = self.bzrdir.root_transport.clone(sub_path)
2370
if tree_transport.base != branch_transport.base:
2371
tree_bzrdir = format.initialize_on_transport(tree_transport)
2372
branch.BranchReferenceFormat().initialize(tree_bzrdir,
2373
target_branch=new_branch)
2374
else:
2375
tree_bzrdir = branch_bzrdir
2376
wt = tree_bzrdir.create_workingtree(_mod_revision.NULL_REVISION)
2377
wt.set_parent_ids(self.get_parent_ids())
2378
my_inv = self.inventory
2379
child_inv = inventory.Inventory(root_id=None)
2380
new_root = my_inv[file_id]
2381
my_inv.remove_recursive_id(file_id)
2382
new_root.parent_id = None
2383
child_inv.add(new_root)
2384
self._write_inventory(my_inv)
2385
wt._write_inventory(child_inv)
2386
return wt
2387
2388
def list_files(self, include_root=False, from_dir=None, recursive=True):
2389
"""List all files as (path, class, kind, id, entry).
2390
2391
Lists, but does not descend into unversioned directories.
2392
This does not include files that have been deleted in this
2393
tree. Skips the control directory.
2394
2395
:param include_root: if True, return an entry for the root
2396
:param from_dir: start from this directory or None for the root
2397
:param recursive: whether to recurse into subdirectories or not
2398
"""
2399
# list_files is an iterator, so @needs_read_lock doesn't work properly
2400
# with it. So callers should be careful to always read_lock the tree.
2401
if not self.is_locked():
2402
raise errors.ObjectNotLocked(self)
2403
2404
inv = self.inventory
2405
if from_dir is None and include_root is True:
2406
yield ('', 'V', 'directory', inv.root.file_id, inv.root)
2407
# Convert these into local objects to save lookup times
2408
pathjoin = osutils.pathjoin
2409
file_kind = self._kind
2410
2411
# transport.base ends in a slash, we want the piece
2412
# between the last two slashes
2413
transport_base_dir = self.bzrdir.transport.base.rsplit('/', 2)[1]
2414
2415
fk_entries = {'directory':TreeDirectory, 'file':TreeFile, 'symlink':TreeLink}
2416
2417
# directory file_id, relative path, absolute path, reverse sorted children
2418
if from_dir is not None:
2419
from_dir_id = inv.path2id(from_dir)
2420
if from_dir_id is None:
2421
# Directory not versioned
2422
return
2423
from_dir_abspath = pathjoin(self.basedir, from_dir)
2424
else:
2425
from_dir_id = inv.root.file_id
2426
from_dir_abspath = self.basedir
2427
children = os.listdir(from_dir_abspath)
2428
children.sort()
2429
# jam 20060527 The kernel sized tree seems equivalent whether we
2430
# use a deque and popleft to keep them sorted, or if we use a plain
2431
# list and just reverse() them.
2432
children = collections.deque(children)
2433
stack = [(from_dir_id, u'', from_dir_abspath, children)]
2434
while stack:
2435
from_dir_id, from_dir_relpath, from_dir_abspath, children = stack[-1]
2436
2437
while children:
2438
f = children.popleft()
2439
## TODO: If we find a subdirectory with its own .bzr
2440
## directory, then that is a separate tree and we
2441
## should exclude it.
2442
2443
# the bzrdir for this tree
2444
if transport_base_dir == f:
2445
continue
2446
2447
# we know that from_dir_relpath and from_dir_abspath never end in a slash
2448
# and 'f' doesn't begin with one, we can do a string op, rather
2449
# than the checks of pathjoin(), all relative paths will have an extra slash
2450
# at the beginning
2451
fp = from_dir_relpath + '/' + f
2452
2453
# absolute path
2454
fap = from_dir_abspath + '/' + f
2455
2456
dir_ie = inv[from_dir_id]
2457
if dir_ie.kind == 'directory':
2458
f_ie = dir_ie.children.get(f)
2459
else:
2460
f_ie = None
2461
if f_ie:
2462
c = 'V'
2463
elif self.is_ignored(fp[1:]):
2464
c = 'I'
2465
else:
2466
# we may not have found this file, because of a unicode
2467
# issue, or because the directory was actually a symlink.
2468
f_norm, can_access = osutils.normalized_filename(f)
2469
if f == f_norm or not can_access:
2470
# No change, so treat this file normally
2471
c = '?'
2472
else:
2473
# this file can be accessed by a normalized path
2474
# check again if it is versioned
2475
# these lines are repeated here for performance
2476
f = f_norm
2477
fp = from_dir_relpath + '/' + f
2478
fap = from_dir_abspath + '/' + f
2479
f_ie = inv.get_child(from_dir_id, f)
2480
if f_ie:
2481
c = 'V'
2482
elif self.is_ignored(fp[1:]):
2483
c = 'I'
2484
else:
2485
c = '?'
2486
2487
fk = file_kind(fap)
2488
2489
# make a last minute entry
2490
if f_ie:
2491
yield fp[1:], c, fk, f_ie.file_id, f_ie
2492
else:
2493
try:
2494
yield fp[1:], c, fk, None, fk_entries[fk]()
2495
except KeyError:
2496
yield fp[1:], c, fk, None, TreeEntry()
2497
continue
2498
2499
if fk != 'directory':
2500
continue
2501
2502
# But do this child first if recursing down
2503
if recursive:
2504
new_children = os.listdir(fap)
2505
new_children.sort()
2506
new_children = collections.deque(new_children)
2507
stack.append((f_ie.file_id, fp, fap, new_children))
2508
# Break out of inner loop,
2509
# so that we start outer loop with child
2510
break
2511
else:
2512
# if we finished all children, pop it off the stack
2513
stack.pop()
2514
2515
@needs_tree_write_lock
2516
def move(self, from_paths, to_dir=None, after=False):
2517
"""Rename files.
2518
2519
to_dir must exist in the inventory.
2520
2521
If to_dir exists and is a directory, the files are moved into
2522
it, keeping their old names.
2523
2524
Note that to_dir is only the last component of the new name;
2525
this doesn't change the directory.
2526
2527
For each entry in from_paths the move mode will be determined
2528
independently.
2529
2530
The first mode moves the file in the filesystem and updates the
2531
inventory. The second mode only updates the inventory without
2532
touching the file on the filesystem.
2533
2534
move uses the second mode if 'after == True' and the target is not
2535
versioned but present in the working tree.
2536
2537
move uses the second mode if 'after == False' and the source is
2538
versioned but no longer in the working tree, and the target is not
2539
versioned but present in the working tree.
2540
2541
move uses the first mode if 'after == False' and the source is
2542
versioned and present in the working tree, and the target is not
2543
versioned and not present in the working tree.
2544
2545
Everything else results in an error.
2546
2547
This returns a list of (from_path, to_path) pairs for each
2548
entry that is moved.
2549
"""
2550
rename_entries = []
2551
rename_tuples = []
2552
2553
# check for deprecated use of signature
2554
if to_dir is None:
2555
raise TypeError('You must supply a target directory')
2556
# check destination directory
2557
if isinstance(from_paths, basestring):
2558
raise ValueError()
2559
inv = self.inventory
2560
to_abs = self.abspath(to_dir)
2561
if not isdir(to_abs):
2562
raise errors.BzrMoveFailedError('',to_dir,
2563
errors.NotADirectory(to_abs))
2564
if not self.has_filename(to_dir):
2565
raise errors.BzrMoveFailedError('',to_dir,
2566
errors.NotInWorkingDirectory(to_dir))
2567
to_dir_id = inv.path2id(to_dir)
2568
if to_dir_id is None:
2569
raise errors.BzrMoveFailedError('',to_dir,
2570
errors.NotVersionedError(path=to_dir))
2571
2572
to_dir_ie = inv[to_dir_id]
2573
if to_dir_ie.kind != 'directory':
2574
raise errors.BzrMoveFailedError('',to_dir,
2575
errors.NotADirectory(to_abs))
2576
2577
# create rename entries and tuples
2578
for from_rel in from_paths:
2579
from_tail = splitpath(from_rel)[-1]
2580
from_id = inv.path2id(from_rel)
2581
if from_id is None:
2582
raise errors.BzrMoveFailedError(from_rel,to_dir,
2583
errors.NotVersionedError(path=from_rel))
2584
2585
from_entry = inv[from_id]
2586
from_parent_id = from_entry.parent_id
2587
to_rel = pathjoin(to_dir, from_tail)
2588
rename_entry = InventoryWorkingTree._RenameEntry(
2589
from_rel=from_rel,
2590
from_id=from_id,
2591
from_tail=from_tail,
2592
from_parent_id=from_parent_id,
2593
to_rel=to_rel, to_tail=from_tail,
2594
to_parent_id=to_dir_id)
2595
rename_entries.append(rename_entry)
2596
rename_tuples.append((from_rel, to_rel))
2597
2598
# determine which move mode to use. checks also for movability
2599
rename_entries = self._determine_mv_mode(rename_entries, after)
2600
2601
original_modified = self._inventory_is_modified
2602
try:
2603
if len(from_paths):
2604
self._inventory_is_modified = True
2605
self._move(rename_entries)
2606
except:
2607
# restore the inventory on error
2608
self._inventory_is_modified = original_modified
2609
raise
2610
self._write_inventory(inv)
2611
return rename_tuples
2612
2613
@needs_tree_write_lock
2614
def rename_one(self, from_rel, to_rel, after=False):
2615
"""Rename one file.
2616
2617
This can change the directory or the filename or both.
2618
2619
rename_one has several 'modes' to work. First, it can rename a physical
2620
file and change the file_id. That is the normal mode. Second, it can
2621
only change the file_id without touching any physical file.
2622
2623
rename_one uses the second mode if 'after == True' and 'to_rel' is not
2624
versioned but present in the working tree.
2625
2626
rename_one uses the second mode if 'after == False' and 'from_rel' is
2627
versioned but no longer in the working tree, and 'to_rel' is not
2628
versioned but present in the working tree.
2629
2630
rename_one uses the first mode if 'after == False' and 'from_rel' is
2631
versioned and present in the working tree, and 'to_rel' is not
2632
versioned and not present in the working tree.
2633
2634
Everything else results in an error.
2635
"""
2636
inv = self.inventory
2637
rename_entries = []
2638
2639
# create rename entries and tuples
2640
from_tail = splitpath(from_rel)[-1]
2641
from_id = inv.path2id(from_rel)
2642
if from_id is None:
2643
# if file is missing in the inventory maybe it's in the basis_tree
2644
basis_tree = self.branch.basis_tree()
2645
from_id = basis_tree.path2id(from_rel)
2646
if from_id is None:
2647
raise errors.BzrRenameFailedError(from_rel,to_rel,
2648
errors.NotVersionedError(path=from_rel))
2649
# put entry back in the inventory so we can rename it
2650
from_entry = basis_tree.inventory[from_id].copy()
2651
inv.add(from_entry)
2652
else:
2653
from_entry = inv[from_id]
2654
from_parent_id = from_entry.parent_id
2655
to_dir, to_tail = os.path.split(to_rel)
2656
to_dir_id = inv.path2id(to_dir)
2657
rename_entry = InventoryWorkingTree._RenameEntry(from_rel=from_rel,
2658
from_id=from_id,
2659
from_tail=from_tail,
2660
from_parent_id=from_parent_id,
2661
to_rel=to_rel, to_tail=to_tail,
2662
to_parent_id=to_dir_id)
2663
rename_entries.append(rename_entry)
2664
2665
# determine which move mode to use. checks also for movability
2666
rename_entries = self._determine_mv_mode(rename_entries, after)
2667
2668
# check if the target changed directory and if the target directory is
2669
# versioned
2670
if to_dir_id is None:
2671
raise errors.BzrMoveFailedError(from_rel,to_rel,
2672
errors.NotVersionedError(path=to_dir))
2673
2674
# all checks done. now we can continue with our actual work
2675
mutter('rename_one:\n'
2676
' from_id {%s}\n'
2677
' from_rel: %r\n'
2678
' to_rel: %r\n'
2679
' to_dir %r\n'
2680
' to_dir_id {%s}\n',
2681
from_id, from_rel, to_rel, to_dir, to_dir_id)
2682
2683
self._move(rename_entries)
2684
self._write_inventory(inv)
2685
2686
class _RenameEntry(object):
2687
def __init__(self, from_rel, from_id, from_tail, from_parent_id,
2688
to_rel, to_tail, to_parent_id, only_change_inv=False):
2689
self.from_rel = from_rel
2690
self.from_id = from_id
2691
self.from_tail = from_tail
2692
self.from_parent_id = from_parent_id
2693
self.to_rel = to_rel
2694
self.to_tail = to_tail
2695
self.to_parent_id = to_parent_id
2696
self.only_change_inv = only_change_inv
2697
2698
def _determine_mv_mode(self, rename_entries, after=False):
2699
"""Determines for each from-to pair if both inventory and working tree
2700
or only the inventory has to be changed.
2701
2702
Also does basic plausability tests.
2703
"""
2704
inv = self.inventory
2705
2706
for rename_entry in rename_entries:
2707
# store to local variables for easier reference
2708
from_rel = rename_entry.from_rel
2709
from_id = rename_entry.from_id
2710
to_rel = rename_entry.to_rel
2711
to_id = inv.path2id(to_rel)
2712
only_change_inv = False
2713
2714
# check the inventory for source and destination
2715
if from_id is None:
2716
raise errors.BzrMoveFailedError(from_rel,to_rel,
2717
errors.NotVersionedError(path=from_rel))
2718
if to_id is not None:
2719
raise errors.BzrMoveFailedError(from_rel,to_rel,
2720
errors.AlreadyVersionedError(path=to_rel))
2721
2722
# try to determine the mode for rename (only change inv or change
2723
# inv and file system)
2724
if after:
2725
if not self.has_filename(to_rel):
2726
raise errors.BzrMoveFailedError(from_id,to_rel,
2727
errors.NoSuchFile(path=to_rel,
2728
extra="New file has not been created yet"))
2729
only_change_inv = True
2730
elif not self.has_filename(from_rel) and self.has_filename(to_rel):
2731
only_change_inv = True
2732
elif self.has_filename(from_rel) and not self.has_filename(to_rel):
2733
only_change_inv = False
2734
elif (not self.case_sensitive
2735
and from_rel.lower() == to_rel.lower()
2736
and self.has_filename(from_rel)):
2737
only_change_inv = False
2738
else:
2739
# something is wrong, so lets determine what exactly
2740
if not self.has_filename(from_rel) and \
2741
not self.has_filename(to_rel):
2742
raise errors.BzrRenameFailedError(from_rel,to_rel,
2743
errors.PathsDoNotExist(paths=(str(from_rel),
2744
str(to_rel))))
2745
else:
2746
raise errors.RenameFailedFilesExist(from_rel, to_rel)
2747
rename_entry.only_change_inv = only_change_inv
2748
return rename_entries
2749
2750
def _move(self, rename_entries):
2751
"""Moves a list of files.
2752
2753
Depending on the value of the flag 'only_change_inv', the
2754
file will be moved on the file system or not.
2755
"""
2756
inv = self.inventory
2757
moved = []
2758
2759
for entry in rename_entries:
2760
try:
2761
self._move_entry(entry)
2762
except:
2763
self._rollback_move(moved)
2764
raise
2765
moved.append(entry)
2766
2767
def _rollback_move(self, moved):
2768
"""Try to rollback a previous move in case of an filesystem error."""
2769
inv = self.inventory
2770
for entry in moved:
2771
try:
2772
self._move_entry(WorkingTree._RenameEntry(
2773
entry.to_rel, entry.from_id,
2774
entry.to_tail, entry.to_parent_id, entry.from_rel,
2775
entry.from_tail, entry.from_parent_id,
2776
entry.only_change_inv))
2777
except errors.BzrMoveFailedError, e:
2778
raise errors.BzrMoveFailedError( '', '', "Rollback failed."
2779
" The working tree is in an inconsistent state."
2780
" Please consider doing a 'bzr revert'."
2781
" Error message is: %s" % e)
2782
2783
def _move_entry(self, entry):
2784
inv = self.inventory
2785
from_rel_abs = self.abspath(entry.from_rel)
2786
to_rel_abs = self.abspath(entry.to_rel)
2787
if from_rel_abs == to_rel_abs:
2788
raise errors.BzrMoveFailedError(entry.from_rel, entry.to_rel,
2789
"Source and target are identical.")
2790
2791
if not entry.only_change_inv:
2792
try:
2793
osutils.rename(from_rel_abs, to_rel_abs)
2794
except OSError, e:
2795
raise errors.BzrMoveFailedError(entry.from_rel,
2796
entry.to_rel, e[1])
2797
inv.rename(entry.from_id, entry.to_parent_id, entry.to_tail)
2798
2799
@needs_tree_write_lock
2800
def unversion(self, file_ids):
2801
"""Remove the file ids in file_ids from the current versioned set.
2802
2803
When a file_id is unversioned, all of its children are automatically
2804
unversioned.
2805
2806
:param file_ids: The file ids to stop versioning.
2807
:raises: NoSuchId if any fileid is not currently versioned.
2808
"""
2809
for file_id in file_ids:
2810
if file_id not in self._inventory:
2811
raise errors.NoSuchId(self, file_id)
2812
for file_id in file_ids:
2813
if self._inventory.has_id(file_id):
2814
self._inventory.remove_recursive_id(file_id)
2815
if len(file_ids):
2816
# in the future this should just set a dirty bit to wait for the
2817
# final unlock. However, until all methods of workingtree start
2818
# with the current in -memory inventory rather than triggering
2819
# a read, it is more complex - we need to teach read_inventory
2820
# to know when to read, and when to not read first... and possibly
2821
# to save first when the in memory one may be corrupted.
2822
# so for now, we just only write it if it is indeed dirty.
2823
# - RBC 20060907
2824
self._write_inventory(self._inventory)
2825
2826
def stored_kind(self, file_id):
2827
"""See Tree.stored_kind"""
2828
return self.inventory[file_id].kind
2829
2830
def extras(self):
2831
"""Yield all unversioned files in this WorkingTree.
2832
2833
If there are any unversioned directories then only the directory is
2834
returned, not all its children. But if there are unversioned files
2835
under a versioned subdirectory, they are returned.
2836
2837
Currently returned depth-first, sorted by name within directories.
2838
This is the same order used by 'osutils.walkdirs'.
2839
"""
2840
## TODO: Work from given directory downwards
2841
for path, dir_entry in self.inventory.directories():
2842
# mutter("search for unknowns in %r", path)
2843
dirabs = self.abspath(path)
2844
if not isdir(dirabs):
2845
# e.g. directory deleted
2846
continue
2847
2848
fl = []
2849
for subf in os.listdir(dirabs):
2850
if self.bzrdir.is_control_filename(subf):
2851
continue
2852
if subf not in dir_entry.children:
2853
try:
2854
(subf_norm,
2855
can_access) = osutils.normalized_filename(subf)
2856
except UnicodeDecodeError:
2857
path_os_enc = path.encode(osutils._fs_enc)
2858
relpath = path_os_enc + '/' + subf
2859
raise errors.BadFilenameEncoding(relpath,
2860
osutils._fs_enc)
2861
if subf_norm != subf and can_access:
2862
if subf_norm not in dir_entry.children:
2863
fl.append(subf_norm)
2864
else:
2865
fl.append(subf)
2866
2867
fl.sort()
2868
for subf in fl:
2869
subp = pathjoin(path, subf)
2870
yield subp
2871
2872
def _walkdirs(self, prefix=""):
2873
"""Walk the directories of this tree.
2874
2875
:prefix: is used as the directrory to start with.
2876
returns a generator which yields items in the form:
2877
((curren_directory_path, fileid),
2878
[(file1_path, file1_name, file1_kind, None, file1_id,
2879
file1_kind), ... ])
2880
"""
2881
_directory = 'directory'
2882
# get the root in the inventory
2883
inv = self.inventory
2884
top_id = inv.path2id(prefix)
2885
if top_id is None:
2886
pending = []
2887
else:
2888
pending = [(prefix, '', _directory, None, top_id, None)]
2889
while pending:
2890
dirblock = []
2891
currentdir = pending.pop()
2892
# 0 - relpath, 1- basename, 2- kind, 3- stat, 4-id, 5-kind
2893
top_id = currentdir[4]
2894
if currentdir[0]:
2895
relroot = currentdir[0] + '/'
2896
else:
2897
relroot = ""
2898
# FIXME: stash the node in pending
2899
entry = inv[top_id]
2900
if entry.kind == 'directory':
2901
for name, child in entry.sorted_children():
2902
dirblock.append((relroot + name, name, child.kind, None,
2903
child.file_id, child.kind
2904
))
2905
yield (currentdir[0], entry.file_id), dirblock
2906
# push the user specified dirs from dirblock
2907
for dir in reversed(dirblock):
2908
if dir[2] == _directory:
2909
pending.append(dir)
2756
def unlock(self):
2757
# do non-implementation specific cleanup
2758
self._cleanup()
2759
if self._control_files._lock_count == 1:
2760
# _inventory_is_modified is always False during a read lock.
2761
if self._inventory_is_modified:
2762
self.flush()
2763
self._write_hashcache_if_dirty()
2764
# reverse order of locking.
2765
try:
2766
return self._control_files.unlock()
2767
finally:
2768
self.branch.unlock()
2910
2769
2911
2770
2912
2771
class WorkingTreeFormatRegistry(controldir.ControlComponentFormatRegistry):
2915
2774
def __init__(self, other_registry=None):
2916
2775
super(WorkingTreeFormatRegistry, self).__init__(other_registry)
2917
2776
self._default_format = None
2918
self._default_format_key = None
2919
2777
2920
2778
def get_default(self):
2921
2779
"""Return the current default format."""
2922
if (self._default_format_key is not None and
2923
self._default_format is None):
2924
self._default_format = self.get(self._default_format_key)
2925
2780
return self._default_format
2926
2781
2927
2782
def set_default(self, format):
2928
"""Set the default format."""
2929
2783
self._default_format = format
2930
self._default_format_key = None
2931
2932
def set_default_key(self, format_string):
2933
"""Set the default format by its format string."""
2934
self._default_format_key = format_string
2935
self._default_format = None
2936
2784
2937
2785
2938
2786
format_registry = WorkingTreeFormatRegistry()
2968
2816
"""If this format supports missing parent conflicts."""
2969
2817
2970
2818
@classmethod
2971
def find_format_string(klass, a_bzrdir):
2972
"""Return format name for the working tree object in a_bzrdir."""
2973
try:
2974
transport = a_bzrdir.get_workingtree_transport(None)
2975
return transport.get_bytes("format")
2976
except errors.NoSuchFile:
2977
raise errors.NoWorkingTree(base=transport.base)
2978
2979
@classmethod
2980
2819
def find_format(klass, a_bzrdir):
2981
2820
"""Return the format for the working tree object in a_bzrdir."""
2982
2821
try:
2983
format_string = klass.find_format_string(a_bzrdir)
2822
transport = a_bzrdir.get_workingtree_transport(None)
2823
format_string = transport.get_bytes("format")
2984
2824
return format_registry.get(format_string)
2825
except errors.NoSuchFile:
2826
raise errors.NoWorkingTree(base=transport.base)
2985
2827
except KeyError:
2986
2828
raise errors.UnknownFormatError(format=format_string,
2987
2829
kind="working tree")
3078
2920
format_registry.remove(format)
3079
2921
3080
2922
2923
class WorkingTreeFormat3(WorkingTreeFormat):
2924
"""The second working tree format updated to record a format marker.
2925
2926
This format:
2927
- exists within a metadir controlling .bzr
2928
- includes an explicit version marker for the workingtree control
2929
files, separate from the BzrDir format
2930
- modifies the hash cache format
2931
- is new in bzr 0.8
2932
- uses a LockDir to guard access for writes.
2933
"""
2934
2935
upgrade_recommended = True
2936
2937
missing_parent_conflicts = True
2938
2939
def get_format_string(self):
2940
"""See WorkingTreeFormat.get_format_string()."""
2941
return "Bazaar-NG Working Tree format 3"
2942
2943
def get_format_description(self):
2944
"""See WorkingTreeFormat.get_format_description()."""
2945
return "Working tree format 3"
2946
2947
_lock_file_name = 'lock'
2948
_lock_class = LockDir
2949
2950
_tree_class = WorkingTree3
2951
2952
def __get_matchingbzrdir(self):
2953
return bzrdir.BzrDirMetaFormat1()
2954
2955
_matchingbzrdir = property(__get_matchingbzrdir)
2956
2957
def _open_control_files(self, a_bzrdir):
2958
transport = a_bzrdir.get_workingtree_transport(None)
2959
return LockableFiles(transport, self._lock_file_name,
2960
self._lock_class)
2961
2962
def initialize(self, a_bzrdir, revision_id=None, from_branch=None,
2963
accelerator_tree=None, hardlink=False):
2964
"""See WorkingTreeFormat.initialize().
2965
2966
:param revision_id: if supplied, create a working tree at a different
2967
revision than the branch is at.
2968
:param accelerator_tree: A tree which can be used for retrieving file
2969
contents more quickly than the revision tree, i.e. a workingtree.
2970
The revision tree will be used for cases where accelerator_tree's
2971
content is different.
2972
:param hardlink: If true, hard-link files from accelerator_tree,
2973
where possible.
2974
"""
2975
if not isinstance(a_bzrdir.transport, LocalTransport):
2976
raise errors.NotLocalUrl(a_bzrdir.transport.base)
2977
transport = a_bzrdir.get_workingtree_transport(self)
2978
control_files = self._open_control_files(a_bzrdir)
2979
control_files.create_lock()
2980
control_files.lock_write()
2981
transport.put_bytes('format', self.get_format_string(),
2982
mode=a_bzrdir._get_file_mode())
2983
if from_branch is not None:
2984
branch = from_branch
2985
else:
2986
branch = a_bzrdir.open_branch()
2987
if revision_id is None:
2988
revision_id = _mod_revision.ensure_null(branch.last_revision())
2989
# WorkingTree3 can handle an inventory which has a unique root id.
2990
# as of bzr 0.12. However, bzr 0.11 and earlier fail to handle
2991
# those trees. And because there isn't a format bump inbetween, we
2992
# are maintaining compatibility with older clients.
2993
# inv = Inventory(root_id=gen_root_id())
2994
inv = self._initial_inventory()
2995
wt = self._tree_class(a_bzrdir.root_transport.local_abspath('.'),
2996
branch,
2997
inv,
2998
_internal=True,
2999
_format=self,
3000
_bzrdir=a_bzrdir,
3001
_control_files=control_files)
3002
wt.lock_tree_write()
3003
try:
3004
basis_tree = branch.repository.revision_tree(revision_id)
3005
# only set an explicit root id if there is one to set.
3006
if basis_tree.inventory.root is not None:
3007
wt.set_root_id(basis_tree.get_root_id())
3008
if revision_id == _mod_revision.NULL_REVISION:
3009
wt.set_parent_trees([])
3010
else:
3011
wt.set_parent_trees([(revision_id, basis_tree)])
3012
transform.build_tree(basis_tree, wt)
3013
finally:
3014
# Unlock in this order so that the unlock-triggers-flush in
3015
# WorkingTree is given a chance to fire.
3016
control_files.unlock()
3017
wt.unlock()
3018
return wt
3019
3020
def _initial_inventory(self):
3021
return inventory.Inventory()
3022
3023
def __init__(self):
3024
super(WorkingTreeFormat3, self).__init__()
3025
3026
def open(self, a_bzrdir, _found=False):
3027
"""Return the WorkingTree object for a_bzrdir
3028
3029
_found is a private parameter, do not use it. It is used to indicate
3030
if format probing has already been done.
3031
"""
3032
if not _found:
3033
# we are being called directly and must probe.
3034
raise NotImplementedError
3035
if not isinstance(a_bzrdir.transport, LocalTransport):
3036
raise errors.NotLocalUrl(a_bzrdir.transport.base)
3037
wt = self._open(a_bzrdir, self._open_control_files(a_bzrdir))
3038
return wt
3039
3040
def _open(self, a_bzrdir, control_files):
3041
"""Open the tree itself.
3042
3043
:param a_bzrdir: the dir for the tree.
3044
:param control_files: the control files for the tree.
3045
"""
3046
return self._tree_class(a_bzrdir.root_transport.local_abspath('.'),
3047
_internal=True,
3048
_format=self,
3049
_bzrdir=a_bzrdir,
3050
_control_files=control_files)
3051
3052
def __str__(self):
3053
return self.get_format_string()
3054
3055
3056
__default_format = WorkingTreeFormat6()
3081
3057
format_registry.register_lazy("Bazaar Working Tree Format 4 (bzr 0.15)\n",
3082
3058
"bzrlib.workingtree_4", "WorkingTreeFormat4")
3083
3059
format_registry.register_lazy("Bazaar Working Tree Format 5 (bzr 1.11)\n",
3084
3060
"bzrlib.workingtree_4", "WorkingTreeFormat5")
3085
3061
format_registry.register_lazy("Bazaar Working Tree Format 6 (bzr 1.14)\n",
3086
3062
"bzrlib.workingtree_4", "WorkingTreeFormat6")
3087
format_registry.register_lazy("Bazaar-NG Working Tree format 3",
3088
"bzrlib.workingtree_3", "WorkingTreeFormat3")
3089
format_registry.set_default_key("Bazaar Working Tree Format 6 (bzr 1.14)\n")
3063
format_registry.register(WorkingTreeFormat3())
3064
format_registry.set_default(__default_format)
Loggerhead is a web-based interface for Breezy
Version: 2.0.1