1
# Copyright (C) 2005 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).
33
# 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
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
89
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
class TreeEntry(object):
132
"""An entry that implements the minium interface used by commands.
134
This needs further inspection, it may be better to have
135
InventoryEntries without ids - though that seems wrong. For now,
136
this is a parallel hierarchy to InventoryEntry, and needs to become
137
one of several things: decorates to that hierarchy, children of, or
139
Another note is that these objects are currently only used when there is
140
no InventoryEntry available - i.e. for unversioned objects.
141
Perhaps they should be UnversionedEntry et al. ? - RBC 20051003
144
def __eq__(self, other):
145
# yes, this us ugly, TODO: best practice __eq__ style.
146
return (isinstance(other, TreeEntry)
147
and other.__class__ == self.__class__)
149
def kind_character(self):
153
class TreeDirectory(TreeEntry):
154
"""See TreeEntry. This is a directory in a working tree."""
156
def __eq__(self, other):
157
return (isinstance(other, TreeDirectory)
158
and other.__class__ == self.__class__)
160
def kind_character(self):
164
class TreeFile(TreeEntry):
165
"""See TreeEntry. This is a regular file in a working tree."""
167
def __eq__(self, other):
168
return (isinstance(other, TreeFile)
169
and other.__class__ == self.__class__)
171
def kind_character(self):
175
class TreeLink(TreeEntry):
176
"""See TreeEntry. This is a symlink in a working tree."""
178
def __eq__(self, other):
179
return (isinstance(other, TreeLink)
180
and other.__class__ == self.__class__)
182
def kind_character(self):
186
class WorkingTree(bzrlib.tree.Tree):
187
"""Working copy tree.
189
The inventory is held in the `Branch` working-inventory, and the
190
files are in a directory on disk.
192
It is possible for a `WorkingTree` to have a filename which is
193
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
226
from bzrlib.hashcache import HashCache
227
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),
259
# update the whole cache up front and write to disk if anything changed;
260
# 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)
268
# is this scan needed ? it makes things kinda slow.
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)
332
"""Iterate through file_ids for this tree.
334
file_ids are in a WorkingTree if they are in the working inventory
335
and the working file exists.
337
inv = self._inventory
338
for path, ie in inv.iter_entries():
339
if bzrlib.osutils.lexists(self.abspath(path)):
343
return "<%s of %s>" % (self.__class__.__name__,
344
getattr(self, 'basedir', None))
346
def abspath(self, filename):
347
return pathjoin(self.basedir, filename)
349
def basis_tree(self):
350
"""Return RevisionTree for the current last revision."""
351
revision_id = self.last_revision()
352
if revision_id is not None:
354
xml = self.read_basis_inventory(revision_id)
355
inv = bzrlib.xml5.serializer_v5.read_inventory_from_string(xml)
356
return bzrlib.tree.RevisionTree(self.branch.repository, inv,
360
return self.branch.repository.revision_tree(revision_id)
363
@deprecated_method(zero_eight)
364
def create(branch, directory):
365
"""Create a workingtree for branch at directory.
367
If existing_directory already exists it must have a .bzr directory.
368
If it does not exist, it will be created.
370
This returns a new WorkingTree object for the new checkout.
372
TODO FIXME RBC 20060124 when we have checkout formats in place this
373
should accept an optional revisionid to checkout [and reject this if
374
checking out into the same dir as a pre-checkout-aware branch format.]
376
XXX: When BzrDir is present, these should be created through that
379
warn('delete WorkingTree.create', stacklevel=3)
380
transport = get_transport(directory)
381
if branch.bzrdir.root_transport.base == transport.base:
383
return branch.bzrdir.create_workingtree()
384
# different directory,
385
# create a branch reference
386
# and now a working tree.
387
raise NotImplementedError
390
@deprecated_method(zero_eight)
391
def create_standalone(directory):
392
"""Create a checkout and a branch and a repo at directory.
394
Directory must exist and be empty.
396
please use BzrDir.create_standalone_workingtree
398
return bzrdir.BzrDir.create_standalone_workingtree(directory)
400
def relpath(self, abs):
401
"""Return the local path portion from a given absolute path."""
402
return relpath(self.basedir, abs)
404
def has_filename(self, filename):
405
return bzrlib.osutils.lexists(self.abspath(filename))
407
def get_file(self, file_id):
408
return self.get_file_byname(self.id2path(file_id))
410
def get_file_byname(self, filename):
411
return file(self.abspath(filename), 'rb')
413
def get_root_id(self):
414
"""Return the id of this trees root"""
415
inv = self.read_working_inventory()
416
return inv.root.file_id
418
def _get_store_filename(self, file_id):
419
## XXX: badly named; this is not in the store at all
420
return self.abspath(self.id2path(file_id))
423
def clone(self, to_bzrdir, revision_id=None, basis=None):
424
"""Duplicate this working tree into to_bzr, including all state.
426
Specifically modified files are kept as modified, but
427
ignored and unknown files are discarded.
429
If you want to make a new line of development, see bzrdir.sprout()
432
If not None, the cloned tree will have its last revision set to
433
revision, and and difference between the source trees last revision
434
and this one merged in.
437
If not None, a closer copy of a tree which may have some files in
438
common, and which file content should be preferentially copied from.
440
# assumes the target bzr dir format is compatible.
441
result = self._format.initialize(to_bzrdir)
442
self.copy_content_into(result, revision_id)
446
def copy_content_into(self, tree, revision_id=None):
447
"""Copy the current content and user files of this tree into tree."""
448
if revision_id is None:
449
transform_tree(tree, self)
451
# TODO now merge from tree.last_revision to revision
452
transform_tree(tree, self)
453
tree.set_last_revision(revision_id)
456
def commit(self, *args, **kwargs):
457
from bzrlib.commit import Commit
458
# args for wt.commit start at message from the Commit.commit method,
459
# but with branch a kwarg now, passing in args as is results in the
460
#message being used for the branch
461
args = (DEPRECATED_PARAMETER, ) + args
462
Commit().commit(working_tree=self, *args, **kwargs)
463
self._set_inventory(self.read_working_inventory())
465
def id2abspath(self, file_id):
466
return self.abspath(self.id2path(file_id))
468
def has_id(self, file_id):
469
# files that have been deleted are excluded
470
inv = self._inventory
471
if not inv.has_id(file_id):
473
path = inv.id2path(file_id)
474
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
__contains__ = has_id
483
def get_file_size(self, file_id):
484
return os.path.getsize(self.id2abspath(file_id))
487
def get_file_sha1(self, file_id):
488
path = self._inventory.id2path(file_id)
489
return self._hashcache.get_sha1(path)
491
def is_executable(self, file_id):
492
if not supports_executable():
493
return self._inventory[file_id].executable
495
path = self._inventory.id2path(file_id)
496
mode = os.lstat(self.abspath(path)).st_mode
497
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
def get_symlink_target(self, file_id):
603
return os.readlink(self.id2abspath(file_id))
605
def file_class(self, filename):
606
if self.path2id(filename):
608
elif self.is_ignored(filename):
613
def list_files(self):
614
"""Recursively list all files as (path, class, kind, id).
616
Lists, but does not descend into unversioned directories.
618
This does not include files that have been deleted in this
621
Skips the control directory.
623
inv = self._inventory
625
def descend(from_dir_relpath, from_dir_id, dp):
629
## TODO: If we find a subdirectory with its own .bzr
630
## directory, then that is a separate tree and we
631
## should exclude it.
633
# the bzrdir for this tree
634
if self.bzrdir.transport.base.endswith(f + '/'):
638
fp = appendpath(from_dir_relpath, f)
641
fap = appendpath(dp, f)
643
f_ie = inv.get_child(from_dir_id, f)
646
elif self.is_ignored(fp):
655
raise BzrCheckError("file %r entered as kind %r id %r, "
657
% (fap, f_ie.kind, f_ie.file_id, fk))
659
# make a last minute entry
663
if fk == 'directory':
664
entry = TreeDirectory()
667
elif fk == 'symlink':
672
yield fp, c, fk, (f_ie and f_ie.file_id), entry
674
if fk != 'directory':
678
# don't descend unversioned directories
681
for ff in descend(fp, f_ie.file_id, fap):
684
for f in descend(u'', 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)
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
for subp in self.extras():
825
if not self.is_ignored(subp):
828
def iter_conflicts(self):
830
for path in (s[0] for s in self.list_files()):
831
stem = get_conflicted_stem(path)
834
if stem not in conflicted:
839
def pull(self, source, overwrite=False, stop_revision=None):
842
old_revision_history = self.branch.revision_history()
843
count = self.branch.pull(source, overwrite, stop_revision)
844
new_revision_history = self.branch.revision_history()
845
if new_revision_history != old_revision_history:
846
if len(old_revision_history):
847
other_revision = old_revision_history[-1]
849
other_revision = None
850
repository = self.branch.repository
851
merge_inner(self.branch,
853
repository.revision_tree(other_revision),
855
pb=bzrlib.ui.ui_factory.progress_bar())
856
self.set_last_revision(self.branch.last_revision())
862
"""Yield all unknown files in this WorkingTree.
864
If there are any unknown directories then only the directory is
865
returned, not all its children. But if there are unknown files
866
under a versioned subdirectory, they are returned.
868
Currently returned depth-first, sorted by name within directories.
870
## TODO: Work from given directory downwards
871
for path, dir_entry in self.inventory.directories():
872
mutter("search for unknowns in %r", path)
873
dirabs = self.abspath(path)
874
if not isdir(dirabs):
875
# e.g. directory deleted
879
for subf in os.listdir(dirabs):
881
and (subf not in dir_entry.children)):
886
subp = appendpath(path, subf)
890
def ignored_files(self):
891
"""Yield list of PATH, IGNORE_PATTERN"""
892
for subp in self.extras():
893
pat = self.is_ignored(subp)
898
def get_ignore_list(self):
899
"""Return list of ignore patterns.
901
Cached in the Tree object after the first call.
903
if hasattr(self, '_ignorelist'):
904
return self._ignorelist
906
l = bzrlib.DEFAULT_IGNORE[:]
907
if self.has_filename(bzrlib.IGNORE_FILENAME):
908
f = self.get_file_byname(bzrlib.IGNORE_FILENAME)
909
l.extend([line.rstrip("\n\r") for line in f.readlines()])
914
def is_ignored(self, filename):
915
r"""Check whether the filename matches an ignore pattern.
917
Patterns containing '/' or '\' need to match the whole path;
918
others match against only the last component.
920
If the file is ignored, returns the pattern which caused it to
921
be ignored, otherwise None. So this can simply be used as a
922
boolean if desired."""
924
# TODO: Use '**' to match directories, and other extended
925
# globbing stuff from cvs/rsync.
927
# XXX: fnmatch is actually not quite what we want: it's only
928
# approximately the same as real Unix fnmatch, and doesn't
929
# treat dotfiles correctly and allows * to match /.
930
# Eventually it should be replaced with something more
933
for pat in self.get_ignore_list():
934
if '/' in pat or '\\' in pat:
936
# as a special case, you can put ./ at the start of a
937
# pattern; this is good to match in the top-level
940
if (pat[:2] == './') or (pat[:2] == '.\\'):
944
if fnmatch.fnmatchcase(filename, newpat):
947
if fnmatch.fnmatchcase(splitpath(filename)[-1], pat):
952
def kind(self, file_id):
953
return file_kind(self.id2abspath(file_id))
956
def last_revision(self):
957
"""Return the last revision id of this working tree.
959
In early branch formats this was == the branch last_revision,
960
but that cannot be relied upon - for working tree operations,
961
always use tree.last_revision().
963
return self.branch.last_revision()
966
"""See Branch.lock_read, and WorkingTree.unlock."""
967
self.branch.lock_read()
969
return self._control_files.lock_read()
974
def lock_write(self):
975
"""See Branch.lock_write, and WorkingTree.unlock."""
976
self.branch.lock_write()
978
return self._control_files.lock_write()
983
def _basis_inventory_name(self, revision_id):
984
return 'basis-inventory.%s' % revision_id
987
def set_last_revision(self, new_revision, old_revision=None):
988
"""Change the last revision in the working tree."""
989
self._remove_old_basis(old_revision)
990
if self._change_last_revision(new_revision):
991
self._cache_basis_inventory(new_revision)
993
def _change_last_revision(self, new_revision):
994
"""Template method part of set_last_revision to perform the change."""
995
if new_revision is None:
996
self.branch.set_revision_history([])
998
# current format is locked in with the branch
999
revision_history = self.branch.revision_history()
1001
position = revision_history.index(new_revision)
1003
raise errors.NoSuchRevision(self.branch, new_revision)
1004
self.branch.set_revision_history(revision_history[:position + 1])
1007
def _cache_basis_inventory(self, new_revision):
1008
"""Cache new_revision as the basis inventory."""
1010
xml = self.branch.repository.get_inventory_xml(new_revision)
1011
path = self._basis_inventory_name(new_revision)
1012
self._control_files.put_utf8(path, xml)
1013
except WeaveRevisionNotPresent:
1016
def _remove_old_basis(self, old_revision):
1017
"""Remove the old basis inventory 'old_revision'."""
1018
if old_revision is not None:
1020
path = self._basis_inventory_name(old_revision)
1021
path = self._control_files._escape(path)
1022
self._control_files._transport.delete(path)
1026
def read_basis_inventory(self, revision_id):
1027
"""Read the cached basis inventory."""
1028
path = self._basis_inventory_name(revision_id)
1029
return self._control_files.get_utf8(path).read()
1032
def read_working_inventory(self):
1033
"""Read the working inventory."""
1034
# ElementTree does its own conversion from UTF-8, so open in
1036
result = bzrlib.xml5.serializer_v5.read_inventory(
1037
self._control_files.get('inventory'))
1038
self._set_inventory(result)
1042
def remove(self, files, verbose=False):
1043
"""Remove nominated files from the working inventory..
1045
This does not remove their text. This does not run on XXX on what? RBC
1047
TODO: Refuse to remove modified files unless --force is given?
1049
TODO: Do something useful with directories.
1051
TODO: Should this remove the text or not? Tough call; not
1052
removing may be useful and the user can just use use rm, and
1053
is the opposite of add. Removing it is consistent with most
1054
other tools. Maybe an option.
1056
## TODO: Normalize names
1057
## TODO: Remove nested loops; better scalability
1058
if isinstance(files, basestring):
1061
inv = self.inventory
1063
# do this before any modifications
1065
fid = inv.path2id(f)
1067
# TODO: Perhaps make this just a warning, and continue?
1068
# This tends to happen when
1069
raise NotVersionedError(path=f)
1070
mutter("remove inventory entry %s {%s}", quotefn(f), fid)
1072
# having remove it, it must be either ignored or unknown
1073
if self.is_ignored(f):
1077
show_status(new_status, inv[fid].kind, quotefn(f))
1080
self._write_inventory(inv)
1083
def revert(self, filenames, old_tree=None, backups=True,
1084
pb=DummyProgress()):
1085
from transform import revert
1086
if old_tree is None:
1087
old_tree = self.basis_tree()
1088
revert(self, old_tree, filenames, backups, pb)
1089
if not len(filenames):
1090
self.set_pending_merges([])
1093
def set_inventory(self, new_inventory_list):
1094
from bzrlib.inventory import (Inventory,
1099
inv = Inventory(self.get_root_id())
1100
for path, file_id, parent, kind in new_inventory_list:
1101
name = os.path.basename(path)
1104
# fixme, there should be a factory function inv,add_??
1105
if kind == 'directory':
1106
inv.add(InventoryDirectory(file_id, name, parent))
1107
elif kind == 'file':
1108
inv.add(InventoryFile(file_id, name, parent))
1109
elif kind == 'symlink':
1110
inv.add(InventoryLink(file_id, name, parent))
1112
raise BzrError("unknown kind %r" % kind)
1113
self._write_inventory(inv)
1116
def set_root_id(self, file_id):
1117
"""Set the root id for this tree."""
1118
inv = self.read_working_inventory()
1119
orig_root_id = inv.root.file_id
1120
del inv._byid[inv.root.file_id]
1121
inv.root.file_id = file_id
1122
inv._byid[inv.root.file_id] = inv.root
1125
if entry.parent_id == orig_root_id:
1126
entry.parent_id = inv.root.file_id
1127
self._write_inventory(inv)
1130
"""See Branch.unlock.
1132
WorkingTree locking just uses the Branch locking facilities.
1133
This is current because all working trees have an embedded branch
1134
within them. IF in the future, we were to make branch data shareable
1135
between multiple working trees, i.e. via shared storage, then we
1136
would probably want to lock both the local tree, and the branch.
1138
# FIXME: We want to write out the hashcache only when the last lock on
1139
# this working copy is released. Peeking at the lock count is a bit
1140
# of a nasty hack; probably it's better to have a transaction object,
1141
# which can do some finalization when it's either successfully or
1142
# unsuccessfully completed. (Denys's original patch did that.)
1143
# RBC 20060206 hookinhg into transaction will couple lock and transaction
1144
# wrongly. Hookinh into unllock on the control files object is fine though.
1146
# TODO: split this per format so there is no ugly if block
1147
if self._hashcache.needs_write and (
1148
# dedicated lock files
1149
self._control_files._lock_count==1 or
1151
(self._control_files is self.branch.control_files and
1152
self._control_files._lock_count==3)):
1153
self._hashcache.write()
1154
# reverse order of locking.
1155
result = self._control_files.unlock()
1157
self.branch.unlock()
1163
self.branch.lock_read()
1165
if self.last_revision() == self.branch.last_revision():
1167
basis = self.basis_tree()
1168
to_tree = self.branch.basis_tree()
1169
result = merge_inner(self.branch,
1173
self.set_last_revision(self.branch.last_revision())
1176
self.branch.unlock()
1179
def _write_inventory(self, inv):
1180
"""Write inventory as the current inventory."""
1182
bzrlib.xml5.serializer_v5.write_inventory(inv, sio)
1184
self._control_files.put('inventory', sio)
1185
self._set_inventory(inv)
1186
mutter('wrote working inventory')
1189
class WorkingTree3(WorkingTree):
1190
"""This is the Format 3 working tree.
1192
This differs from the base WorkingTree by:
1193
- having its own file lock
1194
- having its own last-revision property.
1198
def last_revision(self):
1199
"""See WorkingTree.last_revision."""
1201
return self._control_files.get_utf8('last-revision').read()
1205
def _change_last_revision(self, revision_id):
1206
"""See WorkingTree._change_last_revision."""
1207
if revision_id is None or revision_id == NULL_REVISION:
1209
self._control_files._transport.delete('last-revision')
1210
except errors.NoSuchFile:
1215
self.branch.revision_history().index(revision_id)
1217
raise errors.NoSuchRevision(self.branch, revision_id)
1218
self._control_files.put_utf8('last-revision', revision_id)
1222
CONFLICT_SUFFIXES = ('.THIS', '.BASE', '.OTHER')
1223
def get_conflicted_stem(path):
1224
for suffix in CONFLICT_SUFFIXES:
1225
if path.endswith(suffix):
1226
return path[:-len(suffix)]
1228
@deprecated_function(zero_eight)
1229
def is_control_file(filename):
1230
"""See WorkingTree.is_control_filename(filename)."""
1231
## FIXME: better check
1232
filename = normpath(filename)
1233
while filename != '':
1234
head, tail = os.path.split(filename)
1235
## mutter('check %r for control file' % ((head, tail),))
1238
if filename == head:
1244
class WorkingTreeFormat(object):
1245
"""An encapsulation of the initialization and open routines for a format.
1247
Formats provide three things:
1248
* An initialization routine,
1252
Formats are placed in an dict by their format string for reference
1253
during workingtree opening. Its not required that these be instances, they
1254
can be classes themselves with class methods - it simply depends on
1255
whether state is needed for a given format or not.
1257
Once a format is deprecated, just deprecate the initialize and open
1258
methods on the format class. Do not deprecate the object, as the
1259
object will be created every time regardless.
1262
_default_format = None
1263
"""The default format used for new trees."""
1266
"""The known formats."""
1269
def find_format(klass, a_bzrdir):
1270
"""Return the format for the working tree object in a_bzrdir."""
1272
transport = a_bzrdir.get_workingtree_transport(None)
1273
format_string = transport.get("format").read()
1274
return klass._formats[format_string]
1276
raise errors.NoWorkingTree(base=transport.base)
1278
raise errors.UnknownFormatError(format_string)
1281
def get_default_format(klass):
1282
"""Return the current default format."""
1283
return klass._default_format
1285
def get_format_string(self):
1286
"""Return the ASCII format string that identifies this format."""
1287
raise NotImplementedError(self.get_format_string)
1289
def is_supported(self):
1290
"""Is this format supported?
1292
Supported formats can be initialized and opened.
1293
Unsupported formats may not support initialization or committing or
1294
some other features depending on the reason for not being supported.
1299
def register_format(klass, format):
1300
klass._formats[format.get_format_string()] = format
1303
def set_default_format(klass, format):
1304
klass._default_format = format
1307
def unregister_format(klass, format):
1308
assert klass._formats[format.get_format_string()] is format
1309
del klass._formats[format.get_format_string()]
1313
class WorkingTreeFormat2(WorkingTreeFormat):
1314
"""The second working tree format.
1316
This format modified the hash cache from the format 1 hash cache.
1319
def initialize(self, a_bzrdir, revision_id=None):
1320
"""See WorkingTreeFormat.initialize()."""
1321
if not isinstance(a_bzrdir.transport, LocalTransport):
1322
raise errors.NotLocalUrl(a_bzrdir.transport.base)
1323
branch = a_bzrdir.open_branch()
1324
if revision_id is not None:
1327
revision_history = branch.revision_history()
1329
position = revision_history.index(revision_id)
1331
raise errors.NoSuchRevision(branch, revision_id)
1332
branch.set_revision_history(revision_history[:position + 1])
1335
revision = branch.last_revision()
1337
wt = WorkingTree(a_bzrdir.root_transport.base,
1343
wt._write_inventory(inv)
1344
wt.set_root_id(inv.root.file_id)
1345
wt.set_last_revision(revision)
1346
wt.set_pending_merges([])
1347
build_tree(wt.basis_tree(), wt)
1351
super(WorkingTreeFormat2, self).__init__()
1352
self._matchingbzrdir = bzrdir.BzrDirFormat6()
1354
def open(self, a_bzrdir, _found=False):
1355
"""Return the WorkingTree object for a_bzrdir
1357
_found is a private parameter, do not use it. It is used to indicate
1358
if format probing has already been done.
1361
# we are being called directly and must probe.
1362
raise NotImplementedError
1363
if not isinstance(a_bzrdir.transport, LocalTransport):
1364
raise errors.NotLocalUrl(a_bzrdir.transport.base)
1365
return WorkingTree(a_bzrdir.root_transport.base,
1371
class WorkingTreeFormat3(WorkingTreeFormat):
1372
"""The second working tree format updated to record a format marker.
1374
This format modified the hash cache from the format 1 hash cache.
1377
def get_format_string(self):
1378
"""See WorkingTreeFormat.get_format_string()."""
1379
return "Bazaar-NG Working Tree format 3"
1381
def initialize(self, a_bzrdir, revision_id=None):
1382
"""See WorkingTreeFormat.initialize().
1384
revision_id allows creating a working tree at a differnet
1385
revision than the branch is at.
1387
if not isinstance(a_bzrdir.transport, LocalTransport):
1388
raise errors.NotLocalUrl(a_bzrdir.transport.base)
1389
transport = a_bzrdir.get_workingtree_transport(self)
1390
control_files = LockableFiles(transport, 'lock')
1391
control_files.put_utf8('format', self.get_format_string())
1392
branch = a_bzrdir.open_branch()
1393
if revision_id is None:
1394
revision_id = branch.last_revision()
1396
wt = WorkingTree3(a_bzrdir.root_transport.base,
1402
wt._write_inventory(inv)
1403
wt.set_root_id(inv.root.file_id)
1404
wt.set_last_revision(revision_id)
1405
wt.set_pending_merges([])
1406
build_tree(wt.basis_tree(), wt)
1410
super(WorkingTreeFormat3, self).__init__()
1411
self._matchingbzrdir = bzrdir.BzrDirMetaFormat1()
1413
def open(self, a_bzrdir, _found=False):
1414
"""Return the WorkingTree object for a_bzrdir
1416
_found is a private parameter, do not use it. It is used to indicate
1417
if format probing has already been done.
1420
# we are being called directly and must probe.
1421
raise NotImplementedError
1422
if not isinstance(a_bzrdir.transport, LocalTransport):
1423
raise errors.NotLocalUrl(a_bzrdir.transport.base)
1424
return WorkingTree3(a_bzrdir.root_transport.base,
1430
return self.get_format_string()
1433
# formats which have no format string are not discoverable
1434
# and not independently creatable, so are not registered.
1435
__default_format = WorkingTreeFormat3()
1436
WorkingTreeFormat.register_format(__default_format)
1437
WorkingTreeFormat.set_default_format(__default_format)
1438
_legacy_formats = [WorkingTreeFormat2(),
1442
class WorkingTreeTestProviderAdapter(object):
1443
"""A tool to generate a suite testing multiple workingtree formats at once.
1445
This is done by copying the test once for each transport and injecting
1446
the transport_server, transport_readonly_server, and workingtree_format
1447
classes into each copy. Each copy is also given a new id() to make it
1451
def __init__(self, transport_server, transport_readonly_server, formats):
1452
self._transport_server = transport_server
1453
self._transport_readonly_server = transport_readonly_server
1454
self._formats = formats
1456
def adapt(self, test):
1457
from bzrlib.tests import TestSuite
1458
result = TestSuite()
1459
for workingtree_format, bzrdir_format in self._formats:
1460
new_test = deepcopy(test)
1461
new_test.transport_server = self._transport_server
1462
new_test.transport_readonly_server = self._transport_readonly_server
1463
new_test.bzrdir_format = bzrdir_format
1464
new_test.workingtree_format = workingtree_format
1465
def make_new_test_id():
1466
new_id = "%s(%s)" % (new_test.id(), workingtree_format.__class__.__name__)
1467
return lambda: new_id
1468
new_test.id = make_new_test_id()
1469
result.addTest(new_test)
added
removed
bzrlib/workingtree.py
