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