« back to all changes in this revision
Viewing changes to bzrlib/workingtree.py
- browse files at revision 5550
- compare with another revision
- download diff
- download tarball
- view history from revision 5550
- Committer: Canonical.com Patch Queue Manager
- Date: 2010-11-24 17:20:55 UTC
- mfrom: (5418.5.2 require_testtools_0.9.5_for_selftest)
- Revision ID: pqm@pqm.ubuntu.com-20101124172055-79va5spncm8wu6ay
(gz) Change minimum required testtools version for selftest to 0.9.5 for
unicode fixes (Martin [gz])
unicode fixes (Martin [gz])
- files added:
- bzrlib/util/bencode.py
- files removed:
- bzrlib/cethread.py
- bzrlib/plugins/changelog_merge
- bzrlib/plugins/changelog_merge/tests
- bzrlib/plugins/weave_fmt
- bzrlib/plugins/weave_fmt/tests
- bzrlib/tests/per_repository_vf
- files renamed:
- bzrlib/plugins/weave_fmt/repository.py => bzrlib/repofmt/weaverepo.py
- bzrlib/tests/per_repository_vf/helpers.py => bzrlib/tests/per_repository/helpers.py
- bzrlib/tests/per_repository_vf/test_check_reconcile.py => bzrlib/tests/per_repository/test_check_reconcile.py
- bzrlib/plugins/weave_fmt/xml4.py => bzrlib/xml4.py
- files modified:
- .testr.conf
added
removed
bzrlib/workingtree.py
1
# Copyright (C) 2005-2011 Canonical Ltd
1
# Copyright (C) 2005-2010 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
44
44
import stat
45
45
import re
46
46
47
import bzrlib
47
48
from bzrlib import (
48
49
branch,
49
50
bzrdir,
50
51
conflicts as _mod_conflicts,
51
52
controldir,
52
53
errors,
53
filters as _mod_filters,
54
54
generate_ids,
55
55
globbing,
56
56
graph as _mod_graph,
60
60
merge,
61
61
revision as _mod_revision,
62
62
revisiontree,
63
rio as _mod_rio,
63
trace,
64
64
transform,
65
65
transport,
66
66
ui,
93
93
splitpath,
94
94
supports_executable,
95
95
)
96
from bzrlib.filters import filtered_input_file
96
97
from bzrlib.trace import mutter, note
97
98
from bzrlib.transport.local import LocalTransport
98
99
from bzrlib.revision import CURRENT_REVISION
100
from bzrlib.rio import RioReader, rio_file, Stanza
99
101
from bzrlib.symbol_versioning import (
100
102
deprecated_passed,
101
103
DEPRECATED_PARAMETER,
170
172
controldir.ControlComponent):
171
173
"""Working copy tree.
172
174
175
The inventory is held in the `Branch` working-inventory, and the
176
files are in a directory on disk.
177
178
It is possible for a `WorkingTree` to have a filename which is
179
not listed in the Inventory and vice versa.
180
173
181
:ivar basedir: The root of the tree on disk. This is a unicode path object
174
182
(as opposed to a URL).
175
183
"""
180
188
181
189
def __init__(self, basedir='.',
182
190
branch=DEPRECATED_PARAMETER,
191
_inventory=None,
183
192
_control_files=None,
184
193
_internal=False,
185
194
_format=None,
200
209
else:
201
210
self._branch = self.bzrdir.open_branch()
202
211
self.basedir = realpath(basedir)
203
self._control_files = _control_files
212
# if branch is at our basedir and is a format 6 or less
213
if isinstance(self._format, WorkingTreeFormat2):
214
# share control object
215
self._control_files = self.branch.control_files
216
else:
217
# assume all other formats have their own control files.
218
self._control_files = _control_files
204
219
self._transport = self._control_files._transport
205
220
# update the whole cache up front and write to disk if anything changed;
206
221
# in the future we might want to do this more selectively
222
237
mutter("write hc")
223
238
hc.write()
224
239
240
if _inventory is None:
241
# This will be acquired on lock_read() or lock_write()
242
self._inventory_is_modified = False
243
self._inventory = None
244
else:
245
# the caller of __init__ has provided an inventory,
246
# we assume they know what they are doing - as its only
247
# the Format factory and creation methods that are
248
# permitted to do this.
249
self._set_inventory(_inventory, dirty=False)
225
250
self._detect_case_handling()
226
251
self._rules_searcher = None
227
252
self.views = self._make_views()
234
259
def control_transport(self):
235
260
return self._transport
236
261
237
def is_control_filename(self, filename):
238
"""True if filename is the name of a control file in this tree.
239
240
:param filename: A filename within the tree. This is a relative path
241
from the root of this tree.
242
243
This is true IF and ONLY IF the filename is part of the meta data
244
that bzr controls in this tree. I.E. a random .bzr directory placed
245
on disk will not be a control file for this tree.
246
"""
247
return self.bzrdir.is_control_filename(filename)
248
249
262
def _detect_case_handling(self):
250
263
wt_trans = self.bzrdir.get_workingtree_transport(None)
251
264
try:
252
wt_trans.stat(self._format.case_sensitive_filename)
265
wt_trans.stat("FoRMaT")
253
266
except errors.NoSuchFile:
254
267
self.case_sensitive = True
255
268
else:
298
311
def supports_views(self):
299
312
return self.views.supports_views()
300
313
314
def _set_inventory(self, inv, dirty):
315
"""Set the internal cached inventory.
316
317
:param inv: The inventory to set.
318
:param dirty: A boolean indicating whether the inventory is the same
319
logical inventory as whats on disk. If True the inventory is not
320
the same and should be written to disk or data will be lost, if
321
False then the inventory is the same as that on disk and any
322
serialisation would be unneeded overhead.
323
"""
324
self._inventory = inv
325
self._inventory_is_modified = dirty
326
301
327
@staticmethod
302
328
def open(path=None, _unsupported=False):
303
329
"""Open an existing working tree at path.
416
442
list_current=list_current)
417
443
return [tr for tr in iterator if tr is not None]
418
444
445
# should be deprecated - this is slow and in any case treating them as a
446
# container is (we now know) bad style -- mbp 20070302
447
## @deprecated_method(zero_fifteen)
448
def __iter__(self):
449
"""Iterate through file_ids for this tree.
450
451
file_ids are in a WorkingTree if they are in the working inventory
452
and the working file exists.
453
"""
454
inv = self._inventory
455
for path, ie in inv.iter_entries():
456
if osutils.lexists(self.abspath(path)):
457
yield ie.file_id
458
419
459
def all_file_ids(self):
420
460
"""See Tree.iter_all_file_ids"""
421
raise NotImplementedError(self.all_file_ids)
461
return set(self.inventory)
422
462
423
463
def __repr__(self):
424
464
return "<%s of %s>" % (self.__class__.__name__,
479
519
return self.get_file_with_stat(file_id, path, filtered=filtered)[0]
480
520
481
521
def get_file_with_stat(self, file_id, path=None, filtered=True,
482
_fstat=osutils.fstat):
522
_fstat=os.fstat):
483
523
"""See Tree.get_file_with_stat."""
484
524
if path is None:
485
525
path = self.id2path(file_id)
487
527
stat_value = _fstat(file_obj.fileno())
488
528
if filtered and self.supports_content_filtering():
489
529
filters = self._content_filter_stack(path)
490
file_obj = _mod_filters.filtered_input_file(file_obj, filters)
530
file_obj = filtered_input_file(file_obj, filters)
491
531
return (file_obj, stat_value)
492
532
493
533
def get_file_text(self, file_id, path=None, filtered=True):
502
542
f = file(path, 'rb')
503
543
if filtered and self.supports_content_filtering():
504
544
filters = self._content_filter_stack(filename)
505
return _mod_filters.filtered_input_file(f, filters)
545
return filtered_input_file(f, filters)
506
546
else:
507
547
return f
508
548
514
554
finally:
515
555
file.close()
516
556
557
@needs_read_lock
558
def annotate_iter(self, file_id, default_revision=CURRENT_REVISION):
559
"""See Tree.annotate_iter
560
561
This implementation will use the basis tree implementation if possible.
562
Lines not in the basis are attributed to CURRENT_REVISION
563
564
If there are pending merges, lines added by those merges will be
565
incorrectly attributed to CURRENT_REVISION (but after committing, the
566
attribution will be correct).
567
"""
568
maybe_file_parent_keys = []
569
for parent_id in self.get_parent_ids():
570
try:
571
parent_tree = self.revision_tree(parent_id)
572
except errors.NoSuchRevisionInTree:
573
parent_tree = self.branch.repository.revision_tree(parent_id)
574
parent_tree.lock_read()
575
try:
576
if file_id not in parent_tree:
577
continue
578
ie = parent_tree.inventory[file_id]
579
if ie.kind != 'file':
580
# Note: this is slightly unnecessary, because symlinks and
581
# directories have a "text" which is the empty text, and we
582
# know that won't mess up annotations. But it seems cleaner
583
continue
584
parent_text_key = (file_id, ie.revision)
585
if parent_text_key not in maybe_file_parent_keys:
586
maybe_file_parent_keys.append(parent_text_key)
587
finally:
588
parent_tree.unlock()
589
graph = _mod_graph.Graph(self.branch.repository.texts)
590
heads = graph.heads(maybe_file_parent_keys)
591
file_parent_keys = []
592
for key in maybe_file_parent_keys:
593
if key in heads:
594
file_parent_keys.append(key)
595
596
# Now we have the parents of this content
597
annotator = self.branch.repository.texts.get_annotator()
598
text = self.get_file_text(file_id)
599
this_key =(file_id, default_revision)
600
annotator.add_special_text(this_key, file_parent_keys, text)
601
annotations = [(key[-1], line)
602
for key, line in annotator.annotate_flat(this_key)]
603
return annotations
604
517
605
def _get_ancestors(self, default_revision):
518
606
ancestors = set([default_revision])
519
607
for parent_id in self.get_parent_ids():
542
630
parents.append(revision_id)
543
631
return parents
544
632
633
@needs_read_lock
545
634
def get_root_id(self):
546
635
"""Return the id of this trees root"""
547
raise NotImplementedError(self.get_root_id)
636
return self._inventory.root.file_id
637
638
def _get_store_filename(self, file_id):
639
## XXX: badly named; this is not in the store at all
640
return self.abspath(self.id2path(file_id))
548
641
549
642
@needs_read_lock
550
643
def clone(self, to_bzrdir, revision_id=None):
580
673
def id2abspath(self, file_id):
581
674
return self.abspath(self.id2path(file_id))
582
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
583
691
def get_file_size(self, file_id):
584
692
"""See Tree.get_file_size"""
585
693
# XXX: this returns the on-disk size; it should probably return the
592
700
else:
593
701
return None
594
702
703
@needs_read_lock
595
704
def get_file_sha1(self, file_id, path=None, stat_value=None):
596
# FIXME: Shouldn't this be in Tree?
597
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
598
756
599
757
@needs_tree_write_lock
600
758
def _gather_kinds(self, files, kinds):
726
884
if revision_id in heads and revision_id not in new_revision_ids:
727
885
new_revision_ids.append(revision_id)
728
886
if new_revision_ids != revision_ids:
729
mutter('requested to set revision_ids = %s,'
887
trace.mutter('requested to set revision_ids = %s,'
730
888
' but filtered to %s', revision_ids, new_revision_ids)
731
889
return new_revision_ids
732
890
798
956
def set_merge_modified(self, modified_hashes):
799
957
def iter_stanzas():
800
958
for file_id, hash in modified_hashes.iteritems():
801
yield _mod_rio.Stanza(file_id=file_id.decode('utf8'),
802
hash=hash)
959
yield Stanza(file_id=file_id.decode('utf8'), hash=hash)
803
960
self._put_rio('merge-hashes', iter_stanzas(), MERGE_MODIFIED_HEADER_1)
804
961
805
962
def _sha_from_stat(self, path, stat_result):
814
971
815
972
def _put_rio(self, filename, stanzas, header):
816
973
self._must_be_locked()
817
my_file = _mod_rio.rio_file(stanzas, header)
974
my_file = rio_file(stanzas, header)
818
975
self._transport.put_file(filename, my_file,
819
976
mode=self.bzrdir._get_file_mode())
820
977
862
1019
merger.set_pending()
863
1020
return conflicts
864
1021
1022
@needs_read_lock
865
1023
def merge_modified(self):
866
1024
"""Return a dictionary of files modified by a merge.
867
1025
872
1030
This returns a map of file_id->sha1, containing only files which are
873
1031
still in the working inventory and have that text hash.
874
1032
"""
875
raise NotImplementedError(self.merge_modified)
1033
try:
1034
hashfile = self._transport.get('merge-hashes')
1035
except errors.NoSuchFile:
1036
return {}
1037
try:
1038
merge_hashes = {}
1039
try:
1040
if hashfile.next() != MERGE_MODIFIED_HEADER_1 + '\n':
1041
raise errors.MergeModifiedFormatError()
1042
except StopIteration:
1043
raise errors.MergeModifiedFormatError()
1044
for s in RioReader(hashfile):
1045
# RioReader reads in Unicode, so convert file_ids back to utf8
1046
file_id = osutils.safe_file_id(s.get("file_id"), warn=False)
1047
if file_id not in self.inventory:
1048
continue
1049
text_hash = s.get("hash")
1050
if text_hash == self.get_file_sha1(file_id):
1051
merge_hashes[file_id] = text_hash
1052
return merge_hashes
1053
finally:
1054
hashfile.close()
876
1055
877
1056
@needs_write_lock
878
1057
def mkdir(self, path, file_id=None):
888
1067
target = osutils.readlink(abspath)
889
1068
return target
890
1069
1070
@needs_write_lock
891
1071
def subsume(self, other_tree):
892
raise NotImplementedError(self.subsume)
1072
def add_children(inventory, entry):
1073
for child_entry in entry.children.values():
1074
inventory._byid[child_entry.file_id] = child_entry
1075
if child_entry.kind == 'directory':
1076
add_children(inventory, child_entry)
1077
if other_tree.get_root_id() == self.get_root_id():
1078
raise errors.BadSubsumeSource(self, other_tree,
1079
'Trees have the same root')
1080
try:
1081
other_tree_path = self.relpath(other_tree.basedir)
1082
except errors.PathNotChild:
1083
raise errors.BadSubsumeSource(self, other_tree,
1084
'Tree is not contained by the other')
1085
new_root_parent = self.path2id(osutils.dirname(other_tree_path))
1086
if new_root_parent is None:
1087
raise errors.BadSubsumeSource(self, other_tree,
1088
'Parent directory is not versioned.')
1089
# We need to ensure that the result of a fetch will have a
1090
# versionedfile for the other_tree root, and only fetching into
1091
# RepositoryKnit2 guarantees that.
1092
if not self.branch.repository.supports_rich_root():
1093
raise errors.SubsumeTargetNeedsUpgrade(other_tree)
1094
other_tree.lock_tree_write()
1095
try:
1096
new_parents = other_tree.get_parent_ids()
1097
other_root = other_tree.inventory.root
1098
other_root.parent_id = new_root_parent
1099
other_root.name = osutils.basename(other_tree_path)
1100
self.inventory.add(other_root)
1101
add_children(self.inventory, other_root)
1102
self._write_inventory(self.inventory)
1103
# normally we don't want to fetch whole repositories, but i think
1104
# here we really do want to consolidate the whole thing.
1105
for parent_id in other_tree.get_parent_ids():
1106
self.branch.fetch(other_tree.branch, parent_id)
1107
self.add_parent_tree_id(parent_id)
1108
finally:
1109
other_tree.unlock()
1110
other_tree.bzrdir.retire_bzrdir()
893
1111
894
1112
def _setup_directory_is_tree_reference(self):
895
1113
if self._branch.repository._format.supports_tree_reference:
917
1135
# checkout in a subdirectory. This can be avoided by not adding
918
1136
# it. mbp 20070306
919
1137
1138
@needs_tree_write_lock
920
1139
def extract(self, file_id, format=None):
921
1140
"""Extract a subtree from this tree.
922
1141
923
1142
A new branch will be created, relative to the path for this tree.
924
1143
"""
925
raise NotImplementedError(self.extract)
1144
self.flush()
1145
def mkdirs(path):
1146
segments = osutils.splitpath(path)
1147
transport = self.branch.bzrdir.root_transport
1148
for name in segments:
1149
transport = transport.clone(name)
1150
transport.ensure_base()
1151
return transport
1152
1153
sub_path = self.id2path(file_id)
1154
branch_transport = mkdirs(sub_path)
1155
if format is None:
1156
format = self.bzrdir.cloning_metadir()
1157
branch_transport.ensure_base()
1158
branch_bzrdir = format.initialize_on_transport(branch_transport)
1159
try:
1160
repo = branch_bzrdir.find_repository()
1161
except errors.NoRepositoryPresent:
1162
repo = branch_bzrdir.create_repository()
1163
if not repo.supports_rich_root():
1164
raise errors.RootNotRich()
1165
new_branch = branch_bzrdir.create_branch()
1166
new_branch.pull(self.branch)
1167
for parent_id in self.get_parent_ids():
1168
new_branch.fetch(self.branch, parent_id)
1169
tree_transport = self.bzrdir.root_transport.clone(sub_path)
1170
if tree_transport.base != branch_transport.base:
1171
tree_bzrdir = format.initialize_on_transport(tree_transport)
1172
branch.BranchReferenceFormat().initialize(tree_bzrdir,
1173
target_branch=new_branch)
1174
else:
1175
tree_bzrdir = branch_bzrdir
1176
wt = tree_bzrdir.create_workingtree(_mod_revision.NULL_REVISION)
1177
wt.set_parent_ids(self.get_parent_ids())
1178
my_inv = self.inventory
1179
child_inv = inventory.Inventory(root_id=None)
1180
new_root = my_inv[file_id]
1181
my_inv.remove_recursive_id(file_id)
1182
new_root.parent_id = None
1183
child_inv.add(new_root)
1184
self._write_inventory(my_inv)
1185
wt._write_inventory(child_inv)
1186
return wt
1187
1188
def _serialize(self, inventory, out_file):
1189
xml5.serializer_v5.write_inventory(self._inventory, out_file,
1190
working=True)
1191
1192
def _deserialize(selt, in_file):
1193
return xml5.serializer_v5.read_inventory(in_file)
926
1194
927
1195
def flush(self):
928
"""Write the in memory meta data to disk."""
929
raise NotImplementedError(self.flush)
1196
"""Write the in memory inventory to disk."""
1197
# TODO: Maybe this should only write on dirty ?
1198
if self._control_files._lock_mode != 'w':
1199
raise errors.NotWriteLocked(self)
1200
sio = StringIO()
1201
self._serialize(self._inventory, sio)
1202
sio.seek(0)
1203
self._transport.put_file('inventory', sio,
1204
mode=self.bzrdir._get_file_mode())
1205
self._inventory_is_modified = False
930
1206
931
1207
def _kind(self, relpath):
932
1208
return osutils.file_kind(self.abspath(relpath))
942
1218
:param from_dir: start from this directory or None for the root
943
1219
:param recursive: whether to recurse into subdirectories or not
944
1220
"""
945
raise NotImplementedError(self.list_files)
946
1221
# list_files is an iterator, so @needs_read_lock doesn't work properly
1222
# with it. So callers should be careful to always read_lock the tree.
1223
if not self.is_locked():
1224
raise errors.ObjectNotLocked(self)
1225
1226
inv = self.inventory
1227
if from_dir is None and include_root is True:
1228
yield ('', 'V', 'directory', inv.root.file_id, inv.root)
1229
# Convert these into local objects to save lookup times
1230
pathjoin = osutils.pathjoin
1231
file_kind = self._kind
1232
1233
# transport.base ends in a slash, we want the piece
1234
# between the last two slashes
1235
transport_base_dir = self.bzrdir.transport.base.rsplit('/', 2)[1]
1236
1237
fk_entries = {'directory':TreeDirectory, 'file':TreeFile, 'symlink':TreeLink}
1238
1239
# directory file_id, relative path, absolute path, reverse sorted children
1240
if from_dir is not None:
1241
from_dir_id = inv.path2id(from_dir)
1242
if from_dir_id is None:
1243
# Directory not versioned
1244
return
1245
from_dir_abspath = pathjoin(self.basedir, from_dir)
1246
else:
1247
from_dir_id = inv.root.file_id
1248
from_dir_abspath = self.basedir
1249
children = os.listdir(from_dir_abspath)
1250
children.sort()
1251
# jam 20060527 The kernel sized tree seems equivalent whether we
1252
# use a deque and popleft to keep them sorted, or if we use a plain
1253
# list and just reverse() them.
1254
children = collections.deque(children)
1255
stack = [(from_dir_id, u'', from_dir_abspath, children)]
1256
while stack:
1257
from_dir_id, from_dir_relpath, from_dir_abspath, children = stack[-1]
1258
1259
while children:
1260
f = children.popleft()
1261
## TODO: If we find a subdirectory with its own .bzr
1262
## directory, then that is a separate tree and we
1263
## should exclude it.
1264
1265
# the bzrdir for this tree
1266
if transport_base_dir == f:
1267
continue
1268
1269
# we know that from_dir_relpath and from_dir_abspath never end in a slash
1270
# and 'f' doesn't begin with one, we can do a string op, rather
1271
# than the checks of pathjoin(), all relative paths will have an extra slash
1272
# at the beginning
1273
fp = from_dir_relpath + '/' + f
1274
1275
# absolute path
1276
fap = from_dir_abspath + '/' + f
1277
1278
dir_ie = inv[from_dir_id]
1279
if dir_ie.kind == 'directory':
1280
f_ie = dir_ie.children.get(f)
1281
else:
1282
f_ie = None
1283
if f_ie:
1284
c = 'V'
1285
elif self.is_ignored(fp[1:]):
1286
c = 'I'
1287
else:
1288
# we may not have found this file, because of a unicode
1289
# issue, or because the directory was actually a symlink.
1290
f_norm, can_access = osutils.normalized_filename(f)
1291
if f == f_norm or not can_access:
1292
# No change, so treat this file normally
1293
c = '?'
1294
else:
1295
# this file can be accessed by a normalized path
1296
# check again if it is versioned
1297
# these lines are repeated here for performance
1298
f = f_norm
1299
fp = from_dir_relpath + '/' + f
1300
fap = from_dir_abspath + '/' + f
1301
f_ie = inv.get_child(from_dir_id, f)
1302
if f_ie:
1303
c = 'V'
1304
elif self.is_ignored(fp[1:]):
1305
c = 'I'
1306
else:
1307
c = '?'
1308
1309
fk = file_kind(fap)
1310
1311
# make a last minute entry
1312
if f_ie:
1313
yield fp[1:], c, fk, f_ie.file_id, f_ie
1314
else:
1315
try:
1316
yield fp[1:], c, fk, None, fk_entries[fk]()
1317
except KeyError:
1318
yield fp[1:], c, fk, None, TreeEntry()
1319
continue
1320
1321
if fk != 'directory':
1322
continue
1323
1324
# But do this child first if recursing down
1325
if recursive:
1326
new_children = os.listdir(fap)
1327
new_children.sort()
1328
new_children = collections.deque(new_children)
1329
stack.append((f_ie.file_id, fp, fap, new_children))
1330
# Break out of inner loop,
1331
# so that we start outer loop with child
1332
break
1333
else:
1334
# if we finished all children, pop it off the stack
1335
stack.pop()
1336
1337
@needs_tree_write_lock
947
1338
def move(self, from_paths, to_dir=None, after=False):
948
1339
"""Rename files.
949
1340
950
to_dir must be known to the working tree.
1341
to_dir must exist in the inventory.
951
1342
952
1343
If to_dir exists and is a directory, the files are moved into
953
1344
it, keeping their old names.
959
1350
independently.
960
1351
961
1352
The first mode moves the file in the filesystem and updates the
962
working tree metadata. The second mode only updates the working tree
963
metadata without touching the file on the filesystem.
1353
inventory. The second mode only updates the inventory without
1354
touching the file on the filesystem. This is the new mode introduced
1355
in version 0.15.
964
1356
965
1357
move uses the second mode if 'after == True' and the target is not
966
1358
versioned but present in the working tree.
978
1370
This returns a list of (from_path, to_path) pairs for each
979
1371
entry that is moved.
980
1372
"""
981
raise NotImplementedError(self.move)
1373
rename_entries = []
1374
rename_tuples = []
1375
1376
# check for deprecated use of signature
1377
if to_dir is None:
1378
raise TypeError('You must supply a target directory')
1379
# check destination directory
1380
if isinstance(from_paths, basestring):
1381
raise ValueError()
1382
inv = self.inventory
1383
to_abs = self.abspath(to_dir)
1384
if not isdir(to_abs):
1385
raise errors.BzrMoveFailedError('',to_dir,
1386
errors.NotADirectory(to_abs))
1387
if not self.has_filename(to_dir):
1388
raise errors.BzrMoveFailedError('',to_dir,
1389
errors.NotInWorkingDirectory(to_dir))
1390
to_dir_id = inv.path2id(to_dir)
1391
if to_dir_id is None:
1392
raise errors.BzrMoveFailedError('',to_dir,
1393
errors.NotVersionedError(path=str(to_dir)))
1394
1395
to_dir_ie = inv[to_dir_id]
1396
if to_dir_ie.kind != 'directory':
1397
raise errors.BzrMoveFailedError('',to_dir,
1398
errors.NotADirectory(to_abs))
1399
1400
# create rename entries and tuples
1401
for from_rel in from_paths:
1402
from_tail = splitpath(from_rel)[-1]
1403
from_id = inv.path2id(from_rel)
1404
if from_id is None:
1405
raise errors.BzrMoveFailedError(from_rel,to_dir,
1406
errors.NotVersionedError(path=str(from_rel)))
1407
1408
from_entry = inv[from_id]
1409
from_parent_id = from_entry.parent_id
1410
to_rel = pathjoin(to_dir, from_tail)
1411
rename_entry = WorkingTree._RenameEntry(from_rel=from_rel,
1412
from_id=from_id,
1413
from_tail=from_tail,
1414
from_parent_id=from_parent_id,
1415
to_rel=to_rel, to_tail=from_tail,
1416
to_parent_id=to_dir_id)
1417
rename_entries.append(rename_entry)
1418
rename_tuples.append((from_rel, to_rel))
1419
1420
# determine which move mode to use. checks also for movability
1421
rename_entries = self._determine_mv_mode(rename_entries, after)
1422
1423
original_modified = self._inventory_is_modified
1424
try:
1425
if len(from_paths):
1426
self._inventory_is_modified = True
1427
self._move(rename_entries)
1428
except:
1429
# restore the inventory on error
1430
self._inventory_is_modified = original_modified
1431
raise
1432
self._write_inventory(inv)
1433
return rename_tuples
1434
1435
def _determine_mv_mode(self, rename_entries, after=False):
1436
"""Determines for each from-to pair if both inventory and working tree
1437
or only the inventory has to be changed.
1438
1439
Also does basic plausability tests.
1440
"""
1441
inv = self.inventory
1442
1443
for rename_entry in rename_entries:
1444
# store to local variables for easier reference
1445
from_rel = rename_entry.from_rel
1446
from_id = rename_entry.from_id
1447
to_rel = rename_entry.to_rel
1448
to_id = inv.path2id(to_rel)
1449
only_change_inv = False
1450
1451
# check the inventory for source and destination
1452
if from_id is None:
1453
raise errors.BzrMoveFailedError(from_rel,to_rel,
1454
errors.NotVersionedError(path=str(from_rel)))
1455
if to_id is not None:
1456
raise errors.BzrMoveFailedError(from_rel,to_rel,
1457
errors.AlreadyVersionedError(path=str(to_rel)))
1458
1459
# try to determine the mode for rename (only change inv or change
1460
# inv and file system)
1461
if after:
1462
if not self.has_filename(to_rel):
1463
raise errors.BzrMoveFailedError(from_id,to_rel,
1464
errors.NoSuchFile(path=str(to_rel),
1465
extra="New file has not been created yet"))
1466
only_change_inv = True
1467
elif not self.has_filename(from_rel) and self.has_filename(to_rel):
1468
only_change_inv = True
1469
elif self.has_filename(from_rel) and not self.has_filename(to_rel):
1470
only_change_inv = False
1471
elif (not self.case_sensitive
1472
and from_rel.lower() == to_rel.lower()
1473
and self.has_filename(from_rel)):
1474
only_change_inv = False
1475
else:
1476
# something is wrong, so lets determine what exactly
1477
if not self.has_filename(from_rel) and \
1478
not self.has_filename(to_rel):
1479
raise errors.BzrRenameFailedError(from_rel,to_rel,
1480
errors.PathsDoNotExist(paths=(str(from_rel),
1481
str(to_rel))))
1482
else:
1483
raise errors.RenameFailedFilesExist(from_rel, to_rel)
1484
rename_entry.only_change_inv = only_change_inv
1485
return rename_entries
1486
1487
def _move(self, rename_entries):
1488
"""Moves a list of files.
1489
1490
Depending on the value of the flag 'only_change_inv', the
1491
file will be moved on the file system or not.
1492
"""
1493
inv = self.inventory
1494
moved = []
1495
1496
for entry in rename_entries:
1497
try:
1498
self._move_entry(entry)
1499
except:
1500
self._rollback_move(moved)
1501
raise
1502
moved.append(entry)
1503
1504
def _rollback_move(self, moved):
1505
"""Try to rollback a previous move in case of an filesystem error."""
1506
inv = self.inventory
1507
for entry in moved:
1508
try:
1509
self._move_entry(WorkingTree._RenameEntry(
1510
entry.to_rel, entry.from_id,
1511
entry.to_tail, entry.to_parent_id, entry.from_rel,
1512
entry.from_tail, entry.from_parent_id,
1513
entry.only_change_inv))
1514
except errors.BzrMoveFailedError, e:
1515
raise errors.BzrMoveFailedError( '', '', "Rollback failed."
1516
" The working tree is in an inconsistent state."
1517
" Please consider doing a 'bzr revert'."
1518
" Error message is: %s" % e)
1519
1520
def _move_entry(self, entry):
1521
inv = self.inventory
1522
from_rel_abs = self.abspath(entry.from_rel)
1523
to_rel_abs = self.abspath(entry.to_rel)
1524
if from_rel_abs == to_rel_abs:
1525
raise errors.BzrMoveFailedError(entry.from_rel, entry.to_rel,
1526
"Source and target are identical.")
1527
1528
if not entry.only_change_inv:
1529
try:
1530
osutils.rename(from_rel_abs, to_rel_abs)
1531
except OSError, e:
1532
raise errors.BzrMoveFailedError(entry.from_rel,
1533
entry.to_rel, e[1])
1534
inv.rename(entry.from_id, entry.to_parent_id, entry.to_tail)
982
1535
983
1536
@needs_tree_write_lock
984
1537
def rename_one(self, from_rel, to_rel, after=False):
988
1541
989
1542
rename_one has several 'modes' to work. First, it can rename a physical
990
1543
file and change the file_id. That is the normal mode. Second, it can
991
only change the file_id without touching any physical file.
1544
only change the file_id without touching any physical file. This is
1545
the new mode introduced in version 0.15.
992
1546
993
1547
rename_one uses the second mode if 'after == True' and 'to_rel' is not
994
1548
versioned but present in the working tree.
1003
1557
1004
1558
Everything else results in an error.
1005
1559
"""
1006
raise NotImplementedError(self.rename_one)
1560
inv = self.inventory
1561
rename_entries = []
1562
1563
# create rename entries and tuples
1564
from_tail = splitpath(from_rel)[-1]
1565
from_id = inv.path2id(from_rel)
1566
if from_id is None:
1567
# if file is missing in the inventory maybe it's in the basis_tree
1568
basis_tree = self.branch.basis_tree()
1569
from_id = basis_tree.path2id(from_rel)
1570
if from_id is None:
1571
raise errors.BzrRenameFailedError(from_rel,to_rel,
1572
errors.NotVersionedError(path=str(from_rel)))
1573
# put entry back in the inventory so we can rename it
1574
from_entry = basis_tree.inventory[from_id].copy()
1575
inv.add(from_entry)
1576
else:
1577
from_entry = inv[from_id]
1578
from_parent_id = from_entry.parent_id
1579
to_dir, to_tail = os.path.split(to_rel)
1580
to_dir_id = inv.path2id(to_dir)
1581
rename_entry = WorkingTree._RenameEntry(from_rel=from_rel,
1582
from_id=from_id,
1583
from_tail=from_tail,
1584
from_parent_id=from_parent_id,
1585
to_rel=to_rel, to_tail=to_tail,
1586
to_parent_id=to_dir_id)
1587
rename_entries.append(rename_entry)
1588
1589
# determine which move mode to use. checks also for movability
1590
rename_entries = self._determine_mv_mode(rename_entries, after)
1591
1592
# check if the target changed directory and if the target directory is
1593
# versioned
1594
if to_dir_id is None:
1595
raise errors.BzrMoveFailedError(from_rel,to_rel,
1596
errors.NotVersionedError(path=str(to_dir)))
1597
1598
# all checks done. now we can continue with our actual work
1599
mutter('rename_one:\n'
1600
' from_id {%s}\n'
1601
' from_rel: %r\n'
1602
' to_rel: %r\n'
1603
' to_dir %r\n'
1604
' to_dir_id {%s}\n',
1605
from_id, from_rel, to_rel, to_dir, to_dir_id)
1606
1607
self._move(rename_entries)
1608
self._write_inventory(inv)
1609
1610
class _RenameEntry(object):
1611
def __init__(self, from_rel, from_id, from_tail, from_parent_id,
1612
to_rel, to_tail, to_parent_id, only_change_inv=False):
1613
self.from_rel = from_rel
1614
self.from_id = from_id
1615
self.from_tail = from_tail
1616
self.from_parent_id = from_parent_id
1617
self.to_rel = to_rel
1618
self.to_tail = to_tail
1619
self.to_parent_id = to_parent_id
1620
self.only_change_inv = only_change_inv
1007
1621
1008
1622
@needs_read_lock
1009
1623
def unknowns(self):
1017
1631
return iter(
1018
1632
[subp for subp in self.extras() if not self.is_ignored(subp)])
1019
1633
1634
@needs_tree_write_lock
1020
1635
def unversion(self, file_ids):
1021
1636
"""Remove the file ids in file_ids from the current versioned set.
1022
1637
1026
1641
:param file_ids: The file ids to stop versioning.
1027
1642
:raises: NoSuchId if any fileid is not currently versioned.
1028
1643
"""
1029
raise NotImplementedError(self.unversion)
1644
for file_id in file_ids:
1645
if file_id not in self._inventory:
1646
raise errors.NoSuchId(self, file_id)
1647
for file_id in file_ids:
1648
if self._inventory.has_id(file_id):
1649
self._inventory.remove_recursive_id(file_id)
1650
if len(file_ids):
1651
# in the future this should just set a dirty bit to wait for the
1652
# final unlock. However, until all methods of workingtree start
1653
# with the current in -memory inventory rather than triggering
1654
# a read, it is more complex - we need to teach read_inventory
1655
# to know when to read, and when to not read first... and possibly
1656
# to save first when the in memory one may be corrupted.
1657
# so for now, we just only write it if it is indeed dirty.
1658
# - RBC 20060907
1659
self._write_inventory(self._inventory)
1660
1661
def _iter_conflicts(self):
1662
conflicted = set()
1663
for info in self.list_files():
1664
path = info[0]
1665
stem = get_conflicted_stem(path)
1666
if stem is None:
1667
continue
1668
if stem not in conflicted:
1669
conflicted.add(stem)
1670
yield stem
1030
1671
1031
1672
@needs_write_lock
1032
1673
def pull(self, source, overwrite=False, stop_revision=None,
1097
1738
Currently returned depth-first, sorted by name within directories.
1098
1739
This is the same order used by 'osutils.walkdirs'.
1099
1740
"""
1100
raise NotImplementedError(self.extras)
1741
## TODO: Work from given directory downwards
1742
for path, dir_entry in self.inventory.directories():
1743
# mutter("search for unknowns in %r", path)
1744
dirabs = self.abspath(path)
1745
if not isdir(dirabs):
1746
# e.g. directory deleted
1747
continue
1748
1749
fl = []
1750
for subf in os.listdir(dirabs):
1751
if self.bzrdir.is_control_filename(subf):
1752
continue
1753
if subf not in dir_entry.children:
1754
try:
1755
(subf_norm,
1756
can_access) = osutils.normalized_filename(subf)
1757
except UnicodeDecodeError:
1758
path_os_enc = path.encode(osutils._fs_enc)
1759
relpath = path_os_enc + '/' + subf
1760
raise errors.BadFilenameEncoding(relpath,
1761
osutils._fs_enc)
1762
if subf_norm != subf and can_access:
1763
if subf_norm not in dir_entry.children:
1764
fl.append(subf_norm)
1765
else:
1766
fl.append(subf)
1767
1768
fl.sort()
1769
for subf in fl:
1770
subp = pathjoin(path, subf)
1771
yield subp
1101
1772
1102
1773
def ignored_files(self):
1103
1774
"""Yield list of PATH, IGNORE_PATTERN"""
1152
1823
1153
1824
def stored_kind(self, file_id):
1154
1825
"""See Tree.stored_kind"""
1155
raise NotImplementedError(self.stored_kind)
1826
return self.inventory[file_id].kind
1156
1827
1157
1828
def _comparison_data(self, entry, path):
1158
1829
abspath = self.abspath(path)
1249
1920
def get_physical_lock_status(self):
1250
1921
return self._control_files.get_physical_lock_status()
1251
1922
1923
def _basis_inventory_name(self):
1924
return 'basis-inventory-cache'
1925
1252
1926
def _reset_data(self):
1253
1927
"""Reset transient data that cannot be revalidated."""
1254
raise NotImplementedError(self._reset_data)
1928
self._inventory_is_modified = False
1929
f = self._transport.get('inventory')
1930
try:
1931
result = self._deserialize(f)
1932
finally:
1933
f.close()
1934
self._set_inventory(result, dirty=False)
1255
1935
1936
@needs_tree_write_lock
1256
1937
def set_last_revision(self, new_revision):
1257
1938
"""Change the last revision in the working tree."""
1258
raise NotImplementedError(self.set_last_revision)
1939
if self._change_last_revision(new_revision):
1940
self._cache_basis_inventory(new_revision)
1259
1941
1260
1942
def _change_last_revision(self, new_revision):
1261
1943
"""Template method part of set_last_revision to perform the change.
1264
1946
when their last revision is set.
1265
1947
"""
1266
1948
if _mod_revision.is_null(new_revision):
1267
self.branch.set_last_revision_info(0, new_revision)
1949
self.branch.set_revision_history([])
1268
1950
return False
1269
1951
try:
1270
1952
self.branch.generate_revision_history(new_revision)
1271
1953
except errors.NoSuchRevision:
1272
1954
# not present in the repo - dont try to set it deeper than the tip
1273
self.branch._set_revision_history([new_revision])
1955
self.branch.set_revision_history([new_revision])
1274
1956
return True
1275
1957
1958
def _write_basis_inventory(self, xml):
1959
"""Write the basis inventory XML to the basis-inventory file"""
1960
path = self._basis_inventory_name()
1961
sio = StringIO(xml)
1962
self._transport.put_file(path, sio,
1963
mode=self.bzrdir._get_file_mode())
1964
1965
def _create_basis_xml_from_inventory(self, revision_id, inventory):
1966
"""Create the text that will be saved in basis-inventory"""
1967
inventory.revision_id = revision_id
1968
return xml7.serializer_v7.write_inventory_to_string(inventory)
1969
1970
def _cache_basis_inventory(self, new_revision):
1971
"""Cache new_revision as the basis inventory."""
1972
# TODO: this should allow the ready-to-use inventory to be passed in,
1973
# as commit already has that ready-to-use [while the format is the
1974
# same, that is].
1975
try:
1976
# this double handles the inventory - unpack and repack -
1977
# but is easier to understand. We can/should put a conditional
1978
# in here based on whether the inventory is in the latest format
1979
# - perhaps we should repack all inventories on a repository
1980
# upgrade ?
1981
# the fast path is to copy the raw xml from the repository. If the
1982
# xml contains 'revision_id="', then we assume the right
1983
# revision_id is set. We must check for this full string, because a
1984
# root node id can legitimately look like 'revision_id' but cannot
1985
# contain a '"'.
1986
xml = self.branch.repository._get_inventory_xml(new_revision)
1987
firstline = xml.split('\n', 1)[0]
1988
if (not 'revision_id="' in firstline or
1989
'format="7"' not in firstline):
1990
inv = self.branch.repository._serializer.read_inventory_from_string(
1991
xml, new_revision)
1992
xml = self._create_basis_xml_from_inventory(new_revision, inv)
1993
self._write_basis_inventory(xml)
1994
except (errors.NoSuchRevision, errors.RevisionNotPresent):
1995
pass
1996
1997
def read_basis_inventory(self):
1998
"""Read the cached basis inventory."""
1999
path = self._basis_inventory_name()
2000
return self._transport.get_bytes(path)
2001
2002
@needs_read_lock
2003
def read_working_inventory(self):
2004
"""Read the working inventory.
2005
2006
:raises errors.InventoryModified: read_working_inventory will fail
2007
when the current in memory inventory has been modified.
2008
"""
2009
# conceptually this should be an implementation detail of the tree.
2010
# XXX: Deprecate this.
2011
# ElementTree does its own conversion from UTF-8, so open in
2012
# binary.
2013
if self._inventory_is_modified:
2014
raise errors.InventoryModified(self)
2015
f = self._transport.get('inventory')
2016
try:
2017
result = self._deserialize(f)
2018
finally:
2019
f.close()
2020
self._set_inventory(result, dirty=False)
2021
return result
2022
1276
2023
@needs_tree_write_lock
1277
2024
def remove(self, files, verbose=False, to_file=None, keep_files=True,
1278
2025
force=False):
1279
"""Remove nominated files from the working tree metadata.
2026
"""Remove nominated files from the working inventory.
1280
2027
1281
2028
:files: File paths relative to the basedir.
1282
2029
:keep_files: If true, the files will also be kept.
1347
2094
backup_name)
1348
2095
1349
2096
# Build inv_delta and delete files where applicable,
1350
# do this before any modifications to meta data.
2097
# do this before any modifications to inventory.
1351
2098
for f in files:
1352
2099
fid = self.path2id(f)
1353
2100
message = None
1433
2180
WorkingTree can supply revision_trees for the basis revision only
1434
2181
because there is only one cached inventory in the bzr directory.
1435
2182
"""
1436
raise NotImplementedError(self.revision_tree)
2183
if revision_id == self.last_revision():
2184
try:
2185
xml = self.read_basis_inventory()
2186
except errors.NoSuchFile:
2187
pass
2188
else:
2189
try:
2190
inv = xml7.serializer_v7.read_inventory_from_string(xml)
2191
# dont use the repository revision_tree api because we want
2192
# to supply the inventory.
2193
if inv.revision_id == revision_id:
2194
return revisiontree.RevisionTree(self.branch.repository,
2195
inv, revision_id)
2196
except errors.BadInventoryFormat:
2197
pass
2198
# raise if there was no inventory, or if we read the wrong inventory.
2199
raise errors.NoSuchRevisionInTree(self, revision_id)
2200
2201
# XXX: This method should be deprecated in favour of taking in a proper
2202
# new Inventory object.
2203
@needs_tree_write_lock
2204
def set_inventory(self, new_inventory_list):
2205
from bzrlib.inventory import (Inventory,
2206
InventoryDirectory,
2207
InventoryFile,
2208
InventoryLink)
2209
inv = Inventory(self.get_root_id())
2210
for path, file_id, parent, kind in new_inventory_list:
2211
name = os.path.basename(path)
2212
if name == "":
2213
continue
2214
# fixme, there should be a factory function inv,add_??
2215
if kind == 'directory':
2216
inv.add(InventoryDirectory(file_id, name, parent))
2217
elif kind == 'file':
2218
inv.add(InventoryFile(file_id, name, parent))
2219
elif kind == 'symlink':
2220
inv.add(InventoryLink(file_id, name, parent))
2221
else:
2222
raise errors.BzrError("unknown kind %r" % kind)
2223
self._write_inventory(inv)
1437
2224
1438
2225
@needs_tree_write_lock
1439
2226
def set_root_id(self, file_id):
1452
2239
present in the current inventory or an error will occur. It must
1453
2240
not be None, but rather a valid file id.
1454
2241
"""
1455
raise NotImplementedError(self._set_root_id)
2242
inv = self._inventory
2243
orig_root_id = inv.root.file_id
2244
# TODO: it might be nice to exit early if there was nothing
2245
# to do, saving us from trigger a sync on unlock.
2246
self._inventory_is_modified = True
2247
# we preserve the root inventory entry object, but
2248
# unlinkit from the byid index
2249
del inv._byid[inv.root.file_id]
2250
inv.root.file_id = file_id
2251
# and link it into the index with the new changed id.
2252
inv._byid[inv.root.file_id] = inv.root
2253
# and finally update all children to reference the new id.
2254
# XXX: this should be safe to just look at the root.children
2255
# list, not the WHOLE INVENTORY.
2256
for fid in inv:
2257
entry = inv[fid]
2258
if entry.parent_id == orig_root_id:
2259
entry.parent_id = inv.root.file_id
1456
2260
1457
2261
def unlock(self):
1458
2262
"""See Branch.unlock.
1554
2358
show_base=show_base)
1555
2359
if nb_conflicts:
1556
2360
self.add_parent_tree((old_tip, other_tree))
1557
note('Rerun update after fixing the conflicts.')
2361
trace.note('Rerun update after fixing the conflicts.')
1558
2362
return nb_conflicts
1559
2363
1560
2364
if last_rev != _mod_revision.ensure_null(revision):
1566
2370
basis = self.basis_tree()
1567
2371
basis.lock_read()
1568
2372
try:
1569
if (basis.get_root_id() is None or basis.get_root_id() != to_root_id):
2373
if (basis.inventory.root is None
2374
or basis.inventory.root.file_id != to_root_id):
1570
2375
self.set_root_id(to_root_id)
1571
2376
self.flush()
1572
2377
finally:
1614
2419
# warning might be sufficient to let the user know what
1615
2420
# is going on.
1616
2421
mutter('Could not write hashcache for %s\nError: %s',
1617
self._hashcache.cache_file_name(), e)
2422
self._hashcache.cache_file_name(), e)
2423
2424
@needs_tree_write_lock
2425
def _write_inventory(self, inv):
2426
"""Write inventory as the current inventory."""
2427
self._set_inventory(inv, dirty=True)
2428
self.flush()
1618
2429
1619
2430
def set_conflicts(self, arg):
1620
2431
raise errors.UnsupportedOperation(self.set_conflicts, self)
1622
2433
def add_conflicts(self, arg):
1623
2434
raise errors.UnsupportedOperation(self.add_conflicts, self)
1624
2435
2436
@needs_read_lock
1625
2437
def conflicts(self):
1626
raise NotImplementedError(self.conflicts)
2438
conflicts = _mod_conflicts.ConflictList()
2439
for conflicted in self._iter_conflicts():
2440
text = True
2441
try:
2442
if file_kind(self.abspath(conflicted)) != "file":
2443
text = False
2444
except errors.NoSuchFile:
2445
text = False
2446
if text is True:
2447
for suffix in ('.THIS', '.OTHER'):
2448
try:
2449
kind = file_kind(self.abspath(conflicted+suffix))
2450
if kind != "file":
2451
text = False
2452
except errors.NoSuchFile:
2453
text = False
2454
if text == False:
2455
break
2456
ctype = {True: 'text conflict', False: 'contents conflict'}[text]
2457
conflicts.append(_mod_conflicts.Conflict.factory(ctype,
2458
path=conflicted,
2459
file_id=self.path2id(conflicted)))
2460
return conflicts
1627
2461
1628
2462
def walkdirs(self, prefix=""):
1629
2463
"""Walk the directories of this tree.
1755
2589
[(file1_path, file1_name, file1_kind, None, file1_id,
1756
2590
file1_kind), ... ])
1757
2591
"""
1758
raise NotImplementedError(self._walkdirs)
2592
_directory = 'directory'
2593
# get the root in the inventory
2594
inv = self.inventory
2595
top_id = inv.path2id(prefix)
2596
if top_id is None:
2597
pending = []
2598
else:
2599
pending = [(prefix, '', _directory, None, top_id, None)]
2600
while pending:
2601
dirblock = []
2602
currentdir = pending.pop()
2603
# 0 - relpath, 1- basename, 2- kind, 3- stat, 4-id, 5-kind
2604
top_id = currentdir[4]
2605
if currentdir[0]:
2606
relroot = currentdir[0] + '/'
2607
else:
2608
relroot = ""
2609
# FIXME: stash the node in pending
2610
entry = inv[top_id]
2611
if entry.kind == 'directory':
2612
for name, child in entry.sorted_children():
2613
dirblock.append((relroot + name, name, child.kind, None,
2614
child.file_id, child.kind
2615
))
2616
yield (currentdir[0], entry.file_id), dirblock
2617
# push the user specified dirs from dirblock
2618
for dir in reversed(dirblock):
2619
if dir[2] == _directory:
2620
pending.append(dir)
1759
2621
1760
2622
@needs_tree_write_lock
1761
2623
def auto_resolve(self):
1819
2681
"""
1820
2682
return
1821
2683
1822
@needs_read_lock
1823
def check_state(self):
1824
"""Check that the working state is/isn't valid."""
1825
check_refs = self._get_check_refs()
1826
refs = {}
1827
for ref in check_refs:
1828
kind, value = ref
1829
if kind == 'trees':
1830
refs[ref] = self.branch.repository.revision_tree(value)
1831
self._check(refs)
1832
1833
def reset_state(self, revision_ids=None):
1834
"""Reset the state of the working tree.
1835
1836
This does a hard-reset to a last-known-good state. This is a way to
1837
fix if something got corrupted (like the .bzr/checkout/dirstate file)
1838
"""
1839
raise NotImplementedError(self.reset_state)
1840
1841
2684
def _get_rules_searcher(self, default_searcher):
1842
2685
"""See Tree._get_rules_searcher."""
1843
2686
if self._rules_searcher is None:
1851
2694
return ShelfManager(self, self._transport)
1852
2695
1853
2696
1854
class InventoryWorkingTree(WorkingTree,
1855
bzrlib.mutabletree.MutableInventoryTree):
1856
"""Base class for working trees that are inventory-oriented.
1857
1858
The inventory is held in the `Branch` working-inventory, and the
1859
files are in a directory on disk.
1860
1861
It is possible for a `WorkingTree` to have a filename which is
1862
not listed in the Inventory and vice versa.
2697
class WorkingTree2(WorkingTree):
2698
"""This is the Format 2 working tree.
2699
2700
This was the first weave based working tree.
2701
- uses os locks for locking.
2702
- uses the branch last-revision.
1863
2703
"""
1864
2704
1865
def __init__(self, basedir='.',
1866
branch=DEPRECATED_PARAMETER,
1867
_inventory=None,
1868
_control_files=None,
1869
_internal=False,
1870
_format=None,
1871
_bzrdir=None):
1872
"""Construct a InventoryWorkingTree instance. This is not a public API.
1873
1874
:param branch: A branch to override probing for the branch.
1875
"""
1876
super(InventoryWorkingTree, self).__init__(basedir=basedir,
1877
branch=branch, _control_files=_control_files, _internal=_internal,
1878
_format=_format, _bzrdir=_bzrdir)
1879
1880
if _inventory is None:
1881
# This will be acquired on lock_read() or lock_write()
1882
self._inventory_is_modified = False
1883
self._inventory = None
1884
else:
1885
# the caller of __init__ has provided an inventory,
1886
# we assume they know what they are doing - as its only
1887
# the Format factory and creation methods that are
1888
# permitted to do this.
1889
self._set_inventory(_inventory, dirty=False)
1890
1891
def _set_inventory(self, inv, dirty):
1892
"""Set the internal cached inventory.
1893
1894
:param inv: The inventory to set.
1895
:param dirty: A boolean indicating whether the inventory is the same
1896
logical inventory as whats on disk. If True the inventory is not
1897
the same and should be written to disk or data will be lost, if
1898
False then the inventory is the same as that on disk and any
1899
serialisation would be unneeded overhead.
1900
"""
1901
self._inventory = inv
1902
self._inventory_is_modified = dirty
1903
1904
def _serialize(self, inventory, out_file):
1905
xml5.serializer_v5.write_inventory(self._inventory, out_file,
1906
working=True)
1907
1908
def _deserialize(selt, in_file):
1909
return xml5.serializer_v5.read_inventory(in_file)
1910
1911
@needs_tree_write_lock
1912
def _write_inventory(self, inv):
1913
"""Write inventory as the current inventory."""
1914
self._set_inventory(inv, dirty=True)
1915
self.flush()
1916
1917
# XXX: This method should be deprecated in favour of taking in a proper
1918
# new Inventory object.
1919
@needs_tree_write_lock
1920
def set_inventory(self, new_inventory_list):
1921
from bzrlib.inventory import (Inventory,
1922
InventoryDirectory,
1923
InventoryFile,
1924
InventoryLink)
1925
inv = Inventory(self.get_root_id())
1926
for path, file_id, parent, kind in new_inventory_list:
1927
name = os.path.basename(path)
1928
if name == "":
1929
continue
1930
# fixme, there should be a factory function inv,add_??
1931
if kind == 'directory':
1932
inv.add(InventoryDirectory(file_id, name, parent))
1933
elif kind == 'file':
1934
inv.add(InventoryFile(file_id, name, parent))
1935
elif kind == 'symlink':
1936
inv.add(InventoryLink(file_id, name, parent))
1937
else:
1938
raise errors.BzrError("unknown kind %r" % kind)
1939
self._write_inventory(inv)
1940
1941
def _write_basis_inventory(self, xml):
1942
"""Write the basis inventory XML to the basis-inventory file"""
1943
path = self._basis_inventory_name()
1944
sio = StringIO(xml)
1945
self._transport.put_file(path, sio,
1946
mode=self.bzrdir._get_file_mode())
1947
1948
def _reset_data(self):
1949
"""Reset transient data that cannot be revalidated."""
1950
self._inventory_is_modified = False
1951
f = self._transport.get('inventory')
1952
try:
1953
result = self._deserialize(f)
1954
finally:
1955
f.close()
1956
self._set_inventory(result, dirty=False)
1957
1958
def _set_root_id(self, file_id):
1959
"""Set the root id for this tree, in a format specific manner.
1960
1961
:param file_id: The file id to assign to the root. It must not be
1962
present in the current inventory or an error will occur. It must
1963
not be None, but rather a valid file id.
1964
"""
1965
inv = self._inventory
1966
orig_root_id = inv.root.file_id
1967
# TODO: it might be nice to exit early if there was nothing
1968
# to do, saving us from trigger a sync on unlock.
1969
self._inventory_is_modified = True
1970
# we preserve the root inventory entry object, but
1971
# unlinkit from the byid index
1972
del inv._byid[inv.root.file_id]
1973
inv.root.file_id = file_id
1974
# and link it into the index with the new changed id.
1975
inv._byid[inv.root.file_id] = inv.root
1976
# and finally update all children to reference the new id.
1977
# XXX: this should be safe to just look at the root.children
1978
# list, not the WHOLE INVENTORY.
1979
for fid in inv:
1980
entry = inv[fid]
1981
if entry.parent_id == orig_root_id:
1982
entry.parent_id = inv.root.file_id
1983
1984
def all_file_ids(self):
1985
"""See Tree.iter_all_file_ids"""
1986
return set(self.inventory)
1987
1988
def _cache_basis_inventory(self, new_revision):
1989
"""Cache new_revision as the basis inventory."""
1990
# TODO: this should allow the ready-to-use inventory to be passed in,
1991
# as commit already has that ready-to-use [while the format is the
1992
# same, that is].
1993
try:
1994
# this double handles the inventory - unpack and repack -
1995
# but is easier to understand. We can/should put a conditional
1996
# in here based on whether the inventory is in the latest format
1997
# - perhaps we should repack all inventories on a repository
1998
# upgrade ?
1999
# the fast path is to copy the raw xml from the repository. If the
2000
# xml contains 'revision_id="', then we assume the right
2001
# revision_id is set. We must check for this full string, because a
2002
# root node id can legitimately look like 'revision_id' but cannot
2003
# contain a '"'.
2004
xml = self.branch.repository._get_inventory_xml(new_revision)
2005
firstline = xml.split('\n', 1)[0]
2006
if (not 'revision_id="' in firstline or
2007
'format="7"' not in firstline):
2008
inv = self.branch.repository._serializer.read_inventory_from_string(
2009
xml, new_revision)
2010
xml = self._create_basis_xml_from_inventory(new_revision, inv)
2011
self._write_basis_inventory(xml)
2012
except (errors.NoSuchRevision, errors.RevisionNotPresent):
2013
pass
2014
2015
def _basis_inventory_name(self):
2016
return 'basis-inventory-cache'
2017
2018
def _create_basis_xml_from_inventory(self, revision_id, inventory):
2019
"""Create the text that will be saved in basis-inventory"""
2020
inventory.revision_id = revision_id
2021
return xml7.serializer_v7.write_inventory_to_string(inventory)
2022
2023
def read_basis_inventory(self):
2024
"""Read the cached basis inventory."""
2025
path = self._basis_inventory_name()
2026
return self._transport.get_bytes(path)
2027
2028
@needs_read_lock
2029
def read_working_inventory(self):
2030
"""Read the working inventory.
2031
2032
:raises errors.InventoryModified: read_working_inventory will fail
2033
when the current in memory inventory has been modified.
2034
"""
2035
# conceptually this should be an implementation detail of the tree.
2036
# XXX: Deprecate this.
2037
# ElementTree does its own conversion from UTF-8, so open in
2038
# binary.
2039
if self._inventory_is_modified:
2040
raise errors.InventoryModified(self)
2041
f = self._transport.get('inventory')
2042
try:
2043
result = self._deserialize(f)
2044
finally:
2045
f.close()
2046
self._set_inventory(result, dirty=False)
2047
return result
2048
2049
@needs_read_lock
2050
def get_root_id(self):
2051
"""Return the id of this trees root"""
2052
return self._inventory.root.file_id
2053
2054
def has_id(self, file_id):
2055
# files that have been deleted are excluded
2056
inv = self.inventory
2057
if not inv.has_id(file_id):
2058
return False
2059
path = inv.id2path(file_id)
2060
return osutils.lexists(self.abspath(path))
2061
2062
def has_or_had_id(self, file_id):
2063
if file_id == self.inventory.root.file_id:
2064
return True
2065
return self.inventory.has_id(file_id)
2066
2067
__contains__ = has_id
2068
2069
# should be deprecated - this is slow and in any case treating them as a
2070
# container is (we now know) bad style -- mbp 20070302
2071
## @deprecated_method(zero_fifteen)
2072
def __iter__(self):
2073
"""Iterate through file_ids for this tree.
2074
2075
file_ids are in a WorkingTree if they are in the working inventory
2076
and the working file exists.
2077
"""
2078
inv = self._inventory
2079
for path, ie in inv.iter_entries():
2080
if osutils.lexists(self.abspath(path)):
2081
yield ie.file_id
2082
2083
@needs_tree_write_lock
2084
def set_last_revision(self, new_revision):
2085
"""Change the last revision in the working tree."""
2086
if self._change_last_revision(new_revision):
2087
self._cache_basis_inventory(new_revision)
2088
2089
@needs_tree_write_lock
2090
def reset_state(self, revision_ids=None):
2091
"""Reset the state of the working tree.
2092
2093
This does a hard-reset to a last-known-good state. This is a way to
2094
fix if something got corrupted (like the .bzr/checkout/dirstate file)
2095
"""
2096
if revision_ids is None:
2097
revision_ids = self.get_parent_ids()
2098
if not revision_ids:
2099
rt = self.branch.repository.revision_tree(
2100
_mod_revision.NULL_REVISION)
2101
else:
2102
rt = self.branch.repository.revision_tree(revision_ids[0])
2103
self._write_inventory(rt.inventory)
2104
self.set_parent_ids(revision_ids)
2105
2106
def flush(self):
2107
"""Write the in memory inventory to disk."""
2108
# TODO: Maybe this should only write on dirty ?
2109
if self._control_files._lock_mode != 'w':
2110
raise errors.NotWriteLocked(self)
2111
sio = StringIO()
2112
self._serialize(self._inventory, sio)
2113
sio.seek(0)
2114
self._transport.put_file('inventory', sio,
2115
mode=self.bzrdir._get_file_mode())
2116
self._inventory_is_modified = False
2117
2118
@needs_read_lock
2119
def get_file_sha1(self, file_id, path=None, stat_value=None):
2120
if not path:
2121
path = self._inventory.id2path(file_id)
2122
return self._hashcache.get_sha1(path, stat_value)
2123
2124
def get_file_mtime(self, file_id, path=None):
2125
"""See Tree.get_file_mtime."""
2126
if not path:
2127
path = self.inventory.id2path(file_id)
2128
return os.lstat(self.abspath(path)).st_mtime
2129
2130
def _is_executable_from_path_and_stat_from_basis(self, path, stat_result):
2131
file_id = self.path2id(path)
2132
if file_id is None:
2133
# For unversioned files on win32, we just assume they are not
2134
# executable
2135
return False
2136
return self._inventory[file_id].executable
2137
2138
def _is_executable_from_path_and_stat_from_stat(self, path, stat_result):
2139
mode = stat_result.st_mode
2140
return bool(stat.S_ISREG(mode) and stat.S_IEXEC & mode)
2141
2142
if not supports_executable():
2143
def is_executable(self, file_id, path=None):
2144
return self._inventory[file_id].executable
2145
2146
_is_executable_from_path_and_stat = \
2147
_is_executable_from_path_and_stat_from_basis
2148
else:
2149
def is_executable(self, file_id, path=None):
2150
if not path:
2151
path = self.id2path(file_id)
2152
mode = os.lstat(self.abspath(path)).st_mode
2153
return bool(stat.S_ISREG(mode) and stat.S_IEXEC & mode)
2154
2155
_is_executable_from_path_and_stat = \
2156
_is_executable_from_path_and_stat_from_stat
2157
2158
@needs_tree_write_lock
2159
def _add(self, files, ids, kinds):
2160
"""See MutableTree._add."""
2161
# TODO: Re-adding a file that is removed in the working copy
2162
# should probably put it back with the previous ID.
2163
# the read and write working inventory should not occur in this
2164
# function - they should be part of lock_write and unlock.
2165
inv = self.inventory
2166
for f, file_id, kind in zip(files, ids, kinds):
2167
if file_id is None:
2168
inv.add_path(f, kind=kind)
2169
else:
2170
inv.add_path(f, kind=kind, file_id=file_id)
2171
self._inventory_is_modified = True
2172
2173
def revision_tree(self, revision_id):
2174
"""See WorkingTree.revision_id."""
2175
if revision_id == self.last_revision():
2176
try:
2177
xml = self.read_basis_inventory()
2178
except errors.NoSuchFile:
2179
pass
2180
else:
2181
try:
2182
inv = xml7.serializer_v7.read_inventory_from_string(xml)
2183
# dont use the repository revision_tree api because we want
2184
# to supply the inventory.
2185
if inv.revision_id == revision_id:
2186
return revisiontree.InventoryRevisionTree(
2187
self.branch.repository, inv, revision_id)
2188
except errors.BadInventoryFormat:
2189
pass
2190
# raise if there was no inventory, or if we read the wrong inventory.
2191
raise errors.NoSuchRevisionInTree(self, revision_id)
2192
2193
@needs_read_lock
2194
def annotate_iter(self, file_id, default_revision=CURRENT_REVISION):
2195
"""See Tree.annotate_iter
2196
2197
This implementation will use the basis tree implementation if possible.
2198
Lines not in the basis are attributed to CURRENT_REVISION
2199
2200
If there are pending merges, lines added by those merges will be
2201
incorrectly attributed to CURRENT_REVISION (but after committing, the
2202
attribution will be correct).
2203
"""
2204
maybe_file_parent_keys = []
2205
for parent_id in self.get_parent_ids():
2206
try:
2207
parent_tree = self.revision_tree(parent_id)
2208
except errors.NoSuchRevisionInTree:
2209
parent_tree = self.branch.repository.revision_tree(parent_id)
2210
parent_tree.lock_read()
2211
try:
2212
if file_id not in parent_tree:
2213
continue
2214
ie = parent_tree.inventory[file_id]
2215
if ie.kind != 'file':
2216
# Note: this is slightly unnecessary, because symlinks and
2217
# directories have a "text" which is the empty text, and we
2218
# know that won't mess up annotations. But it seems cleaner
2219
continue
2220
parent_text_key = (file_id, ie.revision)
2221
if parent_text_key not in maybe_file_parent_keys:
2222
maybe_file_parent_keys.append(parent_text_key)
2223
finally:
2224
parent_tree.unlock()
2225
graph = _mod_graph.Graph(self.branch.repository.texts)
2226
heads = graph.heads(maybe_file_parent_keys)
2227
file_parent_keys = []
2228
for key in maybe_file_parent_keys:
2229
if key in heads:
2230
file_parent_keys.append(key)
2231
2232
# Now we have the parents of this content
2233
annotator = self.branch.repository.texts.get_annotator()
2234
text = self.get_file_text(file_id)
2235
this_key =(file_id, default_revision)
2236
annotator.add_special_text(this_key, file_parent_keys, text)
2237
annotations = [(key[-1], line)
2238
for key, line in annotator.annotate_flat(this_key)]
2239
return annotations
2240
2241
@needs_read_lock
2242
def merge_modified(self):
2243
"""Return a dictionary of files modified by a merge.
2244
2245
The list is initialized by WorkingTree.set_merge_modified, which is
2246
typically called after we make some automatic updates to the tree
2247
because of a merge.
2248
2249
This returns a map of file_id->sha1, containing only files which are
2250
still in the working inventory and have that text hash.
2251
"""
2252
try:
2253
hashfile = self._transport.get('merge-hashes')
2254
except errors.NoSuchFile:
2255
return {}
2256
try:
2257
merge_hashes = {}
2258
try:
2259
if hashfile.next() != MERGE_MODIFIED_HEADER_1 + '\n':
2260
raise errors.MergeModifiedFormatError()
2261
except StopIteration:
2262
raise errors.MergeModifiedFormatError()
2263
for s in _mod_rio.RioReader(hashfile):
2264
# RioReader reads in Unicode, so convert file_ids back to utf8
2265
file_id = osutils.safe_file_id(s.get("file_id"), warn=False)
2266
if file_id not in self.inventory:
2267
continue
2268
text_hash = s.get("hash")
2269
if text_hash == self.get_file_sha1(file_id):
2270
merge_hashes[file_id] = text_hash
2271
return merge_hashes
2272
finally:
2273
hashfile.close()
2274
2275
@needs_write_lock
2276
def subsume(self, other_tree):
2277
def add_children(inventory, entry):
2278
for child_entry in entry.children.values():
2279
inventory._byid[child_entry.file_id] = child_entry
2280
if child_entry.kind == 'directory':
2281
add_children(inventory, child_entry)
2282
if other_tree.get_root_id() == self.get_root_id():
2283
raise errors.BadSubsumeSource(self, other_tree,
2284
'Trees have the same root')
2285
try:
2286
other_tree_path = self.relpath(other_tree.basedir)
2287
except errors.PathNotChild:
2288
raise errors.BadSubsumeSource(self, other_tree,
2289
'Tree is not contained by the other')
2290
new_root_parent = self.path2id(osutils.dirname(other_tree_path))
2291
if new_root_parent is None:
2292
raise errors.BadSubsumeSource(self, other_tree,
2293
'Parent directory is not versioned.')
2294
# We need to ensure that the result of a fetch will have a
2295
# versionedfile for the other_tree root, and only fetching into
2296
# RepositoryKnit2 guarantees that.
2297
if not self.branch.repository.supports_rich_root():
2298
raise errors.SubsumeTargetNeedsUpgrade(other_tree)
2299
other_tree.lock_tree_write()
2300
try:
2301
new_parents = other_tree.get_parent_ids()
2302
other_root = other_tree.inventory.root
2303
other_root.parent_id = new_root_parent
2304
other_root.name = osutils.basename(other_tree_path)
2305
self.inventory.add(other_root)
2306
add_children(self.inventory, other_root)
2307
self._write_inventory(self.inventory)
2308
# normally we don't want to fetch whole repositories, but i think
2309
# here we really do want to consolidate the whole thing.
2310
for parent_id in other_tree.get_parent_ids():
2311
self.branch.fetch(other_tree.branch, parent_id)
2312
self.add_parent_tree_id(parent_id)
2313
finally:
2314
other_tree.unlock()
2315
other_tree.bzrdir.retire_bzrdir()
2316
2317
@needs_tree_write_lock
2318
def extract(self, file_id, format=None):
2319
"""Extract a subtree from this tree.
2320
2321
A new branch will be created, relative to the path for this tree.
2322
"""
2323
self.flush()
2324
def mkdirs(path):
2325
segments = osutils.splitpath(path)
2326
transport = self.branch.bzrdir.root_transport
2327
for name in segments:
2328
transport = transport.clone(name)
2329
transport.ensure_base()
2330
return transport
2331
2332
sub_path = self.id2path(file_id)
2333
branch_transport = mkdirs(sub_path)
2334
if format is None:
2335
format = self.bzrdir.cloning_metadir()
2336
branch_transport.ensure_base()
2337
branch_bzrdir = format.initialize_on_transport(branch_transport)
2338
try:
2339
repo = branch_bzrdir.find_repository()
2340
except errors.NoRepositoryPresent:
2341
repo = branch_bzrdir.create_repository()
2342
if not repo.supports_rich_root():
2343
raise errors.RootNotRich()
2344
new_branch = branch_bzrdir.create_branch()
2345
new_branch.pull(self.branch)
2346
for parent_id in self.get_parent_ids():
2347
new_branch.fetch(self.branch, parent_id)
2348
tree_transport = self.bzrdir.root_transport.clone(sub_path)
2349
if tree_transport.base != branch_transport.base:
2350
tree_bzrdir = format.initialize_on_transport(tree_transport)
2351
branch.BranchReferenceFormat().initialize(tree_bzrdir,
2352
target_branch=new_branch)
2353
else:
2354
tree_bzrdir = branch_bzrdir
2355
wt = tree_bzrdir.create_workingtree(_mod_revision.NULL_REVISION)
2356
wt.set_parent_ids(self.get_parent_ids())
2357
my_inv = self.inventory
2358
child_inv = inventory.Inventory(root_id=None)
2359
new_root = my_inv[file_id]
2360
my_inv.remove_recursive_id(file_id)
2361
new_root.parent_id = None
2362
child_inv.add(new_root)
2363
self._write_inventory(my_inv)
2364
wt._write_inventory(child_inv)
2365
return wt
2366
2367
def list_files(self, include_root=False, from_dir=None, recursive=True):
2368
"""List all files as (path, class, kind, id, entry).
2369
2370
Lists, but does not descend into unversioned directories.
2371
This does not include files that have been deleted in this
2372
tree. Skips the control directory.
2373
2374
:param include_root: if True, return an entry for the root
2375
:param from_dir: start from this directory or None for the root
2376
:param recursive: whether to recurse into subdirectories or not
2377
"""
2378
# list_files is an iterator, so @needs_read_lock doesn't work properly
2379
# with it. So callers should be careful to always read_lock the tree.
2380
if not self.is_locked():
2381
raise errors.ObjectNotLocked(self)
2382
2383
inv = self.inventory
2384
if from_dir is None and include_root is True:
2385
yield ('', 'V', 'directory', inv.root.file_id, inv.root)
2386
# Convert these into local objects to save lookup times
2387
pathjoin = osutils.pathjoin
2388
file_kind = self._kind
2389
2390
# transport.base ends in a slash, we want the piece
2391
# between the last two slashes
2392
transport_base_dir = self.bzrdir.transport.base.rsplit('/', 2)[1]
2393
2394
fk_entries = {'directory':TreeDirectory, 'file':TreeFile, 'symlink':TreeLink}
2395
2396
# directory file_id, relative path, absolute path, reverse sorted children
2397
if from_dir is not None:
2398
from_dir_id = inv.path2id(from_dir)
2399
if from_dir_id is None:
2400
# Directory not versioned
2401
return
2402
from_dir_abspath = pathjoin(self.basedir, from_dir)
2403
else:
2404
from_dir_id = inv.root.file_id
2405
from_dir_abspath = self.basedir
2406
children = os.listdir(from_dir_abspath)
2407
children.sort()
2408
# jam 20060527 The kernel sized tree seems equivalent whether we
2409
# use a deque and popleft to keep them sorted, or if we use a plain
2410
# list and just reverse() them.
2411
children = collections.deque(children)
2412
stack = [(from_dir_id, u'', from_dir_abspath, children)]
2413
while stack:
2414
from_dir_id, from_dir_relpath, from_dir_abspath, children = stack[-1]
2415
2416
while children:
2417
f = children.popleft()
2418
## TODO: If we find a subdirectory with its own .bzr
2419
## directory, then that is a separate tree and we
2420
## should exclude it.
2421
2422
# the bzrdir for this tree
2423
if transport_base_dir == f:
2424
continue
2425
2426
# we know that from_dir_relpath and from_dir_abspath never end in a slash
2427
# and 'f' doesn't begin with one, we can do a string op, rather
2428
# than the checks of pathjoin(), all relative paths will have an extra slash
2429
# at the beginning
2430
fp = from_dir_relpath + '/' + f
2431
2432
# absolute path
2433
fap = from_dir_abspath + '/' + f
2434
2435
dir_ie = inv[from_dir_id]
2436
if dir_ie.kind == 'directory':
2437
f_ie = dir_ie.children.get(f)
2438
else:
2439
f_ie = None
2440
if f_ie:
2441
c = 'V'
2442
elif self.is_ignored(fp[1:]):
2443
c = 'I'
2444
else:
2445
# we may not have found this file, because of a unicode
2446
# issue, or because the directory was actually a symlink.
2447
f_norm, can_access = osutils.normalized_filename(f)
2448
if f == f_norm or not can_access:
2449
# No change, so treat this file normally
2450
c = '?'
2451
else:
2452
# this file can be accessed by a normalized path
2453
# check again if it is versioned
2454
# these lines are repeated here for performance
2455
f = f_norm
2456
fp = from_dir_relpath + '/' + f
2457
fap = from_dir_abspath + '/' + f
2458
f_ie = inv.get_child(from_dir_id, f)
2459
if f_ie:
2460
c = 'V'
2461
elif self.is_ignored(fp[1:]):
2462
c = 'I'
2463
else:
2464
c = '?'
2465
2466
fk = file_kind(fap)
2467
2468
# make a last minute entry
2469
if f_ie:
2470
yield fp[1:], c, fk, f_ie.file_id, f_ie
2471
else:
2472
try:
2473
yield fp[1:], c, fk, None, fk_entries[fk]()
2474
except KeyError:
2475
yield fp[1:], c, fk, None, TreeEntry()
2476
continue
2477
2478
if fk != 'directory':
2479
continue
2480
2481
# But do this child first if recursing down
2482
if recursive:
2483
new_children = os.listdir(fap)
2484
new_children.sort()
2485
new_children = collections.deque(new_children)
2486
stack.append((f_ie.file_id, fp, fap, new_children))
2487
# Break out of inner loop,
2488
# so that we start outer loop with child
2489
break
2490
else:
2491
# if we finished all children, pop it off the stack
2492
stack.pop()
2493
2494
@needs_tree_write_lock
2495
def move(self, from_paths, to_dir=None, after=False):
2496
"""Rename files.
2497
2498
to_dir must exist in the inventory.
2499
2500
If to_dir exists and is a directory, the files are moved into
2501
it, keeping their old names.
2502
2503
Note that to_dir is only the last component of the new name;
2504
this doesn't change the directory.
2505
2506
For each entry in from_paths the move mode will be determined
2507
independently.
2508
2509
The first mode moves the file in the filesystem and updates the
2510
inventory. The second mode only updates the inventory without
2511
touching the file on the filesystem.
2512
2513
move uses the second mode if 'after == True' and the target is not
2514
versioned but present in the working tree.
2515
2516
move uses the second mode if 'after == False' and the source is
2517
versioned but no longer in the working tree, and the target is not
2518
versioned but present in the working tree.
2519
2520
move uses the first mode if 'after == False' and the source is
2521
versioned and present in the working tree, and the target is not
2522
versioned and not present in the working tree.
2523
2524
Everything else results in an error.
2525
2526
This returns a list of (from_path, to_path) pairs for each
2527
entry that is moved.
2528
"""
2529
rename_entries = []
2530
rename_tuples = []
2531
2532
# check for deprecated use of signature
2533
if to_dir is None:
2534
raise TypeError('You must supply a target directory')
2535
# check destination directory
2536
if isinstance(from_paths, basestring):
2537
raise ValueError()
2538
inv = self.inventory
2539
to_abs = self.abspath(to_dir)
2540
if not isdir(to_abs):
2541
raise errors.BzrMoveFailedError('',to_dir,
2542
errors.NotADirectory(to_abs))
2543
if not self.has_filename(to_dir):
2544
raise errors.BzrMoveFailedError('',to_dir,
2545
errors.NotInWorkingDirectory(to_dir))
2546
to_dir_id = inv.path2id(to_dir)
2547
if to_dir_id is None:
2548
raise errors.BzrMoveFailedError('',to_dir,
2549
errors.NotVersionedError(path=to_dir))
2550
2551
to_dir_ie = inv[to_dir_id]
2552
if to_dir_ie.kind != 'directory':
2553
raise errors.BzrMoveFailedError('',to_dir,
2554
errors.NotADirectory(to_abs))
2555
2556
# create rename entries and tuples
2557
for from_rel in from_paths:
2558
from_tail = splitpath(from_rel)[-1]
2559
from_id = inv.path2id(from_rel)
2560
if from_id is None:
2561
raise errors.BzrMoveFailedError(from_rel,to_dir,
2562
errors.NotVersionedError(path=from_rel))
2563
2564
from_entry = inv[from_id]
2565
from_parent_id = from_entry.parent_id
2566
to_rel = pathjoin(to_dir, from_tail)
2567
rename_entry = InventoryWorkingTree._RenameEntry(
2568
from_rel=from_rel,
2569
from_id=from_id,
2570
from_tail=from_tail,
2571
from_parent_id=from_parent_id,
2572
to_rel=to_rel, to_tail=from_tail,
2573
to_parent_id=to_dir_id)
2574
rename_entries.append(rename_entry)
2575
rename_tuples.append((from_rel, to_rel))
2576
2577
# determine which move mode to use. checks also for movability
2578
rename_entries = self._determine_mv_mode(rename_entries, after)
2579
2580
original_modified = self._inventory_is_modified
2581
try:
2582
if len(from_paths):
2583
self._inventory_is_modified = True
2584
self._move(rename_entries)
2705
def __init__(self, *args, **kwargs):
2706
super(WorkingTree2, self).__init__(*args, **kwargs)
2707
# WorkingTree2 has more of a constraint that self._inventory must
2708
# exist. Because this is an older format, we don't mind the overhead
2709
# caused by the extra computation here.
2710
2711
# Newer WorkingTree's should only have self._inventory set when they
2712
# have a read lock.
2713
if self._inventory is None:
2714
self.read_working_inventory()
2715
2716
def _get_check_refs(self):
2717
"""Return the references needed to perform a check of this tree."""
2718
return [('trees', self.last_revision())]
2719
2720
def lock_tree_write(self):
2721
"""See WorkingTree.lock_tree_write().
2722
2723
In Format2 WorkingTrees we have a single lock for the branch and tree
2724
so lock_tree_write() degrades to lock_write().
2725
2726
:return: An object with an unlock method which will release the lock
2727
obtained.
2728
"""
2729
self.branch.lock_write()
2730
try:
2731
self._control_files.lock_write()
2732
return self
2585
2733
except:
2586
# restore the inventory on error
2587
self._inventory_is_modified = original_modified
2734
self.branch.unlock()
2588
2735
raise
2589
self._write_inventory(inv)
2590
return rename_tuples
2591
2592
@needs_tree_write_lock
2593
def rename_one(self, from_rel, to_rel, after=False):
2594
"""Rename one file.
2595
2596
This can change the directory or the filename or both.
2597
2598
rename_one has several 'modes' to work. First, it can rename a physical
2599
file and change the file_id. That is the normal mode. Second, it can
2600
only change the file_id without touching any physical file.
2601
2602
rename_one uses the second mode if 'after == True' and 'to_rel' is not
2603
versioned but present in the working tree.
2604
2605
rename_one uses the second mode if 'after == False' and 'from_rel' is
2606
versioned but no longer in the working tree, and 'to_rel' is not
2607
versioned but present in the working tree.
2608
2609
rename_one uses the first mode if 'after == False' and 'from_rel' is
2610
versioned and present in the working tree, and 'to_rel' is not
2611
versioned and not present in the working tree.
2612
2613
Everything else results in an error.
2614
"""
2615
inv = self.inventory
2616
rename_entries = []
2617
2618
# create rename entries and tuples
2619
from_tail = splitpath(from_rel)[-1]
2620
from_id = inv.path2id(from_rel)
2621
if from_id is None:
2622
# if file is missing in the inventory maybe it's in the basis_tree
2623
basis_tree = self.branch.basis_tree()
2624
from_id = basis_tree.path2id(from_rel)
2625
if from_id is None:
2626
raise errors.BzrRenameFailedError(from_rel,to_rel,
2627
errors.NotVersionedError(path=from_rel))
2628
# put entry back in the inventory so we can rename it
2629
from_entry = basis_tree.inventory[from_id].copy()
2630
inv.add(from_entry)
2631
else:
2632
from_entry = inv[from_id]
2633
from_parent_id = from_entry.parent_id
2634
to_dir, to_tail = os.path.split(to_rel)
2635
to_dir_id = inv.path2id(to_dir)
2636
rename_entry = InventoryWorkingTree._RenameEntry(from_rel=from_rel,
2637
from_id=from_id,
2638
from_tail=from_tail,
2639
from_parent_id=from_parent_id,
2640
to_rel=to_rel, to_tail=to_tail,
2641
to_parent_id=to_dir_id)
2642
rename_entries.append(rename_entry)
2643
2644
# determine which move mode to use. checks also for movability
2645
rename_entries = self._determine_mv_mode(rename_entries, after)
2646
2647
# check if the target changed directory and if the target directory is
2648
# versioned
2649
if to_dir_id is None:
2650
raise errors.BzrMoveFailedError(from_rel,to_rel,
2651
errors.NotVersionedError(path=to_dir))
2652
2653
# all checks done. now we can continue with our actual work
2654
mutter('rename_one:\n'
2655
' from_id {%s}\n'
2656
' from_rel: %r\n'
2657
' to_rel: %r\n'
2658
' to_dir %r\n'
2659
' to_dir_id {%s}\n',
2660
from_id, from_rel, to_rel, to_dir, to_dir_id)
2661
2662
self._move(rename_entries)
2663
self._write_inventory(inv)
2664
2665
class _RenameEntry(object):
2666
def __init__(self, from_rel, from_id, from_tail, from_parent_id,
2667
to_rel, to_tail, to_parent_id, only_change_inv=False):
2668
self.from_rel = from_rel
2669
self.from_id = from_id
2670
self.from_tail = from_tail
2671
self.from_parent_id = from_parent_id
2672
self.to_rel = to_rel
2673
self.to_tail = to_tail
2674
self.to_parent_id = to_parent_id
2675
self.only_change_inv = only_change_inv
2676
2677
def _determine_mv_mode(self, rename_entries, after=False):
2678
"""Determines for each from-to pair if both inventory and working tree
2679
or only the inventory has to be changed.
2680
2681
Also does basic plausability tests.
2682
"""
2683
inv = self.inventory
2684
2685
for rename_entry in rename_entries:
2686
# store to local variables for easier reference
2687
from_rel = rename_entry.from_rel
2688
from_id = rename_entry.from_id
2689
to_rel = rename_entry.to_rel
2690
to_id = inv.path2id(to_rel)
2691
only_change_inv = False
2692
2693
# check the inventory for source and destination
2694
if from_id is None:
2695
raise errors.BzrMoveFailedError(from_rel,to_rel,
2696
errors.NotVersionedError(path=from_rel))
2697
if to_id is not None:
2698
raise errors.BzrMoveFailedError(from_rel,to_rel,
2699
errors.AlreadyVersionedError(path=to_rel))
2700
2701
# try to determine the mode for rename (only change inv or change
2702
# inv and file system)
2703
if after:
2704
if not self.has_filename(to_rel):
2705
raise errors.BzrMoveFailedError(from_id,to_rel,
2706
errors.NoSuchFile(path=to_rel,
2707
extra="New file has not been created yet"))
2708
only_change_inv = True
2709
elif not self.has_filename(from_rel) and self.has_filename(to_rel):
2710
only_change_inv = True
2711
elif self.has_filename(from_rel) and not self.has_filename(to_rel):
2712
only_change_inv = False
2713
elif (not self.case_sensitive
2714
and from_rel.lower() == to_rel.lower()
2715
and self.has_filename(from_rel)):
2716
only_change_inv = False
2717
else:
2718
# something is wrong, so lets determine what exactly
2719
if not self.has_filename(from_rel) and \
2720
not self.has_filename(to_rel):
2721
raise errors.BzrRenameFailedError(from_rel,to_rel,
2722
errors.PathsDoNotExist(paths=(str(from_rel),
2723
str(to_rel))))
2724
else:
2725
raise errors.RenameFailedFilesExist(from_rel, to_rel)
2726
rename_entry.only_change_inv = only_change_inv
2727
return rename_entries
2728
2729
def _move(self, rename_entries):
2730
"""Moves a list of files.
2731
2732
Depending on the value of the flag 'only_change_inv', the
2733
file will be moved on the file system or not.
2734
"""
2735
inv = self.inventory
2736
moved = []
2737
2738
for entry in rename_entries:
2739
try:
2740
self._move_entry(entry)
2741
except:
2742
self._rollback_move(moved)
2743
raise
2744
moved.append(entry)
2745
2746
def _rollback_move(self, moved):
2747
"""Try to rollback a previous move in case of an filesystem error."""
2748
inv = self.inventory
2749
for entry in moved:
2750
try:
2751
self._move_entry(WorkingTree._RenameEntry(
2752
entry.to_rel, entry.from_id,
2753
entry.to_tail, entry.to_parent_id, entry.from_rel,
2754
entry.from_tail, entry.from_parent_id,
2755
entry.only_change_inv))
2756
except errors.BzrMoveFailedError, e:
2757
raise errors.BzrMoveFailedError( '', '', "Rollback failed."
2758
" The working tree is in an inconsistent state."
2759
" Please consider doing a 'bzr revert'."
2760
" Error message is: %s" % e)
2761
2762
def _move_entry(self, entry):
2763
inv = self.inventory
2764
from_rel_abs = self.abspath(entry.from_rel)
2765
to_rel_abs = self.abspath(entry.to_rel)
2766
if from_rel_abs == to_rel_abs:
2767
raise errors.BzrMoveFailedError(entry.from_rel, entry.to_rel,
2768
"Source and target are identical.")
2769
2770
if not entry.only_change_inv:
2771
try:
2772
osutils.rename(from_rel_abs, to_rel_abs)
2773
except OSError, e:
2774
raise errors.BzrMoveFailedError(entry.from_rel,
2775
entry.to_rel, e[1])
2776
inv.rename(entry.from_id, entry.to_parent_id, entry.to_tail)
2777
2778
@needs_tree_write_lock
2779
def unversion(self, file_ids):
2780
"""Remove the file ids in file_ids from the current versioned set.
2781
2782
When a file_id is unversioned, all of its children are automatically
2783
unversioned.
2784
2785
:param file_ids: The file ids to stop versioning.
2786
:raises: NoSuchId if any fileid is not currently versioned.
2787
"""
2788
for file_id in file_ids:
2789
if file_id not in self._inventory:
2790
raise errors.NoSuchId(self, file_id)
2791
for file_id in file_ids:
2792
if self._inventory.has_id(file_id):
2793
self._inventory.remove_recursive_id(file_id)
2794
if len(file_ids):
2795
# in the future this should just set a dirty bit to wait for the
2796
# final unlock. However, until all methods of workingtree start
2797
# with the current in -memory inventory rather than triggering
2798
# a read, it is more complex - we need to teach read_inventory
2799
# to know when to read, and when to not read first... and possibly
2800
# to save first when the in memory one may be corrupted.
2801
# so for now, we just only write it if it is indeed dirty.
2802
# - RBC 20060907
2803
self._write_inventory(self._inventory)
2804
2805
def stored_kind(self, file_id):
2806
"""See Tree.stored_kind"""
2807
return self.inventory[file_id].kind
2808
2809
def extras(self):
2810
"""Yield all unversioned files in this WorkingTree.
2811
2812
If there are any unversioned directories then only the directory is
2813
returned, not all its children. But if there are unversioned files
2814
under a versioned subdirectory, they are returned.
2815
2816
Currently returned depth-first, sorted by name within directories.
2817
This is the same order used by 'osutils.walkdirs'.
2818
"""
2819
## TODO: Work from given directory downwards
2820
for path, dir_entry in self.inventory.directories():
2821
# mutter("search for unknowns in %r", path)
2822
dirabs = self.abspath(path)
2823
if not isdir(dirabs):
2824
# e.g. directory deleted
2825
continue
2826
2827
fl = []
2828
for subf in os.listdir(dirabs):
2829
if self.bzrdir.is_control_filename(subf):
2830
continue
2831
if subf not in dir_entry.children:
2832
try:
2833
(subf_norm,
2834
can_access) = osutils.normalized_filename(subf)
2835
except UnicodeDecodeError:
2836
path_os_enc = path.encode(osutils._fs_enc)
2837
relpath = path_os_enc + '/' + subf
2838
raise errors.BadFilenameEncoding(relpath,
2839
osutils._fs_enc)
2840
if subf_norm != subf and can_access:
2841
if subf_norm not in dir_entry.children:
2842
fl.append(subf_norm)
2843
else:
2844
fl.append(subf)
2845
2846
fl.sort()
2847
for subf in fl:
2848
subp = pathjoin(path, subf)
2849
yield subp
2850
2851
def _walkdirs(self, prefix=""):
2852
"""Walk the directories of this tree.
2853
2854
:prefix: is used as the directrory to start with.
2855
returns a generator which yields items in the form:
2856
((curren_directory_path, fileid),
2857
[(file1_path, file1_name, file1_kind, None, file1_id,
2858
file1_kind), ... ])
2859
"""
2860
_directory = 'directory'
2861
# get the root in the inventory
2862
inv = self.inventory
2863
top_id = inv.path2id(prefix)
2864
if top_id is None:
2865
pending = []
2866
else:
2867
pending = [(prefix, '', _directory, None, top_id, None)]
2868
while pending:
2869
dirblock = []
2870
currentdir = pending.pop()
2871
# 0 - relpath, 1- basename, 2- kind, 3- stat, 4-id, 5-kind
2872
top_id = currentdir[4]
2873
if currentdir[0]:
2874
relroot = currentdir[0] + '/'
2875
else:
2876
relroot = ""
2877
# FIXME: stash the node in pending
2878
entry = inv[top_id]
2879
if entry.kind == 'directory':
2880
for name, child in entry.sorted_children():
2881
dirblock.append((relroot + name, name, child.kind, None,
2882
child.file_id, child.kind
2883
))
2884
yield (currentdir[0], entry.file_id), dirblock
2885
# push the user specified dirs from dirblock
2886
for dir in reversed(dirblock):
2887
if dir[2] == _directory:
2888
pending.append(dir)
2889
2890
2891
class WorkingTree3(InventoryWorkingTree):
2736
2737
def unlock(self):
2738
# do non-implementation specific cleanup
2739
self._cleanup()
2740
2741
# we share control files:
2742
if self._control_files._lock_count == 3:
2743
# _inventory_is_modified is always False during a read lock.
2744
if self._inventory_is_modified:
2745
self.flush()
2746
self._write_hashcache_if_dirty()
2747
2748
# reverse order of locking.
2749
try:
2750
return self._control_files.unlock()
2751
finally:
2752
self.branch.unlock()
2753
2754
2755
class WorkingTree3(WorkingTree):
2892
2756
"""This is the Format 3 working tree.
2893
2757
2894
2758
This differs from the base WorkingTree by:
2947
2811
raise errors.ConflictFormatError()
2948
2812
except StopIteration:
2949
2813
raise errors.ConflictFormatError()
2950
reader = _mod_rio.RioReader(confile)
2951
return _mod_conflicts.ConflictList.from_stanzas(reader)
2814
return _mod_conflicts.ConflictList.from_stanzas(RioReader(confile))
2952
2815
finally:
2953
2816
confile.close()
2954
2817
2967
2830
self.branch.unlock()
2968
2831
2969
2832
2970
class WorkingTreeFormatRegistry(controldir.ControlComponentFormatRegistry):
2971
"""Registry for working tree formats."""
2972
2973
def __init__(self, other_registry=None):
2974
super(WorkingTreeFormatRegistry, self).__init__(other_registry)
2975
self._default_format = None
2976
2977
def get_default(self):
2978
"""Return the current default format."""
2979
return self._default_format
2980
2981
def set_default(self, format):
2982
self._default_format = format
2983
2984
2985
format_registry = WorkingTreeFormatRegistry()
2986
2987
2988
class WorkingTreeFormat(controldir.ControlComponentFormat):
2833
def get_conflicted_stem(path):
2834
for suffix in _mod_conflicts.CONFLICT_SUFFIXES:
2835
if path.endswith(suffix):
2836
return path[:-len(suffix)]
2837
2838
2839
class WorkingTreeFormat(object):
2989
2840
"""An encapsulation of the initialization and open routines for a format.
2990
2841
2991
2842
Formats provide three things:
3003
2854
object will be created every time regardless.
3004
2855
"""
3005
2856
2857
_default_format = None
2858
"""The default format used for new trees."""
2859
2860
_formats = {}
2861
"""The known formats."""
2862
3006
2863
requires_rich_root = False
3007
2864
3008
2865
upgrade_recommended = False
3009
2866
3010
requires_normalized_unicode_filenames = False
3011
3012
case_sensitive_filename = "FoRMaT"
3013
3014
missing_parent_conflicts = False
3015
"""If this format supports missing parent conflicts."""
3016
3017
2867
@classmethod
3018
2868
def find_format(klass, a_bzrdir):
3019
2869
"""Return the format for the working tree object in a_bzrdir."""
3020
2870
try:
3021
2871
transport = a_bzrdir.get_workingtree_transport(None)
3022
2872
format_string = transport.get_bytes("format")
3023
return format_registry.get(format_string)
2873
return klass._formats[format_string]
3024
2874
except errors.NoSuchFile:
3025
2875
raise errors.NoWorkingTree(base=transport.base)
3026
2876
except KeyError:
3027
2877
raise errors.UnknownFormatError(format=format_string,
3028
2878
kind="working tree")
3029
2879
3030
def initialize(self, a_bzrdir, revision_id=None, from_branch=None,
3031
accelerator_tree=None, hardlink=False):
3032
"""Initialize a new working tree in a_bzrdir.
3033
3034
:param a_bzrdir: BzrDir to initialize the working tree in.
3035
:param revision_id: allows creating a working tree at a different
3036
revision than the branch is at.
3037
:param from_branch: Branch to checkout
3038
:param accelerator_tree: A tree which can be used for retrieving file
3039
contents more quickly than the revision tree, i.e. a workingtree.
3040
The revision tree will be used for cases where accelerator_tree's
3041
content is different.
3042
:param hardlink: If true, hard-link files from accelerator_tree,
3043
where possible.
3044
"""
3045
raise NotImplementedError(self.initialize)
3046
3047
2880
def __eq__(self, other):
3048
2881
return self.__class__ is other.__class__
3049
2882
3051
2884
return not (self == other)
3052
2885
3053
2886
@classmethod
3054
@symbol_versioning.deprecated_method(
3055
symbol_versioning.deprecated_in((2, 4, 0)))
3056
2887
def get_default_format(klass):
3057
2888
"""Return the current default format."""
3058
return format_registry.get_default()
2889
return klass._default_format
3059
2890
3060
2891
def get_format_string(self):
3061
2892
"""Return the ASCII format string that identifies this format."""
3083
2914
return False
3084
2915
3085
2916
@classmethod
3086
@symbol_versioning.deprecated_method(
3087
symbol_versioning.deprecated_in((2, 4, 0)))
3088
2917
def register_format(klass, format):
3089
format_registry.register(format)
3090
3091
@classmethod
3092
@symbol_versioning.deprecated_method(
3093
symbol_versioning.deprecated_in((2, 4, 0)))
3094
def register_extra_format(klass, format):
3095
format_registry.register_extra(format)
3096
3097
@classmethod
3098
@symbol_versioning.deprecated_method(
3099
symbol_versioning.deprecated_in((2, 4, 0)))
3100
def unregister_extra_format(klass, format):
3101
format_registry.unregister_extra(format)
3102
3103
@classmethod
3104
@symbol_versioning.deprecated_method(
3105
symbol_versioning.deprecated_in((2, 4, 0)))
3106
def get_formats(klass):
3107
return format_registry._get_all()
3108
3109
@classmethod
3110
@symbol_versioning.deprecated_method(
3111
symbol_versioning.deprecated_in((2, 4, 0)))
2918
klass._formats[format.get_format_string()] = format
2919
2920
@classmethod
3112
2921
def set_default_format(klass, format):
3113
format_registry.set_default(format)
2922
klass._default_format = format
3114
2923
3115
2924
@classmethod
3116
@symbol_versioning.deprecated_method(
3117
symbol_versioning.deprecated_in((2, 4, 0)))
3118
2925
def unregister_format(klass, format):
3119
format_registry.remove(format)
3120
2926
del klass._formats[format.get_format_string()]
2927
2928
2929
class WorkingTreeFormat2(WorkingTreeFormat):
2930
"""The second working tree format.
2931
2932
This format modified the hash cache from the format 1 hash cache.
2933
"""
2934
2935
upgrade_recommended = True
2936
2937
def get_format_description(self):
2938
"""See WorkingTreeFormat.get_format_description()."""
2939
return "Working tree format 2"
2940
2941
def _stub_initialize_on_transport(self, transport, file_mode):
2942
"""Workaround: create control files for a remote working tree.
2943
2944
This ensures that it can later be updated and dealt with locally,
2945
since BzrDirFormat6 and BzrDirFormat5 cannot represent dirs with
2946
no working tree. (See bug #43064).
2947
"""
2948
sio = StringIO()
2949
inv = inventory.Inventory()
2950
xml5.serializer_v5.write_inventory(inv, sio, working=True)
2951
sio.seek(0)
2952
transport.put_file('inventory', sio, file_mode)
2953
transport.put_bytes('pending-merges', '', file_mode)
2954
2955
def initialize(self, a_bzrdir, revision_id=None, from_branch=None,
2956
accelerator_tree=None, hardlink=False):
2957
"""See WorkingTreeFormat.initialize()."""
2958
if not isinstance(a_bzrdir.transport, LocalTransport):
2959
raise errors.NotLocalUrl(a_bzrdir.transport.base)
2960
if from_branch is not None:
2961
branch = from_branch
2962
else:
2963
branch = a_bzrdir.open_branch()
2964
if revision_id is None:
2965
revision_id = _mod_revision.ensure_null(branch.last_revision())
2966
branch.lock_write()
2967
try:
2968
branch.generate_revision_history(revision_id)
2969
finally:
2970
branch.unlock()
2971
inv = inventory.Inventory()
2972
wt = WorkingTree2(a_bzrdir.root_transport.local_abspath('.'),
2973
branch,
2974
inv,
2975
_internal=True,
2976
_format=self,
2977
_bzrdir=a_bzrdir)
2978
basis_tree = branch.repository.revision_tree(revision_id)
2979
if basis_tree.inventory.root is not None:
2980
wt.set_root_id(basis_tree.get_root_id())
2981
# set the parent list and cache the basis tree.
2982
if _mod_revision.is_null(revision_id):
2983
parent_trees = []
2984
else:
2985
parent_trees = [(revision_id, basis_tree)]
2986
wt.set_parent_trees(parent_trees)
2987
transform.build_tree(basis_tree, wt)
2988
return wt
2989
2990
def __init__(self):
2991
super(WorkingTreeFormat2, self).__init__()
2992
self._matchingbzrdir = bzrdir.BzrDirFormat6()
2993
2994
def open(self, a_bzrdir, _found=False):
2995
"""Return the WorkingTree object for a_bzrdir
2996
2997
_found is a private parameter, do not use it. It is used to indicate
2998
if format probing has already been done.
2999
"""
3000
if not _found:
3001
# we are being called directly and must probe.
3002
raise NotImplementedError
3003
if not isinstance(a_bzrdir.transport, LocalTransport):
3004
raise errors.NotLocalUrl(a_bzrdir.transport.base)
3005
wt = WorkingTree2(a_bzrdir.root_transport.local_abspath('.'),
3006
_internal=True,
3007
_format=self,
3008
_bzrdir=a_bzrdir)
3009
return wt
3121
3010
3122
3011
class WorkingTreeFormat3(WorkingTreeFormat):
3123
3012
"""The second working tree format updated to record a format marker.
3133
3022
3134
3023
upgrade_recommended = True
3135
3024
3136
missing_parent_conflicts = True
3137
3138
3025
def get_format_string(self):
3139
3026
"""See WorkingTreeFormat.get_format_string()."""
3140
3027
return "Bazaar-NG Working Tree format 3"
3253
3140
3254
3141
3255
3142
__default_format = WorkingTreeFormat6()
3256
format_registry.register_lazy("Bazaar Working Tree Format 4 (bzr 0.15)\n",
3257
"bzrlib.workingtree_4", "WorkingTreeFormat4")
3258
format_registry.register_lazy("Bazaar Working Tree Format 5 (bzr 1.11)\n",
3259
"bzrlib.workingtree_4", "WorkingTreeFormat5")
3260
format_registry.register_lazy("Bazaar Working Tree Format 6 (bzr 1.14)\n",
3261
"bzrlib.workingtree_4", "WorkingTreeFormat6")
3262
format_registry.register(WorkingTreeFormat3())
3263
format_registry.set_default(__default_format)
3143
WorkingTreeFormat.register_format(__default_format)
3144
WorkingTreeFormat.register_format(WorkingTreeFormat5())
3145
WorkingTreeFormat.register_format(WorkingTreeFormat4())
3146
WorkingTreeFormat.register_format(WorkingTreeFormat3())
3147
WorkingTreeFormat.set_default_format(__default_format)
3148
# formats which have no format string are not discoverable
3149
# and not independently creatable, so are not registered.
3150
_legacy_formats = [WorkingTreeFormat2(),
3151
]
Loggerhead is a web-based interface for Breezy
Version: 2.0.1