To get this branch, use:
bzr branch
http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar
« back to all changes in this revision
Viewing changes to bzrlib/workingtree.py
- browse files at revision 5755.2.2
- compare with another revision
- compare with revision 1663
- download diff
- download tarball
- view history from revision 5755.2.2
- Committer: John Arbash Meinel
- Date: 2011-05-11 14:15:36 UTC
- mfrom: (5848 +trunk)
- mto: (5755.2.10 2.4-max-entries-gc-602614)
- mto: This revision was merged to the branch mainline in revision 5870.
- Revision ID: john@arbash-meinel.com-20110511141536-mwg3yo304rhpe1nz
Merge bzr.dev 5848, bringing the code up to date.
- files added:
- bzrlib/repofmt/knitpack_repo.py
- files removed:
- bzrlib/deprecated_graph.py
- files renamed:
- bzrlib/tests/per_repository/helpers.py => bzrlib/tests/per_repository_vf/helpers.py
- bzrlib/tests/per_repository/test_add_inventory_by_delta.py => bzrlib/tests/per_repository_vf/test_add_inventory_by_delta.py
- files modified:
- Makefile
added
removed
bzrlib/workingtree.py
44
44
import stat
45
45
import re
46
46
47
import bzrlib
48
47
from bzrlib import (
49
48
branch,
50
49
bzrdir,
51
50
conflicts as _mod_conflicts,
52
51
controldir,
53
52
errors,
53
filters as _mod_filters,
54
54
generate_ids,
55
55
globbing,
56
56
graph as _mod_graph,
58
58
ignores,
59
59
inventory,
60
60
merge,
61
registry,
62
61
revision as _mod_revision,
63
62
revisiontree,
64
trace,
63
rio as _mod_rio,
65
64
transform,
66
65
transport,
67
66
ui,
69
68
xml5,
70
69
xml7,
71
70
)
72
from bzrlib.workingtree_4 import (
73
WorkingTreeFormat4,
74
WorkingTreeFormat5,
75
WorkingTreeFormat6,
76
)
77
71
""")
78
72
79
73
from bzrlib import symbol_versioning
80
74
from bzrlib.decorators import needs_read_lock, needs_write_lock
81
75
from bzrlib.lock import LogicalLockResult
82
from bzrlib.lockable_files import LockableFiles
83
from bzrlib.lockdir import LockDir
84
76
import bzrlib.mutabletree
85
77
from bzrlib.mutabletree import needs_tree_write_lock
86
78
from bzrlib import osutils
94
86
splitpath,
95
87
supports_executable,
96
88
)
97
from bzrlib.filters import filtered_input_file
98
89
from bzrlib.trace import mutter, note
99
from bzrlib.transport.local import LocalTransport
100
90
from bzrlib.revision import CURRENT_REVISION
101
from bzrlib.rio import RioReader, rio_file, Stanza
102
91
from bzrlib.symbol_versioning import (
103
92
deprecated_passed,
104
93
DEPRECATED_PARAMETER,
173
162
controldir.ControlComponent):
174
163
"""Working copy tree.
175
164
176
The inventory is held in the `Branch` working-inventory, and the
177
files are in a directory on disk.
178
179
It is possible for a `WorkingTree` to have a filename which is
180
not listed in the Inventory and vice versa.
181
182
165
:ivar basedir: The root of the tree on disk. This is a unicode path object
183
166
(as opposed to a URL).
184
167
"""
189
172
190
173
def __init__(self, basedir='.',
191
174
branch=DEPRECATED_PARAMETER,
192
_inventory=None,
193
175
_control_files=None,
194
176
_internal=False,
195
177
_format=None,
232
214
mutter("write hc")
233
215
hc.write()
234
216
235
if _inventory is None:
236
# This will be acquired on lock_read() or lock_write()
237
self._inventory_is_modified = False
238
self._inventory = None
239
else:
240
# the caller of __init__ has provided an inventory,
241
# we assume they know what they are doing - as its only
242
# the Format factory and creation methods that are
243
# permitted to do this.
244
self._set_inventory(_inventory, dirty=False)
245
217
self._detect_case_handling()
246
218
self._rules_searcher = None
247
219
self.views = self._make_views()
318
290
def supports_views(self):
319
291
return self.views.supports_views()
320
292
321
def _set_inventory(self, inv, dirty):
322
"""Set the internal cached inventory.
323
324
:param inv: The inventory to set.
325
:param dirty: A boolean indicating whether the inventory is the same
326
logical inventory as whats on disk. If True the inventory is not
327
the same and should be written to disk or data will be lost, if
328
False then the inventory is the same as that on disk and any
329
serialisation would be unneeded overhead.
330
"""
331
self._inventory = inv
332
self._inventory_is_modified = dirty
333
334
293
@staticmethod
335
294
def open(path=None, _unsupported=False):
336
295
"""Open an existing working tree at path.
449
408
list_current=list_current)
450
409
return [tr for tr in iterator if tr is not None]
451
410
452
# should be deprecated - this is slow and in any case treating them as a
453
# container is (we now know) bad style -- mbp 20070302
454
## @deprecated_method(zero_fifteen)
455
def __iter__(self):
456
"""Iterate through file_ids for this tree.
457
458
file_ids are in a WorkingTree if they are in the working inventory
459
and the working file exists.
460
"""
461
inv = self._inventory
462
for path, ie in inv.iter_entries():
463
if osutils.lexists(self.abspath(path)):
464
yield ie.file_id
465
466
411
def all_file_ids(self):
467
412
"""See Tree.iter_all_file_ids"""
468
return set(self.inventory)
413
raise NotImplementedError(self.all_file_ids)
469
414
470
415
def __repr__(self):
471
416
return "<%s of %s>" % (self.__class__.__name__,
526
471
return self.get_file_with_stat(file_id, path, filtered=filtered)[0]
527
472
528
473
def get_file_with_stat(self, file_id, path=None, filtered=True,
529
_fstat=os.fstat):
474
_fstat=osutils.fstat):
530
475
"""See Tree.get_file_with_stat."""
531
476
if path is None:
532
477
path = self.id2path(file_id)
534
479
stat_value = _fstat(file_obj.fileno())
535
480
if filtered and self.supports_content_filtering():
536
481
filters = self._content_filter_stack(path)
537
file_obj = filtered_input_file(file_obj, filters)
482
file_obj = _mod_filters.filtered_input_file(file_obj, filters)
538
483
return (file_obj, stat_value)
539
484
540
485
def get_file_text(self, file_id, path=None, filtered=True):
549
494
f = file(path, 'rb')
550
495
if filtered and self.supports_content_filtering():
551
496
filters = self._content_filter_stack(filename)
552
return filtered_input_file(f, filters)
497
return _mod_filters.filtered_input_file(f, filters)
553
498
else:
554
499
return f
555
500
561
506
finally:
562
507
file.close()
563
508
564
@needs_read_lock
565
def annotate_iter(self, file_id, default_revision=CURRENT_REVISION):
566
"""See Tree.annotate_iter
567
568
This implementation will use the basis tree implementation if possible.
569
Lines not in the basis are attributed to CURRENT_REVISION
570
571
If there are pending merges, lines added by those merges will be
572
incorrectly attributed to CURRENT_REVISION (but after committing, the
573
attribution will be correct).
574
"""
575
maybe_file_parent_keys = []
576
for parent_id in self.get_parent_ids():
577
try:
578
parent_tree = self.revision_tree(parent_id)
579
except errors.NoSuchRevisionInTree:
580
parent_tree = self.branch.repository.revision_tree(parent_id)
581
parent_tree.lock_read()
582
try:
583
if file_id not in parent_tree:
584
continue
585
ie = parent_tree.inventory[file_id]
586
if ie.kind != 'file':
587
# Note: this is slightly unnecessary, because symlinks and
588
# directories have a "text" which is the empty text, and we
589
# know that won't mess up annotations. But it seems cleaner
590
continue
591
parent_text_key = (file_id, ie.revision)
592
if parent_text_key not in maybe_file_parent_keys:
593
maybe_file_parent_keys.append(parent_text_key)
594
finally:
595
parent_tree.unlock()
596
graph = _mod_graph.Graph(self.branch.repository.texts)
597
heads = graph.heads(maybe_file_parent_keys)
598
file_parent_keys = []
599
for key in maybe_file_parent_keys:
600
if key in heads:
601
file_parent_keys.append(key)
602
603
# Now we have the parents of this content
604
annotator = self.branch.repository.texts.get_annotator()
605
text = self.get_file_text(file_id)
606
this_key =(file_id, default_revision)
607
annotator.add_special_text(this_key, file_parent_keys, text)
608
annotations = [(key[-1], line)
609
for key, line in annotator.annotate_flat(this_key)]
610
return annotations
611
612
509
def _get_ancestors(self, default_revision):
613
510
ancestors = set([default_revision])
614
511
for parent_id in self.get_parent_ids():
637
534
parents.append(revision_id)
638
535
return parents
639
536
640
@needs_read_lock
641
537
def get_root_id(self):
642
538
"""Return the id of this trees root"""
643
return self._inventory.root.file_id
644
645
def _get_store_filename(self, file_id):
646
## XXX: badly named; this is not in the store at all
647
return self.abspath(self.id2path(file_id))
539
raise NotImplementedError(self.get_root_id)
648
540
649
541
@needs_read_lock
650
542
def clone(self, to_bzrdir, revision_id=None):
680
572
def id2abspath(self, file_id):
681
573
return self.abspath(self.id2path(file_id))
682
574
683
def has_id(self, file_id):
684
# files that have been deleted are excluded
685
inv = self.inventory
686
if not inv.has_id(file_id):
687
return False
688
path = inv.id2path(file_id)
689
return osutils.lexists(self.abspath(path))
690
691
def has_or_had_id(self, file_id):
692
if file_id == self.inventory.root.file_id:
693
return True
694
return self.inventory.has_id(file_id)
695
696
__contains__ = has_id
575
def _check_for_tree_references(self, iterator):
576
"""See if directories have become tree-references."""
577
blocked_parent_ids = set()
578
for path, ie in iterator:
579
if ie.parent_id in blocked_parent_ids:
580
# This entry was pruned because one of its parents became a
581
# TreeReference. If this is a directory, mark it as blocked.
582
if ie.kind == 'directory':
583
blocked_parent_ids.add(ie.file_id)
584
continue
585
if ie.kind == 'directory' and self._directory_is_tree_reference(path):
586
# This InventoryDirectory needs to be a TreeReference
587
ie = inventory.TreeReference(ie.file_id, ie.name, ie.parent_id)
588
blocked_parent_ids.add(ie.file_id)
589
yield path, ie
590
591
def iter_entries_by_dir(self, specific_file_ids=None, yield_parents=False):
592
"""See Tree.iter_entries_by_dir()"""
593
# The only trick here is that if we supports_tree_reference then we
594
# need to detect if a directory becomes a tree-reference.
595
iterator = super(WorkingTree, self).iter_entries_by_dir(
596
specific_file_ids=specific_file_ids,
597
yield_parents=yield_parents)
598
if not self.supports_tree_reference():
599
return iterator
600
else:
601
return self._check_for_tree_references(iterator)
697
602
698
603
def get_file_size(self, file_id):
699
604
"""See Tree.get_file_size"""
707
612
else:
708
613
return None
709
614
710
@needs_read_lock
711
615
def get_file_sha1(self, file_id, path=None, stat_value=None):
712
if not path:
713
path = self._inventory.id2path(file_id)
714
return self._hashcache.get_sha1(path, stat_value)
715
716
def get_file_mtime(self, file_id, path=None):
717
if not path:
718
path = self.inventory.id2path(file_id)
719
return os.lstat(self.abspath(path)).st_mtime
720
721
def _is_executable_from_path_and_stat_from_basis(self, path, stat_result):
722
file_id = self.path2id(path)
723
if file_id is None:
724
# For unversioned files on win32, we just assume they are not
725
# executable
726
return False
727
return self._inventory[file_id].executable
728
729
def _is_executable_from_path_and_stat_from_stat(self, path, stat_result):
730
mode = stat_result.st_mode
731
return bool(stat.S_ISREG(mode) and stat.S_IEXEC & mode)
732
733
if not supports_executable():
734
def is_executable(self, file_id, path=None):
735
return self._inventory[file_id].executable
736
737
_is_executable_from_path_and_stat = \
738
_is_executable_from_path_and_stat_from_basis
739
else:
740
def is_executable(self, file_id, path=None):
741
if not path:
742
path = self.id2path(file_id)
743
mode = os.lstat(self.abspath(path)).st_mode
744
return bool(stat.S_ISREG(mode) and stat.S_IEXEC & mode)
745
746
_is_executable_from_path_and_stat = \
747
_is_executable_from_path_and_stat_from_stat
748
749
@needs_tree_write_lock
750
def _add(self, files, ids, kinds):
751
"""See MutableTree._add."""
752
# TODO: Re-adding a file that is removed in the working copy
753
# should probably put it back with the previous ID.
754
# the read and write working inventory should not occur in this
755
# function - they should be part of lock_write and unlock.
756
inv = self.inventory
757
for f, file_id, kind in zip(files, ids, kinds):
758
if file_id is None:
759
inv.add_path(f, kind=kind)
760
else:
761
inv.add_path(f, kind=kind, file_id=file_id)
762
self._inventory_is_modified = True
616
# FIXME: Shouldn't this be in Tree?
617
raise NotImplementedError(self.get_file_sha1)
763
618
764
619
@needs_tree_write_lock
765
620
def _gather_kinds(self, files, kinds):
891
746
if revision_id in heads and revision_id not in new_revision_ids:
892
747
new_revision_ids.append(revision_id)
893
748
if new_revision_ids != revision_ids:
894
trace.mutter('requested to set revision_ids = %s,'
749
mutter('requested to set revision_ids = %s,'
895
750
' but filtered to %s', revision_ids, new_revision_ids)
896
751
return new_revision_ids
897
752
923
778
self._set_merges_from_parent_ids(revision_ids)
924
779
925
780
@needs_tree_write_lock
926
def set_parent_trees(self, parents_list, allow_leftmost_as_ghost=False):
927
"""See MutableTree.set_parent_trees."""
928
parent_ids = [rev for (rev, tree) in parents_list]
929
for revision_id in parent_ids:
930
_mod_revision.check_not_reserved_id(revision_id)
931
932
self._check_parents_for_ghosts(parent_ids,
933
allow_leftmost_as_ghost=allow_leftmost_as_ghost)
934
935
parent_ids = self._filter_parent_ids_by_ancestry(parent_ids)
936
937
if len(parent_ids) == 0:
938
leftmost_parent_id = _mod_revision.NULL_REVISION
939
leftmost_parent_tree = None
940
else:
941
leftmost_parent_id, leftmost_parent_tree = parents_list[0]
942
943
if self._change_last_revision(leftmost_parent_id):
944
if leftmost_parent_tree is None:
945
# If we don't have a tree, fall back to reading the
946
# parent tree from the repository.
947
self._cache_basis_inventory(leftmost_parent_id)
948
else:
949
inv = leftmost_parent_tree.inventory
950
xml = self._create_basis_xml_from_inventory(
951
leftmost_parent_id, inv)
952
self._write_basis_inventory(xml)
953
self._set_merges_from_parent_ids(parent_ids)
954
955
@needs_tree_write_lock
956
781
def set_pending_merges(self, rev_list):
957
782
parents = self.get_parent_ids()
958
783
leftmost = parents[:1]
963
788
def set_merge_modified(self, modified_hashes):
964
789
def iter_stanzas():
965
790
for file_id, hash in modified_hashes.iteritems():
966
yield Stanza(file_id=file_id.decode('utf8'), hash=hash)
791
yield _mod_rio.Stanza(file_id=file_id.decode('utf8'),
792
hash=hash)
967
793
self._put_rio('merge-hashes', iter_stanzas(), MERGE_MODIFIED_HEADER_1)
968
794
969
795
def _sha_from_stat(self, path, stat_result):
978
804
979
805
def _put_rio(self, filename, stanzas, header):
980
806
self._must_be_locked()
981
my_file = rio_file(stanzas, header)
807
my_file = _mod_rio.rio_file(stanzas, header)
982
808
self._transport.put_file(filename, my_file,
983
809
mode=self.bzrdir._get_file_mode())
984
810
1026
852
merger.set_pending()
1027
853
return conflicts
1028
854
1029
@needs_read_lock
1030
855
def merge_modified(self):
1031
856
"""Return a dictionary of files modified by a merge.
1032
857
1037
862
This returns a map of file_id->sha1, containing only files which are
1038
863
still in the working inventory and have that text hash.
1039
864
"""
1040
try:
1041
hashfile = self._transport.get('merge-hashes')
1042
except errors.NoSuchFile:
1043
return {}
1044
try:
1045
merge_hashes = {}
1046
try:
1047
if hashfile.next() != MERGE_MODIFIED_HEADER_1 + '\n':
1048
raise errors.MergeModifiedFormatError()
1049
except StopIteration:
1050
raise errors.MergeModifiedFormatError()
1051
for s in RioReader(hashfile):
1052
# RioReader reads in Unicode, so convert file_ids back to utf8
1053
file_id = osutils.safe_file_id(s.get("file_id"), warn=False)
1054
if file_id not in self.inventory:
1055
continue
1056
text_hash = s.get("hash")
1057
if text_hash == self.get_file_sha1(file_id):
1058
merge_hashes[file_id] = text_hash
1059
return merge_hashes
1060
finally:
1061
hashfile.close()
865
raise NotImplementedError(self.merge_modified)
1062
866
1063
867
@needs_write_lock
1064
868
def mkdir(self, path, file_id=None):
1074
878
target = osutils.readlink(abspath)
1075
879
return target
1076
880
1077
@needs_write_lock
1078
881
def subsume(self, other_tree):
1079
def add_children(inventory, entry):
1080
for child_entry in entry.children.values():
1081
inventory._byid[child_entry.file_id] = child_entry
1082
if child_entry.kind == 'directory':
1083
add_children(inventory, child_entry)
1084
if other_tree.get_root_id() == self.get_root_id():
1085
raise errors.BadSubsumeSource(self, other_tree,
1086
'Trees have the same root')
1087
try:
1088
other_tree_path = self.relpath(other_tree.basedir)
1089
except errors.PathNotChild:
1090
raise errors.BadSubsumeSource(self, other_tree,
1091
'Tree is not contained by the other')
1092
new_root_parent = self.path2id(osutils.dirname(other_tree_path))
1093
if new_root_parent is None:
1094
raise errors.BadSubsumeSource(self, other_tree,
1095
'Parent directory is not versioned.')
1096
# We need to ensure that the result of a fetch will have a
1097
# versionedfile for the other_tree root, and only fetching into
1098
# RepositoryKnit2 guarantees that.
1099
if not self.branch.repository.supports_rich_root():
1100
raise errors.SubsumeTargetNeedsUpgrade(other_tree)
1101
other_tree.lock_tree_write()
1102
try:
1103
new_parents = other_tree.get_parent_ids()
1104
other_root = other_tree.inventory.root
1105
other_root.parent_id = new_root_parent
1106
other_root.name = osutils.basename(other_tree_path)
1107
self.inventory.add(other_root)
1108
add_children(self.inventory, other_root)
1109
self._write_inventory(self.inventory)
1110
# normally we don't want to fetch whole repositories, but i think
1111
# here we really do want to consolidate the whole thing.
1112
for parent_id in other_tree.get_parent_ids():
1113
self.branch.fetch(other_tree.branch, parent_id)
1114
self.add_parent_tree_id(parent_id)
1115
finally:
1116
other_tree.unlock()
1117
other_tree.bzrdir.retire_bzrdir()
882
raise NotImplementedError(self.subsume)
1118
883
1119
884
def _setup_directory_is_tree_reference(self):
1120
885
if self._branch.repository._format.supports_tree_reference:
1142
907
# checkout in a subdirectory. This can be avoided by not adding
1143
908
# it. mbp 20070306
1144
909
1145
@needs_tree_write_lock
1146
910
def extract(self, file_id, format=None):
1147
911
"""Extract a subtree from this tree.
1148
912
1149
913
A new branch will be created, relative to the path for this tree.
1150
914
"""
1151
self.flush()
1152
def mkdirs(path):
1153
segments = osutils.splitpath(path)
1154
transport = self.branch.bzrdir.root_transport
1155
for name in segments:
1156
transport = transport.clone(name)
1157
transport.ensure_base()
1158
return transport
1159
1160
sub_path = self.id2path(file_id)
1161
branch_transport = mkdirs(sub_path)
1162
if format is None:
1163
format = self.bzrdir.cloning_metadir()
1164
branch_transport.ensure_base()
1165
branch_bzrdir = format.initialize_on_transport(branch_transport)
1166
try:
1167
repo = branch_bzrdir.find_repository()
1168
except errors.NoRepositoryPresent:
1169
repo = branch_bzrdir.create_repository()
1170
if not repo.supports_rich_root():
1171
raise errors.RootNotRich()
1172
new_branch = branch_bzrdir.create_branch()
1173
new_branch.pull(self.branch)
1174
for parent_id in self.get_parent_ids():
1175
new_branch.fetch(self.branch, parent_id)
1176
tree_transport = self.bzrdir.root_transport.clone(sub_path)
1177
if tree_transport.base != branch_transport.base:
1178
tree_bzrdir = format.initialize_on_transport(tree_transport)
1179
branch.BranchReferenceFormat().initialize(tree_bzrdir,
1180
target_branch=new_branch)
1181
else:
1182
tree_bzrdir = branch_bzrdir
1183
wt = tree_bzrdir.create_workingtree(_mod_revision.NULL_REVISION)
1184
wt.set_parent_ids(self.get_parent_ids())
1185
my_inv = self.inventory
1186
child_inv = inventory.Inventory(root_id=None)
1187
new_root = my_inv[file_id]
1188
my_inv.remove_recursive_id(file_id)
1189
new_root.parent_id = None
1190
child_inv.add(new_root)
1191
self._write_inventory(my_inv)
1192
wt._write_inventory(child_inv)
1193
return wt
1194
1195
def _serialize(self, inventory, out_file):
1196
xml5.serializer_v5.write_inventory(self._inventory, out_file,
1197
working=True)
1198
1199
def _deserialize(selt, in_file):
1200
return xml5.serializer_v5.read_inventory(in_file)
915
raise NotImplementedError(self.extract)
1201
916
1202
917
def flush(self):
1203
"""Write the in memory inventory to disk."""
1204
# TODO: Maybe this should only write on dirty ?
1205
if self._control_files._lock_mode != 'w':
1206
raise errors.NotWriteLocked(self)
1207
sio = StringIO()
1208
self._serialize(self._inventory, sio)
1209
sio.seek(0)
1210
self._transport.put_file('inventory', sio,
1211
mode=self.bzrdir._get_file_mode())
1212
self._inventory_is_modified = False
918
"""Write the in memory meta data to disk."""
919
raise NotImplementedError(self.flush)
1213
920
1214
921
def _kind(self, relpath):
1215
922
return osutils.file_kind(self.abspath(relpath))
1225
932
:param from_dir: start from this directory or None for the root
1226
933
:param recursive: whether to recurse into subdirectories or not
1227
934
"""
1228
# list_files is an iterator, so @needs_read_lock doesn't work properly
1229
# with it. So callers should be careful to always read_lock the tree.
1230
if not self.is_locked():
1231
raise errors.ObjectNotLocked(self)
1232
1233
inv = self.inventory
1234
if from_dir is None and include_root is True:
1235
yield ('', 'V', 'directory', inv.root.file_id, inv.root)
1236
# Convert these into local objects to save lookup times
1237
pathjoin = osutils.pathjoin
1238
file_kind = self._kind
1239
1240
# transport.base ends in a slash, we want the piece
1241
# between the last two slashes
1242
transport_base_dir = self.bzrdir.transport.base.rsplit('/', 2)[1]
1243
1244
fk_entries = {'directory':TreeDirectory, 'file':TreeFile, 'symlink':TreeLink}
1245
1246
# directory file_id, relative path, absolute path, reverse sorted children
1247
if from_dir is not None:
1248
from_dir_id = inv.path2id(from_dir)
1249
if from_dir_id is None:
1250
# Directory not versioned
1251
return
1252
from_dir_abspath = pathjoin(self.basedir, from_dir)
1253
else:
1254
from_dir_id = inv.root.file_id
1255
from_dir_abspath = self.basedir
1256
children = os.listdir(from_dir_abspath)
1257
children.sort()
1258
# jam 20060527 The kernel sized tree seems equivalent whether we
1259
# use a deque and popleft to keep them sorted, or if we use a plain
1260
# list and just reverse() them.
1261
children = collections.deque(children)
1262
stack = [(from_dir_id, u'', from_dir_abspath, children)]
1263
while stack:
1264
from_dir_id, from_dir_relpath, from_dir_abspath, children = stack[-1]
1265
1266
while children:
1267
f = children.popleft()
1268
## TODO: If we find a subdirectory with its own .bzr
1269
## directory, then that is a separate tree and we
1270
## should exclude it.
1271
1272
# the bzrdir for this tree
1273
if transport_base_dir == f:
1274
continue
1275
1276
# we know that from_dir_relpath and from_dir_abspath never end in a slash
1277
# and 'f' doesn't begin with one, we can do a string op, rather
1278
# than the checks of pathjoin(), all relative paths will have an extra slash
1279
# at the beginning
1280
fp = from_dir_relpath + '/' + f
1281
1282
# absolute path
1283
fap = from_dir_abspath + '/' + f
1284
1285
dir_ie = inv[from_dir_id]
1286
if dir_ie.kind == 'directory':
1287
f_ie = dir_ie.children.get(f)
1288
else:
1289
f_ie = None
1290
if f_ie:
1291
c = 'V'
1292
elif self.is_ignored(fp[1:]):
1293
c = 'I'
1294
else:
1295
# we may not have found this file, because of a unicode
1296
# issue, or because the directory was actually a symlink.
1297
f_norm, can_access = osutils.normalized_filename(f)
1298
if f == f_norm or not can_access:
1299
# No change, so treat this file normally
1300
c = '?'
1301
else:
1302
# this file can be accessed by a normalized path
1303
# check again if it is versioned
1304
# these lines are repeated here for performance
1305
f = f_norm
1306
fp = from_dir_relpath + '/' + f
1307
fap = from_dir_abspath + '/' + f
1308
f_ie = inv.get_child(from_dir_id, f)
1309
if f_ie:
1310
c = 'V'
1311
elif self.is_ignored(fp[1:]):
1312
c = 'I'
1313
else:
1314
c = '?'
1315
1316
fk = file_kind(fap)
1317
1318
# make a last minute entry
1319
if f_ie:
1320
yield fp[1:], c, fk, f_ie.file_id, f_ie
1321
else:
1322
try:
1323
yield fp[1:], c, fk, None, fk_entries[fk]()
1324
except KeyError:
1325
yield fp[1:], c, fk, None, TreeEntry()
1326
continue
1327
1328
if fk != 'directory':
1329
continue
1330
1331
# But do this child first if recursing down
1332
if recursive:
1333
new_children = os.listdir(fap)
1334
new_children.sort()
1335
new_children = collections.deque(new_children)
1336
stack.append((f_ie.file_id, fp, fap, new_children))
1337
# Break out of inner loop,
1338
# so that we start outer loop with child
1339
break
1340
else:
1341
# if we finished all children, pop it off the stack
1342
stack.pop()
1343
1344
@needs_tree_write_lock
935
raise NotImplementedError(self.list_files)
936
1345
937
def move(self, from_paths, to_dir=None, after=False):
1346
938
"""Rename files.
1347
939
1348
to_dir must exist in the inventory.
940
to_dir must be known to the working tree.
1349
941
1350
942
If to_dir exists and is a directory, the files are moved into
1351
943
it, keeping their old names.
1357
949
independently.
1358
950
1359
951
The first mode moves the file in the filesystem and updates the
1360
inventory. The second mode only updates the inventory without
1361
touching the file on the filesystem. This is the new mode introduced
1362
in version 0.15.
952
working tree metadata. The second mode only updates the working tree
953
metadata without touching the file on the filesystem.
1363
954
1364
955
move uses the second mode if 'after == True' and the target is not
1365
956
versioned but present in the working tree.
1377
968
This returns a list of (from_path, to_path) pairs for each
1378
969
entry that is moved.
1379
970
"""
1380
rename_entries = []
1381
rename_tuples = []
1382
1383
# check for deprecated use of signature
1384
if to_dir is None:
1385
raise TypeError('You must supply a target directory')
1386
# check destination directory
1387
if isinstance(from_paths, basestring):
1388
raise ValueError()
1389
inv = self.inventory
1390
to_abs = self.abspath(to_dir)
1391
if not isdir(to_abs):
1392
raise errors.BzrMoveFailedError('',to_dir,
1393
errors.NotADirectory(to_abs))
1394
if not self.has_filename(to_dir):
1395
raise errors.BzrMoveFailedError('',to_dir,
1396
errors.NotInWorkingDirectory(to_dir))
1397
to_dir_id = inv.path2id(to_dir)
1398
if to_dir_id is None:
1399
raise errors.BzrMoveFailedError('',to_dir,
1400
errors.NotVersionedError(path=to_dir))
1401
1402
to_dir_ie = inv[to_dir_id]
1403
if to_dir_ie.kind != 'directory':
1404
raise errors.BzrMoveFailedError('',to_dir,
1405
errors.NotADirectory(to_abs))
1406
1407
# create rename entries and tuples
1408
for from_rel in from_paths:
1409
from_tail = splitpath(from_rel)[-1]
1410
from_id = inv.path2id(from_rel)
1411
if from_id is None:
1412
raise errors.BzrMoveFailedError(from_rel,to_dir,
1413
errors.NotVersionedError(path=from_rel))
1414
1415
from_entry = inv[from_id]
1416
from_parent_id = from_entry.parent_id
1417
to_rel = pathjoin(to_dir, from_tail)
1418
rename_entry = WorkingTree._RenameEntry(from_rel=from_rel,
1419
from_id=from_id,
1420
from_tail=from_tail,
1421
from_parent_id=from_parent_id,
1422
to_rel=to_rel, to_tail=from_tail,
1423
to_parent_id=to_dir_id)
1424
rename_entries.append(rename_entry)
1425
rename_tuples.append((from_rel, to_rel))
1426
1427
# determine which move mode to use. checks also for movability
1428
rename_entries = self._determine_mv_mode(rename_entries, after)
1429
1430
original_modified = self._inventory_is_modified
1431
try:
1432
if len(from_paths):
1433
self._inventory_is_modified = True
1434
self._move(rename_entries)
1435
except:
1436
# restore the inventory on error
1437
self._inventory_is_modified = original_modified
1438
raise
1439
self._write_inventory(inv)
1440
return rename_tuples
1441
1442
def _determine_mv_mode(self, rename_entries, after=False):
1443
"""Determines for each from-to pair if both inventory and working tree
1444
or only the inventory has to be changed.
1445
1446
Also does basic plausability tests.
1447
"""
1448
inv = self.inventory
1449
1450
for rename_entry in rename_entries:
1451
# store to local variables for easier reference
1452
from_rel = rename_entry.from_rel
1453
from_id = rename_entry.from_id
1454
to_rel = rename_entry.to_rel
1455
to_id = inv.path2id(to_rel)
1456
only_change_inv = False
1457
1458
# check the inventory for source and destination
1459
if from_id is None:
1460
raise errors.BzrMoveFailedError(from_rel,to_rel,
1461
errors.NotVersionedError(path=from_rel))
1462
if to_id is not None:
1463
raise errors.BzrMoveFailedError(from_rel,to_rel,
1464
errors.AlreadyVersionedError(path=to_rel))
1465
1466
# try to determine the mode for rename (only change inv or change
1467
# inv and file system)
1468
if after:
1469
if not self.has_filename(to_rel):
1470
raise errors.BzrMoveFailedError(from_id,to_rel,
1471
errors.NoSuchFile(path=to_rel,
1472
extra="New file has not been created yet"))
1473
only_change_inv = True
1474
elif not self.has_filename(from_rel) and self.has_filename(to_rel):
1475
only_change_inv = True
1476
elif self.has_filename(from_rel) and not self.has_filename(to_rel):
1477
only_change_inv = False
1478
elif (not self.case_sensitive
1479
and from_rel.lower() == to_rel.lower()
1480
and self.has_filename(from_rel)):
1481
only_change_inv = False
1482
else:
1483
# something is wrong, so lets determine what exactly
1484
if not self.has_filename(from_rel) and \
1485
not self.has_filename(to_rel):
1486
raise errors.BzrRenameFailedError(from_rel,to_rel,
1487
errors.PathsDoNotExist(paths=(str(from_rel),
1488
str(to_rel))))
1489
else:
1490
raise errors.RenameFailedFilesExist(from_rel, to_rel)
1491
rename_entry.only_change_inv = only_change_inv
1492
return rename_entries
1493
1494
def _move(self, rename_entries):
1495
"""Moves a list of files.
1496
1497
Depending on the value of the flag 'only_change_inv', the
1498
file will be moved on the file system or not.
1499
"""
1500
inv = self.inventory
1501
moved = []
1502
1503
for entry in rename_entries:
1504
try:
1505
self._move_entry(entry)
1506
except:
1507
self._rollback_move(moved)
1508
raise
1509
moved.append(entry)
1510
1511
def _rollback_move(self, moved):
1512
"""Try to rollback a previous move in case of an filesystem error."""
1513
inv = self.inventory
1514
for entry in moved:
1515
try:
1516
self._move_entry(WorkingTree._RenameEntry(
1517
entry.to_rel, entry.from_id,
1518
entry.to_tail, entry.to_parent_id, entry.from_rel,
1519
entry.from_tail, entry.from_parent_id,
1520
entry.only_change_inv))
1521
except errors.BzrMoveFailedError, e:
1522
raise errors.BzrMoveFailedError( '', '', "Rollback failed."
1523
" The working tree is in an inconsistent state."
1524
" Please consider doing a 'bzr revert'."
1525
" Error message is: %s" % e)
1526
1527
def _move_entry(self, entry):
1528
inv = self.inventory
1529
from_rel_abs = self.abspath(entry.from_rel)
1530
to_rel_abs = self.abspath(entry.to_rel)
1531
if from_rel_abs == to_rel_abs:
1532
raise errors.BzrMoveFailedError(entry.from_rel, entry.to_rel,
1533
"Source and target are identical.")
1534
1535
if not entry.only_change_inv:
1536
try:
1537
osutils.rename(from_rel_abs, to_rel_abs)
1538
except OSError, e:
1539
raise errors.BzrMoveFailedError(entry.from_rel,
1540
entry.to_rel, e[1])
1541
inv.rename(entry.from_id, entry.to_parent_id, entry.to_tail)
971
raise NotImplementedError(self.move)
1542
972
1543
973
@needs_tree_write_lock
1544
974
def rename_one(self, from_rel, to_rel, after=False):
1548
978
1549
979
rename_one has several 'modes' to work. First, it can rename a physical
1550
980
file and change the file_id. That is the normal mode. Second, it can
1551
only change the file_id without touching any physical file. This is
1552
the new mode introduced in version 0.15.
981
only change the file_id without touching any physical file.
1553
982
1554
983
rename_one uses the second mode if 'after == True' and 'to_rel' is not
1555
984
versioned but present in the working tree.
1564
993
1565
994
Everything else results in an error.
1566
995
"""
1567
inv = self.inventory
1568
rename_entries = []
1569
1570
# create rename entries and tuples
1571
from_tail = splitpath(from_rel)[-1]
1572
from_id = inv.path2id(from_rel)
1573
if from_id is None:
1574
# if file is missing in the inventory maybe it's in the basis_tree
1575
basis_tree = self.branch.basis_tree()
1576
from_id = basis_tree.path2id(from_rel)
1577
if from_id is None:
1578
raise errors.BzrRenameFailedError(from_rel,to_rel,
1579
errors.NotVersionedError(path=from_rel))
1580
# put entry back in the inventory so we can rename it
1581
from_entry = basis_tree.inventory[from_id].copy()
1582
inv.add(from_entry)
1583
else:
1584
from_entry = inv[from_id]
1585
from_parent_id = from_entry.parent_id
1586
to_dir, to_tail = os.path.split(to_rel)
1587
to_dir_id = inv.path2id(to_dir)
1588
rename_entry = WorkingTree._RenameEntry(from_rel=from_rel,
1589
from_id=from_id,
1590
from_tail=from_tail,
1591
from_parent_id=from_parent_id,
1592
to_rel=to_rel, to_tail=to_tail,
1593
to_parent_id=to_dir_id)
1594
rename_entries.append(rename_entry)
1595
1596
# determine which move mode to use. checks also for movability
1597
rename_entries = self._determine_mv_mode(rename_entries, after)
1598
1599
# check if the target changed directory and if the target directory is
1600
# versioned
1601
if to_dir_id is None:
1602
raise errors.BzrMoveFailedError(from_rel,to_rel,
1603
errors.NotVersionedError(path=to_dir))
1604
1605
# all checks done. now we can continue with our actual work
1606
mutter('rename_one:\n'
1607
' from_id {%s}\n'
1608
' from_rel: %r\n'
1609
' to_rel: %r\n'
1610
' to_dir %r\n'
1611
' to_dir_id {%s}\n',
1612
from_id, from_rel, to_rel, to_dir, to_dir_id)
1613
1614
self._move(rename_entries)
1615
self._write_inventory(inv)
1616
1617
class _RenameEntry(object):
1618
def __init__(self, from_rel, from_id, from_tail, from_parent_id,
1619
to_rel, to_tail, to_parent_id, only_change_inv=False):
1620
self.from_rel = from_rel
1621
self.from_id = from_id
1622
self.from_tail = from_tail
1623
self.from_parent_id = from_parent_id
1624
self.to_rel = to_rel
1625
self.to_tail = to_tail
1626
self.to_parent_id = to_parent_id
1627
self.only_change_inv = only_change_inv
996
raise NotImplementedError(self.rename_one)
1628
997
1629
998
@needs_read_lock
1630
999
def unknowns(self):
1638
1007
return iter(
1639
1008
[subp for subp in self.extras() if not self.is_ignored(subp)])
1640
1009
1641
@needs_tree_write_lock
1642
1010
def unversion(self, file_ids):
1643
1011
"""Remove the file ids in file_ids from the current versioned set.
1644
1012
1648
1016
:param file_ids: The file ids to stop versioning.
1649
1017
:raises: NoSuchId if any fileid is not currently versioned.
1650
1018
"""
1651
for file_id in file_ids:
1652
if file_id not in self._inventory:
1653
raise errors.NoSuchId(self, file_id)
1654
for file_id in file_ids:
1655
if self._inventory.has_id(file_id):
1656
self._inventory.remove_recursive_id(file_id)
1657
if len(file_ids):
1658
# in the future this should just set a dirty bit to wait for the
1659
# final unlock. However, until all methods of workingtree start
1660
# with the current in -memory inventory rather than triggering
1661
# a read, it is more complex - we need to teach read_inventory
1662
# to know when to read, and when to not read first... and possibly
1663
# to save first when the in memory one may be corrupted.
1664
# so for now, we just only write it if it is indeed dirty.
1665
# - RBC 20060907
1666
self._write_inventory(self._inventory)
1019
raise NotImplementedError(self.unversion)
1667
1020
1668
1021
@needs_write_lock
1669
1022
def pull(self, source, overwrite=False, stop_revision=None,
1734
1087
Currently returned depth-first, sorted by name within directories.
1735
1088
This is the same order used by 'osutils.walkdirs'.
1736
1089
"""
1737
## TODO: Work from given directory downwards
1738
for path, dir_entry in self.inventory.directories():
1739
# mutter("search for unknowns in %r", path)
1740
dirabs = self.abspath(path)
1741
if not isdir(dirabs):
1742
# e.g. directory deleted
1743
continue
1744
1745
fl = []
1746
for subf in os.listdir(dirabs):
1747
if self.bzrdir.is_control_filename(subf):
1748
continue
1749
if subf not in dir_entry.children:
1750
try:
1751
(subf_norm,
1752
can_access) = osutils.normalized_filename(subf)
1753
except UnicodeDecodeError:
1754
path_os_enc = path.encode(osutils._fs_enc)
1755
relpath = path_os_enc + '/' + subf
1756
raise errors.BadFilenameEncoding(relpath,
1757
osutils._fs_enc)
1758
if subf_norm != subf and can_access:
1759
if subf_norm not in dir_entry.children:
1760
fl.append(subf_norm)
1761
else:
1762
fl.append(subf)
1763
1764
fl.sort()
1765
for subf in fl:
1766
subp = pathjoin(path, subf)
1767
yield subp
1090
raise NotImplementedError(self.extras)
1768
1091
1769
1092
def ignored_files(self):
1770
1093
"""Yield list of PATH, IGNORE_PATTERN"""
1819
1142
1820
1143
def stored_kind(self, file_id):
1821
1144
"""See Tree.stored_kind"""
1822
return self.inventory[file_id].kind
1145
raise NotImplementedError(self.stored_kind)
1823
1146
1824
1147
def _comparison_data(self, entry, path):
1825
1148
abspath = self.abspath(path)
1916
1239
def get_physical_lock_status(self):
1917
1240
return self._control_files.get_physical_lock_status()
1918
1241
1919
def _basis_inventory_name(self):
1920
return 'basis-inventory-cache'
1921
1922
1242
def _reset_data(self):
1923
1243
"""Reset transient data that cannot be revalidated."""
1924
self._inventory_is_modified = False
1925
f = self._transport.get('inventory')
1926
try:
1927
result = self._deserialize(f)
1928
finally:
1929
f.close()
1930
self._set_inventory(result, dirty=False)
1244
raise NotImplementedError(self._reset_data)
1931
1245
1932
@needs_tree_write_lock
1933
1246
def set_last_revision(self, new_revision):
1934
1247
"""Change the last revision in the working tree."""
1935
if self._change_last_revision(new_revision):
1936
self._cache_basis_inventory(new_revision)
1248
raise NotImplementedError(self.set_last_revision)
1937
1249
1938
1250
def _change_last_revision(self, new_revision):
1939
1251
"""Template method part of set_last_revision to perform the change.
1942
1254
when their last revision is set.
1943
1255
"""
1944
1256
if _mod_revision.is_null(new_revision):
1945
self.branch.set_revision_history([])
1257
self.branch.set_last_revision_info(0, new_revision)
1946
1258
return False
1259
_mod_revision.check_not_reserved_id(new_revision)
1947
1260
try:
1948
1261
self.branch.generate_revision_history(new_revision)
1949
1262
except errors.NoSuchRevision:
1950
1263
# not present in the repo - dont try to set it deeper than the tip
1951
self.branch.set_revision_history([new_revision])
1264
self.branch._set_revision_history([new_revision])
1952
1265
return True
1953
1266
1954
def _write_basis_inventory(self, xml):
1955
"""Write the basis inventory XML to the basis-inventory file"""
1956
path = self._basis_inventory_name()
1957
sio = StringIO(xml)
1958
self._transport.put_file(path, sio,
1959
mode=self.bzrdir._get_file_mode())
1960
1961
def _create_basis_xml_from_inventory(self, revision_id, inventory):
1962
"""Create the text that will be saved in basis-inventory"""
1963
inventory.revision_id = revision_id
1964
return xml7.serializer_v7.write_inventory_to_string(inventory)
1965
1966
def _cache_basis_inventory(self, new_revision):
1967
"""Cache new_revision as the basis inventory."""
1968
# TODO: this should allow the ready-to-use inventory to be passed in,
1969
# as commit already has that ready-to-use [while the format is the
1970
# same, that is].
1971
try:
1972
# this double handles the inventory - unpack and repack -
1973
# but is easier to understand. We can/should put a conditional
1974
# in here based on whether the inventory is in the latest format
1975
# - perhaps we should repack all inventories on a repository
1976
# upgrade ?
1977
# the fast path is to copy the raw xml from the repository. If the
1978
# xml contains 'revision_id="', then we assume the right
1979
# revision_id is set. We must check for this full string, because a
1980
# root node id can legitimately look like 'revision_id' but cannot
1981
# contain a '"'.
1982
xml = self.branch.repository._get_inventory_xml(new_revision)
1983
firstline = xml.split('\n', 1)[0]
1984
if (not 'revision_id="' in firstline or
1985
'format="7"' not in firstline):
1986
inv = self.branch.repository._serializer.read_inventory_from_string(
1987
xml, new_revision)
1988
xml = self._create_basis_xml_from_inventory(new_revision, inv)
1989
self._write_basis_inventory(xml)
1990
except (errors.NoSuchRevision, errors.RevisionNotPresent):
1991
pass
1992
1993
def read_basis_inventory(self):
1994
"""Read the cached basis inventory."""
1995
path = self._basis_inventory_name()
1996
return self._transport.get_bytes(path)
1997
1998
@needs_read_lock
1999
def read_working_inventory(self):
2000
"""Read the working inventory.
2001
2002
:raises errors.InventoryModified: read_working_inventory will fail
2003
when the current in memory inventory has been modified.
2004
"""
2005
# conceptually this should be an implementation detail of the tree.
2006
# XXX: Deprecate this.
2007
# ElementTree does its own conversion from UTF-8, so open in
2008
# binary.
2009
if self._inventory_is_modified:
2010
raise errors.InventoryModified(self)
2011
f = self._transport.get('inventory')
2012
try:
2013
result = self._deserialize(f)
2014
finally:
2015
f.close()
2016
self._set_inventory(result, dirty=False)
2017
return result
2018
2019
1267
@needs_tree_write_lock
2020
1268
def remove(self, files, verbose=False, to_file=None, keep_files=True,
2021
1269
force=False):
2022
"""Remove nominated files from the working inventory.
1270
"""Remove nominated files from the working tree metadata.
2023
1271
2024
1272
:files: File paths relative to the basedir.
2025
1273
:keep_files: If true, the files will also be kept.
2090
1338
backup_name)
2091
1339
2092
1340
# Build inv_delta and delete files where applicable,
2093
# do this before any modifications to inventory.
1341
# do this before any modifications to meta data.
2094
1342
for f in files:
2095
1343
fid = self.path2id(f)
2096
1344
message = None
2176
1424
WorkingTree can supply revision_trees for the basis revision only
2177
1425
because there is only one cached inventory in the bzr directory.
2178
1426
"""
2179
if revision_id == self.last_revision():
2180
try:
2181
xml = self.read_basis_inventory()
2182
except errors.NoSuchFile:
2183
pass
2184
else:
2185
try:
2186
inv = xml7.serializer_v7.read_inventory_from_string(xml)
2187
# dont use the repository revision_tree api because we want
2188
# to supply the inventory.
2189
if inv.revision_id == revision_id:
2190
return revisiontree.RevisionTree(self.branch.repository,
2191
inv, revision_id)
2192
except errors.BadInventoryFormat:
2193
pass
2194
# raise if there was no inventory, or if we read the wrong inventory.
2195
raise errors.NoSuchRevisionInTree(self, revision_id)
2196
2197
# XXX: This method should be deprecated in favour of taking in a proper
2198
# new Inventory object.
2199
@needs_tree_write_lock
2200
def set_inventory(self, new_inventory_list):
2201
from bzrlib.inventory import (Inventory,
2202
InventoryDirectory,
2203
InventoryFile,
2204
InventoryLink)
2205
inv = Inventory(self.get_root_id())
2206
for path, file_id, parent, kind in new_inventory_list:
2207
name = os.path.basename(path)
2208
if name == "":
2209
continue
2210
# fixme, there should be a factory function inv,add_??
2211
if kind == 'directory':
2212
inv.add(InventoryDirectory(file_id, name, parent))
2213
elif kind == 'file':
2214
inv.add(InventoryFile(file_id, name, parent))
2215
elif kind == 'symlink':
2216
inv.add(InventoryLink(file_id, name, parent))
2217
else:
2218
raise errors.BzrError("unknown kind %r" % kind)
2219
self._write_inventory(inv)
1427
raise NotImplementedError(self.revision_tree)
2220
1428
2221
1429
@needs_tree_write_lock
2222
1430
def set_root_id(self, file_id):
2235
1443
present in the current inventory or an error will occur. It must
2236
1444
not be None, but rather a valid file id.
2237
1445
"""
2238
inv = self._inventory
2239
orig_root_id = inv.root.file_id
2240
# TODO: it might be nice to exit early if there was nothing
2241
# to do, saving us from trigger a sync on unlock.
2242
self._inventory_is_modified = True
2243
# we preserve the root inventory entry object, but
2244
# unlinkit from the byid index
2245
del inv._byid[inv.root.file_id]
2246
inv.root.file_id = file_id
2247
# and link it into the index with the new changed id.
2248
inv._byid[inv.root.file_id] = inv.root
2249
# and finally update all children to reference the new id.
2250
# XXX: this should be safe to just look at the root.children
2251
# list, not the WHOLE INVENTORY.
2252
for fid in inv:
2253
entry = inv[fid]
2254
if entry.parent_id == orig_root_id:
2255
entry.parent_id = inv.root.file_id
1446
raise NotImplementedError(self._set_root_id)
2256
1447
2257
1448
def unlock(self):
2258
1449
"""See Branch.unlock.
2354
1545
show_base=show_base)
2355
1546
if nb_conflicts:
2356
1547
self.add_parent_tree((old_tip, other_tree))
2357
trace.note('Rerun update after fixing the conflicts.')
1548
note('Rerun update after fixing the conflicts.')
2358
1549
return nb_conflicts
2359
1550
2360
1551
if last_rev != _mod_revision.ensure_null(revision):
2366
1557
basis = self.basis_tree()
2367
1558
basis.lock_read()
2368
1559
try:
2369
if (basis.inventory.root is None
2370
or basis.inventory.root.file_id != to_root_id):
1560
if (basis.get_root_id() is None or basis.get_root_id() != to_root_id):
2371
1561
self.set_root_id(to_root_id)
2372
1562
self.flush()
2373
1563
finally:
2415
1605
# warning might be sufficient to let the user know what
2416
1606
# is going on.
2417
1607
mutter('Could not write hashcache for %s\nError: %s',
2418
self._hashcache.cache_file_name(), e)
2419
2420
@needs_tree_write_lock
2421
def _write_inventory(self, inv):
2422
"""Write inventory as the current inventory."""
2423
self._set_inventory(inv, dirty=True)
2424
self.flush()
1608
self._hashcache.cache_file_name(), e)
2425
1609
2426
1610
def set_conflicts(self, arg):
2427
1611
raise errors.UnsupportedOperation(self.set_conflicts, self)
2562
1746
[(file1_path, file1_name, file1_kind, None, file1_id,
2563
1747
file1_kind), ... ])
2564
1748
"""
2565
_directory = 'directory'
2566
# get the root in the inventory
2567
inv = self.inventory
2568
top_id = inv.path2id(prefix)
2569
if top_id is None:
2570
pending = []
2571
else:
2572
pending = [(prefix, '', _directory, None, top_id, None)]
2573
while pending:
2574
dirblock = []
2575
currentdir = pending.pop()
2576
# 0 - relpath, 1- basename, 2- kind, 3- stat, 4-id, 5-kind
2577
top_id = currentdir[4]
2578
if currentdir[0]:
2579
relroot = currentdir[0] + '/'
2580
else:
2581
relroot = ""
2582
# FIXME: stash the node in pending
2583
entry = inv[top_id]
2584
if entry.kind == 'directory':
2585
for name, child in entry.sorted_children():
2586
dirblock.append((relroot + name, name, child.kind, None,
2587
child.file_id, child.kind
2588
))
2589
yield (currentdir[0], entry.file_id), dirblock
2590
# push the user specified dirs from dirblock
2591
for dir in reversed(dirblock):
2592
if dir[2] == _directory:
2593
pending.append(dir)
1749
raise NotImplementedError(self._walkdirs)
2594
1750
2595
1751
@needs_tree_write_lock
2596
1752
def auto_resolve(self):
2665
1821
refs[ref] = self.branch.repository.revision_tree(value)
2666
1822
self._check(refs)
2667
1823
2668
@needs_tree_write_lock
2669
1824
def reset_state(self, revision_ids=None):
2670
1825
"""Reset the state of the working tree.
2671
1826
2672
1827
This does a hard-reset to a last-known-good state. This is a way to
2673
1828
fix if something got corrupted (like the .bzr/checkout/dirstate file)
2674
1829
"""
2675
if revision_ids is None:
2676
revision_ids = self.get_parent_ids()
2677
if not revision_ids:
2678
rt = self.branch.repository.revision_tree(
2679
_mod_revision.NULL_REVISION)
2680
else:
2681
rt = self.branch.repository.revision_tree(revision_ids[0])
2682
self._write_inventory(rt.inventory)
2683
self.set_parent_ids(revision_ids)
1830
raise NotImplementedError(self.reset_state)
2684
1831
2685
1832
def _get_rules_searcher(self, default_searcher):
2686
1833
"""See Tree._get_rules_searcher."""
2695
1842
return ShelfManager(self, self._transport)
2696
1843
2697
1844
2698
class WorkingTree3(WorkingTree):
2699
"""This is the Format 3 working tree.
2700
2701
This differs from the base WorkingTree by:
2702
- having its own file lock
2703
- having its own last-revision property.
2704
2705
This is new in bzr 0.8
1845
class InventoryWorkingTree(WorkingTree,
1846
bzrlib.mutabletree.MutableInventoryTree):
1847
"""Base class for working trees that are inventory-oriented.
1848
1849
The inventory is held in the `Branch` working-inventory, and the
1850
files are in a directory on disk.
1851
1852
It is possible for a `WorkingTree` to have a filename which is
1853
not listed in the Inventory and vice versa.
2706
1854
"""
2707
1855
2708
@needs_read_lock
2709
def _last_revision(self):
2710
"""See Mutable.last_revision."""
2711
try:
2712
return self._transport.get_bytes('last-revision')
2713
except errors.NoSuchFile:
2714
return _mod_revision.NULL_REVISION
2715
2716
def _change_last_revision(self, revision_id):
2717
"""See WorkingTree._change_last_revision."""
2718
if revision_id is None or revision_id == _mod_revision.NULL_REVISION:
2719
try:
2720
self._transport.delete('last-revision')
2721
except errors.NoSuchFile:
2722
pass
2723
return False
2724
else:
2725
self._transport.put_bytes('last-revision', revision_id,
2726
mode=self.bzrdir._get_file_mode())
2727
return True
2728
2729
def _get_check_refs(self):
2730
"""Return the references needed to perform a check of this tree."""
2731
return [('trees', self.last_revision())]
1856
def __init__(self, basedir='.',
1857
branch=DEPRECATED_PARAMETER,
1858
_inventory=None,
1859
_control_files=None,
1860
_internal=False,
1861
_format=None,
1862
_bzrdir=None):
1863
"""Construct a InventoryWorkingTree instance. This is not a public API.
1864
1865
:param branch: A branch to override probing for the branch.
1866
"""
1867
super(InventoryWorkingTree, self).__init__(basedir=basedir,
1868
branch=branch, _control_files=_control_files, _internal=_internal,
1869
_format=_format, _bzrdir=_bzrdir)
1870
1871
if _inventory is None:
1872
# This will be acquired on lock_read() or lock_write()
1873
self._inventory_is_modified = False
1874
self._inventory = None
1875
else:
1876
# the caller of __init__ has provided an inventory,
1877
# we assume they know what they are doing - as its only
1878
# the Format factory and creation methods that are
1879
# permitted to do this.
1880
self._set_inventory(_inventory, dirty=False)
1881
1882
def _set_inventory(self, inv, dirty):
1883
"""Set the internal cached inventory.
1884
1885
:param inv: The inventory to set.
1886
:param dirty: A boolean indicating whether the inventory is the same
1887
logical inventory as whats on disk. If True the inventory is not
1888
the same and should be written to disk or data will be lost, if
1889
False then the inventory is the same as that on disk and any
1890
serialisation would be unneeded overhead.
1891
"""
1892
self._inventory = inv
1893
self._inventory_is_modified = dirty
1894
1895
def _serialize(self, inventory, out_file):
1896
xml5.serializer_v5.write_inventory(self._inventory, out_file,
1897
working=True)
1898
1899
def _deserialize(selt, in_file):
1900
return xml5.serializer_v5.read_inventory(in_file)
1901
1902
@needs_tree_write_lock
1903
def _write_inventory(self, inv):
1904
"""Write inventory as the current inventory."""
1905
self._set_inventory(inv, dirty=True)
1906
self.flush()
1907
1908
# XXX: This method should be deprecated in favour of taking in a proper
1909
# new Inventory object.
1910
@needs_tree_write_lock
1911
def set_inventory(self, new_inventory_list):
1912
from bzrlib.inventory import (Inventory,
1913
InventoryDirectory,
1914
InventoryFile,
1915
InventoryLink)
1916
inv = Inventory(self.get_root_id())
1917
for path, file_id, parent, kind in new_inventory_list:
1918
name = os.path.basename(path)
1919
if name == "":
1920
continue
1921
# fixme, there should be a factory function inv,add_??
1922
if kind == 'directory':
1923
inv.add(InventoryDirectory(file_id, name, parent))
1924
elif kind == 'file':
1925
inv.add(InventoryFile(file_id, name, parent))
1926
elif kind == 'symlink':
1927
inv.add(InventoryLink(file_id, name, parent))
1928
else:
1929
raise errors.BzrError("unknown kind %r" % kind)
1930
self._write_inventory(inv)
1931
1932
def _write_basis_inventory(self, xml):
1933
"""Write the basis inventory XML to the basis-inventory file"""
1934
path = self._basis_inventory_name()
1935
sio = StringIO(xml)
1936
self._transport.put_file(path, sio,
1937
mode=self.bzrdir._get_file_mode())
1938
1939
def _reset_data(self):
1940
"""Reset transient data that cannot be revalidated."""
1941
self._inventory_is_modified = False
1942
f = self._transport.get('inventory')
1943
try:
1944
result = self._deserialize(f)
1945
finally:
1946
f.close()
1947
self._set_inventory(result, dirty=False)
1948
1949
def _set_root_id(self, file_id):
1950
"""Set the root id for this tree, in a format specific manner.
1951
1952
:param file_id: The file id to assign to the root. It must not be
1953
present in the current inventory or an error will occur. It must
1954
not be None, but rather a valid file id.
1955
"""
1956
inv = self._inventory
1957
orig_root_id = inv.root.file_id
1958
# TODO: it might be nice to exit early if there was nothing
1959
# to do, saving us from trigger a sync on unlock.
1960
self._inventory_is_modified = True
1961
# we preserve the root inventory entry object, but
1962
# unlinkit from the byid index
1963
del inv._byid[inv.root.file_id]
1964
inv.root.file_id = file_id
1965
# and link it into the index with the new changed id.
1966
inv._byid[inv.root.file_id] = inv.root
1967
# and finally update all children to reference the new id.
1968
# XXX: this should be safe to just look at the root.children
1969
# list, not the WHOLE INVENTORY.
1970
for fid in inv:
1971
entry = inv[fid]
1972
if entry.parent_id == orig_root_id:
1973
entry.parent_id = inv.root.file_id
1974
1975
def all_file_ids(self):
1976
"""See Tree.iter_all_file_ids"""
1977
return set(self.inventory)
1978
1979
@needs_tree_write_lock
1980
def set_parent_trees(self, parents_list, allow_leftmost_as_ghost=False):
1981
"""See MutableTree.set_parent_trees."""
1982
parent_ids = [rev for (rev, tree) in parents_list]
1983
for revision_id in parent_ids:
1984
_mod_revision.check_not_reserved_id(revision_id)
1985
1986
self._check_parents_for_ghosts(parent_ids,
1987
allow_leftmost_as_ghost=allow_leftmost_as_ghost)
1988
1989
parent_ids = self._filter_parent_ids_by_ancestry(parent_ids)
1990
1991
if len(parent_ids) == 0:
1992
leftmost_parent_id = _mod_revision.NULL_REVISION
1993
leftmost_parent_tree = None
1994
else:
1995
leftmost_parent_id, leftmost_parent_tree = parents_list[0]
1996
1997
if self._change_last_revision(leftmost_parent_id):
1998
if leftmost_parent_tree is None:
1999
# If we don't have a tree, fall back to reading the
2000
# parent tree from the repository.
2001
self._cache_basis_inventory(leftmost_parent_id)
2002
else:
2003
inv = leftmost_parent_tree.inventory
2004
xml = self._create_basis_xml_from_inventory(
2005
leftmost_parent_id, inv)
2006
self._write_basis_inventory(xml)
2007
self._set_merges_from_parent_ids(parent_ids)
2008
2009
def _cache_basis_inventory(self, new_revision):
2010
"""Cache new_revision as the basis inventory."""
2011
# TODO: this should allow the ready-to-use inventory to be passed in,
2012
# as commit already has that ready-to-use [while the format is the
2013
# same, that is].
2014
try:
2015
# this double handles the inventory - unpack and repack -
2016
# but is easier to understand. We can/should put a conditional
2017
# in here based on whether the inventory is in the latest format
2018
# - perhaps we should repack all inventories on a repository
2019
# upgrade ?
2020
# the fast path is to copy the raw xml from the repository. If the
2021
# xml contains 'revision_id="', then we assume the right
2022
# revision_id is set. We must check for this full string, because a
2023
# root node id can legitimately look like 'revision_id' but cannot
2024
# contain a '"'.
2025
xml = self.branch.repository._get_inventory_xml(new_revision)
2026
firstline = xml.split('\n', 1)[0]
2027
if (not 'revision_id="' in firstline or
2028
'format="7"' not in firstline):
2029
inv = self.branch.repository._serializer.read_inventory_from_string(
2030
xml, new_revision)
2031
xml = self._create_basis_xml_from_inventory(new_revision, inv)
2032
self._write_basis_inventory(xml)
2033
except (errors.NoSuchRevision, errors.RevisionNotPresent):
2034
pass
2035
2036
def _basis_inventory_name(self):
2037
return 'basis-inventory-cache'
2038
2039
def _create_basis_xml_from_inventory(self, revision_id, inventory):
2040
"""Create the text that will be saved in basis-inventory"""
2041
inventory.revision_id = revision_id
2042
return xml7.serializer_v7.write_inventory_to_string(inventory)
2732
2043
2733
2044
@needs_tree_write_lock
2734
2045
def set_conflicts(self, conflicts):
2754
2065
raise errors.ConflictFormatError()
2755
2066
except StopIteration:
2756
2067
raise errors.ConflictFormatError()
2757
return _mod_conflicts.ConflictList.from_stanzas(RioReader(confile))
2068
reader = _mod_rio.RioReader(confile)
2069
return _mod_conflicts.ConflictList.from_stanzas(reader)
2758
2070
finally:
2759
2071
confile.close()
2760
2072
2761
def unlock(self):
2762
# do non-implementation specific cleanup
2763
self._cleanup()
2764
if self._control_files._lock_count == 1:
2765
# _inventory_is_modified is always False during a read lock.
2766
if self._inventory_is_modified:
2767
self.flush()
2768
self._write_hashcache_if_dirty()
2769
# reverse order of locking.
2770
try:
2771
return self._control_files.unlock()
2772
finally:
2773
self.branch.unlock()
2073
def read_basis_inventory(self):
2074
"""Read the cached basis inventory."""
2075
path = self._basis_inventory_name()
2076
return self._transport.get_bytes(path)
2077
2078
@needs_read_lock
2079
def read_working_inventory(self):
2080
"""Read the working inventory.
2081
2082
:raises errors.InventoryModified: read_working_inventory will fail
2083
when the current in memory inventory has been modified.
2084
"""
2085
# conceptually this should be an implementation detail of the tree.
2086
# XXX: Deprecate this.
2087
# ElementTree does its own conversion from UTF-8, so open in
2088
# binary.
2089
if self._inventory_is_modified:
2090
raise errors.InventoryModified(self)
2091
f = self._transport.get('inventory')
2092
try:
2093
result = self._deserialize(f)
2094
finally:
2095
f.close()
2096
self._set_inventory(result, dirty=False)
2097
return result
2098
2099
@needs_read_lock
2100
def get_root_id(self):
2101
"""Return the id of this trees root"""
2102
return self._inventory.root.file_id
2103
2104
def has_id(self, file_id):
2105
# files that have been deleted are excluded
2106
inv = self.inventory
2107
if not inv.has_id(file_id):
2108
return False
2109
path = inv.id2path(file_id)
2110
return osutils.lexists(self.abspath(path))
2111
2112
def has_or_had_id(self, file_id):
2113
if file_id == self.inventory.root.file_id:
2114
return True
2115
return self.inventory.has_id(file_id)
2116
2117
__contains__ = has_id
2118
2119
@symbol_versioning.deprecated_method(symbol_versioning.deprecated_in((2, 4, 0)))
2120
def __iter__(self):
2121
"""Iterate through file_ids for this tree.
2122
2123
file_ids are in a WorkingTree if they are in the working inventory
2124
and the working file exists.
2125
"""
2126
inv = self._inventory
2127
for path, ie in inv.iter_entries():
2128
if osutils.lexists(self.abspath(path)):
2129
yield ie.file_id
2130
2131
@needs_tree_write_lock
2132
def set_last_revision(self, new_revision):
2133
"""Change the last revision in the working tree."""
2134
if self._change_last_revision(new_revision):
2135
self._cache_basis_inventory(new_revision)
2136
2137
@needs_tree_write_lock
2138
def reset_state(self, revision_ids=None):
2139
"""Reset the state of the working tree.
2140
2141
This does a hard-reset to a last-known-good state. This is a way to
2142
fix if something got corrupted (like the .bzr/checkout/dirstate file)
2143
"""
2144
if revision_ids is None:
2145
revision_ids = self.get_parent_ids()
2146
if not revision_ids:
2147
rt = self.branch.repository.revision_tree(
2148
_mod_revision.NULL_REVISION)
2149
else:
2150
rt = self.branch.repository.revision_tree(revision_ids[0])
2151
self._write_inventory(rt.inventory)
2152
self.set_parent_ids(revision_ids)
2153
2154
def flush(self):
2155
"""Write the in memory inventory to disk."""
2156
# TODO: Maybe this should only write on dirty ?
2157
if self._control_files._lock_mode != 'w':
2158
raise errors.NotWriteLocked(self)
2159
sio = StringIO()
2160
self._serialize(self._inventory, sio)
2161
sio.seek(0)
2162
self._transport.put_file('inventory', sio,
2163
mode=self.bzrdir._get_file_mode())
2164
self._inventory_is_modified = False
2165
2166
@needs_read_lock
2167
def get_file_sha1(self, file_id, path=None, stat_value=None):
2168
if not path:
2169
path = self._inventory.id2path(file_id)
2170
return self._hashcache.get_sha1(path, stat_value)
2171
2172
def get_file_mtime(self, file_id, path=None):
2173
"""See Tree.get_file_mtime."""
2174
if not path:
2175
path = self.inventory.id2path(file_id)
2176
return os.lstat(self.abspath(path)).st_mtime
2177
2178
def _is_executable_from_path_and_stat_from_basis(self, path, stat_result):
2179
file_id = self.path2id(path)
2180
if file_id is None:
2181
# For unversioned files on win32, we just assume they are not
2182
# executable
2183
return False
2184
return self._inventory[file_id].executable
2185
2186
def _is_executable_from_path_and_stat_from_stat(self, path, stat_result):
2187
mode = stat_result.st_mode
2188
return bool(stat.S_ISREG(mode) and stat.S_IEXEC & mode)
2189
2190
if not supports_executable():
2191
def is_executable(self, file_id, path=None):
2192
return self._inventory[file_id].executable
2193
2194
_is_executable_from_path_and_stat = \
2195
_is_executable_from_path_and_stat_from_basis
2196
else:
2197
def is_executable(self, file_id, path=None):
2198
if not path:
2199
path = self.id2path(file_id)
2200
mode = os.lstat(self.abspath(path)).st_mode
2201
return bool(stat.S_ISREG(mode) and stat.S_IEXEC & mode)
2202
2203
_is_executable_from_path_and_stat = \
2204
_is_executable_from_path_and_stat_from_stat
2205
2206
@needs_tree_write_lock
2207
def _add(self, files, ids, kinds):
2208
"""See MutableTree._add."""
2209
# TODO: Re-adding a file that is removed in the working copy
2210
# should probably put it back with the previous ID.
2211
# the read and write working inventory should not occur in this
2212
# function - they should be part of lock_write and unlock.
2213
inv = self.inventory
2214
for f, file_id, kind in zip(files, ids, kinds):
2215
if file_id is None:
2216
inv.add_path(f, kind=kind)
2217
else:
2218
inv.add_path(f, kind=kind, file_id=file_id)
2219
self._inventory_is_modified = True
2220
2221
def revision_tree(self, revision_id):
2222
"""See WorkingTree.revision_id."""
2223
if revision_id == self.last_revision():
2224
try:
2225
xml = self.read_basis_inventory()
2226
except errors.NoSuchFile:
2227
pass
2228
else:
2229
try:
2230
inv = xml7.serializer_v7.read_inventory_from_string(xml)
2231
# dont use the repository revision_tree api because we want
2232
# to supply the inventory.
2233
if inv.revision_id == revision_id:
2234
return revisiontree.InventoryRevisionTree(
2235
self.branch.repository, inv, revision_id)
2236
except errors.BadInventoryFormat:
2237
pass
2238
# raise if there was no inventory, or if we read the wrong inventory.
2239
raise errors.NoSuchRevisionInTree(self, revision_id)
2240
2241
@needs_read_lock
2242
def annotate_iter(self, file_id, default_revision=CURRENT_REVISION):
2243
"""See Tree.annotate_iter
2244
2245
This implementation will use the basis tree implementation if possible.
2246
Lines not in the basis are attributed to CURRENT_REVISION
2247
2248
If there are pending merges, lines added by those merges will be
2249
incorrectly attributed to CURRENT_REVISION (but after committing, the
2250
attribution will be correct).
2251
"""
2252
maybe_file_parent_keys = []
2253
for parent_id in self.get_parent_ids():
2254
try:
2255
parent_tree = self.revision_tree(parent_id)
2256
except errors.NoSuchRevisionInTree:
2257
parent_tree = self.branch.repository.revision_tree(parent_id)
2258
parent_tree.lock_read()
2259
try:
2260
if file_id not in parent_tree:
2261
continue
2262
ie = parent_tree.inventory[file_id]
2263
if ie.kind != 'file':
2264
# Note: this is slightly unnecessary, because symlinks and
2265
# directories have a "text" which is the empty text, and we
2266
# know that won't mess up annotations. But it seems cleaner
2267
continue
2268
parent_text_key = (file_id, ie.revision)
2269
if parent_text_key not in maybe_file_parent_keys:
2270
maybe_file_parent_keys.append(parent_text_key)
2271
finally:
2272
parent_tree.unlock()
2273
graph = _mod_graph.Graph(self.branch.repository.texts)
2274
heads = graph.heads(maybe_file_parent_keys)
2275
file_parent_keys = []
2276
for key in maybe_file_parent_keys:
2277
if key in heads:
2278
file_parent_keys.append(key)
2279
2280
# Now we have the parents of this content
2281
annotator = self.branch.repository.texts.get_annotator()
2282
text = self.get_file_text(file_id)
2283
this_key =(file_id, default_revision)
2284
annotator.add_special_text(this_key, file_parent_keys, text)
2285
annotations = [(key[-1], line)
2286
for key, line in annotator.annotate_flat(this_key)]
2287
return annotations
2288
2289
@needs_read_lock
2290
def merge_modified(self):
2291
"""Return a dictionary of files modified by a merge.
2292
2293
The list is initialized by WorkingTree.set_merge_modified, which is
2294
typically called after we make some automatic updates to the tree
2295
because of a merge.
2296
2297
This returns a map of file_id->sha1, containing only files which are
2298
still in the working inventory and have that text hash.
2299
"""
2300
try:
2301
hashfile = self._transport.get('merge-hashes')
2302
except errors.NoSuchFile:
2303
return {}
2304
try:
2305
merge_hashes = {}
2306
try:
2307
if hashfile.next() != MERGE_MODIFIED_HEADER_1 + '\n':
2308
raise errors.MergeModifiedFormatError()
2309
except StopIteration:
2310
raise errors.MergeModifiedFormatError()
2311
for s in _mod_rio.RioReader(hashfile):
2312
# RioReader reads in Unicode, so convert file_ids back to utf8
2313
file_id = osutils.safe_file_id(s.get("file_id"), warn=False)
2314
if file_id not in self.inventory:
2315
continue
2316
text_hash = s.get("hash")
2317
if text_hash == self.get_file_sha1(file_id):
2318
merge_hashes[file_id] = text_hash
2319
return merge_hashes
2320
finally:
2321
hashfile.close()
2322
2323
@needs_write_lock
2324
def subsume(self, other_tree):
2325
def add_children(inventory, entry):
2326
for child_entry in entry.children.values():
2327
inventory._byid[child_entry.file_id] = child_entry
2328
if child_entry.kind == 'directory':
2329
add_children(inventory, child_entry)
2330
if other_tree.get_root_id() == self.get_root_id():
2331
raise errors.BadSubsumeSource(self, other_tree,
2332
'Trees have the same root')
2333
try:
2334
other_tree_path = self.relpath(other_tree.basedir)
2335
except errors.PathNotChild:
2336
raise errors.BadSubsumeSource(self, other_tree,
2337
'Tree is not contained by the other')
2338
new_root_parent = self.path2id(osutils.dirname(other_tree_path))
2339
if new_root_parent is None:
2340
raise errors.BadSubsumeSource(self, other_tree,
2341
'Parent directory is not versioned.')
2342
# We need to ensure that the result of a fetch will have a
2343
# versionedfile for the other_tree root, and only fetching into
2344
# RepositoryKnit2 guarantees that.
2345
if not self.branch.repository.supports_rich_root():
2346
raise errors.SubsumeTargetNeedsUpgrade(other_tree)
2347
other_tree.lock_tree_write()
2348
try:
2349
new_parents = other_tree.get_parent_ids()
2350
other_root = other_tree.inventory.root
2351
other_root.parent_id = new_root_parent
2352
other_root.name = osutils.basename(other_tree_path)
2353
self.inventory.add(other_root)
2354
add_children(self.inventory, other_root)
2355
self._write_inventory(self.inventory)
2356
# normally we don't want to fetch whole repositories, but i think
2357
# here we really do want to consolidate the whole thing.
2358
for parent_id in other_tree.get_parent_ids():
2359
self.branch.fetch(other_tree.branch, parent_id)
2360
self.add_parent_tree_id(parent_id)
2361
finally:
2362
other_tree.unlock()
2363
other_tree.bzrdir.retire_bzrdir()
2364
2365
@needs_tree_write_lock
2366
def extract(self, file_id, format=None):
2367
"""Extract a subtree from this tree.
2368
2369
A new branch will be created, relative to the path for this tree.
2370
"""
2371
self.flush()
2372
def mkdirs(path):
2373
segments = osutils.splitpath(path)
2374
transport = self.branch.bzrdir.root_transport
2375
for name in segments:
2376
transport = transport.clone(name)
2377
transport.ensure_base()
2378
return transport
2379
2380
sub_path = self.id2path(file_id)
2381
branch_transport = mkdirs(sub_path)
2382
if format is None:
2383
format = self.bzrdir.cloning_metadir()
2384
branch_transport.ensure_base()
2385
branch_bzrdir = format.initialize_on_transport(branch_transport)
2386
try:
2387
repo = branch_bzrdir.find_repository()
2388
except errors.NoRepositoryPresent:
2389
repo = branch_bzrdir.create_repository()
2390
if not repo.supports_rich_root():
2391
raise errors.RootNotRich()
2392
new_branch = branch_bzrdir.create_branch()
2393
new_branch.pull(self.branch)
2394
for parent_id in self.get_parent_ids():
2395
new_branch.fetch(self.branch, parent_id)
2396
tree_transport = self.bzrdir.root_transport.clone(sub_path)
2397
if tree_transport.base != branch_transport.base:
2398
tree_bzrdir = format.initialize_on_transport(tree_transport)
2399
branch.BranchReferenceFormat().initialize(tree_bzrdir,
2400
target_branch=new_branch)
2401
else:
2402
tree_bzrdir = branch_bzrdir
2403
wt = tree_bzrdir.create_workingtree(_mod_revision.NULL_REVISION)
2404
wt.set_parent_ids(self.get_parent_ids())
2405
my_inv = self.inventory
2406
child_inv = inventory.Inventory(root_id=None)
2407
new_root = my_inv[file_id]
2408
my_inv.remove_recursive_id(file_id)
2409
new_root.parent_id = None
2410
child_inv.add(new_root)
2411
self._write_inventory(my_inv)
2412
wt._write_inventory(child_inv)
2413
return wt
2414
2415
def list_files(self, include_root=False, from_dir=None, recursive=True):
2416
"""List all files as (path, class, kind, id, entry).
2417
2418
Lists, but does not descend into unversioned directories.
2419
This does not include files that have been deleted in this
2420
tree. Skips the control directory.
2421
2422
:param include_root: if True, return an entry for the root
2423
:param from_dir: start from this directory or None for the root
2424
:param recursive: whether to recurse into subdirectories or not
2425
"""
2426
# list_files is an iterator, so @needs_read_lock doesn't work properly
2427
# with it. So callers should be careful to always read_lock the tree.
2428
if not self.is_locked():
2429
raise errors.ObjectNotLocked(self)
2430
2431
inv = self.inventory
2432
if from_dir is None and include_root is True:
2433
yield ('', 'V', 'directory', inv.root.file_id, inv.root)
2434
# Convert these into local objects to save lookup times
2435
pathjoin = osutils.pathjoin
2436
file_kind = self._kind
2437
2438
# transport.base ends in a slash, we want the piece
2439
# between the last two slashes
2440
transport_base_dir = self.bzrdir.transport.base.rsplit('/', 2)[1]
2441
2442
fk_entries = {'directory':TreeDirectory, 'file':TreeFile, 'symlink':TreeLink}
2443
2444
# directory file_id, relative path, absolute path, reverse sorted children
2445
if from_dir is not None:
2446
from_dir_id = inv.path2id(from_dir)
2447
if from_dir_id is None:
2448
# Directory not versioned
2449
return
2450
from_dir_abspath = pathjoin(self.basedir, from_dir)
2451
else:
2452
from_dir_id = inv.root.file_id
2453
from_dir_abspath = self.basedir
2454
children = os.listdir(from_dir_abspath)
2455
children.sort()
2456
# jam 20060527 The kernel sized tree seems equivalent whether we
2457
# use a deque and popleft to keep them sorted, or if we use a plain
2458
# list and just reverse() them.
2459
children = collections.deque(children)
2460
stack = [(from_dir_id, u'', from_dir_abspath, children)]
2461
while stack:
2462
from_dir_id, from_dir_relpath, from_dir_abspath, children = stack[-1]
2463
2464
while children:
2465
f = children.popleft()
2466
## TODO: If we find a subdirectory with its own .bzr
2467
## directory, then that is a separate tree and we
2468
## should exclude it.
2469
2470
# the bzrdir for this tree
2471
if transport_base_dir == f:
2472
continue
2473
2474
# we know that from_dir_relpath and from_dir_abspath never end in a slash
2475
# and 'f' doesn't begin with one, we can do a string op, rather
2476
# than the checks of pathjoin(), all relative paths will have an extra slash
2477
# at the beginning
2478
fp = from_dir_relpath + '/' + f
2479
2480
# absolute path
2481
fap = from_dir_abspath + '/' + f
2482
2483
dir_ie = inv[from_dir_id]
2484
if dir_ie.kind == 'directory':
2485
f_ie = dir_ie.children.get(f)
2486
else:
2487
f_ie = None
2488
if f_ie:
2489
c = 'V'
2490
elif self.is_ignored(fp[1:]):
2491
c = 'I'
2492
else:
2493
# we may not have found this file, because of a unicode
2494
# issue, or because the directory was actually a symlink.
2495
f_norm, can_access = osutils.normalized_filename(f)
2496
if f == f_norm or not can_access:
2497
# No change, so treat this file normally
2498
c = '?'
2499
else:
2500
# this file can be accessed by a normalized path
2501
# check again if it is versioned
2502
# these lines are repeated here for performance
2503
f = f_norm
2504
fp = from_dir_relpath + '/' + f
2505
fap = from_dir_abspath + '/' + f
2506
f_ie = inv.get_child(from_dir_id, f)
2507
if f_ie:
2508
c = 'V'
2509
elif self.is_ignored(fp[1:]):
2510
c = 'I'
2511
else:
2512
c = '?'
2513
2514
fk = file_kind(fap)
2515
2516
# make a last minute entry
2517
if f_ie:
2518
yield fp[1:], c, fk, f_ie.file_id, f_ie
2519
else:
2520
try:
2521
yield fp[1:], c, fk, None, fk_entries[fk]()
2522
except KeyError:
2523
yield fp[1:], c, fk, None, TreeEntry()
2524
continue
2525
2526
if fk != 'directory':
2527
continue
2528
2529
# But do this child first if recursing down
2530
if recursive:
2531
new_children = os.listdir(fap)
2532
new_children.sort()
2533
new_children = collections.deque(new_children)
2534
stack.append((f_ie.file_id, fp, fap, new_children))
2535
# Break out of inner loop,
2536
# so that we start outer loop with child
2537
break
2538
else:
2539
# if we finished all children, pop it off the stack
2540
stack.pop()
2541
2542
@needs_tree_write_lock
2543
def move(self, from_paths, to_dir=None, after=False):
2544
"""Rename files.
2545
2546
to_dir must exist in the inventory.
2547
2548
If to_dir exists and is a directory, the files are moved into
2549
it, keeping their old names.
2550
2551
Note that to_dir is only the last component of the new name;
2552
this doesn't change the directory.
2553
2554
For each entry in from_paths the move mode will be determined
2555
independently.
2556
2557
The first mode moves the file in the filesystem and updates the
2558
inventory. The second mode only updates the inventory without
2559
touching the file on the filesystem.
2560
2561
move uses the second mode if 'after == True' and the target is not
2562
versioned but present in the working tree.
2563
2564
move uses the second mode if 'after == False' and the source is
2565
versioned but no longer in the working tree, and the target is not
2566
versioned but present in the working tree.
2567
2568
move uses the first mode if 'after == False' and the source is
2569
versioned and present in the working tree, and the target is not
2570
versioned and not present in the working tree.
2571
2572
Everything else results in an error.
2573
2574
This returns a list of (from_path, to_path) pairs for each
2575
entry that is moved.
2576
"""
2577
rename_entries = []
2578
rename_tuples = []
2579
2580
# check for deprecated use of signature
2581
if to_dir is None:
2582
raise TypeError('You must supply a target directory')
2583
# check destination directory
2584
if isinstance(from_paths, basestring):
2585
raise ValueError()
2586
inv = self.inventory
2587
to_abs = self.abspath(to_dir)
2588
if not isdir(to_abs):
2589
raise errors.BzrMoveFailedError('',to_dir,
2590
errors.NotADirectory(to_abs))
2591
if not self.has_filename(to_dir):
2592
raise errors.BzrMoveFailedError('',to_dir,
2593
errors.NotInWorkingDirectory(to_dir))
2594
to_dir_id = inv.path2id(to_dir)
2595
if to_dir_id is None:
2596
raise errors.BzrMoveFailedError('',to_dir,
2597
errors.NotVersionedError(path=to_dir))
2598
2599
to_dir_ie = inv[to_dir_id]
2600
if to_dir_ie.kind != 'directory':
2601
raise errors.BzrMoveFailedError('',to_dir,
2602
errors.NotADirectory(to_abs))
2603
2604
# create rename entries and tuples
2605
for from_rel in from_paths:
2606
from_tail = splitpath(from_rel)[-1]
2607
from_id = inv.path2id(from_rel)
2608
if from_id is None:
2609
raise errors.BzrMoveFailedError(from_rel,to_dir,
2610
errors.NotVersionedError(path=from_rel))
2611
2612
from_entry = inv[from_id]
2613
from_parent_id = from_entry.parent_id
2614
to_rel = pathjoin(to_dir, from_tail)
2615
rename_entry = InventoryWorkingTree._RenameEntry(
2616
from_rel=from_rel,
2617
from_id=from_id,
2618
from_tail=from_tail,
2619
from_parent_id=from_parent_id,
2620
to_rel=to_rel, to_tail=from_tail,
2621
to_parent_id=to_dir_id)
2622
rename_entries.append(rename_entry)
2623
rename_tuples.append((from_rel, to_rel))
2624
2625
# determine which move mode to use. checks also for movability
2626
rename_entries = self._determine_mv_mode(rename_entries, after)
2627
2628
original_modified = self._inventory_is_modified
2629
try:
2630
if len(from_paths):
2631
self._inventory_is_modified = True
2632
self._move(rename_entries)
2633
except:
2634
# restore the inventory on error
2635
self._inventory_is_modified = original_modified
2636
raise
2637
self._write_inventory(inv)
2638
return rename_tuples
2639
2640
@needs_tree_write_lock
2641
def rename_one(self, from_rel, to_rel, after=False):
2642
"""Rename one file.
2643
2644
This can change the directory or the filename or both.
2645
2646
rename_one has several 'modes' to work. First, it can rename a physical
2647
file and change the file_id. That is the normal mode. Second, it can
2648
only change the file_id without touching any physical file.
2649
2650
rename_one uses the second mode if 'after == True' and 'to_rel' is not
2651
versioned but present in the working tree.
2652
2653
rename_one uses the second mode if 'after == False' and 'from_rel' is
2654
versioned but no longer in the working tree, and 'to_rel' is not
2655
versioned but present in the working tree.
2656
2657
rename_one uses the first mode if 'after == False' and 'from_rel' is
2658
versioned and present in the working tree, and 'to_rel' is not
2659
versioned and not present in the working tree.
2660
2661
Everything else results in an error.
2662
"""
2663
inv = self.inventory
2664
rename_entries = []
2665
2666
# create rename entries and tuples
2667
from_tail = splitpath(from_rel)[-1]
2668
from_id = inv.path2id(from_rel)
2669
if from_id is None:
2670
# if file is missing in the inventory maybe it's in the basis_tree
2671
basis_tree = self.branch.basis_tree()
2672
from_id = basis_tree.path2id(from_rel)
2673
if from_id is None:
2674
raise errors.BzrRenameFailedError(from_rel,to_rel,
2675
errors.NotVersionedError(path=from_rel))
2676
# put entry back in the inventory so we can rename it
2677
from_entry = basis_tree.inventory[from_id].copy()
2678
inv.add(from_entry)
2679
else:
2680
from_entry = inv[from_id]
2681
from_parent_id = from_entry.parent_id
2682
to_dir, to_tail = os.path.split(to_rel)
2683
to_dir_id = inv.path2id(to_dir)
2684
rename_entry = InventoryWorkingTree._RenameEntry(from_rel=from_rel,
2685
from_id=from_id,
2686
from_tail=from_tail,
2687
from_parent_id=from_parent_id,
2688
to_rel=to_rel, to_tail=to_tail,
2689
to_parent_id=to_dir_id)
2690
rename_entries.append(rename_entry)
2691
2692
# determine which move mode to use. checks also for movability
2693
rename_entries = self._determine_mv_mode(rename_entries, after)
2694
2695
# check if the target changed directory and if the target directory is
2696
# versioned
2697
if to_dir_id is None:
2698
raise errors.BzrMoveFailedError(from_rel,to_rel,
2699
errors.NotVersionedError(path=to_dir))
2700
2701
# all checks done. now we can continue with our actual work
2702
mutter('rename_one:\n'
2703
' from_id {%s}\n'
2704
' from_rel: %r\n'
2705
' to_rel: %r\n'
2706
' to_dir %r\n'
2707
' to_dir_id {%s}\n',
2708
from_id, from_rel, to_rel, to_dir, to_dir_id)
2709
2710
self._move(rename_entries)
2711
self._write_inventory(inv)
2712
2713
class _RenameEntry(object):
2714
def __init__(self, from_rel, from_id, from_tail, from_parent_id,
2715
to_rel, to_tail, to_parent_id, only_change_inv=False):
2716
self.from_rel = from_rel
2717
self.from_id = from_id
2718
self.from_tail = from_tail
2719
self.from_parent_id = from_parent_id
2720
self.to_rel = to_rel
2721
self.to_tail = to_tail
2722
self.to_parent_id = to_parent_id
2723
self.only_change_inv = only_change_inv
2724
2725
def _determine_mv_mode(self, rename_entries, after=False):
2726
"""Determines for each from-to pair if both inventory and working tree
2727
or only the inventory has to be changed.
2728
2729
Also does basic plausability tests.
2730
"""
2731
inv = self.inventory
2732
2733
for rename_entry in rename_entries:
2734
# store to local variables for easier reference
2735
from_rel = rename_entry.from_rel
2736
from_id = rename_entry.from_id
2737
to_rel = rename_entry.to_rel
2738
to_id = inv.path2id(to_rel)
2739
only_change_inv = False
2740
2741
# check the inventory for source and destination
2742
if from_id is None:
2743
raise errors.BzrMoveFailedError(from_rel,to_rel,
2744
errors.NotVersionedError(path=from_rel))
2745
if to_id is not None:
2746
raise errors.BzrMoveFailedError(from_rel,to_rel,
2747
errors.AlreadyVersionedError(path=to_rel))
2748
2749
# try to determine the mode for rename (only change inv or change
2750
# inv and file system)
2751
if after:
2752
if not self.has_filename(to_rel):
2753
raise errors.BzrMoveFailedError(from_id,to_rel,
2754
errors.NoSuchFile(path=to_rel,
2755
extra="New file has not been created yet"))
2756
only_change_inv = True
2757
elif not self.has_filename(from_rel) and self.has_filename(to_rel):
2758
only_change_inv = True
2759
elif self.has_filename(from_rel) and not self.has_filename(to_rel):
2760
only_change_inv = False
2761
elif (not self.case_sensitive
2762
and from_rel.lower() == to_rel.lower()
2763
and self.has_filename(from_rel)):
2764
only_change_inv = False
2765
else:
2766
# something is wrong, so lets determine what exactly
2767
if not self.has_filename(from_rel) and \
2768
not self.has_filename(to_rel):
2769
raise errors.BzrRenameFailedError(from_rel,to_rel,
2770
errors.PathsDoNotExist(paths=(str(from_rel),
2771
str(to_rel))))
2772
else:
2773
raise errors.RenameFailedFilesExist(from_rel, to_rel)
2774
rename_entry.only_change_inv = only_change_inv
2775
return rename_entries
2776
2777
def _move(self, rename_entries):
2778
"""Moves a list of files.
2779
2780
Depending on the value of the flag 'only_change_inv', the
2781
file will be moved on the file system or not.
2782
"""
2783
inv = self.inventory
2784
moved = []
2785
2786
for entry in rename_entries:
2787
try:
2788
self._move_entry(entry)
2789
except:
2790
self._rollback_move(moved)
2791
raise
2792
moved.append(entry)
2793
2794
def _rollback_move(self, moved):
2795
"""Try to rollback a previous move in case of an filesystem error."""
2796
inv = self.inventory
2797
for entry in moved:
2798
try:
2799
self._move_entry(WorkingTree._RenameEntry(
2800
entry.to_rel, entry.from_id,
2801
entry.to_tail, entry.to_parent_id, entry.from_rel,
2802
entry.from_tail, entry.from_parent_id,
2803
entry.only_change_inv))
2804
except errors.BzrMoveFailedError, e:
2805
raise errors.BzrMoveFailedError( '', '', "Rollback failed."
2806
" The working tree is in an inconsistent state."
2807
" Please consider doing a 'bzr revert'."
2808
" Error message is: %s" % e)
2809
2810
def _move_entry(self, entry):
2811
inv = self.inventory
2812
from_rel_abs = self.abspath(entry.from_rel)
2813
to_rel_abs = self.abspath(entry.to_rel)
2814
if from_rel_abs == to_rel_abs:
2815
raise errors.BzrMoveFailedError(entry.from_rel, entry.to_rel,
2816
"Source and target are identical.")
2817
2818
if not entry.only_change_inv:
2819
try:
2820
osutils.rename(from_rel_abs, to_rel_abs)
2821
except OSError, e:
2822
raise errors.BzrMoveFailedError(entry.from_rel,
2823
entry.to_rel, e[1])
2824
inv.rename(entry.from_id, entry.to_parent_id, entry.to_tail)
2825
2826
@needs_tree_write_lock
2827
def unversion(self, file_ids):
2828
"""Remove the file ids in file_ids from the current versioned set.
2829
2830
When a file_id is unversioned, all of its children are automatically
2831
unversioned.
2832
2833
:param file_ids: The file ids to stop versioning.
2834
:raises: NoSuchId if any fileid is not currently versioned.
2835
"""
2836
for file_id in file_ids:
2837
if file_id not in self._inventory:
2838
raise errors.NoSuchId(self, file_id)
2839
for file_id in file_ids:
2840
if self._inventory.has_id(file_id):
2841
self._inventory.remove_recursive_id(file_id)
2842
if len(file_ids):
2843
# in the future this should just set a dirty bit to wait for the
2844
# final unlock. However, until all methods of workingtree start
2845
# with the current in -memory inventory rather than triggering
2846
# a read, it is more complex - we need to teach read_inventory
2847
# to know when to read, and when to not read first... and possibly
2848
# to save first when the in memory one may be corrupted.
2849
# so for now, we just only write it if it is indeed dirty.
2850
# - RBC 20060907
2851
self._write_inventory(self._inventory)
2852
2853
def stored_kind(self, file_id):
2854
"""See Tree.stored_kind"""
2855
return self.inventory[file_id].kind
2856
2857
def extras(self):
2858
"""Yield all unversioned files in this WorkingTree.
2859
2860
If there are any unversioned directories then only the directory is
2861
returned, not all its children. But if there are unversioned files
2862
under a versioned subdirectory, they are returned.
2863
2864
Currently returned depth-first, sorted by name within directories.
2865
This is the same order used by 'osutils.walkdirs'.
2866
"""
2867
## TODO: Work from given directory downwards
2868
for path, dir_entry in self.inventory.directories():
2869
# mutter("search for unknowns in %r", path)
2870
dirabs = self.abspath(path)
2871
if not isdir(dirabs):
2872
# e.g. directory deleted
2873
continue
2874
2875
fl = []
2876
for subf in os.listdir(dirabs):
2877
if self.bzrdir.is_control_filename(subf):
2878
continue
2879
if subf not in dir_entry.children:
2880
try:
2881
(subf_norm,
2882
can_access) = osutils.normalized_filename(subf)
2883
except UnicodeDecodeError:
2884
path_os_enc = path.encode(osutils._fs_enc)
2885
relpath = path_os_enc + '/' + subf
2886
raise errors.BadFilenameEncoding(relpath,
2887
osutils._fs_enc)
2888
if subf_norm != subf and can_access:
2889
if subf_norm not in dir_entry.children:
2890
fl.append(subf_norm)
2891
else:
2892
fl.append(subf)
2893
2894
fl.sort()
2895
for subf in fl:
2896
subp = pathjoin(path, subf)
2897
yield subp
2898
2899
def _walkdirs(self, prefix=""):
2900
"""Walk the directories of this tree.
2901
2902
:prefix: is used as the directrory to start with.
2903
returns a generator which yields items in the form:
2904
((curren_directory_path, fileid),
2905
[(file1_path, file1_name, file1_kind, None, file1_id,
2906
file1_kind), ... ])
2907
"""
2908
_directory = 'directory'
2909
# get the root in the inventory
2910
inv = self.inventory
2911
top_id = inv.path2id(prefix)
2912
if top_id is None:
2913
pending = []
2914
else:
2915
pending = [(prefix, '', _directory, None, top_id, None)]
2916
while pending:
2917
dirblock = []
2918
currentdir = pending.pop()
2919
# 0 - relpath, 1- basename, 2- kind, 3- stat, 4-id, 5-kind
2920
top_id = currentdir[4]
2921
if currentdir[0]:
2922
relroot = currentdir[0] + '/'
2923
else:
2924
relroot = ""
2925
# FIXME: stash the node in pending
2926
entry = inv[top_id]
2927
if entry.kind == 'directory':
2928
for name, child in entry.sorted_children():
2929
dirblock.append((relroot + name, name, child.kind, None,
2930
child.file_id, child.kind
2931
))
2932
yield (currentdir[0], entry.file_id), dirblock
2933
# push the user specified dirs from dirblock
2934
for dir in reversed(dirblock):
2935
if dir[2] == _directory:
2936
pending.append(dir)
2774
2937
2775
2938
2776
2939
class WorkingTreeFormatRegistry(controldir.ControlComponentFormatRegistry):
2779
2942
def __init__(self, other_registry=None):
2780
2943
super(WorkingTreeFormatRegistry, self).__init__(other_registry)
2781
2944
self._default_format = None
2945
self._default_format_key = None
2782
2946
2783
2947
def get_default(self):
2784
2948
"""Return the current default format."""
2949
if (self._default_format_key is not None and
2950
self._default_format is None):
2951
self._default_format = self.get(self._default_format_key)
2785
2952
return self._default_format
2786
2953
2787
2954
def set_default(self, format):
2955
"""Set the default format."""
2788
2956
self._default_format = format
2957
self._default_format_key = None
2958
2959
def set_default_key(self, format_string):
2960
"""Set the default format by its format string."""
2961
self._default_format_key = format_string
2962
self._default_format = None
2789
2963
2790
2964
2791
2965
format_registry = WorkingTreeFormatRegistry()
2821
2995
"""If this format supports missing parent conflicts."""
2822
2996
2823
2997
@classmethod
2998
def find_format_string(klass, a_bzrdir):
2999
"""Return format name for the working tree object in a_bzrdir."""
3000
try:
3001
transport = a_bzrdir.get_workingtree_transport(None)
3002
return transport.get_bytes("format")
3003
except errors.NoSuchFile:
3004
raise errors.NoWorkingTree(base=transport.base)
3005
3006
@classmethod
2824
3007
def find_format(klass, a_bzrdir):
2825
3008
"""Return the format for the working tree object in a_bzrdir."""
2826
3009
try:
2827
transport = a_bzrdir.get_workingtree_transport(None)
2828
format_string = transport.get_bytes("format")
3010
format_string = klass.find_format_string(a_bzrdir)
2829
3011
return format_registry.get(format_string)
2830
except errors.NoSuchFile:
2831
raise errors.NoWorkingTree(base=transport.base)
2832
3012
except KeyError:
2833
3013
raise errors.UnknownFormatError(format=format_string,
2834
3014
kind="working tree")
2925
3105
format_registry.remove(format)
2926
3106
2927
3107
2928
class WorkingTreeFormat3(WorkingTreeFormat):
2929
"""The second working tree format updated to record a format marker.
2930
2931
This format:
2932
- exists within a metadir controlling .bzr
2933
- includes an explicit version marker for the workingtree control
2934
files, separate from the BzrDir format
2935
- modifies the hash cache format
2936
- is new in bzr 0.8
2937
- uses a LockDir to guard access for writes.
2938
"""
2939
2940
upgrade_recommended = True
2941
2942
missing_parent_conflicts = True
2943
2944
def get_format_string(self):
2945
"""See WorkingTreeFormat.get_format_string()."""
2946
return "Bazaar-NG Working Tree format 3"
2947
2948
def get_format_description(self):
2949
"""See WorkingTreeFormat.get_format_description()."""
2950
return "Working tree format 3"
2951
2952
_lock_file_name = 'lock'
2953
_lock_class = LockDir
2954
2955
_tree_class = WorkingTree3
2956
2957
def __get_matchingbzrdir(self):
2958
return bzrdir.BzrDirMetaFormat1()
2959
2960
_matchingbzrdir = property(__get_matchingbzrdir)
2961
2962
def _open_control_files(self, a_bzrdir):
2963
transport = a_bzrdir.get_workingtree_transport(None)
2964
return LockableFiles(transport, self._lock_file_name,
2965
self._lock_class)
2966
2967
def initialize(self, a_bzrdir, revision_id=None, from_branch=None,
2968
accelerator_tree=None, hardlink=False):
2969
"""See WorkingTreeFormat.initialize().
2970
2971
:param revision_id: if supplied, create a working tree at a different
2972
revision than the branch is at.
2973
:param accelerator_tree: A tree which can be used for retrieving file
2974
contents more quickly than the revision tree, i.e. a workingtree.
2975
The revision tree will be used for cases where accelerator_tree's
2976
content is different.
2977
:param hardlink: If true, hard-link files from accelerator_tree,
2978
where possible.
2979
"""
2980
if not isinstance(a_bzrdir.transport, LocalTransport):
2981
raise errors.NotLocalUrl(a_bzrdir.transport.base)
2982
transport = a_bzrdir.get_workingtree_transport(self)
2983
control_files = self._open_control_files(a_bzrdir)
2984
control_files.create_lock()
2985
control_files.lock_write()
2986
transport.put_bytes('format', self.get_format_string(),
2987
mode=a_bzrdir._get_file_mode())
2988
if from_branch is not None:
2989
branch = from_branch
2990
else:
2991
branch = a_bzrdir.open_branch()
2992
if revision_id is None:
2993
revision_id = _mod_revision.ensure_null(branch.last_revision())
2994
# WorkingTree3 can handle an inventory which has a unique root id.
2995
# as of bzr 0.12. However, bzr 0.11 and earlier fail to handle
2996
# those trees. And because there isn't a format bump inbetween, we
2997
# are maintaining compatibility with older clients.
2998
# inv = Inventory(root_id=gen_root_id())
2999
inv = self._initial_inventory()
3000
wt = self._tree_class(a_bzrdir.root_transport.local_abspath('.'),
3001
branch,
3002
inv,
3003
_internal=True,
3004
_format=self,
3005
_bzrdir=a_bzrdir,
3006
_control_files=control_files)
3007
wt.lock_tree_write()
3008
try:
3009
basis_tree = branch.repository.revision_tree(revision_id)
3010
# only set an explicit root id if there is one to set.
3011
if basis_tree.inventory.root is not None:
3012
wt.set_root_id(basis_tree.get_root_id())
3013
if revision_id == _mod_revision.NULL_REVISION:
3014
wt.set_parent_trees([])
3015
else:
3016
wt.set_parent_trees([(revision_id, basis_tree)])
3017
transform.build_tree(basis_tree, wt)
3018
finally:
3019
# Unlock in this order so that the unlock-triggers-flush in
3020
# WorkingTree is given a chance to fire.
3021
control_files.unlock()
3022
wt.unlock()
3023
return wt
3024
3025
def _initial_inventory(self):
3026
return inventory.Inventory()
3027
3028
def __init__(self):
3029
super(WorkingTreeFormat3, self).__init__()
3030
3031
def open(self, a_bzrdir, _found=False):
3032
"""Return the WorkingTree object for a_bzrdir
3033
3034
_found is a private parameter, do not use it. It is used to indicate
3035
if format probing has already been done.
3036
"""
3037
if not _found:
3038
# we are being called directly and must probe.
3039
raise NotImplementedError
3040
if not isinstance(a_bzrdir.transport, LocalTransport):
3041
raise errors.NotLocalUrl(a_bzrdir.transport.base)
3042
wt = self._open(a_bzrdir, self._open_control_files(a_bzrdir))
3043
return wt
3044
3045
def _open(self, a_bzrdir, control_files):
3046
"""Open the tree itself.
3047
3048
:param a_bzrdir: the dir for the tree.
3049
:param control_files: the control files for the tree.
3050
"""
3051
return self._tree_class(a_bzrdir.root_transport.local_abspath('.'),
3052
_internal=True,
3053
_format=self,
3054
_bzrdir=a_bzrdir,
3055
_control_files=control_files)
3056
3057
def __str__(self):
3058
return self.get_format_string()
3059
3060
3061
__default_format = WorkingTreeFormat6()
3062
3108
format_registry.register_lazy("Bazaar Working Tree Format 4 (bzr 0.15)\n",
3063
3109
"bzrlib.workingtree_4", "WorkingTreeFormat4")
3064
3110
format_registry.register_lazy("Bazaar Working Tree Format 5 (bzr 1.11)\n",
3065
3111
"bzrlib.workingtree_4", "WorkingTreeFormat5")
3066
3112
format_registry.register_lazy("Bazaar Working Tree Format 6 (bzr 1.14)\n",
3067
3113
"bzrlib.workingtree_4", "WorkingTreeFormat6")
3068
format_registry.register(WorkingTreeFormat3())
3069
format_registry.set_default(__default_format)
3114
format_registry.register_lazy("Bazaar-NG Working Tree format 3",
3115
"bzrlib.workingtree_3", "WorkingTreeFormat3")
3116
format_registry.set_default_key("Bazaar Working Tree Format 6 (bzr 1.14)\n")
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0