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
basis_tree = self.basis_tree()
844
count = self.branch.pull(source, overwrite, stop_revision)
845
new_revision_history = self.branch.revision_history()
846
if new_revision_history != old_revision_history:
847
if len(old_revision_history):
848
other_revision = old_revision_history[-1]
850
other_revision = None
851
repository = self.branch.repository
852
merge_inner(self.branch,
853
self.branch.basis_tree(),
856
pb=bzrlib.ui.ui_factory.progress_bar())
857
self.set_last_revision(self.branch.last_revision())
863
"""Yield all unknown files in this WorkingTree.
865
If there are any unknown directories then only the directory is
866
returned, not all its children. But if there are unknown files
867
under a versioned subdirectory, they are returned.
869
Currently returned depth-first, sorted by name within directories.
871
## TODO: Work from given directory downwards
872
for path, dir_entry in self.inventory.directories():
873
mutter("search for unknowns in %r", path)
874
dirabs = self.abspath(path)
875
if not isdir(dirabs):
876
# e.g. directory deleted
880
for subf in os.listdir(dirabs):
882
and (subf not in dir_entry.children)):
887
subp = appendpath(path, subf)
891
def ignored_files(self):
892
"""Yield list of PATH, IGNORE_PATTERN"""
893
for subp in self.extras():
894
pat = self.is_ignored(subp)
899
def get_ignore_list(self):
900
"""Return list of ignore patterns.
902
Cached in the Tree object after the first call.
904
if hasattr(self, '_ignorelist'):
905
return self._ignorelist
907
l = bzrlib.DEFAULT_IGNORE[:]
908
if self.has_filename(bzrlib.IGNORE_FILENAME):
909
f = self.get_file_byname(bzrlib.IGNORE_FILENAME)
910
l.extend([line.rstrip("\n\r") for line in f.readlines()])
915
def is_ignored(self, filename):
916
r"""Check whether the filename matches an ignore pattern.
918
Patterns containing '/' or '\' need to match the whole path;
919
others match against only the last component.
921
If the file is ignored, returns the pattern which caused it to
922
be ignored, otherwise None. So this can simply be used as a
923
boolean if desired."""
925
# TODO: Use '**' to match directories, and other extended
926
# globbing stuff from cvs/rsync.
928
# XXX: fnmatch is actually not quite what we want: it's only
929
# approximately the same as real Unix fnmatch, and doesn't
930
# treat dotfiles correctly and allows * to match /.
931
# Eventually it should be replaced with something more
934
for pat in self.get_ignore_list():
935
if '/' in pat or '\\' in pat:
937
# as a special case, you can put ./ at the start of a
938
# pattern; this is good to match in the top-level
941
if (pat[:2] == './') or (pat[:2] == '.\\'):
945
if fnmatch.fnmatchcase(filename, newpat):
948
if fnmatch.fnmatchcase(splitpath(filename)[-1], pat):
953
def kind(self, file_id):
954
return file_kind(self.id2abspath(file_id))
957
def last_revision(self):
958
"""Return the last revision id of this working tree.
960
In early branch formats this was == the branch last_revision,
961
but that cannot be relied upon - for working tree operations,
962
always use tree.last_revision().
964
return self.branch.last_revision()
967
"""See Branch.lock_read, and WorkingTree.unlock."""
968
self.branch.lock_read()
970
return self._control_files.lock_read()
975
def lock_write(self):
976
"""See Branch.lock_write, and WorkingTree.unlock."""
977
self.branch.lock_write()
979
return self._control_files.lock_write()
984
def _basis_inventory_name(self, revision_id):
985
return 'basis-inventory.%s' % revision_id
988
def set_last_revision(self, new_revision, old_revision=None):
989
"""Change the last revision in the working tree."""
990
self._remove_old_basis(old_revision)
991
if self._change_last_revision(new_revision):
992
self._cache_basis_inventory(new_revision)
994
def _change_last_revision(self, new_revision):
995
"""Template method part of set_last_revision to perform the change."""
996
if new_revision is None:
997
self.branch.set_revision_history([])
999
# current format is locked in with the branch
1000
revision_history = self.branch.revision_history()
1002
position = revision_history.index(new_revision)
1004
raise errors.NoSuchRevision(self.branch, new_revision)
1005
self.branch.set_revision_history(revision_history[:position + 1])
1008
def _cache_basis_inventory(self, new_revision):
1009
"""Cache new_revision as the basis inventory."""
1011
xml = self.branch.repository.get_inventory_xml(new_revision)
1012
path = self._basis_inventory_name(new_revision)
1013
self._control_files.put_utf8(path, xml)
1014
except WeaveRevisionNotPresent:
1017
def _remove_old_basis(self, old_revision):
1018
"""Remove the old basis inventory 'old_revision'."""
1019
if old_revision is not None:
1021
path = self._basis_inventory_name(old_revision)
1022
path = self._control_files._escape(path)
1023
self._control_files._transport.delete(path)
1027
def read_basis_inventory(self, revision_id):
1028
"""Read the cached basis inventory."""
1029
path = self._basis_inventory_name(revision_id)
1030
return self._control_files.get_utf8(path).read()
1033
def read_working_inventory(self):
1034
"""Read the working inventory."""
1035
# ElementTree does its own conversion from UTF-8, so open in
1037
result = bzrlib.xml5.serializer_v5.read_inventory(
1038
self._control_files.get('inventory'))
1039
self._set_inventory(result)
1043
def remove(self, files, verbose=False):
1044
"""Remove nominated files from the working inventory..
1046
This does not remove their text. This does not run on XXX on what? RBC
1048
TODO: Refuse to remove modified files unless --force is given?
1050
TODO: Do something useful with directories.
1052
TODO: Should this remove the text or not? Tough call; not
1053
removing may be useful and the user can just use use rm, and
1054
is the opposite of add. Removing it is consistent with most
1055
other tools. Maybe an option.
1057
## TODO: Normalize names
1058
## TODO: Remove nested loops; better scalability
1059
if isinstance(files, basestring):
1062
inv = self.inventory
1064
# do this before any modifications
1066
fid = inv.path2id(f)
1068
# TODO: Perhaps make this just a warning, and continue?
1069
# This tends to happen when
1070
raise NotVersionedError(path=f)
1071
mutter("remove inventory entry %s {%s}", quotefn(f), fid)
1073
# having remove it, it must be either ignored or unknown
1074
if self.is_ignored(f):
1078
show_status(new_status, inv[fid].kind, quotefn(f))
1081
self._write_inventory(inv)
1084
def revert(self, filenames, old_tree=None, backups=True,
1085
pb=DummyProgress()):
1086
from transform import revert
1087
if old_tree is None:
1088
old_tree = self.basis_tree()
1089
revert(self, old_tree, filenames, backups, pb)
1090
if not len(filenames):
1091
self.set_pending_merges([])
1094
def set_inventory(self, new_inventory_list):
1095
from bzrlib.inventory import (Inventory,
1100
inv = Inventory(self.get_root_id())
1101
for path, file_id, parent, kind in new_inventory_list:
1102
name = os.path.basename(path)
1105
# fixme, there should be a factory function inv,add_??
1106
if kind == 'directory':
1107
inv.add(InventoryDirectory(file_id, name, parent))
1108
elif kind == 'file':
1109
inv.add(InventoryFile(file_id, name, parent))
1110
elif kind == 'symlink':
1111
inv.add(InventoryLink(file_id, name, parent))
1113
raise BzrError("unknown kind %r" % kind)
1114
self._write_inventory(inv)
1117
def set_root_id(self, file_id):
1118
"""Set the root id for this tree."""
1119
inv = self.read_working_inventory()
1120
orig_root_id = inv.root.file_id
1121
del inv._byid[inv.root.file_id]
1122
inv.root.file_id = file_id
1123
inv._byid[inv.root.file_id] = inv.root
1126
if entry.parent_id == orig_root_id:
1127
entry.parent_id = inv.root.file_id
1128
self._write_inventory(inv)
1131
"""See Branch.unlock.
1133
WorkingTree locking just uses the Branch locking facilities.
1134
This is current because all working trees have an embedded branch
1135
within them. IF in the future, we were to make branch data shareable
1136
between multiple working trees, i.e. via shared storage, then we
1137
would probably want to lock both the local tree, and the branch.
1139
# FIXME: We want to write out the hashcache only when the last lock on
1140
# this working copy is released. Peeking at the lock count is a bit
1141
# of a nasty hack; probably it's better to have a transaction object,
1142
# which can do some finalization when it's either successfully or
1143
# unsuccessfully completed. (Denys's original patch did that.)
1144
# RBC 20060206 hookinhg into transaction will couple lock and transaction
1145
# wrongly. Hookinh into unllock on the control files object is fine though.
1147
# TODO: split this per format so there is no ugly if block
1148
if self._hashcache.needs_write and (
1149
# dedicated lock files
1150
self._control_files._lock_count==1 or
1152
(self._control_files is self.branch.control_files and
1153
self._control_files._lock_count==3)):
1154
self._hashcache.write()
1155
# reverse order of locking.
1156
result = self._control_files.unlock()
1158
self.branch.unlock()
1164
self.branch.lock_read()
1166
if self.last_revision() == self.branch.last_revision():
1168
basis = self.basis_tree()
1169
to_tree = self.branch.basis_tree()
1170
result = merge_inner(self.branch,
1174
self.set_last_revision(self.branch.last_revision())
1177
self.branch.unlock()
1180
def _write_inventory(self, inv):
1181
"""Write inventory as the current inventory."""
1183
bzrlib.xml5.serializer_v5.write_inventory(inv, sio)
1185
self._control_files.put('inventory', sio)
1186
self._set_inventory(inv)
1187
mutter('wrote working inventory')
1190
class WorkingTree3(WorkingTree):
1191
"""This is the Format 3 working tree.
1193
This differs from the base WorkingTree by:
1194
- having its own file lock
1195
- having its own last-revision property.
1199
def last_revision(self):
1200
"""See WorkingTree.last_revision."""
1202
return self._control_files.get_utf8('last-revision').read()
1206
def _change_last_revision(self, revision_id):
1207
"""See WorkingTree._change_last_revision."""
1208
if revision_id is None or revision_id == NULL_REVISION:
1210
self._control_files._transport.delete('last-revision')
1211
except errors.NoSuchFile:
1216
self.branch.revision_history().index(revision_id)
1218
raise errors.NoSuchRevision(self.branch, revision_id)
1219
self._control_files.put_utf8('last-revision', revision_id)
1223
CONFLICT_SUFFIXES = ('.THIS', '.BASE', '.OTHER')
1224
def get_conflicted_stem(path):
1225
for suffix in CONFLICT_SUFFIXES:
1226
if path.endswith(suffix):
1227
return path[:-len(suffix)]
1229
@deprecated_function(zero_eight)
1230
def is_control_file(filename):
1231
"""See WorkingTree.is_control_filename(filename)."""
1232
## FIXME: better check
1233
filename = normpath(filename)
1234
while filename != '':
1235
head, tail = os.path.split(filename)
1236
## mutter('check %r for control file' % ((head, tail),))
1239
if filename == head:
1245
class WorkingTreeFormat(object):
1246
"""An encapsulation of the initialization and open routines for a format.
1248
Formats provide three things:
1249
* An initialization routine,
1253
Formats are placed in an dict by their format string for reference
1254
during workingtree opening. Its not required that these be instances, they
1255
can be classes themselves with class methods - it simply depends on
1256
whether state is needed for a given format or not.
1258
Once a format is deprecated, just deprecate the initialize and open
1259
methods on the format class. Do not deprecate the object, as the
1260
object will be created every time regardless.
1263
_default_format = None
1264
"""The default format used for new trees."""
1267
"""The known formats."""
1270
def find_format(klass, a_bzrdir):
1271
"""Return the format for the working tree object in a_bzrdir."""
1273
transport = a_bzrdir.get_workingtree_transport(None)
1274
format_string = transport.get("format").read()
1275
return klass._formats[format_string]
1277
raise errors.NoWorkingTree(base=transport.base)
1279
raise errors.UnknownFormatError(format_string)
1282
def get_default_format(klass):
1283
"""Return the current default format."""
1284
return klass._default_format
1286
def get_format_string(self):
1287
"""Return the ASCII format string that identifies this format."""
1288
raise NotImplementedError(self.get_format_string)
1290
def is_supported(self):
1291
"""Is this format supported?
1293
Supported formats can be initialized and opened.
1294
Unsupported formats may not support initialization or committing or
1295
some other features depending on the reason for not being supported.
1300
def register_format(klass, format):
1301
klass._formats[format.get_format_string()] = format
1304
def set_default_format(klass, format):
1305
klass._default_format = format
1308
def unregister_format(klass, format):
1309
assert klass._formats[format.get_format_string()] is format
1310
del klass._formats[format.get_format_string()]
1314
class WorkingTreeFormat2(WorkingTreeFormat):
1315
"""The second working tree format.
1317
This format modified the hash cache from the format 1 hash cache.
1320
def initialize(self, a_bzrdir, revision_id=None):
1321
"""See WorkingTreeFormat.initialize()."""
1322
if not isinstance(a_bzrdir.transport, LocalTransport):
1323
raise errors.NotLocalUrl(a_bzrdir.transport.base)
1324
branch = a_bzrdir.open_branch()
1325
if revision_id is not None:
1328
revision_history = branch.revision_history()
1330
position = revision_history.index(revision_id)
1332
raise errors.NoSuchRevision(branch, revision_id)
1333
branch.set_revision_history(revision_history[:position + 1])
1336
revision = branch.last_revision()
1338
wt = WorkingTree(a_bzrdir.root_transport.base,
1344
wt._write_inventory(inv)
1345
wt.set_root_id(inv.root.file_id)
1346
wt.set_last_revision(revision)
1347
wt.set_pending_merges([])
1348
build_tree(wt.basis_tree(), wt)
1352
super(WorkingTreeFormat2, self).__init__()
1353
self._matchingbzrdir = bzrdir.BzrDirFormat6()
1355
def open(self, a_bzrdir, _found=False):
1356
"""Return the WorkingTree object for a_bzrdir
1358
_found is a private parameter, do not use it. It is used to indicate
1359
if format probing has already been done.
1362
# we are being called directly and must probe.
1363
raise NotImplementedError
1364
if not isinstance(a_bzrdir.transport, LocalTransport):
1365
raise errors.NotLocalUrl(a_bzrdir.transport.base)
1366
return WorkingTree(a_bzrdir.root_transport.base,
1372
class WorkingTreeFormat3(WorkingTreeFormat):
1373
"""The second working tree format updated to record a format marker.
1375
This format modified the hash cache from the format 1 hash cache.
1378
def get_format_string(self):
1379
"""See WorkingTreeFormat.get_format_string()."""
1380
return "Bazaar-NG Working Tree format 3"
1382
def initialize(self, a_bzrdir, revision_id=None):
1383
"""See WorkingTreeFormat.initialize().
1385
revision_id allows creating a working tree at a differnet
1386
revision than the branch is at.
1388
if not isinstance(a_bzrdir.transport, LocalTransport):
1389
raise errors.NotLocalUrl(a_bzrdir.transport.base)
1390
transport = a_bzrdir.get_workingtree_transport(self)
1391
control_files = LockableFiles(transport, 'lock')
1392
control_files.put_utf8('format', self.get_format_string())
1393
branch = a_bzrdir.open_branch()
1394
if revision_id is None:
1395
revision_id = branch.last_revision()
1397
wt = WorkingTree3(a_bzrdir.root_transport.base,
1403
wt._write_inventory(inv)
1404
wt.set_root_id(inv.root.file_id)
1405
wt.set_last_revision(revision_id)
1406
wt.set_pending_merges([])
1407
build_tree(wt.basis_tree(), wt)
1411
super(WorkingTreeFormat3, self).__init__()
1412
self._matchingbzrdir = bzrdir.BzrDirMetaFormat1()
1414
def open(self, a_bzrdir, _found=False):
1415
"""Return the WorkingTree object for a_bzrdir
1417
_found is a private parameter, do not use it. It is used to indicate
1418
if format probing has already been done.
1421
# we are being called directly and must probe.
1422
raise NotImplementedError
1423
if not isinstance(a_bzrdir.transport, LocalTransport):
1424
raise errors.NotLocalUrl(a_bzrdir.transport.base)
1425
return WorkingTree3(a_bzrdir.root_transport.base,
1431
return self.get_format_string()
1434
# formats which have no format string are not discoverable
1435
# and not independently creatable, so are not registered.
1436
__default_format = WorkingTreeFormat3()
1437
WorkingTreeFormat.register_format(__default_format)
1438
WorkingTreeFormat.set_default_format(__default_format)
1439
_legacy_formats = [WorkingTreeFormat2(),
1443
class WorkingTreeTestProviderAdapter(object):
1444
"""A tool to generate a suite testing multiple workingtree formats at once.
1446
This is done by copying the test once for each transport and injecting
1447
the transport_server, transport_readonly_server, and workingtree_format
1448
classes into each copy. Each copy is also given a new id() to make it
1452
def __init__(self, transport_server, transport_readonly_server, formats):
1453
self._transport_server = transport_server
1454
self._transport_readonly_server = transport_readonly_server
1455
self._formats = formats
1457
def adapt(self, test):
1458
from bzrlib.tests import TestSuite
1459
result = TestSuite()
1460
for workingtree_format, bzrdir_format in self._formats:
1461
new_test = deepcopy(test)
1462
new_test.transport_server = self._transport_server
1463
new_test.transport_readonly_server = self._transport_readonly_server
1464
new_test.bzrdir_format = bzrdir_format
1465
new_test.workingtree_format = workingtree_format
1466
def make_new_test_id():
1467
new_id = "%s(%s)" % (new_test.id(), workingtree_format.__class__.__name__)
1468
return lambda: new_id
1469
new_test.id = make_new_test_id()
1470
result.addTest(new_test)
added
removed
bzrlib/workingtree.py
