1
# Copyright (C) 2005, 2006 Canonical Ltd
3
# This program is free software; you can redistribute it and/or modify
4
# it under the terms of the GNU General Public License as published by
5
# the Free Software Foundation; either version 2 of the License, or
6
# (at your option) any later version.
8
# This program is distributed in the hope that it will be useful,
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11
# GNU General Public License for more details.
13
# You should have received a copy of the GNU General Public License
14
# along with this program; if not, write to the Free Software
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).
32
MERGE_MODIFIED_HEADER_1 = "BZR merge-modified list format 1"
33
CONFLICT_HEADER_1 = "BZR conflict list format 1"
35
# TODO: Give the workingtree sole responsibility for the working inventory;
36
# remove the variable and references to it from the branch. This may require
37
# updating the commit code so as to update the inventory within the working
38
# copy, and making sure there's only one WorkingTree for any directory on disk.
39
# At the moment they may alias the inventory and have old copies of it in
40
# memory. (Now done? -- mbp 20060309)
42
from binascii import hexlify
44
from copy import deepcopy
45
from cStringIO import StringIO
53
from bzrlib.atomicfile import AtomicFile
54
from bzrlib.branch import (Branch,
56
from bzrlib.conflicts import Conflict, ConflictList, CONFLICT_SUFFIXES
57
import bzrlib.bzrdir as bzrdir
58
from bzrlib.decorators import needs_read_lock, needs_write_lock
59
import bzrlib.errors as errors
60
from bzrlib.errors import (BzrCheckError,
64
WeaveRevisionNotPresent,
68
MergeModifiedFormatError,
71
from bzrlib.inventory import InventoryEntry, Inventory
72
from bzrlib.lockable_files import LockableFiles, TransportLock
73
from bzrlib.lockdir import LockDir
74
from bzrlib.merge import merge_inner, transform_tree
75
from bzrlib.osutils import (
92
from bzrlib.progress import DummyProgress, ProgressPhase
93
from bzrlib.revision import NULL_REVISION
94
from bzrlib.rio import RioReader, rio_file, Stanza
95
from bzrlib.symbol_versioning import *
96
from bzrlib.textui import show_status
98
from bzrlib.transform import build_tree
99
from bzrlib.trace import mutter, note
100
from bzrlib.transport import get_transport
101
from bzrlib.transport.local import LocalTransport
102
import bzrlib.urlutils as urlutils
107
# the regex here does the following:
108
# 1) remove any weird characters; we don't escape them but rather
110
# 2) match leading '.'s to make it not hidden
111
_gen_file_id_re = re.compile(r'[^\w.]|(^\.*)')
112
_gen_id_suffix = None
116
def _next_id_suffix():
117
"""Create a new file id suffix that is reasonably unique.
119
On the first call we combine the current time with 64 bits of randomness
120
to give a highly probably globally unique number. Then each call in the same
121
process adds 1 to a serial number we append to that unique value.
123
# XXX TODO: change bzrlib.add.smart_add to call workingtree.add() rather
124
# than having to move the id randomness out of the inner loop like this.
125
# XXX TODO: for the global randomness this uses we should add the thread-id
126
# before the serial #.
127
global _gen_id_suffix, _gen_id_serial
128
if _gen_id_suffix is None:
129
_gen_id_suffix = "-%s-%s-" % (compact_date(time()), rand_chars(16))
131
return _gen_id_suffix + str(_gen_id_serial)
134
def gen_file_id(name):
135
"""Return new file id for the basename 'name'.
137
The uniqueness is supplied from _next_id_suffix.
139
# XXX TODO: squash the filename to lowercase.
140
# XXX TODO: truncate the filename to something like 20 or 30 chars.
141
# XXX TODO: consider what to do with ids that look like illegal filepaths
142
# on platforms we support.
143
return _gen_file_id_re.sub('', name) + _next_id_suffix()
147
"""Return a new tree-root file id."""
148
return gen_file_id('TREE_ROOT')
151
class TreeEntry(object):
152
"""An entry that implements the minimum interface used by commands.
154
This needs further inspection, it may be better to have
155
InventoryEntries without ids - though that seems wrong. For now,
156
this is a parallel hierarchy to InventoryEntry, and needs to become
157
one of several things: decorates to that hierarchy, children of, or
159
Another note is that these objects are currently only used when there is
160
no InventoryEntry available - i.e. for unversioned objects.
161
Perhaps they should be UnversionedEntry et al. ? - RBC 20051003
164
def __eq__(self, other):
165
# yes, this us ugly, TODO: best practice __eq__ style.
166
return (isinstance(other, TreeEntry)
167
and other.__class__ == self.__class__)
169
def kind_character(self):
173
class TreeDirectory(TreeEntry):
174
"""See TreeEntry. This is a directory in a working tree."""
176
def __eq__(self, other):
177
return (isinstance(other, TreeDirectory)
178
and other.__class__ == self.__class__)
180
def kind_character(self):
184
class TreeFile(TreeEntry):
185
"""See TreeEntry. This is a regular file in a working tree."""
187
def __eq__(self, other):
188
return (isinstance(other, TreeFile)
189
and other.__class__ == self.__class__)
191
def kind_character(self):
195
class TreeLink(TreeEntry):
196
"""See TreeEntry. This is a symlink in a working tree."""
198
def __eq__(self, other):
199
return (isinstance(other, TreeLink)
200
and other.__class__ == self.__class__)
202
def kind_character(self):
206
class WorkingTree(bzrlib.tree.Tree):
207
"""Working copy tree.
209
The inventory is held in the `Branch` working-inventory, and the
210
files are in a directory on disk.
212
It is possible for a `WorkingTree` to have a filename which is
213
not listed in the Inventory and vice versa.
216
def __init__(self, basedir='.',
217
branch=DEPRECATED_PARAMETER,
223
"""Construct a WorkingTree for basedir.
225
If the branch is not supplied, it is opened automatically.
226
If the branch is supplied, it must be the branch for this basedir.
227
(branch.base is not cross checked, because for remote branches that
228
would be meaningless).
230
self._format = _format
231
self.bzrdir = _bzrdir
233
# not created via open etc.
234
warn("WorkingTree() is deprecated as of bzr version 0.8. "
235
"Please use bzrdir.open_workingtree or WorkingTree.open().",
238
wt = WorkingTree.open(basedir)
239
self._branch = wt.branch
240
self.basedir = wt.basedir
241
self._control_files = wt._control_files
242
self._hashcache = wt._hashcache
243
self._set_inventory(wt._inventory)
244
self._format = wt._format
245
self.bzrdir = wt.bzrdir
246
from bzrlib.hashcache import HashCache
247
from bzrlib.trace import note, mutter
248
assert isinstance(basedir, basestring), \
249
"base directory %r is not a string" % basedir
250
basedir = safe_unicode(basedir)
251
mutter("opening working tree %r", basedir)
252
if deprecated_passed(branch):
254
warn("WorkingTree(..., branch=XXX) is deprecated as of bzr 0.8."
255
" Please use bzrdir.open_workingtree() or"
256
" WorkingTree.open().",
260
self._branch = branch
262
self._branch = self.bzrdir.open_branch()
263
assert isinstance(self.branch, Branch), \
264
"branch %r is not a Branch" % self.branch
265
self.basedir = realpath(basedir)
266
# if branch is at our basedir and is a format 6 or less
267
if isinstance(self._format, WorkingTreeFormat2):
268
# share control object
269
self._control_files = self.branch.control_files
271
# only ready for format 3
272
assert isinstance(self._format, WorkingTreeFormat3)
273
assert isinstance(_control_files, LockableFiles), \
274
"_control_files must be a LockableFiles, not %r" \
276
self._control_files = _control_files
277
# update the whole cache up front and write to disk if anything changed;
278
# in the future we might want to do this more selectively
279
# two possible ways offer themselves : in self._unlock, write the cache
280
# if needed, or, when the cache sees a change, append it to the hash
281
# cache file, and have the parser take the most recent entry for a
283
cache_filename = self.bzrdir.get_workingtree_transport(None).local_abspath('stat-cache')
284
hc = self._hashcache = HashCache(basedir, cache_filename, self._control_files._file_mode)
286
# is this scan needed ? it makes things kinda slow.
293
if _inventory is None:
294
self._set_inventory(self.read_working_inventory())
296
self._set_inventory(_inventory)
299
fget=lambda self: self._branch,
300
doc="""The branch this WorkingTree is connected to.
302
This cannot be set - it is reflective of the actual disk structure
303
the working tree has been constructed from.
306
def break_lock(self):
307
"""Break a lock if one is present from another instance.
309
Uses the ui factory to ask for confirmation if the lock may be from
312
This will probe the repository for its lock as well.
314
self._control_files.break_lock()
315
self.branch.break_lock()
317
def _set_inventory(self, inv):
318
self._inventory = inv
319
self.path2id = self._inventory.path2id
321
def is_control_filename(self, filename):
322
"""True if filename is the name of a control file in this tree.
324
:param filename: A filename within the tree. This is a relative path
325
from the root of this tree.
327
This is true IF and ONLY IF the filename is part of the meta data
328
that bzr controls in this tree. I.E. a random .bzr directory placed
329
on disk will not be a control file for this tree.
331
return self.bzrdir.is_control_filename(filename)
334
def open(path=None, _unsupported=False):
335
"""Open an existing working tree at path.
339
path = os.path.getcwdu()
340
control = bzrdir.BzrDir.open(path, _unsupported)
341
return control.open_workingtree(_unsupported)
344
def open_containing(path=None):
345
"""Open an existing working tree which has its root about path.
347
This probes for a working tree at path and searches upwards from there.
349
Basically we keep looking up until we find the control directory or
350
run into /. If there isn't one, raises NotBranchError.
351
TODO: give this a new exception.
352
If there is one, it is returned, along with the unused portion of path.
354
:return: The WorkingTree that contains 'path', and the rest of path
358
control, relpath = bzrdir.BzrDir.open_containing(path)
360
return control.open_workingtree(), relpath
363
def open_downlevel(path=None):
364
"""Open an unsupported working tree.
366
Only intended for advanced situations like upgrading part of a bzrdir.
368
return WorkingTree.open(path, _unsupported=True)
371
"""Iterate through file_ids for this tree.
373
file_ids are in a WorkingTree if they are in the working inventory
374
and the working file exists.
376
inv = self._inventory
377
for path, ie in inv.iter_entries():
378
if bzrlib.osutils.lexists(self.abspath(path)):
382
return "<%s of %s>" % (self.__class__.__name__,
383
getattr(self, 'basedir', None))
385
def abspath(self, filename):
386
return pathjoin(self.basedir, filename)
388
def basis_tree(self):
389
"""Return RevisionTree for the current last revision."""
390
revision_id = self.last_revision()
391
if revision_id is not None:
393
xml = self.read_basis_inventory()
394
inv = bzrlib.xml5.serializer_v5.read_inventory_from_string(xml)
397
if inv is not None and inv.revision_id == revision_id:
398
return bzrlib.tree.RevisionTree(self.branch.repository, inv,
400
# FIXME? RBC 20060403 should we cache the inventory here ?
401
return self.branch.repository.revision_tree(revision_id)
404
@deprecated_method(zero_eight)
405
def create(branch, directory):
406
"""Create a workingtree for branch at directory.
408
If existing_directory already exists it must have a .bzr directory.
409
If it does not exist, it will be created.
411
This returns a new WorkingTree object for the new checkout.
413
TODO FIXME RBC 20060124 when we have checkout formats in place this
414
should accept an optional revisionid to checkout [and reject this if
415
checking out into the same dir as a pre-checkout-aware branch format.]
417
XXX: When BzrDir is present, these should be created through that
420
warn('delete WorkingTree.create', stacklevel=3)
421
transport = get_transport(directory)
422
if branch.bzrdir.root_transport.base == transport.base:
424
return branch.bzrdir.create_workingtree()
425
# different directory,
426
# create a branch reference
427
# and now a working tree.
428
raise NotImplementedError
431
@deprecated_method(zero_eight)
432
def create_standalone(directory):
433
"""Create a checkout and a branch and a repo at directory.
435
Directory must exist and be empty.
437
please use BzrDir.create_standalone_workingtree
439
return bzrdir.BzrDir.create_standalone_workingtree(directory)
441
def relpath(self, path):
442
"""Return the local path portion from a given path.
444
The path may be absolute or relative. If its a relative path it is
445
interpreted relative to the python current working directory.
447
return relpath(self.basedir, path)
449
def has_filename(self, filename):
450
return bzrlib.osutils.lexists(self.abspath(filename))
452
def get_file(self, file_id):
453
return self.get_file_byname(self.id2path(file_id))
455
def get_file_byname(self, filename):
456
return file(self.abspath(filename), 'rb')
458
def get_parent_ids(self):
459
"""See Tree.get_parent_ids.
461
This implementation reads the pending merges list and last_revision
462
value and uses that to decide what the parents list should be.
464
last_rev = self.last_revision()
469
other_parents = self.pending_merges()
470
return parents + other_parents
472
def get_root_id(self):
473
"""Return the id of this trees root"""
474
inv = self.read_working_inventory()
475
return inv.root.file_id
477
def _get_store_filename(self, file_id):
478
## XXX: badly named; this is not in the store at all
479
return self.abspath(self.id2path(file_id))
482
def clone(self, to_bzrdir, revision_id=None, basis=None):
483
"""Duplicate this working tree into to_bzr, including all state.
485
Specifically modified files are kept as modified, but
486
ignored and unknown files are discarded.
488
If you want to make a new line of development, see bzrdir.sprout()
491
If not None, the cloned tree will have its last revision set to
492
revision, and and difference between the source trees last revision
493
and this one merged in.
496
If not None, a closer copy of a tree which may have some files in
497
common, and which file content should be preferentially copied from.
499
# assumes the target bzr dir format is compatible.
500
result = self._format.initialize(to_bzrdir)
501
self.copy_content_into(result, revision_id)
505
def copy_content_into(self, tree, revision_id=None):
506
"""Copy the current content and user files of this tree into tree."""
507
if revision_id is None:
508
transform_tree(tree, self)
510
# TODO now merge from tree.last_revision to revision
511
transform_tree(tree, self)
512
tree.set_last_revision(revision_id)
515
def commit(self, message=None, revprops=None, *args, **kwargs):
516
# avoid circular imports
517
from bzrlib.commit import Commit
520
if not 'branch-nick' in revprops:
521
revprops['branch-nick'] = self.branch.nick
522
# args for wt.commit start at message from the Commit.commit method,
523
# but with branch a kwarg now, passing in args as is results in the
524
#message being used for the branch
525
args = (DEPRECATED_PARAMETER, message, ) + args
526
committed_id = Commit().commit( working_tree=self, revprops=revprops,
528
self._set_inventory(self.read_working_inventory())
531
def id2abspath(self, file_id):
532
return self.abspath(self.id2path(file_id))
534
def has_id(self, file_id):
535
# files that have been deleted are excluded
536
inv = self._inventory
537
if not inv.has_id(file_id):
539
path = inv.id2path(file_id)
540
return bzrlib.osutils.lexists(self.abspath(path))
542
def has_or_had_id(self, file_id):
543
if file_id == self.inventory.root.file_id:
545
return self.inventory.has_id(file_id)
547
__contains__ = has_id
549
def get_file_size(self, file_id):
550
return os.path.getsize(self.id2abspath(file_id))
553
def get_file_sha1(self, file_id, path=None):
555
path = self._inventory.id2path(file_id)
556
return self._hashcache.get_sha1(path)
558
def get_file_mtime(self, file_id, path=None):
560
path = self._inventory.id2path(file_id)
561
return os.lstat(self.abspath(path)).st_mtime
563
if not supports_executable():
564
def is_executable(self, file_id, path=None):
565
return self._inventory[file_id].executable
567
def is_executable(self, file_id, path=None):
569
path = self._inventory.id2path(file_id)
570
mode = os.lstat(self.abspath(path)).st_mode
571
return bool(stat.S_ISREG(mode) and stat.S_IEXEC & mode)
574
def add(self, files, ids=None):
575
"""Make files versioned.
577
Note that the command line normally calls smart_add instead,
578
which can automatically recurse.
580
This adds the files to the inventory, so that they will be
581
recorded by the next commit.
584
List of paths to add, relative to the base of the tree.
587
If set, use these instead of automatically generated ids.
588
Must be the same length as the list of files, but may
589
contain None for ids that are to be autogenerated.
591
TODO: Perhaps have an option to add the ids even if the files do
594
TODO: Perhaps callback with the ids and paths as they're added.
596
# TODO: Re-adding a file that is removed in the working copy
597
# should probably put it back with the previous ID.
598
if isinstance(files, basestring):
599
assert(ids is None or isinstance(ids, basestring))
605
ids = [None] * len(files)
607
assert(len(ids) == len(files))
609
inv = self.read_working_inventory()
610
for f,file_id in zip(files, ids):
611
if self.is_control_filename(f):
612
raise BzrError("cannot add control file %s" % quotefn(f))
617
raise BzrError("cannot add top-level %r" % f)
619
fullpath = normpath(self.abspath(f))
622
kind = file_kind(fullpath)
624
if e.errno == errno.ENOENT:
625
raise NoSuchFile(fullpath)
626
# maybe something better?
627
raise BzrError('cannot add: not a regular file, symlink or directory: %s' % quotefn(f))
629
if not InventoryEntry.versionable_kind(kind):
630
raise BzrError('cannot add: not a versionable file ('
631
'i.e. regular file, symlink or directory): %s' % quotefn(f))
634
inv.add_path(f, kind=kind)
636
inv.add_path(f, kind=kind, file_id=file_id)
638
self._write_inventory(inv)
641
def add_pending_merge(self, *revision_ids):
642
# TODO: Perhaps should check at this point that the
643
# history of the revision is actually present?
644
p = self.pending_merges()
646
for rev_id in revision_ids:
652
self.set_pending_merges(p)
655
def pending_merges(self):
656
"""Return a list of pending merges.
658
These are revisions that have been merged into the working
659
directory but not yet committed.
662
merges_file = self._control_files.get_utf8('pending-merges')
664
if e.errno != errno.ENOENT:
668
for l in merges_file.readlines():
669
p.append(l.rstrip('\n'))
673
def set_pending_merges(self, rev_list):
674
self._control_files.put_utf8('pending-merges', '\n'.join(rev_list))
677
def set_merge_modified(self, modified_hashes):
679
for file_id, hash in modified_hashes.iteritems():
680
yield Stanza(file_id=file_id, hash=hash)
681
self._put_rio('merge-hashes', iter_stanzas(), MERGE_MODIFIED_HEADER_1)
684
def _put_rio(self, filename, stanzas, header):
685
my_file = rio_file(stanzas, header)
686
self._control_files.put(filename, my_file)
689
def merge_modified(self):
691
hashfile = self._control_files.get('merge-hashes')
696
if hashfile.next() != MERGE_MODIFIED_HEADER_1 + '\n':
697
raise MergeModifiedFormatError()
698
except StopIteration:
699
raise MergeModifiedFormatError()
700
for s in RioReader(hashfile):
701
file_id = s.get("file_id")
702
if file_id not in self.inventory:
705
if hash == self.get_file_sha1(file_id):
706
merge_hashes[file_id] = hash
709
def get_symlink_target(self, file_id):
710
return os.readlink(self.id2abspath(file_id))
712
def file_class(self, filename):
713
if self.path2id(filename):
715
elif self.is_ignored(filename):
720
def list_files(self):
721
"""Recursively list all files as (path, class, kind, id, entry).
723
Lists, but does not descend into unversioned directories.
725
This does not include files that have been deleted in this
728
Skips the control directory.
730
inv = self._inventory
731
# Convert these into local objects to save lookup times
732
pathjoin = bzrlib.osutils.pathjoin
733
file_kind = bzrlib.osutils.file_kind
735
# transport.base ends in a slash, we want the piece
736
# between the last two slashes
737
transport_base_dir = self.bzrdir.transport.base.rsplit('/', 2)[1]
739
fk_entries = {'directory':TreeDirectory, 'file':TreeFile, 'symlink':TreeLink}
741
# directory file_id, relative path, absolute path, reverse sorted children
742
children = os.listdir(self.basedir)
744
# jam 20060527 The kernel sized tree seems equivalent whether we
745
# use a deque and popleft to keep them sorted, or if we use a plain
746
# list and just reverse() them.
747
children = collections.deque(children)
748
stack = [(inv.root.file_id, u'', self.basedir, children)]
750
from_dir_id, from_dir_relpath, from_dir_abspath, children = stack[-1]
753
f = children.popleft()
754
## TODO: If we find a subdirectory with its own .bzr
755
## directory, then that is a separate tree and we
756
## should exclude it.
758
# the bzrdir for this tree
759
if transport_base_dir == f:
762
# we know that from_dir_relpath and from_dir_abspath never end in a slash
763
# and 'f' doesn't begin with one, we can do a string op, rather
764
# than the checks of pathjoin(), all relative paths will have an extra slash
766
fp = from_dir_relpath + '/' + f
769
fap = from_dir_abspath + '/' + f
771
f_ie = inv.get_child(from_dir_id, f)
774
elif self.is_ignored(fp[1:]):
783
raise BzrCheckError("file %r entered as kind %r id %r, "
785
% (fap, f_ie.kind, f_ie.file_id, fk))
787
# make a last minute entry
789
yield fp[1:], c, fk, f_ie.file_id, f_ie
792
yield fp[1:], c, fk, None, fk_entries[fk]()
794
yield fp[1:], c, fk, None, TreeEntry()
797
if fk != 'directory':
800
# But do this child first
801
new_children = os.listdir(fap)
803
new_children = collections.deque(new_children)
804
stack.append((f_ie.file_id, fp, fap, new_children))
805
# Break out of inner loop, so that we start outer loop with child
808
# if we finished all children, pop it off the stack
813
def move(self, from_paths, to_name):
816
to_name must exist in the inventory.
818
If to_name exists and is a directory, the files are moved into
819
it, keeping their old names.
821
Note that to_name is only the last component of the new name;
822
this doesn't change the directory.
824
This returns a list of (from_path, to_path) pairs for each
828
## TODO: Option to move IDs only
829
assert not isinstance(from_paths, basestring)
831
to_abs = self.abspath(to_name)
832
if not isdir(to_abs):
833
raise BzrError("destination %r is not a directory" % to_abs)
834
if not self.has_filename(to_name):
835
raise BzrError("destination %r not in working directory" % to_abs)
836
to_dir_id = inv.path2id(to_name)
837
if to_dir_id == None and to_name != '':
838
raise BzrError("destination %r is not a versioned directory" % to_name)
839
to_dir_ie = inv[to_dir_id]
840
if to_dir_ie.kind not in ('directory', 'root_directory'):
841
raise BzrError("destination %r is not a directory" % to_abs)
843
to_idpath = inv.get_idpath(to_dir_id)
846
if not self.has_filename(f):
847
raise BzrError("%r does not exist in working tree" % f)
848
f_id = inv.path2id(f)
850
raise BzrError("%r is not versioned" % f)
851
name_tail = splitpath(f)[-1]
852
dest_path = pathjoin(to_name, name_tail)
853
if self.has_filename(dest_path):
854
raise BzrError("destination %r already exists" % dest_path)
855
if f_id in to_idpath:
856
raise BzrError("can't move %r to a subdirectory of itself" % f)
858
# OK, so there's a race here, it's possible that someone will
859
# create a file in this interval and then the rename might be
860
# left half-done. But we should have caught most problems.
861
orig_inv = deepcopy(self.inventory)
864
name_tail = splitpath(f)[-1]
865
dest_path = pathjoin(to_name, name_tail)
866
result.append((f, dest_path))
867
inv.rename(inv.path2id(f), to_dir_id, name_tail)
869
rename(self.abspath(f), self.abspath(dest_path))
871
raise BzrError("failed to rename %r to %r: %s" %
872
(f, dest_path, e[1]),
873
["rename rolled back"])
875
# restore the inventory on error
876
self._set_inventory(orig_inv)
878
self._write_inventory(inv)
882
def rename_one(self, from_rel, to_rel):
885
This can change the directory or the filename or both.
888
if not self.has_filename(from_rel):
889
raise BzrError("can't rename: old working file %r does not exist" % from_rel)
890
if self.has_filename(to_rel):
891
raise BzrError("can't rename: new working file %r already exists" % to_rel)
893
file_id = inv.path2id(from_rel)
895
raise BzrError("can't rename: old name %r is not versioned" % from_rel)
898
from_parent = entry.parent_id
899
from_name = entry.name
901
if inv.path2id(to_rel):
902
raise BzrError("can't rename: new name %r is already versioned" % to_rel)
904
to_dir, to_tail = os.path.split(to_rel)
905
to_dir_id = inv.path2id(to_dir)
906
if to_dir_id == None and to_dir != '':
907
raise BzrError("can't determine destination directory id for %r" % to_dir)
909
mutter("rename_one:")
910
mutter(" file_id {%s}" % file_id)
911
mutter(" from_rel %r" % from_rel)
912
mutter(" to_rel %r" % to_rel)
913
mutter(" to_dir %r" % to_dir)
914
mutter(" to_dir_id {%s}" % to_dir_id)
916
inv.rename(file_id, to_dir_id, to_tail)
918
from_abs = self.abspath(from_rel)
919
to_abs = self.abspath(to_rel)
921
rename(from_abs, to_abs)
923
inv.rename(file_id, from_parent, from_name)
924
raise BzrError("failed to rename %r to %r: %s"
925
% (from_abs, to_abs, e[1]),
926
["rename rolled back"])
927
self._write_inventory(inv)
931
"""Return all unknown files.
933
These are files in the working directory that are not versioned or
934
control files or ignored.
936
>>> from bzrlib.bzrdir import ScratchDir
937
>>> d = ScratchDir(files=['foo', 'foo~'])
938
>>> b = d.open_branch()
939
>>> tree = d.open_workingtree()
940
>>> map(str, tree.unknowns())
943
>>> list(b.unknowns())
945
>>> tree.remove('foo')
946
>>> list(b.unknowns())
949
for subp in self.extras():
950
if not self.is_ignored(subp):
953
@deprecated_method(zero_eight)
954
def iter_conflicts(self):
955
"""List all files in the tree that have text or content conflicts.
956
DEPRECATED. Use conflicts instead."""
957
return self._iter_conflicts()
959
def _iter_conflicts(self):
961
for info in self.list_files():
963
stem = get_conflicted_stem(path)
966
if stem not in conflicted:
971
def pull(self, source, overwrite=False, stop_revision=None):
972
top_pb = bzrlib.ui.ui_factory.nested_progress_bar()
975
pp = ProgressPhase("Pull phase", 2, top_pb)
977
old_revision_history = self.branch.revision_history()
978
basis_tree = self.basis_tree()
979
count = self.branch.pull(source, overwrite, stop_revision)
980
new_revision_history = self.branch.revision_history()
981
if new_revision_history != old_revision_history:
983
if len(old_revision_history):
984
other_revision = old_revision_history[-1]
986
other_revision = None
987
repository = self.branch.repository
988
pb = bzrlib.ui.ui_factory.nested_progress_bar()
990
merge_inner(self.branch,
991
self.branch.basis_tree(),
997
self.set_last_revision(self.branch.last_revision())
1004
"""Yield all unknown files in this WorkingTree.
1006
If there are any unknown directories then only the directory is
1007
returned, not all its children. But if there are unknown files
1008
under a versioned subdirectory, they are returned.
1010
Currently returned depth-first, sorted by name within directories.
1012
## TODO: Work from given directory downwards
1013
for path, dir_entry in self.inventory.directories():
1014
mutter("search for unknowns in %r", path)
1015
dirabs = self.abspath(path)
1016
if not isdir(dirabs):
1017
# e.g. directory deleted
1021
for subf in os.listdir(dirabs):
1023
and (subf not in dir_entry.children)):
1028
subp = pathjoin(path, subf)
1031
def _translate_ignore_rule(self, rule):
1032
"""Translate a single ignore rule to a regex.
1034
There are two types of ignore rules. Those that do not contain a / are
1035
matched against the tail of the filename (that is, they do not care
1036
what directory the file is in.) Rules which do contain a slash must
1037
match the entire path. As a special case, './' at the start of the
1038
string counts as a slash in the string but is removed before matching
1039
(e.g. ./foo.c, ./src/foo.c)
1041
:return: The translated regex.
1043
if rule[:2] in ('./', '.\\'):
1045
result = fnmatch.translate(rule[2:])
1046
elif '/' in rule or '\\' in rule:
1048
result = fnmatch.translate(rule)
1050
# default rule style.
1051
result = "(?:.*/)?(?!.*/)" + fnmatch.translate(rule)
1052
assert result[-1] == '$', "fnmatch.translate did not add the expected $"
1053
return "(" + result + ")"
1055
def _combine_ignore_rules(self, rules):
1056
"""Combine a list of ignore rules into a single regex object.
1058
Each individual rule is combined with | to form a big regex, which then
1059
has $ added to it to form something like ()|()|()$. The group index for
1060
each subregex's outermost group is placed in a dictionary mapping back
1061
to the rule. This allows quick identification of the matching rule that
1063
:return: a list of the compiled regex and the matching-group index
1064
dictionaries. We return a list because python complains if you try to
1065
combine more than 100 regexes.
1070
translated_rules = []
1072
translated_rule = self._translate_ignore_rule(rule)
1073
compiled_rule = re.compile(translated_rule)
1074
groups[next_group] = rule
1075
next_group += compiled_rule.groups
1076
translated_rules.append(translated_rule)
1077
if next_group == 99:
1078
result.append((re.compile("|".join(translated_rules)), groups))
1081
translated_rules = []
1082
if len(translated_rules):
1083
result.append((re.compile("|".join(translated_rules)), groups))
1086
def ignored_files(self):
1087
"""Yield list of PATH, IGNORE_PATTERN"""
1088
for subp in self.extras():
1089
pat = self.is_ignored(subp)
1093
def get_ignore_list(self):
1094
"""Return list of ignore patterns.
1096
Cached in the Tree object after the first call.
1098
if hasattr(self, '_ignorelist'):
1099
return self._ignorelist
1101
l = bzrlib.DEFAULT_IGNORE[:]
1102
if self.has_filename(bzrlib.IGNORE_FILENAME):
1103
f = self.get_file_byname(bzrlib.IGNORE_FILENAME)
1104
l.extend([line.rstrip("\n\r").decode('utf-8')
1105
for line in f.readlines()])
1106
self._ignorelist = l
1107
self._ignore_regex = self._combine_ignore_rules(l)
1110
def _get_ignore_rules_as_regex(self):
1111
"""Return a regex of the ignore rules and a mapping dict.
1113
:return: (ignore rules compiled regex, dictionary mapping rule group
1114
indices to original rule.)
1116
if getattr(self, '_ignorelist', None) is None:
1117
self.get_ignore_list()
1118
return self._ignore_regex
1120
def is_ignored(self, filename):
1121
r"""Check whether the filename matches an ignore pattern.
1123
Patterns containing '/' or '\' need to match the whole path;
1124
others match against only the last component.
1126
If the file is ignored, returns the pattern which caused it to
1127
be ignored, otherwise None. So this can simply be used as a
1128
boolean if desired."""
1130
# TODO: Use '**' to match directories, and other extended
1131
# globbing stuff from cvs/rsync.
1133
# XXX: fnmatch is actually not quite what we want: it's only
1134
# approximately the same as real Unix fnmatch, and doesn't
1135
# treat dotfiles correctly and allows * to match /.
1136
# Eventually it should be replaced with something more
1139
rules = self._get_ignore_rules_as_regex()
1140
for regex, mapping in rules:
1141
match = regex.match(filename)
1142
if match is not None:
1143
# one or more of the groups in mapping will have a non-None group
1145
groups = match.groups()
1146
rules = [mapping[group] for group in
1147
mapping if groups[group] is not None]
1151
def kind(self, file_id):
1152
return file_kind(self.id2abspath(file_id))
1155
def last_revision(self):
1156
"""Return the last revision id of this working tree.
1158
In early branch formats this was == the branch last_revision,
1159
but that cannot be relied upon - for working tree operations,
1160
always use tree.last_revision().
1162
return self.branch.last_revision()
1164
def is_locked(self):
1165
return self._control_files.is_locked()
1167
def lock_read(self):
1168
"""See Branch.lock_read, and WorkingTree.unlock."""
1169
self.branch.lock_read()
1171
return self._control_files.lock_read()
1173
self.branch.unlock()
1176
def lock_write(self):
1177
"""See Branch.lock_write, and WorkingTree.unlock."""
1178
self.branch.lock_write()
1180
return self._control_files.lock_write()
1182
self.branch.unlock()
1185
def get_physical_lock_status(self):
1186
return self._control_files.get_physical_lock_status()
1188
def _basis_inventory_name(self):
1189
return 'basis-inventory'
1192
def set_last_revision(self, new_revision):
1193
"""Change the last revision in the working tree."""
1194
if self._change_last_revision(new_revision):
1195
self._cache_basis_inventory(new_revision)
1197
def _change_last_revision(self, new_revision):
1198
"""Template method part of set_last_revision to perform the change.
1200
This is used to allow WorkingTree3 instances to not affect branch
1201
when their last revision is set.
1203
if new_revision is None:
1204
self.branch.set_revision_history([])
1206
# current format is locked in with the branch
1207
revision_history = self.branch.revision_history()
1209
position = revision_history.index(new_revision)
1211
raise errors.NoSuchRevision(self.branch, new_revision)
1212
self.branch.set_revision_history(revision_history[:position + 1])
1215
def _cache_basis_inventory(self, new_revision):
1216
"""Cache new_revision as the basis inventory."""
1217
# TODO: this should allow the ready-to-use inventory to be passed in,
1218
# as commit already has that ready-to-use [while the format is the
1221
# this double handles the inventory - unpack and repack -
1222
# but is easier to understand. We can/should put a conditional
1223
# in here based on whether the inventory is in the latest format
1224
# - perhaps we should repack all inventories on a repository
1226
# the fast path is to copy the raw xml from the repository. If the
1227
# xml contains 'revision_id="', then we assume the right
1228
# revision_id is set. We must check for this full string, because a
1229
# root node id can legitimately look like 'revision_id' but cannot
1231
xml = self.branch.repository.get_inventory_xml(new_revision)
1232
if not 'revision_id="' in xml.split('\n', 1)[0]:
1233
inv = self.branch.repository.deserialise_inventory(
1235
inv.revision_id = new_revision
1236
xml = bzrlib.xml5.serializer_v5.write_inventory_to_string(inv)
1237
assert isinstance(xml, str), 'serialised xml must be bytestring.'
1238
path = self._basis_inventory_name()
1240
self._control_files.put(path, sio)
1241
except WeaveRevisionNotPresent:
1244
def read_basis_inventory(self):
1245
"""Read the cached basis inventory."""
1246
path = self._basis_inventory_name()
1247
return self._control_files.get(path).read()
1250
def read_working_inventory(self):
1251
"""Read the working inventory."""
1252
# ElementTree does its own conversion from UTF-8, so open in
1254
result = bzrlib.xml5.serializer_v5.read_inventory(
1255
self._control_files.get('inventory'))
1256
self._set_inventory(result)
1260
def remove(self, files, verbose=False, to_file=None):
1261
"""Remove nominated files from the working inventory..
1263
This does not remove their text. This does not run on XXX on what? RBC
1265
TODO: Refuse to remove modified files unless --force is given?
1267
TODO: Do something useful with directories.
1269
TODO: Should this remove the text or not? Tough call; not
1270
removing may be useful and the user can just use use rm, and
1271
is the opposite of add. Removing it is consistent with most
1272
other tools. Maybe an option.
1274
## TODO: Normalize names
1275
## TODO: Remove nested loops; better scalability
1276
if isinstance(files, basestring):
1279
inv = self.inventory
1281
# do this before any modifications
1283
fid = inv.path2id(f)
1285
# TODO: Perhaps make this just a warning, and continue?
1286
# This tends to happen when
1287
raise NotVersionedError(path=f)
1288
mutter("remove inventory entry %s {%s}", quotefn(f), fid)
1290
# having remove it, it must be either ignored or unknown
1291
if self.is_ignored(f):
1295
show_status(new_status, inv[fid].kind, quotefn(f), to_file=to_file)
1298
self._write_inventory(inv)
1301
def revert(self, filenames, old_tree=None, backups=True,
1302
pb=DummyProgress()):
1303
from transform import revert
1304
from conflicts import resolve
1305
if old_tree is None:
1306
old_tree = self.basis_tree()
1307
conflicts = revert(self, old_tree, filenames, backups, pb)
1308
if not len(filenames):
1309
self.set_pending_merges([])
1312
resolve(self, filenames, ignore_misses=True)
1315
# XXX: This method should be deprecated in favour of taking in a proper
1316
# new Inventory object.
1318
def set_inventory(self, new_inventory_list):
1319
from bzrlib.inventory import (Inventory,
1324
inv = Inventory(self.get_root_id())
1325
for path, file_id, parent, kind in new_inventory_list:
1326
name = os.path.basename(path)
1329
# fixme, there should be a factory function inv,add_??
1330
if kind == 'directory':
1331
inv.add(InventoryDirectory(file_id, name, parent))
1332
elif kind == 'file':
1333
inv.add(InventoryFile(file_id, name, parent))
1334
elif kind == 'symlink':
1335
inv.add(InventoryLink(file_id, name, parent))
1337
raise BzrError("unknown kind %r" % kind)
1338
self._write_inventory(inv)
1341
def set_root_id(self, file_id):
1342
"""Set the root id for this tree."""
1343
inv = self.read_working_inventory()
1344
orig_root_id = inv.root.file_id
1345
del inv._byid[inv.root.file_id]
1346
inv.root.file_id = file_id
1347
inv._byid[inv.root.file_id] = inv.root
1350
if entry.parent_id == orig_root_id:
1351
entry.parent_id = inv.root.file_id
1352
self._write_inventory(inv)
1355
"""See Branch.unlock.
1357
WorkingTree locking just uses the Branch locking facilities.
1358
This is current because all working trees have an embedded branch
1359
within them. IF in the future, we were to make branch data shareable
1360
between multiple working trees, i.e. via shared storage, then we
1361
would probably want to lock both the local tree, and the branch.
1363
# FIXME: We want to write out the hashcache only when the last lock on
1364
# this working copy is released. Peeking at the lock count is a bit
1365
# of a nasty hack; probably it's better to have a transaction object,
1366
# which can do some finalization when it's either successfully or
1367
# unsuccessfully completed. (Denys's original patch did that.)
1368
# RBC 20060206 hooking into transaction will couple lock and transaction
1369
# wrongly. Hooking into unlock on the control files object is fine though.
1371
# TODO: split this per format so there is no ugly if block
1372
if self._hashcache.needs_write and (
1373
# dedicated lock files
1374
self._control_files._lock_count==1 or
1376
(self._control_files is self.branch.control_files and
1377
self._control_files._lock_count==3)):
1378
self._hashcache.write()
1379
# reverse order of locking.
1381
return self._control_files.unlock()
1383
self.branch.unlock()
1387
"""Update a working tree along its branch.
1389
This will update the branch if its bound too, which means we have multiple trees involved:
1390
The new basis tree of the master.
1391
The old basis tree of the branch.
1392
The old basis tree of the working tree.
1393
The current working tree state.
1394
pathologically all three may be different, and non ancestors of each other.
1395
Conceptually we want to:
1396
Preserve the wt.basis->wt.state changes
1397
Transform the wt.basis to the new master basis.
1398
Apply a merge of the old branch basis to get any 'local' changes from it into the tree.
1399
Restore the wt.basis->wt.state changes.
1401
There isn't a single operation at the moment to do that, so we:
1402
Merge current state -> basis tree of the master w.r.t. the old tree basis.
1403
Do a 'normal' merge of the old branch basis if it is relevant.
1405
old_tip = self.branch.update()
1406
if old_tip is not None:
1407
self.add_pending_merge(old_tip)
1408
self.branch.lock_read()
1411
if self.last_revision() != self.branch.last_revision():
1412
# merge tree state up to new branch tip.
1413
basis = self.basis_tree()
1414
to_tree = self.branch.basis_tree()
1415
result += merge_inner(self.branch,
1419
self.set_last_revision(self.branch.last_revision())
1420
if old_tip and old_tip != self.last_revision():
1421
# our last revision was not the prior branch last revision
1422
# and we have converted that last revision to a pending merge.
1423
# base is somewhere between the branch tip now
1424
# and the now pending merge
1425
from bzrlib.revision import common_ancestor
1427
base_rev_id = common_ancestor(self.branch.last_revision(),
1429
self.branch.repository)
1430
except errors.NoCommonAncestor:
1432
base_tree = self.branch.repository.revision_tree(base_rev_id)
1433
other_tree = self.branch.repository.revision_tree(old_tip)
1434
result += merge_inner(self.branch,
1440
self.branch.unlock()
1443
def _write_inventory(self, inv):
1444
"""Write inventory as the current inventory."""
1446
bzrlib.xml5.serializer_v5.write_inventory(inv, sio)
1448
self._control_files.put('inventory', sio)
1449
self._set_inventory(inv)
1450
mutter('wrote working inventory')
1452
def set_conflicts(self, arg):
1453
raise UnsupportedOperation(self.set_conflicts, self)
1456
def conflicts(self):
1457
conflicts = ConflictList()
1458
for conflicted in self._iter_conflicts():
1461
if file_kind(self.abspath(conflicted)) != "file":
1463
except errors.NoSuchFile:
1466
for suffix in ('.THIS', '.OTHER'):
1468
kind = file_kind(self.abspath(conflicted+suffix))
1471
except errors.NoSuchFile:
1475
ctype = {True: 'text conflict', False: 'contents conflict'}[text]
1476
conflicts.append(Conflict.factory(ctype, path=conflicted,
1477
file_id=self.path2id(conflicted)))
1481
class WorkingTree3(WorkingTree):
1482
"""This is the Format 3 working tree.
1484
This differs from the base WorkingTree by:
1485
- having its own file lock
1486
- having its own last-revision property.
1488
This is new in bzr 0.8
1492
def last_revision(self):
1493
"""See WorkingTree.last_revision."""
1495
return self._control_files.get_utf8('last-revision').read()
1499
def _change_last_revision(self, revision_id):
1500
"""See WorkingTree._change_last_revision."""
1501
if revision_id is None or revision_id == NULL_REVISION:
1503
self._control_files._transport.delete('last-revision')
1504
except errors.NoSuchFile:
1509
self.branch.revision_history().index(revision_id)
1511
raise errors.NoSuchRevision(self.branch, revision_id)
1512
self._control_files.put_utf8('last-revision', revision_id)
1516
def set_conflicts(self, conflicts):
1517
self._put_rio('conflicts', conflicts.to_stanzas(),
1521
def conflicts(self):
1523
confile = self._control_files.get('conflicts')
1525
return ConflictList()
1527
if confile.next() != CONFLICT_HEADER_1 + '\n':
1528
raise ConflictFormatError()
1529
except StopIteration:
1530
raise ConflictFormatError()
1531
return ConflictList.from_stanzas(RioReader(confile))
1534
def get_conflicted_stem(path):
1535
for suffix in CONFLICT_SUFFIXES:
1536
if path.endswith(suffix):
1537
return path[:-len(suffix)]
1539
@deprecated_function(zero_eight)
1540
def is_control_file(filename):
1541
"""See WorkingTree.is_control_filename(filename)."""
1542
## FIXME: better check
1543
filename = normpath(filename)
1544
while filename != '':
1545
head, tail = os.path.split(filename)
1546
## mutter('check %r for control file' % ((head, tail),))
1549
if filename == head:
1555
class WorkingTreeFormat(object):
1556
"""An encapsulation of the initialization and open routines for a format.
1558
Formats provide three things:
1559
* An initialization routine,
1563
Formats are placed in an dict by their format string for reference
1564
during workingtree opening. Its not required that these be instances, they
1565
can be classes themselves with class methods - it simply depends on
1566
whether state is needed for a given format or not.
1568
Once a format is deprecated, just deprecate the initialize and open
1569
methods on the format class. Do not deprecate the object, as the
1570
object will be created every time regardless.
1573
_default_format = None
1574
"""The default format used for new trees."""
1577
"""The known formats."""
1580
def find_format(klass, a_bzrdir):
1581
"""Return the format for the working tree object in a_bzrdir."""
1583
transport = a_bzrdir.get_workingtree_transport(None)
1584
format_string = transport.get("format").read()
1585
return klass._formats[format_string]
1587
raise errors.NoWorkingTree(base=transport.base)
1589
raise errors.UnknownFormatError(format_string)
1592
def get_default_format(klass):
1593
"""Return the current default format."""
1594
return klass._default_format
1596
def get_format_string(self):
1597
"""Return the ASCII format string that identifies this format."""
1598
raise NotImplementedError(self.get_format_string)
1600
def get_format_description(self):
1601
"""Return the short description for this format."""
1602
raise NotImplementedError(self.get_format_description)
1604
def is_supported(self):
1605
"""Is this format supported?
1607
Supported formats can be initialized and opened.
1608
Unsupported formats may not support initialization or committing or
1609
some other features depending on the reason for not being supported.
1614
def register_format(klass, format):
1615
klass._formats[format.get_format_string()] = format
1618
def set_default_format(klass, format):
1619
klass._default_format = format
1622
def unregister_format(klass, format):
1623
assert klass._formats[format.get_format_string()] is format
1624
del klass._formats[format.get_format_string()]
1628
class WorkingTreeFormat2(WorkingTreeFormat):
1629
"""The second working tree format.
1631
This format modified the hash cache from the format 1 hash cache.
1634
def get_format_description(self):
1635
"""See WorkingTreeFormat.get_format_description()."""
1636
return "Working tree format 2"
1638
def stub_initialize_remote(self, control_files):
1639
"""As a special workaround create critical control files for a remote working tree
1641
This ensures that it can later be updated and dealt with locally,
1642
since BzrDirFormat6 and BzrDirFormat5 cannot represent dirs with
1643
no working tree. (See bug #43064).
1647
bzrlib.xml5.serializer_v5.write_inventory(inv, sio)
1649
control_files.put('inventory', sio)
1651
control_files.put_utf8('pending-merges', '')
1654
def initialize(self, a_bzrdir, revision_id=None):
1655
"""See WorkingTreeFormat.initialize()."""
1656
if not isinstance(a_bzrdir.transport, LocalTransport):
1657
raise errors.NotLocalUrl(a_bzrdir.transport.base)
1658
branch = a_bzrdir.open_branch()
1659
if revision_id is not None:
1662
revision_history = branch.revision_history()
1664
position = revision_history.index(revision_id)
1666
raise errors.NoSuchRevision(branch, revision_id)
1667
branch.set_revision_history(revision_history[:position + 1])
1670
revision = branch.last_revision()
1672
wt = WorkingTree(a_bzrdir.root_transport.local_abspath('.'),
1678
wt._write_inventory(inv)
1679
wt.set_root_id(inv.root.file_id)
1680
wt.set_last_revision(revision)
1681
wt.set_pending_merges([])
1682
build_tree(wt.basis_tree(), wt)
1686
super(WorkingTreeFormat2, self).__init__()
1687
self._matchingbzrdir = bzrdir.BzrDirFormat6()
1689
def open(self, a_bzrdir, _found=False):
1690
"""Return the WorkingTree object for a_bzrdir
1692
_found is a private parameter, do not use it. It is used to indicate
1693
if format probing has already been done.
1696
# we are being called directly and must probe.
1697
raise NotImplementedError
1698
if not isinstance(a_bzrdir.transport, LocalTransport):
1699
raise errors.NotLocalUrl(a_bzrdir.transport.base)
1700
return WorkingTree(a_bzrdir.root_transport.local_abspath('.'),
1706
class WorkingTreeFormat3(WorkingTreeFormat):
1707
"""The second working tree format updated to record a format marker.
1710
- exists within a metadir controlling .bzr
1711
- includes an explicit version marker for the workingtree control
1712
files, separate from the BzrDir format
1713
- modifies the hash cache format
1715
- uses a LockDir to guard access to the repository
1718
def get_format_string(self):
1719
"""See WorkingTreeFormat.get_format_string()."""
1720
return "Bazaar-NG Working Tree format 3"
1722
def get_format_description(self):
1723
"""See WorkingTreeFormat.get_format_description()."""
1724
return "Working tree format 3"
1726
_lock_file_name = 'lock'
1727
_lock_class = LockDir
1729
def _open_control_files(self, a_bzrdir):
1730
transport = a_bzrdir.get_workingtree_transport(None)
1731
return LockableFiles(transport, self._lock_file_name,
1734
def initialize(self, a_bzrdir, revision_id=None):
1735
"""See WorkingTreeFormat.initialize().
1737
revision_id allows creating a working tree at a different
1738
revision than the branch is at.
1740
if not isinstance(a_bzrdir.transport, LocalTransport):
1741
raise errors.NotLocalUrl(a_bzrdir.transport.base)
1742
transport = a_bzrdir.get_workingtree_transport(self)
1743
control_files = self._open_control_files(a_bzrdir)
1744
control_files.create_lock()
1745
control_files.lock_write()
1746
control_files.put_utf8('format', self.get_format_string())
1747
branch = a_bzrdir.open_branch()
1748
if revision_id is None:
1749
revision_id = branch.last_revision()
1751
wt = WorkingTree3(a_bzrdir.root_transport.local_abspath('.'),
1757
_control_files=control_files)
1760
wt._write_inventory(inv)
1761
wt.set_root_id(inv.root.file_id)
1762
wt.set_last_revision(revision_id)
1763
wt.set_pending_merges([])
1764
build_tree(wt.basis_tree(), wt)
1767
control_files.unlock()
1771
super(WorkingTreeFormat3, self).__init__()
1772
self._matchingbzrdir = bzrdir.BzrDirMetaFormat1()
1774
def open(self, a_bzrdir, _found=False):
1775
"""Return the WorkingTree object for a_bzrdir
1777
_found is a private parameter, do not use it. It is used to indicate
1778
if format probing has already been done.
1781
# we are being called directly and must probe.
1782
raise NotImplementedError
1783
if not isinstance(a_bzrdir.transport, LocalTransport):
1784
raise errors.NotLocalUrl(a_bzrdir.transport.base)
1785
control_files = self._open_control_files(a_bzrdir)
1786
return WorkingTree3(a_bzrdir.root_transport.local_abspath('.'),
1790
_control_files=control_files)
1793
return self.get_format_string()
1796
# formats which have no format string are not discoverable
1797
# and not independently creatable, so are not registered.
1798
__default_format = WorkingTreeFormat3()
1799
WorkingTreeFormat.register_format(__default_format)
1800
WorkingTreeFormat.set_default_format(__default_format)
1801
_legacy_formats = [WorkingTreeFormat2(),
1805
class WorkingTreeTestProviderAdapter(object):
1806
"""A tool to generate a suite testing multiple workingtree formats at once.
1808
This is done by copying the test once for each transport and injecting
1809
the transport_server, transport_readonly_server, and workingtree_format
1810
classes into each copy. Each copy is also given a new id() to make it
1814
def __init__(self, transport_server, transport_readonly_server, formats):
1815
self._transport_server = transport_server
1816
self._transport_readonly_server = transport_readonly_server
1817
self._formats = formats
1819
def adapt(self, test):
1820
from bzrlib.tests import TestSuite
1821
result = TestSuite()
1822
for workingtree_format, bzrdir_format in self._formats:
1823
new_test = deepcopy(test)
1824
new_test.transport_server = self._transport_server
1825
new_test.transport_readonly_server = self._transport_readonly_server
1826
new_test.bzrdir_format = bzrdir_format
1827
new_test.workingtree_format = workingtree_format
1828
def make_new_test_id():
1829
new_id = "%s(%s)" % (new_test.id(), workingtree_format.__class__.__name__)
1830
return lambda: new_id
1831
new_test.id = make_new_test_id()
1832
result.addTest(new_test)
added
removed
bzrlib/workingtree.py
