« back to all changes in this revision
Viewing changes to bzrlib/workingtree.py
- browse files at revision 1553.5.28
- compare with another revision
- compare with revision 2664.6.3
- download diff
- download tarball
- view history from revision 1553.5.28
- Committer: Martin Pool
- Date: 2006-02-22 04:29:54 UTC
- mfrom: (1566 +trunk)
- mto: This revision was merged to the branch mainline in revision 1569.
- Revision ID: mbp@sourcefrog.net-20060222042954-60333f08dd56a646
[merge] from bzr.dev before integration
Fix undefined ordering in sign_my_revisions breaking tests
Fix undefined ordering in sign_my_revisions breaking tests
- files added:
- bzrlib/bzrdir.py
- bzrlib/tests/bzrdir_implementations
- bzrlib/tests/interrepository_implementations
- bzrlib/tests/repository_implementations
- bzrlib/tests/workingtree_implementations
- files removed:
- bzrlib/_changeset.py
- patches
- files renamed:
- bzrlib/tests/test_parent.py => bzrlib/tests/branch_implementations/test_parent.py
- bzrlib/tests/test_fileid_involved.py => bzrlib/tests/repository_implementations/test_fileid_involved.py
- files modified:
- BRANCH.TODO
added
removed
bzrlib/workingtree.py
25
25
At the moment every WorkingTree has its own branch. Remote
26
26
WorkingTrees aren't supported.
27
27
28
To get a WorkingTree, call WorkingTree(dir[, branch])
28
To get a WorkingTree, call bzrdir.open_workingtree() or
29
WorkingTree.open(dir).
29
30
"""
30
31
31
32
49
50
50
51
from bzrlib.atomicfile import AtomicFile
51
52
from bzrlib.branch import (Branch,
52
BzrBranchFormat4,
53
BzrBranchFormat5,
54
BzrBranchFormat6,
55
is_control_file,
56
53
quotefn)
54
import bzrlib.bzrdir as bzrdir
57
55
from bzrlib.decorators import needs_read_lock, needs_write_lock
56
import bzrlib.errors as errors
58
57
from bzrlib.errors import (BzrCheckError,
59
58
BzrError,
60
59
DivergedBranches,
62
61
NotBranchError,
63
62
NoSuchFile,
64
63
NotVersionedError)
65
from bzrlib.inventory import InventoryEntry
64
from bzrlib.inventory import InventoryEntry, Inventory
66
65
from bzrlib.lockable_files import LockableFiles
66
from bzrlib.merge import merge_inner, transform_tree
67
67
from bzrlib.osutils import (appendpath,
68
68
compact_date,
69
69
file_kind,
78
78
normpath,
79
79
realpath,
80
80
relpath,
81
rename)
81
rename,
82
supports_executable,
83
)
84
from bzrlib.progress import DummyProgress
85
from bzrlib.revision import NULL_REVISION
82
86
from bzrlib.symbol_versioning import *
83
87
from bzrlib.textui import show_status
84
88
import bzrlib.tree
85
89
from bzrlib.trace import mutter
90
from bzrlib.transform import build_tree
86
91
from bzrlib.transport import get_transport
92
from bzrlib.transport.local import LocalTransport
93
import bzrlib.ui
87
94
import bzrlib.xml5
88
95
89
96
186
193
not listed in the Inventory and vice versa.
187
194
"""
188
195
189
def __init__(self, basedir='.', branch=None, _inventory=None, _control_files=None):
196
def __init__(self, basedir='.',
197
branch=DEPRECATED_PARAMETER,
198
_inventory=None,
199
_control_files=None,
200
_internal=False,
201
_format=None,
202
_bzrdir=None):
190
203
"""Construct a WorkingTree for basedir.
191
204
192
205
If the branch is not supplied, it is opened automatically.
194
207
(branch.base is not cross checked, because for remote branches that
195
208
would be meaningless).
196
209
"""
210
self._format = _format
211
self.bzrdir = _bzrdir
212
if not _internal:
213
# not created via open etc.
214
warn("WorkingTree() is deprecated as of bzr version 0.8. "
215
"Please use bzrdir.open_workingtree or WorkingTree.open().",
216
DeprecationWarning,
217
stacklevel=2)
218
wt = WorkingTree.open(basedir)
219
self.branch = wt.branch
220
self.basedir = wt.basedir
221
self._control_files = wt._control_files
222
self._hashcache = wt._hashcache
223
self._set_inventory(wt._inventory)
224
self._format = wt._format
225
self.bzrdir = wt.bzrdir
197
226
from bzrlib.hashcache import HashCache
198
227
from bzrlib.trace import note, mutter
199
228
assert isinstance(basedir, basestring), \
200
229
"base directory %r is not a string" % basedir
201
230
basedir = safe_unicode(basedir)
202
mutter("openeing working tree %r", basedir)
203
if branch is None:
204
branch = Branch.open(basedir)
205
assert isinstance(branch, Branch), \
206
"branch %r is not a Branch" % branch
207
self.branch = branch
231
mutter("opening working tree %r", basedir)
232
if deprecated_passed(branch):
233
if not _internal:
234
warn("WorkingTree(..., branch=XXX) is deprecated as of bzr 0.8."
235
" Please use bzrdir.open_workingtree() or WorkingTree.open().",
236
DeprecationWarning,
237
stacklevel=2
238
)
239
self.branch = branch
240
else:
241
self.branch = self.bzrdir.open_branch()
242
assert isinstance(self.branch, Branch), \
243
"branch %r is not a Branch" % self.branch
208
244
self.basedir = realpath(basedir)
209
245
# if branch is at our basedir and is a format 6 or less
210
if (isinstance(self.branch._branch_format,
211
(BzrBranchFormat4, BzrBranchFormat5, BzrBranchFormat6))
212
# might be able to share control object
213
and self.branch.base.split('/')[-2] == self.basedir.split('/')[-1]):
246
if isinstance(self._format, WorkingTreeFormat2):
247
# share control object
214
248
self._control_files = self.branch.control_files
215
249
elif _control_files is not None:
216
250
assert False, "not done yet"
217
251
# self._control_files = _control_files
218
252
else:
253
# only ready for format 3
254
assert isinstance(self._format, WorkingTreeFormat3)
219
255
self._control_files = LockableFiles(
220
get_transport(self.basedir).clone(bzrlib.BZRDIR), 'branch-lock')
256
self.bzrdir.get_workingtree_transport(None),
257
'lock')
221
258
222
259
# update the whole cache up front and write to disk if anything changed;
223
260
# in the future we might want to do this more selectively
225
262
# if needed, or, when the cache sees a change, append it to the hash
226
263
# cache file, and have the parser take the most recent entry for a
227
264
# given path only.
228
hc = self._hashcache = HashCache(basedir)
265
cache_filename = self.bzrdir.get_workingtree_transport(None).abspath('stat-cache')
266
hc = self._hashcache = HashCache(basedir, cache_filename, self._control_files._file_mode)
229
267
hc.read()
268
# is this scan needed ? it makes things kinda slow.
230
269
hc.scan()
231
270
232
271
if hc.needs_write:
242
281
self._inventory = inv
243
282
self.path2id = self._inventory.path2id
244
283
284
def is_control_filename(self, filename):
285
"""True if filename is the name of a control file in this tree.
286
287
This is true IF and ONLY IF the filename is part of the meta data
288
that bzr controls in this tree. I.E. a random .bzr directory placed
289
on disk will not be a control file for this tree.
290
"""
291
try:
292
self.bzrdir.transport.relpath(self.abspath(filename))
293
return True
294
except errors.PathNotChild:
295
return False
296
297
@staticmethod
298
def open(path=None, _unsupported=False):
299
"""Open an existing working tree at path.
300
301
"""
302
if path is None:
303
path = os.path.getcwdu()
304
control = bzrdir.BzrDir.open(path, _unsupported)
305
return control.open_workingtree(_unsupported)
306
245
307
@staticmethod
246
308
def open_containing(path=None):
247
309
"""Open an existing working tree which has its root about path.
254
316
If there is one, it is returned, along with the unused portion of path.
255
317
"""
256
318
if path is None:
257
path = getcwd()
258
else:
259
# sanity check.
260
if path.find('://') != -1:
261
raise NotBranchError(path=path)
262
path = abspath(path)
263
orig_path = path[:]
264
tail = u''
265
while True:
266
try:
267
return WorkingTree(path), tail
268
except NotBranchError:
269
pass
270
if tail:
271
tail = pathjoin(os.path.basename(path), tail)
272
else:
273
tail = os.path.basename(path)
274
lastpath = path
275
path = os.path.dirname(path)
276
if lastpath == path:
277
# reached the root, whatever that may be
278
raise NotBranchError(path=orig_path)
319
path = os.getcwdu()
320
control, relpath = bzrdir.BzrDir.open_containing(path)
321
return control.open_workingtree(), relpath
322
323
@staticmethod
324
def open_downlevel(path=None):
325
"""Open an unsupported working tree.
326
327
Only intended for advanced situations like upgrading part of a bzrdir.
328
"""
329
return WorkingTree.open(path, _unsupported=True)
279
330
280
331
def __iter__(self):
281
332
"""Iterate through file_ids for this tree.
294
345
295
346
def abspath(self, filename):
296
347
return pathjoin(self.basedir, filename)
348
349
def basis_tree(self):
350
"""Return RevisionTree for the current last revision."""
351
revision_id = self.last_revision()
352
if revision_id is not None:
353
try:
354
xml = self.read_basis_inventory(revision_id)
355
inv = bzrlib.xml5.serializer_v5.read_inventory_from_string(xml)
356
return bzrlib.tree.RevisionTree(self.branch.repository, inv,
357
revision_id)
358
except NoSuchFile:
359
pass
360
return self.branch.repository.revision_tree(revision_id)
297
361
298
362
@staticmethod
363
@deprecated_method(zero_eight)
299
364
def create(branch, directory):
300
365
"""Create a workingtree for branch at directory.
301
366
311
376
XXX: When BzrDir is present, these should be created through that
312
377
interface instead.
313
378
"""
314
try:
315
os.mkdir(directory)
316
except OSError, e:
317
if e.errno != errno.EEXIST:
318
raise
319
try:
320
os.mkdir(pathjoin(directory, '.bzr'))
321
except OSError, e:
322
if e.errno != errno.EEXIST:
323
raise
324
inv = branch.repository.revision_tree(branch.last_revision()).inventory
325
wt = WorkingTree(directory, branch, inv)
326
wt._write_inventory(inv)
327
if branch.last_revision() is not None:
328
wt.set_last_revision(branch.last_revision())
329
wt.set_pending_merges([])
330
wt.revert([])
331
return wt
379
warn('delete WorkingTree.create', stacklevel=3)
380
transport = get_transport(directory)
381
if branch.bzrdir.root_transport.base == transport.base:
382
# same dir
383
return branch.bzrdir.create_workingtree()
384
# different directory,
385
# create a branch reference
386
# and now a working tree.
387
raise NotImplementedError
332
388
333
389
@staticmethod
390
@deprecated_method(zero_eight)
334
391
def create_standalone(directory):
335
"""Create a checkout and a branch at directory.
392
"""Create a checkout and a branch and a repo at directory.
336
393
337
394
Directory must exist and be empty.
338
395
339
XXX: When BzrDir is present, these should be created through that
340
interface instead.
396
please use BzrDir.create_standalone_workingtree
341
397
"""
342
directory = safe_unicode(directory)
343
b = Branch.create(directory)
344
return WorkingTree.create(b, directory)
398
return bzrdir.BzrDir.create_standalone_workingtree(directory)
345
399
346
400
def relpath(self, abs):
347
401
"""Return the local path portion from a given absolute path."""
365
419
## XXX: badly named; this is not in the store at all
366
420
return self.abspath(self.id2path(file_id))
367
421
422
@needs_read_lock
423
def clone(self, to_bzrdir, revision_id=None, basis=None):
424
"""Duplicate this working tree into to_bzr, including all state.
425
426
Specifically modified files are kept as modified, but
427
ignored and unknown files are discarded.
428
429
If you want to make a new line of development, see bzrdir.sprout()
430
431
revision
432
If not None, the cloned tree will have its last revision set to
433
revision, and and difference between the source trees last revision
434
and this one merged in.
435
436
basis
437
If not None, a closer copy of a tree which may have some files in
438
common, and which file content should be preferentially copied from.
439
"""
440
# assumes the target bzr dir format is compatible.
441
result = self._format.initialize(to_bzrdir)
442
self.copy_content_into(result, revision_id)
443
return result
444
445
@needs_read_lock
446
def copy_content_into(self, tree, revision_id=None):
447
"""Copy the current content and user files of this tree into tree."""
448
if revision_id is None:
449
transform_tree(tree, self)
450
else:
451
# TODO now merge from tree.last_revision to revision
452
transform_tree(tree, self)
453
tree.set_last_revision(revision_id)
454
368
455
@needs_write_lock
369
456
def commit(self, *args, **kwargs):
370
457
from bzrlib.commit import Commit
402
489
return self._hashcache.get_sha1(path)
403
490
404
491
def is_executable(self, file_id):
405
if os.name == "nt":
492
if not supports_executable():
406
493
return self._inventory[file_id].executable
407
494
else:
408
495
path = self._inventory.id2path(file_id)
447
534
448
535
inv = self.read_working_inventory()
449
536
for f,file_id in zip(files, ids):
450
if is_control_file(f):
537
if self.is_control_filename(f):
451
538
raise BzrError("cannot add control file %s" % quotefn(f))
452
539
453
540
fp = splitpath(f)
459
546
460
547
try:
461
548
kind = file_kind(fullpath)
462
except OSError:
549
except OSError, e:
550
if e.errno == errno.ENOENT:
551
raise NoSuchFile(fullpath)
463
552
# maybe something better?
464
553
raise BzrError('cannot add: not a regular file, symlink or directory: %s' % quotefn(f))
465
554
521
610
else:
522
611
return '?'
523
612
524
525
613
def list_files(self):
526
614
"""Recursively list all files as (path, class, kind, id).
527
615
541
629
## TODO: If we find a subdirectory with its own .bzr
542
630
## directory, then that is a separate tree and we
543
631
## should exclude it.
544
if bzrlib.BZRDIR == f:
632
633
# the bzrdir for this tree
634
if self.bzrdir.transport.base.endswith(f + '/'):
545
635
continue
546
636
547
637
# path within tree
718
808
These are files in the working directory that are not versioned or
719
809
control files or ignored.
720
810
721
>>> from bzrlib.branch import ScratchBranch
722
>>> b = ScratchBranch(files=['foo', 'foo~'])
723
>>> tree = WorkingTree(b.base, b)
811
>>> from bzrlib.bzrdir import ScratchDir
812
>>> d = ScratchDir(files=['foo', 'foo~'])
813
>>> b = d.open_branch()
814
>>> tree = d.open_workingtree()
724
815
>>> map(str, tree.unknowns())
725
816
['foo']
726
817
>>> tree.add('foo')
745
836
yield stem
746
837
747
838
@needs_write_lock
748
def pull(self, source, overwrite=False):
749
from bzrlib.merge import merge_inner
839
def pull(self, source, overwrite=False, stop_revision=None):
750
840
source.lock_read()
751
841
try:
752
842
old_revision_history = self.branch.revision_history()
753
count = self.branch.pull(source, overwrite)
843
count = self.branch.pull(source, overwrite, stop_revision)
754
844
new_revision_history = self.branch.revision_history()
755
845
if new_revision_history != old_revision_history:
756
846
if len(old_revision_history):
759
849
other_revision = None
760
850
repository = self.branch.repository
761
851
merge_inner(self.branch,
762
self.branch.basis_tree(),
852
self.basis_tree(),
763
853
repository.revision_tree(other_revision),
764
this_tree=self)
854
this_tree=self,
855
pb=bzrlib.ui.ui_factory.progress_bar())
765
856
self.set_last_revision(self.branch.last_revision())
766
857
return count
767
858
finally:
861
952
def kind(self, file_id):
862
953
return file_kind(self.id2abspath(file_id))
863
954
955
@needs_read_lock
956
def last_revision(self):
957
"""Return the last revision id of this working tree.
958
959
In early branch formats this was == the branch last_revision,
960
but that cannot be relied upon - for working tree operations,
961
always use tree.last_revision().
962
"""
963
return self.branch.last_revision()
964
864
965
def lock_read(self):
865
966
"""See Branch.lock_read, and WorkingTree.unlock."""
866
return self.branch.lock_read()
967
self.branch.lock_read()
968
try:
969
return self._control_files.lock_read()
970
except:
971
self.branch.unlock()
972
raise
867
973
868
974
def lock_write(self):
869
975
"""See Branch.lock_write, and WorkingTree.unlock."""
870
return self.branch.lock_write()
976
self.branch.lock_write()
977
try:
978
return self._control_files.lock_write()
979
except:
980
self.branch.unlock()
981
raise
871
982
872
983
def _basis_inventory_name(self, revision_id):
873
984
return 'basis-inventory.%s' % revision_id
874
985
986
@needs_write_lock
875
987
def set_last_revision(self, new_revision, old_revision=None):
876
if old_revision is not None:
877
try:
878
path = self._basis_inventory_name(old_revision)
879
path = self.branch.control_files._escape(path)
880
self.branch.control_files._transport.delete(path)
881
except NoSuchFile:
882
pass
988
"""Change the last revision in the working tree."""
989
self._remove_old_basis(old_revision)
990
if self._change_last_revision(new_revision):
991
self._cache_basis_inventory(new_revision)
992
993
def _change_last_revision(self, new_revision):
994
"""Template method part of set_last_revision to perform the change."""
995
if new_revision is None:
996
self.branch.set_revision_history([])
997
return False
998
# current format is locked in with the branch
999
revision_history = self.branch.revision_history()
1000
try:
1001
position = revision_history.index(new_revision)
1002
except ValueError:
1003
raise errors.NoSuchRevision(self.branch, new_revision)
1004
self.branch.set_revision_history(revision_history[:position + 1])
1005
return True
1006
1007
def _cache_basis_inventory(self, new_revision):
1008
"""Cache new_revision as the basis inventory."""
883
1009
try:
884
1010
xml = self.branch.repository.get_inventory_xml(new_revision)
885
1011
path = self._basis_inventory_name(new_revision)
886
self.branch.control_files.put_utf8(path, xml)
1012
self._control_files.put_utf8(path, xml)
887
1013
except WeaveRevisionNotPresent:
888
1014
pass
889
1015
1016
def _remove_old_basis(self, old_revision):
1017
"""Remove the old basis inventory 'old_revision'."""
1018
if old_revision is not None:
1019
try:
1020
path = self._basis_inventory_name(old_revision)
1021
path = self._control_files._escape(path)
1022
self._control_files._transport.delete(path)
1023
except NoSuchFile:
1024
pass
1025
890
1026
def read_basis_inventory(self, revision_id):
891
1027
"""Read the cached basis inventory."""
892
1028
path = self._basis_inventory_name(revision_id)
893
return self.branch.control_files.get_utf8(path).read()
1029
return self._control_files.get_utf8(path).read()
894
1030
895
1031
@needs_read_lock
896
1032
def read_working_inventory(self):
897
1033
"""Read the working inventory."""
898
1034
# ElementTree does its own conversion from UTF-8, so open in
899
1035
# binary.
900
return bzrlib.xml5.serializer_v5.read_inventory(
1036
result = bzrlib.xml5.serializer_v5.read_inventory(
901
1037
self._control_files.get('inventory'))
1038
self._set_inventory(result)
1039
return result
902
1040
903
1041
@needs_write_lock
904
1042
def remove(self, files, verbose=False):
942
1080
self._write_inventory(inv)
943
1081
944
1082
@needs_write_lock
945
def revert(self, filenames, old_tree=None, backups=True):
946
from bzrlib.merge import merge_inner
1083
def revert(self, filenames, old_tree=None, backups=True,
1084
pb=DummyProgress()):
1085
from transform import revert
947
1086
if old_tree is None:
948
old_tree = self.branch.basis_tree()
949
merge_inner(self.branch, old_tree,
950
self, ignore_zero=True,
951
backup_files=backups,
952
interesting_files=filenames,
953
this_tree=self)
1087
old_tree = self.basis_tree()
1088
revert(self, old_tree, filenames, backups, pb)
954
1089
if not len(filenames):
955
1090
self.set_pending_merges([])
956
1091
987
1122
inv._byid[inv.root.file_id] = inv.root
988
1123
for fid in inv:
989
1124
entry = inv[fid]
990
if entry.parent_id in (None, orig_root_id):
1125
if entry.parent_id == orig_root_id:
991
1126
entry.parent_id = inv.root.file_id
992
1127
self._write_inventory(inv)
993
1128
1005
1140
# of a nasty hack; probably it's better to have a transaction object,
1006
1141
# which can do some finalization when it's either successfully or
1007
1142
# unsuccessfully completed. (Denys's original patch did that.)
1008
if self._hashcache.needs_write and self.branch.control_files._lock_count==1:
1143
# RBC 20060206 hookinhg into transaction will couple lock and transaction
1144
# wrongly. Hookinh into unllock on the control files object is fine though.
1145
1146
# TODO: split this per format so there is no ugly if block
1147
if self._hashcache.needs_write and (
1148
# dedicated lock files
1149
self._control_files._lock_count==1 or
1150
# shared lock files
1151
(self._control_files is self.branch.control_files and
1152
self._control_files._lock_count==3)):
1009
1153
self._hashcache.write()
1010
return self.branch.unlock()
1154
# reverse order of locking.
1155
result = self._control_files.unlock()
1156
try:
1157
self.branch.unlock()
1158
finally:
1159
return result
1160
1161
@needs_write_lock
1162
def update(self):
1163
self.branch.lock_read()
1164
try:
1165
if self.last_revision() == self.branch.last_revision():
1166
return
1167
basis = self.basis_tree()
1168
to_tree = self.branch.basis_tree()
1169
result = merge_inner(self.branch,
1170
to_tree,
1171
basis,
1172
this_tree=self)
1173
self.set_last_revision(self.branch.last_revision())
1174
return result
1175
finally:
1176
self.branch.unlock()
1011
1177
1012
1178
@needs_write_lock
1013
1179
def _write_inventory(self, inv):
1018
1184
self._control_files.put('inventory', sio)
1019
1185
self._set_inventory(inv)
1020
1186
mutter('wrote working inventory')
1021
1187
1188
1189
class WorkingTree3(WorkingTree):
1190
"""This is the Format 3 working tree.
1191
1192
This differs from the base WorkingTree by:
1193
- having its own file lock
1194
- having its own last-revision property.
1195
"""
1196
1197
@needs_read_lock
1198
def last_revision(self):
1199
"""See WorkingTree.last_revision."""
1200
try:
1201
return self._control_files.get_utf8('last-revision').read()
1202
except NoSuchFile:
1203
return None
1204
1205
def _change_last_revision(self, revision_id):
1206
"""See WorkingTree._change_last_revision."""
1207
if revision_id is None or revision_id == NULL_REVISION:
1208
try:
1209
self._control_files._transport.delete('last-revision')
1210
except errors.NoSuchFile:
1211
pass
1212
return False
1213
else:
1214
try:
1215
self.branch.revision_history().index(revision_id)
1216
except ValueError:
1217
raise errors.NoSuchRevision(self.branch, revision_id)
1218
self._control_files.put_utf8('last-revision', revision_id)
1219
return True
1220
1022
1221
1023
1222
CONFLICT_SUFFIXES = ('.THIS', '.BASE', '.OTHER')
1024
1223
def get_conflicted_stem(path):
1025
1224
for suffix in CONFLICT_SUFFIXES:
1026
1225
if path.endswith(suffix):
1027
1226
return path[:-len(suffix)]
1227
1228
@deprecated_function(zero_eight)
1229
def is_control_file(filename):
1230
"""See WorkingTree.is_control_filename(filename)."""
1231
## FIXME: better check
1232
filename = normpath(filename)
1233
while filename != '':
1234
head, tail = os.path.split(filename)
1235
## mutter('check %r for control file' % ((head, tail),))
1236
if tail == '.bzr':
1237
return True
1238
if filename == head:
1239
break
1240
filename = head
1241
return False
1242
1243
1244
class WorkingTreeFormat(object):
1245
"""An encapsulation of the initialization and open routines for a format.
1246
1247
Formats provide three things:
1248
* An initialization routine,
1249
* a format string,
1250
* an open routine.
1251
1252
Formats are placed in an dict by their format string for reference
1253
during workingtree opening. Its not required that these be instances, they
1254
can be classes themselves with class methods - it simply depends on
1255
whether state is needed for a given format or not.
1256
1257
Once a format is deprecated, just deprecate the initialize and open
1258
methods on the format class. Do not deprecate the object, as the
1259
object will be created every time regardless.
1260
"""
1261
1262
_default_format = None
1263
"""The default format used for new trees."""
1264
1265
_formats = {}
1266
"""The known formats."""
1267
1268
@classmethod
1269
def find_format(klass, a_bzrdir):
1270
"""Return the format for the working tree object in a_bzrdir."""
1271
try:
1272
transport = a_bzrdir.get_workingtree_transport(None)
1273
format_string = transport.get("format").read()
1274
return klass._formats[format_string]
1275
except NoSuchFile:
1276
raise errors.NoWorkingTree(base=transport.base)
1277
except KeyError:
1278
raise errors.UnknownFormatError(format_string)
1279
1280
@classmethod
1281
def get_default_format(klass):
1282
"""Return the current default format."""
1283
return klass._default_format
1284
1285
def get_format_string(self):
1286
"""Return the ASCII format string that identifies this format."""
1287
raise NotImplementedError(self.get_format_string)
1288
1289
def is_supported(self):
1290
"""Is this format supported?
1291
1292
Supported formats can be initialized and opened.
1293
Unsupported formats may not support initialization or committing or
1294
some other features depending on the reason for not being supported.
1295
"""
1296
return True
1297
1298
@classmethod
1299
def register_format(klass, format):
1300
klass._formats[format.get_format_string()] = format
1301
1302
@classmethod
1303
def set_default_format(klass, format):
1304
klass._default_format = format
1305
1306
@classmethod
1307
def unregister_format(klass, format):
1308
assert klass._formats[format.get_format_string()] is format
1309
del klass._formats[format.get_format_string()]
1310
1311
1312
1313
class WorkingTreeFormat2(WorkingTreeFormat):
1314
"""The second working tree format.
1315
1316
This format modified the hash cache from the format 1 hash cache.
1317
"""
1318
1319
def initialize(self, a_bzrdir, revision_id=None):
1320
"""See WorkingTreeFormat.initialize()."""
1321
if not isinstance(a_bzrdir.transport, LocalTransport):
1322
raise errors.NotLocalUrl(a_bzrdir.transport.base)
1323
branch = a_bzrdir.open_branch()
1324
if revision_id is not None:
1325
branch.lock_write()
1326
try:
1327
revision_history = branch.revision_history()
1328
try:
1329
position = revision_history.index(revision_id)
1330
except ValueError:
1331
raise errors.NoSuchRevision(branch, revision_id)
1332
branch.set_revision_history(revision_history[:position + 1])
1333
finally:
1334
branch.unlock()
1335
revision = branch.last_revision()
1336
inv = Inventory()
1337
wt = WorkingTree(a_bzrdir.root_transport.base,
1338
branch,
1339
inv,
1340
_internal=True,
1341
_format=self,
1342
_bzrdir=a_bzrdir)
1343
wt._write_inventory(inv)
1344
wt.set_root_id(inv.root.file_id)
1345
wt.set_last_revision(revision)
1346
wt.set_pending_merges([])
1347
build_tree(wt.basis_tree(), wt)
1348
return wt
1349
1350
def __init__(self):
1351
super(WorkingTreeFormat2, self).__init__()
1352
self._matchingbzrdir = bzrdir.BzrDirFormat6()
1353
1354
def open(self, a_bzrdir, _found=False):
1355
"""Return the WorkingTree object for a_bzrdir
1356
1357
_found is a private parameter, do not use it. It is used to indicate
1358
if format probing has already been done.
1359
"""
1360
if not _found:
1361
# we are being called directly and must probe.
1362
raise NotImplementedError
1363
if not isinstance(a_bzrdir.transport, LocalTransport):
1364
raise errors.NotLocalUrl(a_bzrdir.transport.base)
1365
return WorkingTree(a_bzrdir.root_transport.base,
1366
_internal=True,
1367
_format=self,
1368
_bzrdir=a_bzrdir)
1369
1370
1371
class WorkingTreeFormat3(WorkingTreeFormat):
1372
"""The second working tree format updated to record a format marker.
1373
1374
This format modified the hash cache from the format 1 hash cache.
1375
"""
1376
1377
def get_format_string(self):
1378
"""See WorkingTreeFormat.get_format_string()."""
1379
return "Bazaar-NG Working Tree format 3"
1380
1381
def initialize(self, a_bzrdir, revision_id=None):
1382
"""See WorkingTreeFormat.initialize().
1383
1384
revision_id allows creating a working tree at a differnet
1385
revision than the branch is at.
1386
"""
1387
if not isinstance(a_bzrdir.transport, LocalTransport):
1388
raise errors.NotLocalUrl(a_bzrdir.transport.base)
1389
transport = a_bzrdir.get_workingtree_transport(self)
1390
control_files = LockableFiles(transport, 'lock')
1391
control_files.put_utf8('format', self.get_format_string())
1392
branch = a_bzrdir.open_branch()
1393
if revision_id is None:
1394
revision_id = branch.last_revision()
1395
inv = Inventory()
1396
wt = WorkingTree3(a_bzrdir.root_transport.base,
1397
branch,
1398
inv,
1399
_internal=True,
1400
_format=self,
1401
_bzrdir=a_bzrdir)
1402
wt._write_inventory(inv)
1403
wt.set_root_id(inv.root.file_id)
1404
wt.set_last_revision(revision_id)
1405
wt.set_pending_merges([])
1406
build_tree(wt.basis_tree(), wt)
1407
return wt
1408
1409
def __init__(self):
1410
super(WorkingTreeFormat3, self).__init__()
1411
self._matchingbzrdir = bzrdir.BzrDirMetaFormat1()
1412
1413
def open(self, a_bzrdir, _found=False):
1414
"""Return the WorkingTree object for a_bzrdir
1415
1416
_found is a private parameter, do not use it. It is used to indicate
1417
if format probing has already been done.
1418
"""
1419
if not _found:
1420
# we are being called directly and must probe.
1421
raise NotImplementedError
1422
if not isinstance(a_bzrdir.transport, LocalTransport):
1423
raise errors.NotLocalUrl(a_bzrdir.transport.base)
1424
return WorkingTree3(a_bzrdir.root_transport.base,
1425
_internal=True,
1426
_format=self,
1427
_bzrdir=a_bzrdir)
1428
1429
def __str__(self):
1430
return self.get_format_string()
1431
1432
1433
# formats which have no format string are not discoverable
1434
# and not independently creatable, so are not registered.
1435
__default_format = WorkingTreeFormat3()
1436
WorkingTreeFormat.register_format(__default_format)
1437
WorkingTreeFormat.set_default_format(__default_format)
1438
_legacy_formats = [WorkingTreeFormat2(),
1439
]
1440
1441
1442
class WorkingTreeTestProviderAdapter(object):
1443
"""A tool to generate a suite testing multiple workingtree formats at once.
1444
1445
This is done by copying the test once for each transport and injecting
1446
the transport_server, transport_readonly_server, and workingtree_format
1447
classes into each copy. Each copy is also given a new id() to make it
1448
easy to identify.
1449
"""
1450
1451
def __init__(self, transport_server, transport_readonly_server, formats):
1452
self._transport_server = transport_server
1453
self._transport_readonly_server = transport_readonly_server
1454
self._formats = formats
1455
1456
def adapt(self, test):
1457
from bzrlib.tests import TestSuite
1458
result = TestSuite()
1459
for workingtree_format, bzrdir_format in self._formats:
1460
new_test = deepcopy(test)
1461
new_test.transport_server = self._transport_server
1462
new_test.transport_readonly_server = self._transport_readonly_server
1463
new_test.bzrdir_format = bzrdir_format
1464
new_test.workingtree_format = workingtree_format
1465
def make_new_test_id():
1466
new_id = "%s(%s)" % (new_test.id(), workingtree_format.__class__.__name__)
1467
return lambda: new_id
1468
new_test.id = make_new_test_id()
1469
result.addTest(new_test)
1470
return result
Loggerhead is a web-based interface for Breezy
Version: 2.0.1