14
14
# along with this program; if not, write to the Free Software
15
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
17
"""WorkingTree object and friends.
19
A WorkingTree represents the editable working copy of a branch.
20
Operations which represent the WorkingTree are also done here,
21
such as renaming or adding files. The WorkingTree has an inventory
22
which is updated by these operations. A commit produces a
23
new revision based on the workingtree and its inventory.
25
At the moment every WorkingTree has its own branch. Remote
26
WorkingTrees aren't supported.
28
To get a WorkingTree, call bzrdir.open_workingtree() or
29
WorkingTree.open(dir).
17
# TODO: Don't allow WorkingTrees to be constructed for remote branches.
33
19
# FIXME: I don't know if writing out the cache from the destructor is really a
34
# good idea, because destructors are considered poor taste in Python, and it's
35
# not predictable when it will be written out.
37
# TODO: Give the workingtree sole responsibility for the working inventory;
38
# remove the variable and references to it from the branch. This may require
39
# updating the commit code so as to update the inventory within the working
40
# copy, and making sure there's only one WorkingTree for any directory on disk.
41
# At the momenthey may alias the inventory and have old copies of it in memory.
43
from copy import deepcopy
44
from cStringIO import StringIO
20
# good idea, because destructors are considered poor taste in Python, and
21
# it's not predictable when it will be written out.
51
from bzrlib.atomicfile import AtomicFile
52
from bzrlib.branch import (Branch,
54
import bzrlib.bzrdir as bzrdir
55
from bzrlib.decorators import needs_read_lock, needs_write_lock
56
import bzrlib.errors as errors
57
from bzrlib.errors import (BzrCheckError,
60
WeaveRevisionNotPresent,
64
from bzrlib.inventory import InventoryEntry, Inventory
65
from bzrlib.lockable_files import LockableFiles
66
from bzrlib.merge import merge_inner, transform_tree
67
from bzrlib.osutils import (appendpath,
84
from bzrlib.progress import DummyProgress
85
from bzrlib.revision import NULL_REVISION
86
from bzrlib.symbol_versioning import *
87
from bzrlib.textui import show_status
28
from bzrlib.osutils import appendpath, file_kind, isdir, splitpath
29
from bzrlib.errors import BzrCheckError
89
30
from bzrlib.trace import mutter
90
from bzrlib.transform import build_tree
91
from bzrlib.transport import get_transport
92
from bzrlib.transport.local import LocalTransport
97
def gen_file_id(name):
98
"""Return new file id.
100
This should probably generate proper UUIDs, but for the moment we
101
cope with just randomness because running uuidgen every time is
104
from binascii import hexlify
105
from time import time
108
idx = name.rfind('/')
110
name = name[idx+1 : ]
111
idx = name.rfind('\\')
113
name = name[idx+1 : ]
115
# make it not a hidden file
116
name = name.lstrip('.')
118
# remove any wierd characters; we don't escape them but rather
120
name = re.sub(r'[^\w.]', '', name)
122
s = hexlify(rand_bytes(8))
123
return '-'.join((name, compact_date(time()), s))
127
"""Return a new tree-root file id."""
128
return gen_file_id('TREE_ROOT')
131
32
class TreeEntry(object):
132
33
"""An entry that implements the minium interface used by commands.
192
93
It is possible for a `WorkingTree` to have a filename which is
193
94
not listed in the Inventory and vice versa.
196
def __init__(self, basedir='.',
197
branch=DEPRECATED_PARAMETER,
203
"""Construct a WorkingTree for basedir.
205
If the branch is not supplied, it is opened automatically.
206
If the branch is supplied, it must be the branch for this basedir.
207
(branch.base is not cross checked, because for remote branches that
208
would be meaningless).
210
self._format = _format
211
self.bzrdir = _bzrdir
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().",
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
96
def __init__(self, basedir, inv):
226
97
from bzrlib.hashcache import HashCache
227
98
from bzrlib.trace import note, mutter
228
assert isinstance(basedir, basestring), \
229
"base directory %r is not a string" % basedir
230
basedir = safe_unicode(basedir)
231
mutter("opening working tree %r", basedir)
232
if deprecated_passed(branch):
234
warn("WorkingTree(..., branch=XXX) is deprecated as of bzr 0.8."
235
" Please use bzrdir.open_workingtree() or WorkingTree.open().",
241
self.branch = self.bzrdir.open_branch()
242
assert isinstance(self.branch, Branch), \
243
"branch %r is not a Branch" % self.branch
244
self.basedir = realpath(basedir)
245
# if branch is at our basedir and is a format 6 or less
246
if isinstance(self._format, WorkingTreeFormat2):
247
# share control object
248
self._control_files = self.branch.control_files
249
elif _control_files is not None:
250
assert False, "not done yet"
251
# self._control_files = _control_files
253
# only ready for format 3
254
assert isinstance(self._format, WorkingTreeFormat3)
255
self._control_files = LockableFiles(
256
self.bzrdir.get_workingtree_transport(None),
100
self._inventory = inv
101
self.basedir = basedir
102
self.path2id = inv.path2id
259
104
# update the whole cache up front and write to disk if anything changed;
260
105
# in the future we might want to do this more selectively
261
# two possible ways offer themselves : in self._unlock, write the cache
262
# if needed, or, when the cache sees a change, append it to the hash
263
# cache file, and have the parser take the most recent entry for a
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)
106
hc = self._hashcache = HashCache(basedir)
268
# is this scan needed ? it makes things kinda slow.
271
110
if hc.needs_write:
272
111
mutter("write hc")
275
if _inventory is None:
276
self._set_inventory(self.read_working_inventory())
278
self._set_inventory(_inventory)
280
def _set_inventory(self, inv):
281
self._inventory = inv
282
self.path2id = self._inventory.path2id
284
def is_control_filename(self, filename):
285
"""True if filename is the name of a control file in this tree.
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.
292
self.bzrdir.transport.relpath(self.abspath(filename))
294
except errors.PathNotChild:
298
def open(path=None, _unsupported=False):
299
"""Open an existing working tree at path.
303
path = os.path.getcwdu()
304
control = bzrdir.BzrDir.open(path, _unsupported)
305
return control.open_workingtree(_unsupported)
308
def open_containing(path=None):
309
"""Open an existing working tree which has its root about path.
311
This probes for a working tree at path and searches upwards from there.
313
Basically we keep looking up until we find the control directory or
314
run into /. If there isn't one, raises NotBranchError.
315
TODO: give this a new exception.
316
If there is one, it is returned, along with the unused portion of path.
320
control, relpath = bzrdir.BzrDir.open_containing(path)
321
return control.open_workingtree(), relpath
324
def open_downlevel(path=None):
325
"""Open an unsupported working tree.
327
Only intended for advanced situations like upgrading part of a bzrdir.
329
return WorkingTree.open(path, _unsupported=True)
116
if self._hashcache.needs_write:
117
self._hashcache.write()
331
120
def __iter__(self):
332
121
"""Iterate through file_ids for this tree.
473
164
path = inv.id2path(file_id)
474
165
return bzrlib.osutils.lexists(self.abspath(path))
476
def has_or_had_id(self, file_id):
477
if file_id == self.inventory.root.file_id:
479
return self.inventory.has_id(file_id)
481
168
__contains__ = has_id
483
171
def get_file_size(self, file_id):
484
172
return os.path.getsize(self.id2abspath(file_id))
487
174
def get_file_sha1(self, file_id):
488
175
path = self._inventory.id2path(file_id)
489
176
return self._hashcache.get_sha1(path)
491
179
def is_executable(self, file_id):
492
if not supports_executable():
493
181
return self._inventory[file_id].executable
495
183
path = self._inventory.id2path(file_id)
496
184
mode = os.lstat(self.abspath(path)).st_mode
497
185
return bool(stat.S_ISREG(mode) and stat.S_IEXEC&mode)
500
def add(self, files, ids=None):
501
"""Make files versioned.
503
Note that the command line normally calls smart_add instead,
504
which can automatically recurse.
506
This adds the files to the inventory, so that they will be
507
recorded by the next commit.
510
List of paths to add, relative to the base of the tree.
513
If set, use these instead of automatically generated ids.
514
Must be the same length as the list of files, but may
515
contain None for ids that are to be autogenerated.
517
TODO: Perhaps have an option to add the ids even if the files do
520
TODO: Perhaps callback with the ids and paths as they're added.
522
# TODO: Re-adding a file that is removed in the working copy
523
# should probably put it back with the previous ID.
524
if isinstance(files, basestring):
525
assert(ids is None or isinstance(ids, basestring))
531
ids = [None] * len(files)
533
assert(len(ids) == len(files))
535
inv = self.read_working_inventory()
536
for f,file_id in zip(files, ids):
537
if self.is_control_filename(f):
538
raise BzrError("cannot add control file %s" % quotefn(f))
543
raise BzrError("cannot add top-level %r" % f)
545
fullpath = normpath(self.abspath(f))
548
kind = file_kind(fullpath)
550
if e.errno == errno.ENOENT:
551
raise NoSuchFile(fullpath)
552
# maybe something better?
553
raise BzrError('cannot add: not a regular file, symlink or directory: %s' % quotefn(f))
555
if not InventoryEntry.versionable_kind(kind):
556
raise BzrError('cannot add: not a versionable file ('
557
'i.e. regular file, symlink or directory): %s' % quotefn(f))
560
file_id = gen_file_id(f)
561
inv.add_path(f, kind=kind, file_id=file_id)
563
mutter("add file %s file_id:{%s} kind=%r" % (f, file_id, kind))
564
self._write_inventory(inv)
567
def add_pending_merge(self, *revision_ids):
568
# TODO: Perhaps should check at this point that the
569
# history of the revision is actually present?
570
p = self.pending_merges()
572
for rev_id in revision_ids:
578
self.set_pending_merges(p)
581
def pending_merges(self):
582
"""Return a list of pending merges.
584
These are revisions that have been merged into the working
585
directory but not yet committed.
588
merges_file = self._control_files.get_utf8('pending-merges')
590
if e.errno != errno.ENOENT:
594
for l in merges_file.readlines():
595
p.append(l.rstrip('\n'))
599
def set_pending_merges(self, rev_list):
600
self._control_files.put_utf8('pending-merges', '\n'.join(rev_list))
602
187
def get_symlink_target(self, file_id):
603
188
return os.readlink(self.id2abspath(file_id))
681
265
for ff in descend(fp, f_ie.file_id, fap):
684
for f in descend(u'', inv.root.file_id, self.basedir):
268
for f in descend('', inv.root.file_id, self.basedir):
688
def move(self, from_paths, to_name):
691
to_name must exist in the inventory.
693
If to_name exists and is a directory, the files are moved into
694
it, keeping their old names.
696
Note that to_name is only the last component of the new name;
697
this doesn't change the directory.
699
This returns a list of (from_path, to_path) pairs for each
703
## TODO: Option to move IDs only
704
assert not isinstance(from_paths, basestring)
706
to_abs = self.abspath(to_name)
707
if not isdir(to_abs):
708
raise BzrError("destination %r is not a directory" % to_abs)
709
if not self.has_filename(to_name):
710
raise BzrError("destination %r not in working directory" % to_abs)
711
to_dir_id = inv.path2id(to_name)
712
if to_dir_id == None and to_name != '':
713
raise BzrError("destination %r is not a versioned directory" % to_name)
714
to_dir_ie = inv[to_dir_id]
715
if to_dir_ie.kind not in ('directory', 'root_directory'):
716
raise BzrError("destination %r is not a directory" % to_abs)
718
to_idpath = inv.get_idpath(to_dir_id)
721
if not self.has_filename(f):
722
raise BzrError("%r does not exist in working tree" % f)
723
f_id = inv.path2id(f)
725
raise BzrError("%r is not versioned" % f)
726
name_tail = splitpath(f)[-1]
727
dest_path = appendpath(to_name, name_tail)
728
if self.has_filename(dest_path):
729
raise BzrError("destination %r already exists" % dest_path)
730
if f_id in to_idpath:
731
raise BzrError("can't move %r to a subdirectory of itself" % f)
733
# OK, so there's a race here, it's possible that someone will
734
# create a file in this interval and then the rename might be
735
# left half-done. But we should have caught most problems.
736
orig_inv = deepcopy(self.inventory)
739
name_tail = splitpath(f)[-1]
740
dest_path = appendpath(to_name, name_tail)
741
result.append((f, dest_path))
742
inv.rename(inv.path2id(f), to_dir_id, name_tail)
744
rename(self.abspath(f), self.abspath(dest_path))
746
raise BzrError("failed to rename %r to %r: %s" %
747
(f, dest_path, e[1]),
748
["rename rolled back"])
750
# restore the inventory on error
751
self._set_inventory(orig_inv)
753
self._write_inventory(inv)
757
def rename_one(self, from_rel, to_rel):
760
This can change the directory or the filename or both.
763
if not self.has_filename(from_rel):
764
raise BzrError("can't rename: old working file %r does not exist" % from_rel)
765
if self.has_filename(to_rel):
766
raise BzrError("can't rename: new working file %r already exists" % to_rel)
768
file_id = inv.path2id(from_rel)
770
raise BzrError("can't rename: old name %r is not versioned" % from_rel)
773
from_parent = entry.parent_id
774
from_name = entry.name
776
if inv.path2id(to_rel):
777
raise BzrError("can't rename: new name %r is already versioned" % to_rel)
779
to_dir, to_tail = os.path.split(to_rel)
780
to_dir_id = inv.path2id(to_dir)
781
if to_dir_id == None and to_dir != '':
782
raise BzrError("can't determine destination directory id for %r" % to_dir)
784
mutter("rename_one:")
785
mutter(" file_id {%s}" % file_id)
786
mutter(" from_rel %r" % from_rel)
787
mutter(" to_rel %r" % to_rel)
788
mutter(" to_dir %r" % to_dir)
789
mutter(" to_dir_id {%s}" % to_dir_id)
791
inv.rename(file_id, to_dir_id, to_tail)
793
from_abs = self.abspath(from_rel)
794
to_abs = self.abspath(to_rel)
796
rename(from_abs, to_abs)
798
inv.rename(file_id, from_parent, from_name)
799
raise BzrError("failed to rename %r to %r: %s"
800
% (from_abs, to_abs, e[1]),
801
["rename rolled back"])
802
self._write_inventory(inv)
805
273
def unknowns(self):
806
"""Return all unknown files.
808
These are files in the working directory that are not versioned or
809
control files or ignored.
811
>>> from bzrlib.bzrdir import ScratchDir
812
>>> d = ScratchDir(files=['foo', 'foo~'])
813
>>> b = d.open_branch()
814
>>> tree = d.open_workingtree()
815
>>> map(str, tree.unknowns())
818
>>> list(b.unknowns())
820
>>> tree.remove('foo')
821
>>> list(b.unknowns())
824
274
for subp in self.extras():
825
275
if not self.is_ignored(subp):
953
def kind(self, file_id):
954
return file_kind(self.id2abspath(file_id))
957
def last_revision(self):
958
"""Return the last revision id of this working tree.
960
In early branch formats this was == the branch last_revision,
961
but that cannot be relied upon - for working tree operations,
962
always use tree.last_revision().
964
return self.branch.last_revision()
967
"""See Branch.lock_read, and WorkingTree.unlock."""
968
self.branch.lock_read()
970
return self._control_files.lock_read()
975
def lock_write(self):
976
"""See Branch.lock_write, and WorkingTree.unlock."""
977
self.branch.lock_write()
979
return self._control_files.lock_write()
984
def _basis_inventory_name(self, revision_id):
985
return 'basis-inventory.%s' % revision_id
988
def set_last_revision(self, new_revision, old_revision=None):
989
"""Change the last revision in the working tree."""
990
self._remove_old_basis(old_revision)
991
if self._change_last_revision(new_revision):
992
self._cache_basis_inventory(new_revision)
994
def _change_last_revision(self, new_revision):
995
"""Template method part of set_last_revision to perform the change."""
996
if new_revision is None:
997
self.branch.set_revision_history([])
999
# current format is locked in with the branch
1000
revision_history = self.branch.revision_history()
1002
position = revision_history.index(new_revision)
1004
raise errors.NoSuchRevision(self.branch, new_revision)
1005
self.branch.set_revision_history(revision_history[:position + 1])
1008
def _cache_basis_inventory(self, new_revision):
1009
"""Cache new_revision as the basis inventory."""
1011
xml = self.branch.repository.get_inventory_xml(new_revision)
1012
path = self._basis_inventory_name(new_revision)
1013
self._control_files.put_utf8(path, xml)
1014
except WeaveRevisionNotPresent:
1017
def _remove_old_basis(self, old_revision):
1018
"""Remove the old basis inventory 'old_revision'."""
1019
if old_revision is not None:
1021
path = self._basis_inventory_name(old_revision)
1022
path = self._control_files._escape(path)
1023
self._control_files._transport.delete(path)
1027
def read_basis_inventory(self, revision_id):
1028
"""Read the cached basis inventory."""
1029
path = self._basis_inventory_name(revision_id)
1030
return self._control_files.get_utf8(path).read()
1033
def read_working_inventory(self):
1034
"""Read the working inventory."""
1035
# ElementTree does its own conversion from UTF-8, so open in
1037
result = bzrlib.xml5.serializer_v5.read_inventory(
1038
self._control_files.get('inventory'))
1039
self._set_inventory(result)
1043
def remove(self, files, verbose=False):
1044
"""Remove nominated files from the working inventory..
1046
This does not remove their text. This does not run on XXX on what? RBC
1048
TODO: Refuse to remove modified files unless --force is given?
1050
TODO: Do something useful with directories.
1052
TODO: Should this remove the text or not? Tough call; not
1053
removing may be useful and the user can just use use rm, and
1054
is the opposite of add. Removing it is consistent with most
1055
other tools. Maybe an option.
1057
## TODO: Normalize names
1058
## TODO: Remove nested loops; better scalability
1059
if isinstance(files, basestring):
1062
inv = self.inventory
1064
# do this before any modifications
1066
fid = inv.path2id(f)
1068
# TODO: Perhaps make this just a warning, and continue?
1069
# This tends to happen when
1070
raise NotVersionedError(path=f)
1071
mutter("remove inventory entry %s {%s}", quotefn(f), fid)
1073
# having remove it, it must be either ignored or unknown
1074
if self.is_ignored(f):
1078
show_status(new_status, inv[fid].kind, quotefn(f))
1081
self._write_inventory(inv)
1084
def revert(self, filenames, old_tree=None, backups=True,
1085
pb=DummyProgress()):
1086
from transform import revert
1087
if old_tree is None:
1088
old_tree = self.basis_tree()
1089
revert(self, old_tree, filenames, backups, pb)
1090
if not len(filenames):
1091
self.set_pending_merges([])
1094
def set_inventory(self, new_inventory_list):
1095
from bzrlib.inventory import (Inventory,
1100
inv = Inventory(self.get_root_id())
1101
for path, file_id, parent, kind in new_inventory_list:
1102
name = os.path.basename(path)
1105
# fixme, there should be a factory function inv,add_??
1106
if kind == 'directory':
1107
inv.add(InventoryDirectory(file_id, name, parent))
1108
elif kind == 'file':
1109
inv.add(InventoryFile(file_id, name, parent))
1110
elif kind == 'symlink':
1111
inv.add(InventoryLink(file_id, name, parent))
1113
raise BzrError("unknown kind %r" % kind)
1114
self._write_inventory(inv)
1117
def set_root_id(self, file_id):
1118
"""Set the root id for this tree."""
1119
inv = self.read_working_inventory()
1120
orig_root_id = inv.root.file_id
1121
del inv._byid[inv.root.file_id]
1122
inv.root.file_id = file_id
1123
inv._byid[inv.root.file_id] = inv.root
1126
if entry.parent_id == orig_root_id:
1127
entry.parent_id = inv.root.file_id
1128
self._write_inventory(inv)
1131
"""See Branch.unlock.
1133
WorkingTree locking just uses the Branch locking facilities.
1134
This is current because all working trees have an embedded branch
1135
within them. IF in the future, we were to make branch data shareable
1136
between multiple working trees, i.e. via shared storage, then we
1137
would probably want to lock both the local tree, and the branch.
1139
# FIXME: We want to write out the hashcache only when the last lock on
1140
# this working copy is released. Peeking at the lock count is a bit
1141
# of a nasty hack; probably it's better to have a transaction object,
1142
# which can do some finalization when it's either successfully or
1143
# unsuccessfully completed. (Denys's original patch did that.)
1144
# RBC 20060206 hookinhg into transaction will couple lock and transaction
1145
# wrongly. Hookinh into unllock on the control files object is fine though.
1147
# TODO: split this per format so there is no ugly if block
1148
if self._hashcache.needs_write and (
1149
# dedicated lock files
1150
self._control_files._lock_count==1 or
1152
(self._control_files is self.branch.control_files and
1153
self._control_files._lock_count==3)):
1154
self._hashcache.write()
1155
# reverse order of locking.
1156
result = self._control_files.unlock()
1158
self.branch.unlock()
1164
self.branch.lock_read()
1166
if self.last_revision() == self.branch.last_revision():
1168
basis = self.basis_tree()
1169
to_tree = self.branch.basis_tree()
1170
result = merge_inner(self.branch,
1174
self.set_last_revision(self.branch.last_revision())
1177
self.branch.unlock()
1180
def _write_inventory(self, inv):
1181
"""Write inventory as the current inventory."""
1183
bzrlib.xml5.serializer_v5.write_inventory(inv, sio)
1185
self._control_files.put('inventory', sio)
1186
self._set_inventory(inv)
1187
mutter('wrote working inventory')
1190
class WorkingTree3(WorkingTree):
1191
"""This is the Format 3 working tree.
1193
This differs from the base WorkingTree by:
1194
- having its own file lock
1195
- having its own last-revision property.
1199
def last_revision(self):
1200
"""See WorkingTree.last_revision."""
1202
return self._control_files.get_utf8('last-revision').read()
1206
def _change_last_revision(self, revision_id):
1207
"""See WorkingTree._change_last_revision."""
1208
if revision_id is None or revision_id == NULL_REVISION:
1210
self._control_files._transport.delete('last-revision')
1211
except errors.NoSuchFile:
1216
self.branch.revision_history().index(revision_id)
1218
raise errors.NoSuchRevision(self.branch, revision_id)
1219
self._control_files.put_utf8('last-revision', revision_id)
1223
379
CONFLICT_SUFFIXES = ('.THIS', '.BASE', '.OTHER')
1224
380
def get_conflicted_stem(path):
1225
381
for suffix in CONFLICT_SUFFIXES:
1226
382
if path.endswith(suffix):
1227
383
return path[:-len(suffix)]
1229
@deprecated_function(zero_eight)
1230
def is_control_file(filename):
1231
"""See WorkingTree.is_control_filename(filename)."""
1232
## FIXME: better check
1233
filename = normpath(filename)
1234
while filename != '':
1235
head, tail = os.path.split(filename)
1236
## mutter('check %r for control file' % ((head, tail),))
1239
if filename == head:
1245
class WorkingTreeFormat(object):
1246
"""An encapsulation of the initialization and open routines for a format.
1248
Formats provide three things:
1249
* An initialization routine,
1253
Formats are placed in an dict by their format string for reference
1254
during workingtree opening. Its not required that these be instances, they
1255
can be classes themselves with class methods - it simply depends on
1256
whether state is needed for a given format or not.
1258
Once a format is deprecated, just deprecate the initialize and open
1259
methods on the format class. Do not deprecate the object, as the
1260
object will be created every time regardless.
1263
_default_format = None
1264
"""The default format used for new trees."""
1267
"""The known formats."""
1270
def find_format(klass, a_bzrdir):
1271
"""Return the format for the working tree object in a_bzrdir."""
1273
transport = a_bzrdir.get_workingtree_transport(None)
1274
format_string = transport.get("format").read()
1275
return klass._formats[format_string]
1277
raise errors.NoWorkingTree(base=transport.base)
1279
raise errors.UnknownFormatError(format_string)
1282
def get_default_format(klass):
1283
"""Return the current default format."""
1284
return klass._default_format
1286
def get_format_string(self):
1287
"""Return the ASCII format string that identifies this format."""
1288
raise NotImplementedError(self.get_format_string)
1290
def is_supported(self):
1291
"""Is this format supported?
1293
Supported formats can be initialized and opened.
1294
Unsupported formats may not support initialization or committing or
1295
some other features depending on the reason for not being supported.
1300
def register_format(klass, format):
1301
klass._formats[format.get_format_string()] = format
1304
def set_default_format(klass, format):
1305
klass._default_format = format
1308
def unregister_format(klass, format):
1309
assert klass._formats[format.get_format_string()] is format
1310
del klass._formats[format.get_format_string()]
1314
class WorkingTreeFormat2(WorkingTreeFormat):
1315
"""The second working tree format.
1317
This format modified the hash cache from the format 1 hash cache.
1320
def initialize(self, a_bzrdir, revision_id=None):
1321
"""See WorkingTreeFormat.initialize()."""
1322
if not isinstance(a_bzrdir.transport, LocalTransport):
1323
raise errors.NotLocalUrl(a_bzrdir.transport.base)
1324
branch = a_bzrdir.open_branch()
1325
if revision_id is not None:
1328
revision_history = branch.revision_history()
1330
position = revision_history.index(revision_id)
1332
raise errors.NoSuchRevision(branch, revision_id)
1333
branch.set_revision_history(revision_history[:position + 1])
1336
revision = branch.last_revision()
1338
wt = WorkingTree(a_bzrdir.root_transport.base,
1344
wt._write_inventory(inv)
1345
wt.set_root_id(inv.root.file_id)
1346
wt.set_last_revision(revision)
1347
wt.set_pending_merges([])
1348
build_tree(wt.basis_tree(), wt)
1352
super(WorkingTreeFormat2, self).__init__()
1353
self._matchingbzrdir = bzrdir.BzrDirFormat6()
1355
def open(self, a_bzrdir, _found=False):
1356
"""Return the WorkingTree object for a_bzrdir
1358
_found is a private parameter, do not use it. It is used to indicate
1359
if format probing has already been done.
1362
# we are being called directly and must probe.
1363
raise NotImplementedError
1364
if not isinstance(a_bzrdir.transport, LocalTransport):
1365
raise errors.NotLocalUrl(a_bzrdir.transport.base)
1366
return WorkingTree(a_bzrdir.root_transport.base,
1372
class WorkingTreeFormat3(WorkingTreeFormat):
1373
"""The second working tree format updated to record a format marker.
1375
This format modified the hash cache from the format 1 hash cache.
1378
def get_format_string(self):
1379
"""See WorkingTreeFormat.get_format_string()."""
1380
return "Bazaar-NG Working Tree format 3"
1382
def initialize(self, a_bzrdir, revision_id=None):
1383
"""See WorkingTreeFormat.initialize().
1385
revision_id allows creating a working tree at a differnet
1386
revision than the branch is at.
1388
if not isinstance(a_bzrdir.transport, LocalTransport):
1389
raise errors.NotLocalUrl(a_bzrdir.transport.base)
1390
transport = a_bzrdir.get_workingtree_transport(self)
1391
control_files = LockableFiles(transport, 'lock')
1392
control_files.put_utf8('format', self.get_format_string())
1393
branch = a_bzrdir.open_branch()
1394
if revision_id is None:
1395
revision_id = branch.last_revision()
1397
wt = WorkingTree3(a_bzrdir.root_transport.base,
1403
wt._write_inventory(inv)
1404
wt.set_root_id(inv.root.file_id)
1405
wt.set_last_revision(revision_id)
1406
wt.set_pending_merges([])
1407
build_tree(wt.basis_tree(), wt)
1411
super(WorkingTreeFormat3, self).__init__()
1412
self._matchingbzrdir = bzrdir.BzrDirMetaFormat1()
1414
def open(self, a_bzrdir, _found=False):
1415
"""Return the WorkingTree object for a_bzrdir
1417
_found is a private parameter, do not use it. It is used to indicate
1418
if format probing has already been done.
1421
# we are being called directly and must probe.
1422
raise NotImplementedError
1423
if not isinstance(a_bzrdir.transport, LocalTransport):
1424
raise errors.NotLocalUrl(a_bzrdir.transport.base)
1425
return WorkingTree3(a_bzrdir.root_transport.base,
1431
return self.get_format_string()
1434
# formats which have no format string are not discoverable
1435
# and not independently creatable, so are not registered.
1436
__default_format = WorkingTreeFormat3()
1437
WorkingTreeFormat.register_format(__default_format)
1438
WorkingTreeFormat.set_default_format(__default_format)
1439
_legacy_formats = [WorkingTreeFormat2(),
1443
class WorkingTreeTestProviderAdapter(object):
1444
"""A tool to generate a suite testing multiple workingtree formats at once.
1446
This is done by copying the test once for each transport and injecting
1447
the transport_server, transport_readonly_server, and workingtree_format
1448
classes into each copy. Each copy is also given a new id() to make it
1452
def __init__(self, transport_server, transport_readonly_server, formats):
1453
self._transport_server = transport_server
1454
self._transport_readonly_server = transport_readonly_server
1455
self._formats = formats
1457
def adapt(self, test):
1458
from bzrlib.tests import TestSuite
1459
result = TestSuite()
1460
for workingtree_format, bzrdir_format in self._formats:
1461
new_test = deepcopy(test)
1462
new_test.transport_server = self._transport_server
1463
new_test.transport_readonly_server = self._transport_readonly_server
1464
new_test.bzrdir_format = bzrdir_format
1465
new_test.workingtree_format = workingtree_format
1466
def make_new_test_id():
1467
new_id = "%s(%s)" % (new_test.id(), workingtree_format.__class__.__name__)
1468
return lambda: new_id
1469
new_test.id = make_new_test_id()
1470
result.addTest(new_test)
added
removed
bzrlib/workingtree.py
