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