1
# Copyright (C) 2005-2011 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 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
from cStringIO import StringIO
37
from bzrlib.lazy_import import lazy_import
38
lazy_import(globals(), """
39
from bisect import bisect_left
50
conflicts as _mod_conflicts,
53
filters as _mod_filters,
61
revision as _mod_revision,
71
from bzrlib.workingtree_4 import (
78
from bzrlib import symbol_versioning
79
from bzrlib.decorators import needs_read_lock, needs_write_lock
80
from bzrlib.lock import LogicalLockResult
81
from bzrlib.lockable_files import LockableFiles
82
from bzrlib.lockdir import LockDir
83
import bzrlib.mutabletree
84
from bzrlib.mutabletree import needs_tree_write_lock
85
from bzrlib import osutils
86
from bzrlib.osutils import (
96
from bzrlib.trace import mutter, note
97
from bzrlib.transport.local import LocalTransport
98
from bzrlib.revision import CURRENT_REVISION
99
from bzrlib.symbol_versioning import (
101
DEPRECATED_PARAMETER,
105
MERGE_MODIFIED_HEADER_1 = "BZR merge-modified list format 1"
106
# TODO: Modifying the conflict objects or their type is currently nearly
107
# impossible as there is no clear relationship between the working tree format
108
# and the conflict list file format.
109
CONFLICT_HEADER_1 = "BZR conflict list format 1"
111
ERROR_PATH_NOT_FOUND = 3 # WindowsError errno code, equivalent to ENOENT
114
class TreeEntry(object):
115
"""An entry that implements the minimum interface used by commands.
117
This needs further inspection, it may be better to have
118
InventoryEntries without ids - though that seems wrong. For now,
119
this is a parallel hierarchy to InventoryEntry, and needs to become
120
one of several things: decorates to that hierarchy, children of, or
122
Another note is that these objects are currently only used when there is
123
no InventoryEntry available - i.e. for unversioned objects.
124
Perhaps they should be UnversionedEntry et al. ? - RBC 20051003
127
def __eq__(self, other):
128
# yes, this us ugly, TODO: best practice __eq__ style.
129
return (isinstance(other, TreeEntry)
130
and other.__class__ == self.__class__)
132
def kind_character(self):
136
class TreeDirectory(TreeEntry):
137
"""See TreeEntry. This is a directory in a working tree."""
139
def __eq__(self, other):
140
return (isinstance(other, TreeDirectory)
141
and other.__class__ == self.__class__)
143
def kind_character(self):
147
class TreeFile(TreeEntry):
148
"""See TreeEntry. This is a regular file in a working tree."""
150
def __eq__(self, other):
151
return (isinstance(other, TreeFile)
152
and other.__class__ == self.__class__)
154
def kind_character(self):
158
class TreeLink(TreeEntry):
159
"""See TreeEntry. This is a symlink in a working tree."""
161
def __eq__(self, other):
162
return (isinstance(other, TreeLink)
163
and other.__class__ == self.__class__)
165
def kind_character(self):
169
class WorkingTree(bzrlib.mutabletree.MutableTree,
170
controldir.ControlComponent):
171
"""Working copy tree.
173
:ivar basedir: The root of the tree on disk. This is a unicode path object
174
(as opposed to a URL).
177
# override this to set the strategy for storing views
178
def _make_views(self):
179
return views.DisabledViews(self)
181
def __init__(self, basedir='.',
182
branch=DEPRECATED_PARAMETER,
187
"""Construct a WorkingTree instance. This is not a public API.
189
:param branch: A branch to override probing for the branch.
191
self._format = _format
192
self.bzrdir = _bzrdir
194
raise errors.BzrError("Please use bzrdir.open_workingtree or "
195
"WorkingTree.open() to obtain a WorkingTree.")
196
basedir = safe_unicode(basedir)
197
mutter("opening working tree %r", basedir)
198
if deprecated_passed(branch):
199
self._branch = branch
201
self._branch = self.bzrdir.open_branch()
202
self.basedir = realpath(basedir)
203
self._control_files = _control_files
204
self._transport = self._control_files._transport
205
# update the whole cache up front and write to disk if anything changed;
206
# in the future we might want to do this more selectively
207
# two possible ways offer themselves : in self._unlock, write the cache
208
# if needed, or, when the cache sees a change, append it to the hash
209
# cache file, and have the parser take the most recent entry for a
211
wt_trans = self.bzrdir.get_workingtree_transport(None)
212
cache_filename = wt_trans.local_abspath('stat-cache')
213
self._hashcache = hashcache.HashCache(basedir, cache_filename,
214
self.bzrdir._get_file_mode(),
215
self._content_filter_stack_provider())
218
# is this scan needed ? it makes things kinda slow.
225
self._detect_case_handling()
226
self._rules_searcher = None
227
self.views = self._make_views()
230
def user_transport(self):
231
return self.bzrdir.user_transport
234
def control_transport(self):
235
return self._transport
237
def is_control_filename(self, filename):
238
"""True if filename is the name of a control file in this tree.
240
:param filename: A filename within the tree. This is a relative path
241
from the root of this tree.
243
This is true IF and ONLY IF the filename is part of the meta data
244
that bzr controls in this tree. I.E. a random .bzr directory placed
245
on disk will not be a control file for this tree.
247
return self.bzrdir.is_control_filename(filename)
249
def _detect_case_handling(self):
250
wt_trans = self.bzrdir.get_workingtree_transport(None)
252
wt_trans.stat(self._format.case_sensitive_filename)
253
except errors.NoSuchFile:
254
self.case_sensitive = True
256
self.case_sensitive = False
258
self._setup_directory_is_tree_reference()
261
fget=lambda self: self._branch,
262
doc="""The branch this WorkingTree is connected to.
264
This cannot be set - it is reflective of the actual disk structure
265
the working tree has been constructed from.
268
def break_lock(self):
269
"""Break a lock if one is present from another instance.
271
Uses the ui factory to ask for confirmation if the lock may be from
274
This will probe the repository for its lock as well.
276
self._control_files.break_lock()
277
self.branch.break_lock()
279
def _get_check_refs(self):
280
"""Return the references needed to perform a check of this tree.
282
The default implementation returns no refs, and is only suitable for
283
trees that have no local caching and can commit on ghosts at any time.
285
:seealso: bzrlib.check for details about check_refs.
289
def requires_rich_root(self):
290
return self._format.requires_rich_root
292
def supports_tree_reference(self):
295
def supports_content_filtering(self):
296
return self._format.supports_content_filtering()
298
def supports_views(self):
299
return self.views.supports_views()
302
def open(path=None, _unsupported=False):
303
"""Open an existing working tree at path.
307
path = osutils.getcwd()
308
control = bzrdir.BzrDir.open(path, _unsupported)
309
return control.open_workingtree(_unsupported)
312
def open_containing(path=None):
313
"""Open an existing working tree which has its root about path.
315
This probes for a working tree at path and searches upwards from there.
317
Basically we keep looking up until we find the control directory or
318
run into /. If there isn't one, raises NotBranchError.
319
TODO: give this a new exception.
320
If there is one, it is returned, along with the unused portion of path.
322
:return: The WorkingTree that contains 'path', and the rest of path
325
path = osutils.getcwd()
326
control, relpath = bzrdir.BzrDir.open_containing(path)
327
return control.open_workingtree(), relpath
330
def open_containing_paths(file_list, default_directory=None,
331
canonicalize=True, apply_view=True):
332
"""Open the WorkingTree that contains a set of paths.
334
Fail if the paths given are not all in a single tree.
336
This is used for the many command-line interfaces that take a list of
337
any number of files and that require they all be in the same tree.
339
if default_directory is None:
340
default_directory = u'.'
341
# recommended replacement for builtins.internal_tree_files
342
if file_list is None or len(file_list) == 0:
343
tree = WorkingTree.open_containing(default_directory)[0]
344
# XXX: doesn't really belong here, and seems to have the strange
345
# side effect of making it return a bunch of files, not the whole
346
# tree -- mbp 20100716
347
if tree.supports_views() and apply_view:
348
view_files = tree.views.lookup_view()
350
file_list = view_files
351
view_str = views.view_display_str(view_files)
352
note("Ignoring files outside view. View is %s" % view_str)
353
return tree, file_list
354
if default_directory == u'.':
357
seed = default_directory
358
file_list = [osutils.pathjoin(default_directory, f)
360
tree = WorkingTree.open_containing(seed)[0]
361
return tree, tree.safe_relpath_files(file_list, canonicalize,
362
apply_view=apply_view)
364
def safe_relpath_files(self, file_list, canonicalize=True, apply_view=True):
365
"""Convert file_list into a list of relpaths in tree.
367
:param self: A tree to operate on.
368
:param file_list: A list of user provided paths or None.
369
:param apply_view: if True and a view is set, apply it or check that
370
specified files are within it
371
:return: A list of relative paths.
372
:raises errors.PathNotChild: When a provided path is in a different self
375
if file_list is None:
377
if self.supports_views() and apply_view:
378
view_files = self.views.lookup_view()
382
# self.relpath exists as a "thunk" to osutils, but canonical_relpath
383
# doesn't - fix that up here before we enter the loop.
385
fixer = lambda p: osutils.canonical_relpath(self.basedir, p)
388
for filename in file_list:
389
relpath = fixer(osutils.dereference_path(filename))
390
if view_files and not osutils.is_inside_any(view_files, relpath):
391
raise errors.FileOutsideView(filename, view_files)
392
new_list.append(relpath)
396
def open_downlevel(path=None):
397
"""Open an unsupported working tree.
399
Only intended for advanced situations like upgrading part of a bzrdir.
401
return WorkingTree.open(path, _unsupported=True)
404
def find_trees(location):
405
def list_current(transport):
406
return [d for d in transport.list_dir('') if d != '.bzr']
407
def evaluate(bzrdir):
409
tree = bzrdir.open_workingtree()
410
except errors.NoWorkingTree:
414
t = transport.get_transport(location)
415
iterator = bzrdir.BzrDir.find_bzrdirs(t, evaluate=evaluate,
416
list_current=list_current)
417
return [tr for tr in iterator if tr is not None]
419
def all_file_ids(self):
420
"""See Tree.iter_all_file_ids"""
421
raise NotImplementedError(self.all_file_ids)
424
return "<%s of %s>" % (self.__class__.__name__,
425
getattr(self, 'basedir', None))
427
def abspath(self, filename):
428
return pathjoin(self.basedir, filename)
430
def basis_tree(self):
431
"""Return RevisionTree for the current last revision.
433
If the left most parent is a ghost then the returned tree will be an
434
empty tree - one obtained by calling
435
repository.revision_tree(NULL_REVISION).
438
revision_id = self.get_parent_ids()[0]
440
# no parents, return an empty revision tree.
441
# in the future this should return the tree for
442
# 'empty:' - the implicit root empty tree.
443
return self.branch.repository.revision_tree(
444
_mod_revision.NULL_REVISION)
446
return self.revision_tree(revision_id)
447
except errors.NoSuchRevision:
449
# No cached copy available, retrieve from the repository.
450
# FIXME? RBC 20060403 should we cache the inventory locally
453
return self.branch.repository.revision_tree(revision_id)
454
except (errors.RevisionNotPresent, errors.NoSuchRevision):
455
# the basis tree *may* be a ghost or a low level error may have
456
# occurred. If the revision is present, its a problem, if its not
458
if self.branch.repository.has_revision(revision_id):
460
# the basis tree is a ghost so return an empty tree.
461
return self.branch.repository.revision_tree(
462
_mod_revision.NULL_REVISION)
465
self._flush_ignore_list_cache()
467
def relpath(self, path):
468
"""Return the local path portion from a given path.
470
The path may be absolute or relative. If its a relative path it is
471
interpreted relative to the python current working directory.
473
return osutils.relpath(self.basedir, path)
475
def has_filename(self, filename):
476
return osutils.lexists(self.abspath(filename))
478
def get_file(self, file_id, path=None, filtered=True):
479
return self.get_file_with_stat(file_id, path, filtered=filtered)[0]
481
def get_file_with_stat(self, file_id, path=None, filtered=True,
482
_fstat=osutils.fstat):
483
"""See Tree.get_file_with_stat."""
485
path = self.id2path(file_id)
486
file_obj = self.get_file_byname(path, filtered=False)
487
stat_value = _fstat(file_obj.fileno())
488
if filtered and self.supports_content_filtering():
489
filters = self._content_filter_stack(path)
490
file_obj = _mod_filters.filtered_input_file(file_obj, filters)
491
return (file_obj, stat_value)
493
def get_file_text(self, file_id, path=None, filtered=True):
494
my_file = self.get_file(file_id, path=path, filtered=filtered)
496
return my_file.read()
500
def get_file_byname(self, filename, filtered=True):
501
path = self.abspath(filename)
503
if filtered and self.supports_content_filtering():
504
filters = self._content_filter_stack(filename)
505
return _mod_filters.filtered_input_file(f, filters)
509
def get_file_lines(self, file_id, path=None, filtered=True):
510
"""See Tree.get_file_lines()"""
511
file = self.get_file(file_id, path, filtered=filtered)
513
return file.readlines()
517
def _get_ancestors(self, default_revision):
518
ancestors = set([default_revision])
519
for parent_id in self.get_parent_ids():
520
ancestors.update(self.branch.repository.get_ancestry(
521
parent_id, topo_sorted=False))
524
def get_parent_ids(self):
525
"""See Tree.get_parent_ids.
527
This implementation reads the pending merges list and last_revision
528
value and uses that to decide what the parents list should be.
530
last_rev = _mod_revision.ensure_null(self._last_revision())
531
if _mod_revision.NULL_REVISION == last_rev:
536
merges_bytes = self._transport.get_bytes('pending-merges')
537
except errors.NoSuchFile:
540
for l in osutils.split_lines(merges_bytes):
541
revision_id = l.rstrip('\n')
542
parents.append(revision_id)
545
def get_root_id(self):
546
"""Return the id of this trees root"""
547
raise NotImplementedError(self.get_root_id)
550
def clone(self, to_bzrdir, revision_id=None):
551
"""Duplicate this working tree into to_bzr, including all state.
553
Specifically modified files are kept as modified, but
554
ignored and unknown files are discarded.
556
If you want to make a new line of development, see bzrdir.sprout()
559
If not None, the cloned tree will have its last revision set to
560
revision, and difference between the source trees last revision
561
and this one merged in.
563
# assumes the target bzr dir format is compatible.
564
result = to_bzrdir.create_workingtree()
565
self.copy_content_into(result, revision_id)
569
def copy_content_into(self, tree, revision_id=None):
570
"""Copy the current content and user files of this tree into tree."""
571
tree.set_root_id(self.get_root_id())
572
if revision_id is None:
573
merge.transform_tree(tree, self)
575
# TODO now merge from tree.last_revision to revision (to preserve
576
# user local changes)
577
merge.transform_tree(tree, self)
578
tree.set_parent_ids([revision_id])
580
def id2abspath(self, file_id):
581
return self.abspath(self.id2path(file_id))
583
def get_file_size(self, file_id):
584
"""See Tree.get_file_size"""
585
# XXX: this returns the on-disk size; it should probably return the
588
return os.path.getsize(self.id2abspath(file_id))
590
if e.errno != errno.ENOENT:
595
def get_file_sha1(self, file_id, path=None, stat_value=None):
596
# FIXME: Shouldn't this be in Tree?
597
raise NotImplementedError(self.get_file_sha1)
599
@needs_tree_write_lock
600
def _gather_kinds(self, files, kinds):
601
"""See MutableTree._gather_kinds."""
602
for pos, f in enumerate(files):
603
if kinds[pos] is None:
604
fullpath = normpath(self.abspath(f))
606
kinds[pos] = file_kind(fullpath)
608
if e.errno == errno.ENOENT:
609
raise errors.NoSuchFile(fullpath)
612
def add_parent_tree_id(self, revision_id, allow_leftmost_as_ghost=False):
613
"""Add revision_id as a parent.
615
This is equivalent to retrieving the current list of parent ids
616
and setting the list to its value plus revision_id.
618
:param revision_id: The revision id to add to the parent list. It may
619
be a ghost revision as long as its not the first parent to be added,
620
or the allow_leftmost_as_ghost parameter is set True.
621
:param allow_leftmost_as_ghost: Allow the first parent to be a ghost.
623
parents = self.get_parent_ids() + [revision_id]
624
self.set_parent_ids(parents, allow_leftmost_as_ghost=len(parents) > 1
625
or allow_leftmost_as_ghost)
627
@needs_tree_write_lock
628
def add_parent_tree(self, parent_tuple, allow_leftmost_as_ghost=False):
629
"""Add revision_id, tree tuple as a parent.
631
This is equivalent to retrieving the current list of parent trees
632
and setting the list to its value plus parent_tuple. See also
633
add_parent_tree_id - if you only have a parent id available it will be
634
simpler to use that api. If you have the parent already available, using
635
this api is preferred.
637
:param parent_tuple: The (revision id, tree) to add to the parent list.
638
If the revision_id is a ghost, pass None for the tree.
639
:param allow_leftmost_as_ghost: Allow the first parent to be a ghost.
641
parent_ids = self.get_parent_ids() + [parent_tuple[0]]
642
if len(parent_ids) > 1:
643
# the leftmost may have already been a ghost, preserve that if it
645
allow_leftmost_as_ghost = True
646
self.set_parent_ids(parent_ids,
647
allow_leftmost_as_ghost=allow_leftmost_as_ghost)
649
@needs_tree_write_lock
650
def add_pending_merge(self, *revision_ids):
651
# TODO: Perhaps should check at this point that the
652
# history of the revision is actually present?
653
parents = self.get_parent_ids()
655
for rev_id in revision_ids:
656
if rev_id in parents:
658
parents.append(rev_id)
661
self.set_parent_ids(parents, allow_leftmost_as_ghost=True)
663
def path_content_summary(self, path, _lstat=os.lstat,
664
_mapper=osutils.file_kind_from_stat_mode):
665
"""See Tree.path_content_summary."""
666
abspath = self.abspath(path)
668
stat_result = _lstat(abspath)
670
if getattr(e, 'errno', None) == errno.ENOENT:
672
return ('missing', None, None, None)
673
# propagate other errors
675
kind = _mapper(stat_result.st_mode)
677
return self._file_content_summary(path, stat_result)
678
elif kind == 'directory':
679
# perhaps it looks like a plain directory, but it's really a
681
if self._directory_is_tree_reference(path):
682
kind = 'tree-reference'
683
return kind, None, None, None
684
elif kind == 'symlink':
685
target = osutils.readlink(abspath)
686
return ('symlink', None, None, target)
688
return (kind, None, None, None)
690
def _file_content_summary(self, path, stat_result):
691
size = stat_result.st_size
692
executable = self._is_executable_from_path_and_stat(path, stat_result)
693
# try for a stat cache lookup
694
return ('file', size, executable, self._sha_from_stat(
697
def _check_parents_for_ghosts(self, revision_ids, allow_leftmost_as_ghost):
698
"""Common ghost checking functionality from set_parent_*.
700
This checks that the left hand-parent exists if there are any
703
if len(revision_ids) > 0:
704
leftmost_id = revision_ids[0]
705
if (not allow_leftmost_as_ghost and not
706
self.branch.repository.has_revision(leftmost_id)):
707
raise errors.GhostRevisionUnusableHere(leftmost_id)
709
def _set_merges_from_parent_ids(self, parent_ids):
710
merges = parent_ids[1:]
711
self._transport.put_bytes('pending-merges', '\n'.join(merges),
712
mode=self.bzrdir._get_file_mode())
714
def _filter_parent_ids_by_ancestry(self, revision_ids):
715
"""Check that all merged revisions are proper 'heads'.
717
This will always return the first revision_id, and any merged revisions
720
if len(revision_ids) == 0:
722
graph = self.branch.repository.get_graph()
723
heads = graph.heads(revision_ids)
724
new_revision_ids = revision_ids[:1]
725
for revision_id in revision_ids[1:]:
726
if revision_id in heads and revision_id not in new_revision_ids:
727
new_revision_ids.append(revision_id)
728
if new_revision_ids != revision_ids:
729
mutter('requested to set revision_ids = %s,'
730
' but filtered to %s', revision_ids, new_revision_ids)
731
return new_revision_ids
733
@needs_tree_write_lock
734
def set_parent_ids(self, revision_ids, allow_leftmost_as_ghost=False):
735
"""Set the parent ids to revision_ids.
737
See also set_parent_trees. This api will try to retrieve the tree data
738
for each element of revision_ids from the trees repository. If you have
739
tree data already available, it is more efficient to use
740
set_parent_trees rather than set_parent_ids. set_parent_ids is however
741
an easier API to use.
743
:param revision_ids: The revision_ids to set as the parent ids of this
744
working tree. Any of these may be ghosts.
746
self._check_parents_for_ghosts(revision_ids,
747
allow_leftmost_as_ghost=allow_leftmost_as_ghost)
748
for revision_id in revision_ids:
749
_mod_revision.check_not_reserved_id(revision_id)
751
revision_ids = self._filter_parent_ids_by_ancestry(revision_ids)
753
if len(revision_ids) > 0:
754
self.set_last_revision(revision_ids[0])
756
self.set_last_revision(_mod_revision.NULL_REVISION)
758
self._set_merges_from_parent_ids(revision_ids)
760
@needs_tree_write_lock
761
def set_parent_trees(self, parents_list, allow_leftmost_as_ghost=False):
762
"""See MutableTree.set_parent_trees."""
763
parent_ids = [rev for (rev, tree) in parents_list]
764
for revision_id in parent_ids:
765
_mod_revision.check_not_reserved_id(revision_id)
767
self._check_parents_for_ghosts(parent_ids,
768
allow_leftmost_as_ghost=allow_leftmost_as_ghost)
770
parent_ids = self._filter_parent_ids_by_ancestry(parent_ids)
772
if len(parent_ids) == 0:
773
leftmost_parent_id = _mod_revision.NULL_REVISION
774
leftmost_parent_tree = None
776
leftmost_parent_id, leftmost_parent_tree = parents_list[0]
778
if self._change_last_revision(leftmost_parent_id):
779
if leftmost_parent_tree is None:
780
# If we don't have a tree, fall back to reading the
781
# parent tree from the repository.
782
self._cache_basis_inventory(leftmost_parent_id)
784
inv = leftmost_parent_tree.inventory
785
xml = self._create_basis_xml_from_inventory(
786
leftmost_parent_id, inv)
787
self._write_basis_inventory(xml)
788
self._set_merges_from_parent_ids(parent_ids)
790
@needs_tree_write_lock
791
def set_pending_merges(self, rev_list):
792
parents = self.get_parent_ids()
793
leftmost = parents[:1]
794
new_parents = leftmost + rev_list
795
self.set_parent_ids(new_parents)
797
@needs_tree_write_lock
798
def set_merge_modified(self, modified_hashes):
800
for file_id, hash in modified_hashes.iteritems():
801
yield _mod_rio.Stanza(file_id=file_id.decode('utf8'),
803
self._put_rio('merge-hashes', iter_stanzas(), MERGE_MODIFIED_HEADER_1)
805
def _sha_from_stat(self, path, stat_result):
806
"""Get a sha digest from the tree's stat cache.
808
The default implementation assumes no stat cache is present.
810
:param path: The path.
811
:param stat_result: The stat result being looked up.
815
def _put_rio(self, filename, stanzas, header):
816
self._must_be_locked()
817
my_file = _mod_rio.rio_file(stanzas, header)
818
self._transport.put_file(filename, my_file,
819
mode=self.bzrdir._get_file_mode())
821
@needs_write_lock # because merge pulls data into the branch.
822
def merge_from_branch(self, branch, to_revision=None, from_revision=None,
823
merge_type=None, force=False):
824
"""Merge from a branch into this working tree.
826
:param branch: The branch to merge from.
827
:param to_revision: If non-None, the merge will merge to to_revision,
828
but not beyond it. to_revision does not need to be in the history
829
of the branch when it is supplied. If None, to_revision defaults to
830
branch.last_revision().
832
from bzrlib.merge import Merger, Merge3Merger
833
merger = Merger(self.branch, this_tree=self)
834
# check that there are no local alterations
835
if not force and self.has_changes():
836
raise errors.UncommittedChanges(self)
837
if to_revision is None:
838
to_revision = _mod_revision.ensure_null(branch.last_revision())
839
merger.other_rev_id = to_revision
840
if _mod_revision.is_null(merger.other_rev_id):
841
raise errors.NoCommits(branch)
842
self.branch.fetch(branch, last_revision=merger.other_rev_id)
843
merger.other_basis = merger.other_rev_id
844
merger.other_tree = self.branch.repository.revision_tree(
846
merger.other_branch = branch
847
if from_revision is None:
850
merger.set_base_revision(from_revision, branch)
851
if merger.base_rev_id == merger.other_rev_id:
852
raise errors.PointlessMerge
853
merger.backup_files = False
854
if merge_type is None:
855
merger.merge_type = Merge3Merger
857
merger.merge_type = merge_type
858
merger.set_interesting_files(None)
859
merger.show_base = False
860
merger.reprocess = False
861
conflicts = merger.do_merge()
865
def merge_modified(self):
866
"""Return a dictionary of files modified by a merge.
868
The list is initialized by WorkingTree.set_merge_modified, which is
869
typically called after we make some automatic updates to the tree
872
This returns a map of file_id->sha1, containing only files which are
873
still in the working inventory and have that text hash.
875
raise NotImplementedError(self.merge_modified)
878
def mkdir(self, path, file_id=None):
879
"""See MutableTree.mkdir()."""
881
file_id = generate_ids.gen_file_id(os.path.basename(path))
882
os.mkdir(self.abspath(path))
883
self.add(path, file_id, 'directory')
886
def get_symlink_target(self, file_id):
887
abspath = self.id2abspath(file_id)
888
target = osutils.readlink(abspath)
891
def subsume(self, other_tree):
892
raise NotImplementedError(self.subsume)
894
def _setup_directory_is_tree_reference(self):
895
if self._branch.repository._format.supports_tree_reference:
896
self._directory_is_tree_reference = \
897
self._directory_may_be_tree_reference
899
self._directory_is_tree_reference = \
900
self._directory_is_never_tree_reference
902
def _directory_is_never_tree_reference(self, relpath):
905
def _directory_may_be_tree_reference(self, relpath):
906
# as a special case, if a directory contains control files then
907
# it's a tree reference, except that the root of the tree is not
908
return relpath and osutils.isdir(self.abspath(relpath) + u"/.bzr")
909
# TODO: We could ask all the control formats whether they
910
# recognize this directory, but at the moment there's no cheap api
911
# to do that. Since we probably can only nest bzr checkouts and
912
# they always use this name it's ok for now. -- mbp 20060306
914
# FIXME: There is an unhandled case here of a subdirectory
915
# containing .bzr but not a branch; that will probably blow up
916
# when you try to commit it. It might happen if there is a
917
# checkout in a subdirectory. This can be avoided by not adding
920
def extract(self, file_id, format=None):
921
"""Extract a subtree from this tree.
923
A new branch will be created, relative to the path for this tree.
925
raise NotImplementedError(self.extract)
928
"""Write the in memory meta data to disk."""
929
raise NotImplementedError(self.flush)
931
def _kind(self, relpath):
932
return osutils.file_kind(self.abspath(relpath))
934
def list_files(self, include_root=False, from_dir=None, recursive=True):
935
"""List all files as (path, class, kind, id, entry).
937
Lists, but does not descend into unversioned directories.
938
This does not include files that have been deleted in this
939
tree. Skips the control directory.
941
:param include_root: if True, return an entry for the root
942
:param from_dir: start from this directory or None for the root
943
:param recursive: whether to recurse into subdirectories or not
945
raise NotImplementedError(self.list_files)
947
def move(self, from_paths, to_dir=None, after=False):
950
to_dir must be known to the working tree.
952
If to_dir exists and is a directory, the files are moved into
953
it, keeping their old names.
955
Note that to_dir is only the last component of the new name;
956
this doesn't change the directory.
958
For each entry in from_paths the move mode will be determined
961
The first mode moves the file in the filesystem and updates the
962
working tree metadata. The second mode only updates the working tree
963
metadata without touching the file on the filesystem.
965
move uses the second mode if 'after == True' and the target is not
966
versioned but present in the working tree.
968
move uses the second mode if 'after == False' and the source is
969
versioned but no longer in the working tree, and the target is not
970
versioned but present in the working tree.
972
move uses the first mode if 'after == False' and the source is
973
versioned and present in the working tree, and the target is not
974
versioned and not present in the working tree.
976
Everything else results in an error.
978
This returns a list of (from_path, to_path) pairs for each
981
raise NotImplementedError(self.move)
983
@needs_tree_write_lock
984
def rename_one(self, from_rel, to_rel, after=False):
987
This can change the directory or the filename or both.
989
rename_one has several 'modes' to work. First, it can rename a physical
990
file and change the file_id. That is the normal mode. Second, it can
991
only change the file_id without touching any physical file.
993
rename_one uses the second mode if 'after == True' and 'to_rel' is not
994
versioned but present in the working tree.
996
rename_one uses the second mode if 'after == False' and 'from_rel' is
997
versioned but no longer in the working tree, and 'to_rel' is not
998
versioned but present in the working tree.
1000
rename_one uses the first mode if 'after == False' and 'from_rel' is
1001
versioned and present in the working tree, and 'to_rel' is not
1002
versioned and not present in the working tree.
1004
Everything else results in an error.
1006
raise NotImplementedError(self.rename_one)
1010
"""Return all unknown files.
1012
These are files in the working directory that are not versioned or
1013
control files or ignored.
1015
# force the extras method to be fully executed before returning, to
1016
# prevent race conditions with the lock
1018
[subp for subp in self.extras() if not self.is_ignored(subp)])
1020
def unversion(self, file_ids):
1021
"""Remove the file ids in file_ids from the current versioned set.
1023
When a file_id is unversioned, all of its children are automatically
1026
:param file_ids: The file ids to stop versioning.
1027
:raises: NoSuchId if any fileid is not currently versioned.
1029
raise NotImplementedError(self.unversion)
1032
def pull(self, source, overwrite=False, stop_revision=None,
1033
change_reporter=None, possible_transports=None, local=False,
1037
old_revision_info = self.branch.last_revision_info()
1038
basis_tree = self.basis_tree()
1039
count = self.branch.pull(source, overwrite, stop_revision,
1040
possible_transports=possible_transports,
1042
new_revision_info = self.branch.last_revision_info()
1043
if new_revision_info != old_revision_info:
1044
repository = self.branch.repository
1045
basis_tree.lock_read()
1047
new_basis_tree = self.branch.basis_tree()
1054
change_reporter=change_reporter,
1055
show_base=show_base)
1056
basis_root_id = basis_tree.get_root_id()
1057
new_root_id = new_basis_tree.get_root_id()
1058
if basis_root_id != new_root_id:
1059
self.set_root_id(new_root_id)
1062
# TODO - dedup parents list with things merged by pull ?
1063
# reuse the revisiontree we merged against to set the new
1065
parent_trees = [(self.branch.last_revision(), new_basis_tree)]
1066
# we have to pull the merge trees out again, because
1067
# merge_inner has set the ids. - this corner is not yet
1068
# layered well enough to prevent double handling.
1069
# XXX TODO: Fix the double handling: telling the tree about
1070
# the already known parent data is wasteful.
1071
merges = self.get_parent_ids()[1:]
1072
parent_trees.extend([
1073
(parent, repository.revision_tree(parent)) for
1075
self.set_parent_trees(parent_trees)
1081
def put_file_bytes_non_atomic(self, file_id, bytes):
1082
"""See MutableTree.put_file_bytes_non_atomic."""
1083
stream = file(self.id2abspath(file_id), 'wb')
1088
# TODO: update the hashcache here ?
1091
"""Yield all unversioned files in this WorkingTree.
1093
If there are any unversioned directories then only the directory is
1094
returned, not all its children. But if there are unversioned files
1095
under a versioned subdirectory, they are returned.
1097
Currently returned depth-first, sorted by name within directories.
1098
This is the same order used by 'osutils.walkdirs'.
1100
raise NotImplementedError(self.extras)
1102
def ignored_files(self):
1103
"""Yield list of PATH, IGNORE_PATTERN"""
1104
for subp in self.extras():
1105
pat = self.is_ignored(subp)
1109
def get_ignore_list(self):
1110
"""Return list of ignore patterns.
1112
Cached in the Tree object after the first call.
1114
ignoreset = getattr(self, '_ignoreset', None)
1115
if ignoreset is not None:
1118
ignore_globs = set()
1119
ignore_globs.update(ignores.get_runtime_ignores())
1120
ignore_globs.update(ignores.get_user_ignores())
1121
if self.has_filename(bzrlib.IGNORE_FILENAME):
1122
f = self.get_file_byname(bzrlib.IGNORE_FILENAME)
1124
ignore_globs.update(ignores.parse_ignore_file(f))
1127
self._ignoreset = ignore_globs
1130
def _flush_ignore_list_cache(self):
1131
"""Resets the cached ignore list to force a cache rebuild."""
1132
self._ignoreset = None
1133
self._ignoreglobster = None
1135
def is_ignored(self, filename):
1136
r"""Check whether the filename matches an ignore pattern.
1138
Patterns containing '/' or '\' need to match the whole path;
1139
others match against only the last component. Patterns starting
1140
with '!' are ignore exceptions. Exceptions take precedence
1141
over regular patterns and cause the filename to not be ignored.
1143
If the file is ignored, returns the pattern which caused it to
1144
be ignored, otherwise None. So this can simply be used as a
1145
boolean if desired."""
1146
if getattr(self, '_ignoreglobster', None) is None:
1147
self._ignoreglobster = globbing.ExceptionGlobster(self.get_ignore_list())
1148
return self._ignoreglobster.match(filename)
1150
def kind(self, file_id):
1151
return file_kind(self.id2abspath(file_id))
1153
def stored_kind(self, file_id):
1154
"""See Tree.stored_kind"""
1155
raise NotImplementedError(self.stored_kind)
1157
def _comparison_data(self, entry, path):
1158
abspath = self.abspath(path)
1160
stat_value = os.lstat(abspath)
1162
if getattr(e, 'errno', None) == errno.ENOENT:
1169
mode = stat_value.st_mode
1170
kind = osutils.file_kind_from_stat_mode(mode)
1171
if not supports_executable():
1172
executable = entry is not None and entry.executable
1174
executable = bool(stat.S_ISREG(mode) and stat.S_IEXEC & mode)
1175
return kind, executable, stat_value
1177
def _file_size(self, entry, stat_value):
1178
return stat_value.st_size
1180
def last_revision(self):
1181
"""Return the last revision of the branch for this tree.
1183
This format tree does not support a separate marker for last-revision
1184
compared to the branch.
1186
See MutableTree.last_revision
1188
return self._last_revision()
1191
def _last_revision(self):
1192
"""helper for get_parent_ids."""
1193
return _mod_revision.ensure_null(self.branch.last_revision())
1195
def is_locked(self):
1196
return self._control_files.is_locked()
1198
def _must_be_locked(self):
1199
if not self.is_locked():
1200
raise errors.ObjectNotLocked(self)
1202
def lock_read(self):
1203
"""Lock the tree for reading.
1205
This also locks the branch, and can be unlocked via self.unlock().
1207
:return: A bzrlib.lock.LogicalLockResult.
1209
if not self.is_locked():
1211
self.branch.lock_read()
1213
self._control_files.lock_read()
1214
return LogicalLockResult(self.unlock)
1216
self.branch.unlock()
1219
def lock_tree_write(self):
1220
"""See MutableTree.lock_tree_write, and WorkingTree.unlock.
1222
:return: A bzrlib.lock.LogicalLockResult.
1224
if not self.is_locked():
1226
self.branch.lock_read()
1228
self._control_files.lock_write()
1229
return LogicalLockResult(self.unlock)
1231
self.branch.unlock()
1234
def lock_write(self):
1235
"""See MutableTree.lock_write, and WorkingTree.unlock.
1237
:return: A bzrlib.lock.LogicalLockResult.
1239
if not self.is_locked():
1241
self.branch.lock_write()
1243
self._control_files.lock_write()
1244
return LogicalLockResult(self.unlock)
1246
self.branch.unlock()
1249
def get_physical_lock_status(self):
1250
return self._control_files.get_physical_lock_status()
1252
def _reset_data(self):
1253
"""Reset transient data that cannot be revalidated."""
1254
raise NotImplementedError(self._reset_data)
1256
def set_last_revision(self, new_revision):
1257
"""Change the last revision in the working tree."""
1258
raise NotImplementedError(self.set_last_revision)
1260
def _change_last_revision(self, new_revision):
1261
"""Template method part of set_last_revision to perform the change.
1263
This is used to allow WorkingTree3 instances to not affect branch
1264
when their last revision is set.
1266
if _mod_revision.is_null(new_revision):
1267
self.branch.set_last_revision_info(0, new_revision)
1270
self.branch.generate_revision_history(new_revision)
1271
except errors.NoSuchRevision:
1272
# not present in the repo - dont try to set it deeper than the tip
1273
self.branch._set_revision_history([new_revision])
1276
@needs_tree_write_lock
1277
def remove(self, files, verbose=False, to_file=None, keep_files=True,
1279
"""Remove nominated files from the working tree metadata.
1281
:files: File paths relative to the basedir.
1282
:keep_files: If true, the files will also be kept.
1283
:force: Delete files and directories, even if they are changed and
1284
even if the directories are not empty.
1286
if isinstance(files, basestring):
1291
all_files = set() # specified and nested files
1292
unknown_nested_files=set()
1294
to_file = sys.stdout
1296
files_to_backup = []
1298
def recurse_directory_to_add_files(directory):
1299
# Recurse directory and add all files
1300
# so we can check if they have changed.
1301
for parent_info, file_infos in self.walkdirs(directory):
1302
for relpath, basename, kind, lstat, fileid, kind in file_infos:
1303
# Is it versioned or ignored?
1304
if self.path2id(relpath):
1305
# Add nested content for deletion.
1306
all_files.add(relpath)
1308
# Files which are not versioned
1309
# should be treated as unknown.
1310
files_to_backup.append(relpath)
1312
for filename in files:
1313
# Get file name into canonical form.
1314
abspath = self.abspath(filename)
1315
filename = self.relpath(abspath)
1316
if len(filename) > 0:
1317
all_files.add(filename)
1318
recurse_directory_to_add_files(filename)
1320
files = list(all_files)
1323
return # nothing to do
1325
# Sort needed to first handle directory content before the directory
1326
files.sort(reverse=True)
1328
# Bail out if we are going to delete files we shouldn't
1329
if not keep_files and not force:
1330
for (file_id, path, content_change, versioned, parent_id, name,
1331
kind, executable) in self.iter_changes(self.basis_tree(),
1332
include_unchanged=True, require_versioned=False,
1333
want_unversioned=True, specific_files=files):
1334
if versioned[0] == False:
1335
# The record is unknown or newly added
1336
files_to_backup.append(path[1])
1337
elif (content_change and (kind[1] is not None) and
1338
osutils.is_inside_any(files, path[1])):
1339
# Versioned and changed, but not deleted, and still
1340
# in one of the dirs to be deleted.
1341
files_to_backup.append(path[1])
1343
def backup(file_to_backup):
1344
backup_name = self.bzrdir._available_backup_name(file_to_backup)
1345
osutils.rename(abs_path, self.abspath(backup_name))
1346
return "removed %s (but kept a copy: %s)" % (file_to_backup,
1349
# Build inv_delta and delete files where applicable,
1350
# do this before any modifications to meta data.
1352
fid = self.path2id(f)
1355
message = "%s is not versioned." % (f,)
1358
# having removed it, it must be either ignored or unknown
1359
if self.is_ignored(f):
1363
# XXX: Really should be a more abstract reporter interface
1364
kind_ch = osutils.kind_marker(self.kind(fid))
1365
to_file.write(new_status + ' ' + f + kind_ch + '\n')
1367
inv_delta.append((f, None, fid, None))
1368
message = "removed %s" % (f,)
1371
abs_path = self.abspath(f)
1372
if osutils.lexists(abs_path):
1373
if (osutils.isdir(abs_path) and
1374
len(os.listdir(abs_path)) > 0):
1376
osutils.rmtree(abs_path)
1377
message = "deleted %s" % (f,)
1381
if f in files_to_backup:
1384
osutils.delete_any(abs_path)
1385
message = "deleted %s" % (f,)
1386
elif message is not None:
1387
# Only care if we haven't done anything yet.
1388
message = "%s does not exist." % (f,)
1390
# Print only one message (if any) per file.
1391
if message is not None:
1393
self.apply_inventory_delta(inv_delta)
1395
@needs_tree_write_lock
1396
def revert(self, filenames=None, old_tree=None, backups=True,
1397
pb=None, report_changes=False):
1398
from bzrlib.conflicts import resolve
1401
symbol_versioning.warn('Using [] to revert all files is deprecated'
1402
' as of bzr 0.91. Please use None (the default) instead.',
1403
DeprecationWarning, stacklevel=2)
1404
if old_tree is None:
1405
basis_tree = self.basis_tree()
1406
basis_tree.lock_read()
1407
old_tree = basis_tree
1411
conflicts = transform.revert(self, old_tree, filenames, backups, pb,
1413
if filenames is None and len(self.get_parent_ids()) > 1:
1415
last_revision = self.last_revision()
1416
if last_revision != _mod_revision.NULL_REVISION:
1417
if basis_tree is None:
1418
basis_tree = self.basis_tree()
1419
basis_tree.lock_read()
1420
parent_trees.append((last_revision, basis_tree))
1421
self.set_parent_trees(parent_trees)
1424
resolve(self, filenames, ignore_misses=True, recursive=True)
1426
if basis_tree is not None:
1430
def revision_tree(self, revision_id):
1431
"""See Tree.revision_tree.
1433
WorkingTree can supply revision_trees for the basis revision only
1434
because there is only one cached inventory in the bzr directory.
1436
raise NotImplementedError(self.revision_tree)
1438
@needs_tree_write_lock
1439
def set_root_id(self, file_id):
1440
"""Set the root id for this tree."""
1444
'WorkingTree.set_root_id with fileid=None')
1445
file_id = osutils.safe_file_id(file_id)
1446
self._set_root_id(file_id)
1448
def _set_root_id(self, file_id):
1449
"""Set the root id for this tree, in a format specific manner.
1451
:param file_id: The file id to assign to the root. It must not be
1452
present in the current inventory or an error will occur. It must
1453
not be None, but rather a valid file id.
1455
raise NotImplementedError(self._set_root_id)
1458
"""See Branch.unlock.
1460
WorkingTree locking just uses the Branch locking facilities.
1461
This is current because all working trees have an embedded branch
1462
within them. IF in the future, we were to make branch data shareable
1463
between multiple working trees, i.e. via shared storage, then we
1464
would probably want to lock both the local tree, and the branch.
1466
raise NotImplementedError(self.unlock)
1470
def update(self, change_reporter=None, possible_transports=None,
1471
revision=None, old_tip=_marker, show_base=False):
1472
"""Update a working tree along its branch.
1474
This will update the branch if its bound too, which means we have
1475
multiple trees involved:
1477
- The new basis tree of the master.
1478
- The old basis tree of the branch.
1479
- The old basis tree of the working tree.
1480
- The current working tree state.
1482
Pathologically, all three may be different, and non-ancestors of each
1483
other. Conceptually we want to:
1485
- Preserve the wt.basis->wt.state changes
1486
- Transform the wt.basis to the new master basis.
1487
- Apply a merge of the old branch basis to get any 'local' changes from
1489
- Restore the wt.basis->wt.state changes.
1491
There isn't a single operation at the moment to do that, so we:
1492
- Merge current state -> basis tree of the master w.r.t. the old tree
1494
- Do a 'normal' merge of the old branch basis if it is relevant.
1496
:param revision: The target revision to update to. Must be in the
1498
:param old_tip: If branch.update() has already been run, the value it
1499
returned (old tip of the branch or None). _marker is used
1502
if self.branch.get_bound_location() is not None:
1504
update_branch = (old_tip is self._marker)
1506
self.lock_tree_write()
1507
update_branch = False
1510
old_tip = self.branch.update(possible_transports)
1512
if old_tip is self._marker:
1514
return self._update_tree(old_tip, change_reporter, revision, show_base)
1518
@needs_tree_write_lock
1519
def _update_tree(self, old_tip=None, change_reporter=None, revision=None,
1521
"""Update a tree to the master branch.
1523
:param old_tip: if supplied, the previous tip revision the branch,
1524
before it was changed to the master branch's tip.
1526
# here if old_tip is not None, it is the old tip of the branch before
1527
# it was updated from the master branch. This should become a pending
1528
# merge in the working tree to preserve the user existing work. we
1529
# cant set that until we update the working trees last revision to be
1530
# one from the new branch, because it will just get absorbed by the
1531
# parent de-duplication logic.
1533
# We MUST save it even if an error occurs, because otherwise the users
1534
# local work is unreferenced and will appear to have been lost.
1538
last_rev = self.get_parent_ids()[0]
1540
last_rev = _mod_revision.NULL_REVISION
1541
if revision is None:
1542
revision = self.branch.last_revision()
1544
old_tip = old_tip or _mod_revision.NULL_REVISION
1546
if not _mod_revision.is_null(old_tip) and old_tip != last_rev:
1547
# the branch we are bound to was updated
1548
# merge those changes in first
1549
base_tree = self.basis_tree()
1550
other_tree = self.branch.repository.revision_tree(old_tip)
1551
nb_conflicts = merge.merge_inner(self.branch, other_tree,
1552
base_tree, this_tree=self,
1553
change_reporter=change_reporter,
1554
show_base=show_base)
1556
self.add_parent_tree((old_tip, other_tree))
1557
note('Rerun update after fixing the conflicts.')
1560
if last_rev != _mod_revision.ensure_null(revision):
1561
# the working tree is up to date with the branch
1562
# we can merge the specified revision from master
1563
to_tree = self.branch.repository.revision_tree(revision)
1564
to_root_id = to_tree.get_root_id()
1566
basis = self.basis_tree()
1569
if (basis.get_root_id() is None or basis.get_root_id() != to_root_id):
1570
self.set_root_id(to_root_id)
1575
# determine the branch point
1576
graph = self.branch.repository.get_graph()
1577
base_rev_id = graph.find_unique_lca(self.branch.last_revision(),
1579
base_tree = self.branch.repository.revision_tree(base_rev_id)
1581
nb_conflicts = merge.merge_inner(self.branch, to_tree, base_tree,
1583
change_reporter=change_reporter,
1584
show_base=show_base)
1585
self.set_last_revision(revision)
1586
# TODO - dedup parents list with things merged by pull ?
1587
# reuse the tree we've updated to to set the basis:
1588
parent_trees = [(revision, to_tree)]
1589
merges = self.get_parent_ids()[1:]
1590
# Ideally we ask the tree for the trees here, that way the working
1591
# tree can decide whether to give us the entire tree or give us a
1592
# lazy initialised tree. dirstate for instance will have the trees
1593
# in ram already, whereas a last-revision + basis-inventory tree
1594
# will not, but also does not need them when setting parents.
1595
for parent in merges:
1596
parent_trees.append(
1597
(parent, self.branch.repository.revision_tree(parent)))
1598
if not _mod_revision.is_null(old_tip):
1599
parent_trees.append(
1600
(old_tip, self.branch.repository.revision_tree(old_tip)))
1601
self.set_parent_trees(parent_trees)
1602
last_rev = parent_trees[0][0]
1605
def _write_hashcache_if_dirty(self):
1606
"""Write out the hashcache if it is dirty."""
1607
if self._hashcache.needs_write:
1609
self._hashcache.write()
1611
if e.errno not in (errno.EPERM, errno.EACCES):
1613
# TODO: jam 20061219 Should this be a warning? A single line
1614
# warning might be sufficient to let the user know what
1616
mutter('Could not write hashcache for %s\nError: %s',
1617
self._hashcache.cache_file_name(), e)
1619
def set_conflicts(self, arg):
1620
raise errors.UnsupportedOperation(self.set_conflicts, self)
1622
def add_conflicts(self, arg):
1623
raise errors.UnsupportedOperation(self.add_conflicts, self)
1625
def conflicts(self):
1626
raise NotImplementedError(self.conflicts)
1628
def walkdirs(self, prefix=""):
1629
"""Walk the directories of this tree.
1631
returns a generator which yields items in the form:
1632
((curren_directory_path, fileid),
1633
[(file1_path, file1_name, file1_kind, (lstat), file1_id,
1636
This API returns a generator, which is only valid during the current
1637
tree transaction - within a single lock_read or lock_write duration.
1639
If the tree is not locked, it may cause an error to be raised,
1640
depending on the tree implementation.
1642
disk_top = self.abspath(prefix)
1643
if disk_top.endswith('/'):
1644
disk_top = disk_top[:-1]
1645
top_strip_len = len(disk_top) + 1
1646
inventory_iterator = self._walkdirs(prefix)
1647
disk_iterator = osutils.walkdirs(disk_top, prefix)
1649
current_disk = disk_iterator.next()
1650
disk_finished = False
1652
if not (e.errno == errno.ENOENT or
1653
(sys.platform == 'win32' and e.errno == ERROR_PATH_NOT_FOUND)):
1656
disk_finished = True
1658
current_inv = inventory_iterator.next()
1659
inv_finished = False
1660
except StopIteration:
1663
while not inv_finished or not disk_finished:
1665
((cur_disk_dir_relpath, cur_disk_dir_path_from_top),
1666
cur_disk_dir_content) = current_disk
1668
((cur_disk_dir_relpath, cur_disk_dir_path_from_top),
1669
cur_disk_dir_content) = ((None, None), None)
1670
if not disk_finished:
1671
# strip out .bzr dirs
1672
if (cur_disk_dir_path_from_top[top_strip_len:] == '' and
1673
len(cur_disk_dir_content) > 0):
1674
# osutils.walkdirs can be made nicer -
1675
# yield the path-from-prefix rather than the pathjoined
1677
bzrdir_loc = bisect_left(cur_disk_dir_content,
1679
if (bzrdir_loc < len(cur_disk_dir_content)
1680
and self.bzrdir.is_control_filename(
1681
cur_disk_dir_content[bzrdir_loc][0])):
1682
# we dont yield the contents of, or, .bzr itself.
1683
del cur_disk_dir_content[bzrdir_loc]
1685
# everything is unknown
1688
# everything is missing
1691
direction = cmp(current_inv[0][0], cur_disk_dir_relpath)
1693
# disk is before inventory - unknown
1694
dirblock = [(relpath, basename, kind, stat, None, None) for
1695
relpath, basename, kind, stat, top_path in
1696
cur_disk_dir_content]
1697
yield (cur_disk_dir_relpath, None), dirblock
1699
current_disk = disk_iterator.next()
1700
except StopIteration:
1701
disk_finished = True
1703
# inventory is before disk - missing.
1704
dirblock = [(relpath, basename, 'unknown', None, fileid, kind)
1705
for relpath, basename, dkind, stat, fileid, kind in
1707
yield (current_inv[0][0], current_inv[0][1]), dirblock
1709
current_inv = inventory_iterator.next()
1710
except StopIteration:
1713
# versioned present directory
1714
# merge the inventory and disk data together
1716
for relpath, subiterator in itertools.groupby(sorted(
1717
current_inv[1] + cur_disk_dir_content,
1718
key=operator.itemgetter(0)), operator.itemgetter(1)):
1719
path_elements = list(subiterator)
1720
if len(path_elements) == 2:
1721
inv_row, disk_row = path_elements
1722
# versioned, present file
1723
dirblock.append((inv_row[0],
1724
inv_row[1], disk_row[2],
1725
disk_row[3], inv_row[4],
1727
elif len(path_elements[0]) == 5:
1729
dirblock.append((path_elements[0][0],
1730
path_elements[0][1], path_elements[0][2],
1731
path_elements[0][3], None, None))
1732
elif len(path_elements[0]) == 6:
1733
# versioned, absent file.
1734
dirblock.append((path_elements[0][0],
1735
path_elements[0][1], 'unknown', None,
1736
path_elements[0][4], path_elements[0][5]))
1738
raise NotImplementedError('unreachable code')
1739
yield current_inv[0], dirblock
1741
current_inv = inventory_iterator.next()
1742
except StopIteration:
1745
current_disk = disk_iterator.next()
1746
except StopIteration:
1747
disk_finished = True
1749
def _walkdirs(self, prefix=""):
1750
"""Walk the directories of this tree.
1752
:prefix: is used as the directrory to start with.
1753
returns a generator which yields items in the form:
1754
((curren_directory_path, fileid),
1755
[(file1_path, file1_name, file1_kind, None, file1_id,
1758
raise NotImplementedError(self._walkdirs)
1760
@needs_tree_write_lock
1761
def auto_resolve(self):
1762
"""Automatically resolve text conflicts according to contents.
1764
Only text conflicts are auto_resolvable. Files with no conflict markers
1765
are considered 'resolved', because bzr always puts conflict markers
1766
into files that have text conflicts. The corresponding .THIS .BASE and
1767
.OTHER files are deleted, as per 'resolve'.
1768
:return: a tuple of ConflictLists: (un_resolved, resolved).
1770
un_resolved = _mod_conflicts.ConflictList()
1771
resolved = _mod_conflicts.ConflictList()
1772
conflict_re = re.compile('^(<{7}|={7}|>{7})')
1773
for conflict in self.conflicts():
1774
if (conflict.typestring != 'text conflict' or
1775
self.kind(conflict.file_id) != 'file'):
1776
un_resolved.append(conflict)
1778
my_file = open(self.id2abspath(conflict.file_id), 'rb')
1780
for line in my_file:
1781
if conflict_re.search(line):
1782
un_resolved.append(conflict)
1785
resolved.append(conflict)
1788
resolved.remove_files(self)
1789
self.set_conflicts(un_resolved)
1790
return un_resolved, resolved
1793
def _check(self, references):
1794
"""Check the tree for consistency.
1796
:param references: A dict with keys matching the items returned by
1797
self._get_check_refs(), and values from looking those keys up in
1800
tree_basis = self.basis_tree()
1801
tree_basis.lock_read()
1803
repo_basis = references[('trees', self.last_revision())]
1804
if len(list(repo_basis.iter_changes(tree_basis))) > 0:
1805
raise errors.BzrCheckError(
1806
"Mismatched basis inventory content.")
1811
def _validate(self):
1812
"""Validate internal structures.
1814
This is meant mostly for the test suite. To give it a chance to detect
1815
corruption after actions have occurred. The default implementation is a
1818
:return: None. An exception should be raised if there is an error.
1823
def check_state(self):
1824
"""Check that the working state is/isn't valid."""
1825
check_refs = self._get_check_refs()
1827
for ref in check_refs:
1830
refs[ref] = self.branch.repository.revision_tree(value)
1833
def reset_state(self, revision_ids=None):
1834
"""Reset the state of the working tree.
1836
This does a hard-reset to a last-known-good state. This is a way to
1837
fix if something got corrupted (like the .bzr/checkout/dirstate file)
1839
raise NotImplementedError(self.reset_state)
1841
def _get_rules_searcher(self, default_searcher):
1842
"""See Tree._get_rules_searcher."""
1843
if self._rules_searcher is None:
1844
self._rules_searcher = super(WorkingTree,
1845
self)._get_rules_searcher(default_searcher)
1846
return self._rules_searcher
1848
def get_shelf_manager(self):
1849
"""Return the ShelfManager for this WorkingTree."""
1850
from bzrlib.shelf import ShelfManager
1851
return ShelfManager(self, self._transport)
1854
class InventoryWorkingTree(WorkingTree,
1855
bzrlib.mutabletree.MutableInventoryTree):
1856
"""Base class for working trees that are inventory-oriented.
1858
The inventory is held in the `Branch` working-inventory, and the
1859
files are in a directory on disk.
1861
It is possible for a `WorkingTree` to have a filename which is
1862
not listed in the Inventory and vice versa.
1865
def __init__(self, basedir='.',
1866
branch=DEPRECATED_PARAMETER,
1868
_control_files=None,
1872
"""Construct a InventoryWorkingTree instance. This is not a public API.
1874
:param branch: A branch to override probing for the branch.
1876
super(InventoryWorkingTree, self).__init__(basedir=basedir,
1877
branch=branch, _control_files=_control_files, _internal=_internal,
1878
_format=_format, _bzrdir=_bzrdir)
1880
if _inventory is None:
1881
# This will be acquired on lock_read() or lock_write()
1882
self._inventory_is_modified = False
1883
self._inventory = None
1885
# the caller of __init__ has provided an inventory,
1886
# we assume they know what they are doing - as its only
1887
# the Format factory and creation methods that are
1888
# permitted to do this.
1889
self._set_inventory(_inventory, dirty=False)
1891
def _set_inventory(self, inv, dirty):
1892
"""Set the internal cached inventory.
1894
:param inv: The inventory to set.
1895
:param dirty: A boolean indicating whether the inventory is the same
1896
logical inventory as whats on disk. If True the inventory is not
1897
the same and should be written to disk or data will be lost, if
1898
False then the inventory is the same as that on disk and any
1899
serialisation would be unneeded overhead.
1901
self._inventory = inv
1902
self._inventory_is_modified = dirty
1904
def _serialize(self, inventory, out_file):
1905
xml5.serializer_v5.write_inventory(self._inventory, out_file,
1908
def _deserialize(selt, in_file):
1909
return xml5.serializer_v5.read_inventory(in_file)
1911
@needs_tree_write_lock
1912
def _write_inventory(self, inv):
1913
"""Write inventory as the current inventory."""
1914
self._set_inventory(inv, dirty=True)
1917
# XXX: This method should be deprecated in favour of taking in a proper
1918
# new Inventory object.
1919
@needs_tree_write_lock
1920
def set_inventory(self, new_inventory_list):
1921
from bzrlib.inventory import (Inventory,
1925
inv = Inventory(self.get_root_id())
1926
for path, file_id, parent, kind in new_inventory_list:
1927
name = os.path.basename(path)
1930
# fixme, there should be a factory function inv,add_??
1931
if kind == 'directory':
1932
inv.add(InventoryDirectory(file_id, name, parent))
1933
elif kind == 'file':
1934
inv.add(InventoryFile(file_id, name, parent))
1935
elif kind == 'symlink':
1936
inv.add(InventoryLink(file_id, name, parent))
1938
raise errors.BzrError("unknown kind %r" % kind)
1939
self._write_inventory(inv)
1941
def _write_basis_inventory(self, xml):
1942
"""Write the basis inventory XML to the basis-inventory file"""
1943
path = self._basis_inventory_name()
1945
self._transport.put_file(path, sio,
1946
mode=self.bzrdir._get_file_mode())
1948
def _reset_data(self):
1949
"""Reset transient data that cannot be revalidated."""
1950
self._inventory_is_modified = False
1951
f = self._transport.get('inventory')
1953
result = self._deserialize(f)
1956
self._set_inventory(result, dirty=False)
1958
def _set_root_id(self, file_id):
1959
"""Set the root id for this tree, in a format specific manner.
1961
:param file_id: The file id to assign to the root. It must not be
1962
present in the current inventory or an error will occur. It must
1963
not be None, but rather a valid file id.
1965
inv = self._inventory
1966
orig_root_id = inv.root.file_id
1967
# TODO: it might be nice to exit early if there was nothing
1968
# to do, saving us from trigger a sync on unlock.
1969
self._inventory_is_modified = True
1970
# we preserve the root inventory entry object, but
1971
# unlinkit from the byid index
1972
del inv._byid[inv.root.file_id]
1973
inv.root.file_id = file_id
1974
# and link it into the index with the new changed id.
1975
inv._byid[inv.root.file_id] = inv.root
1976
# and finally update all children to reference the new id.
1977
# XXX: this should be safe to just look at the root.children
1978
# list, not the WHOLE INVENTORY.
1981
if entry.parent_id == orig_root_id:
1982
entry.parent_id = inv.root.file_id
1984
def all_file_ids(self):
1985
"""See Tree.iter_all_file_ids"""
1986
return set(self.inventory)
1988
def _cache_basis_inventory(self, new_revision):
1989
"""Cache new_revision as the basis inventory."""
1990
# TODO: this should allow the ready-to-use inventory to be passed in,
1991
# as commit already has that ready-to-use [while the format is the
1994
# this double handles the inventory - unpack and repack -
1995
# but is easier to understand. We can/should put a conditional
1996
# in here based on whether the inventory is in the latest format
1997
# - perhaps we should repack all inventories on a repository
1999
# the fast path is to copy the raw xml from the repository. If the
2000
# xml contains 'revision_id="', then we assume the right
2001
# revision_id is set. We must check for this full string, because a
2002
# root node id can legitimately look like 'revision_id' but cannot
2004
xml = self.branch.repository._get_inventory_xml(new_revision)
2005
firstline = xml.split('\n', 1)[0]
2006
if (not 'revision_id="' in firstline or
2007
'format="7"' not in firstline):
2008
inv = self.branch.repository._serializer.read_inventory_from_string(
2010
xml = self._create_basis_xml_from_inventory(new_revision, inv)
2011
self._write_basis_inventory(xml)
2012
except (errors.NoSuchRevision, errors.RevisionNotPresent):
2015
def _basis_inventory_name(self):
2016
return 'basis-inventory-cache'
2018
def _create_basis_xml_from_inventory(self, revision_id, inventory):
2019
"""Create the text that will be saved in basis-inventory"""
2020
inventory.revision_id = revision_id
2021
return xml7.serializer_v7.write_inventory_to_string(inventory)
2023
def read_basis_inventory(self):
2024
"""Read the cached basis inventory."""
2025
path = self._basis_inventory_name()
2026
return self._transport.get_bytes(path)
2029
def read_working_inventory(self):
2030
"""Read the working inventory.
2032
:raises errors.InventoryModified: read_working_inventory will fail
2033
when the current in memory inventory has been modified.
2035
# conceptually this should be an implementation detail of the tree.
2036
# XXX: Deprecate this.
2037
# ElementTree does its own conversion from UTF-8, so open in
2039
if self._inventory_is_modified:
2040
raise errors.InventoryModified(self)
2041
f = self._transport.get('inventory')
2043
result = self._deserialize(f)
2046
self._set_inventory(result, dirty=False)
2050
def get_root_id(self):
2051
"""Return the id of this trees root"""
2052
return self._inventory.root.file_id
2054
def has_id(self, file_id):
2055
# files that have been deleted are excluded
2056
inv = self.inventory
2057
if not inv.has_id(file_id):
2059
path = inv.id2path(file_id)
2060
return osutils.lexists(self.abspath(path))
2062
def has_or_had_id(self, file_id):
2063
if file_id == self.inventory.root.file_id:
2065
return self.inventory.has_id(file_id)
2067
__contains__ = has_id
2069
# should be deprecated - this is slow and in any case treating them as a
2070
# container is (we now know) bad style -- mbp 20070302
2071
## @deprecated_method(zero_fifteen)
2073
"""Iterate through file_ids for this tree.
2075
file_ids are in a WorkingTree if they are in the working inventory
2076
and the working file exists.
2078
inv = self._inventory
2079
for path, ie in inv.iter_entries():
2080
if osutils.lexists(self.abspath(path)):
2083
@needs_tree_write_lock
2084
def set_last_revision(self, new_revision):
2085
"""Change the last revision in the working tree."""
2086
if self._change_last_revision(new_revision):
2087
self._cache_basis_inventory(new_revision)
2089
@needs_tree_write_lock
2090
def reset_state(self, revision_ids=None):
2091
"""Reset the state of the working tree.
2093
This does a hard-reset to a last-known-good state. This is a way to
2094
fix if something got corrupted (like the .bzr/checkout/dirstate file)
2096
if revision_ids is None:
2097
revision_ids = self.get_parent_ids()
2098
if not revision_ids:
2099
rt = self.branch.repository.revision_tree(
2100
_mod_revision.NULL_REVISION)
2102
rt = self.branch.repository.revision_tree(revision_ids[0])
2103
self._write_inventory(rt.inventory)
2104
self.set_parent_ids(revision_ids)
2107
"""Write the in memory inventory to disk."""
2108
# TODO: Maybe this should only write on dirty ?
2109
if self._control_files._lock_mode != 'w':
2110
raise errors.NotWriteLocked(self)
2112
self._serialize(self._inventory, sio)
2114
self._transport.put_file('inventory', sio,
2115
mode=self.bzrdir._get_file_mode())
2116
self._inventory_is_modified = False
2119
def get_file_sha1(self, file_id, path=None, stat_value=None):
2121
path = self._inventory.id2path(file_id)
2122
return self._hashcache.get_sha1(path, stat_value)
2124
def get_file_mtime(self, file_id, path=None):
2125
"""See Tree.get_file_mtime."""
2127
path = self.inventory.id2path(file_id)
2128
return os.lstat(self.abspath(path)).st_mtime
2130
def _is_executable_from_path_and_stat_from_basis(self, path, stat_result):
2131
file_id = self.path2id(path)
2133
# For unversioned files on win32, we just assume they are not
2136
return self._inventory[file_id].executable
2138
def _is_executable_from_path_and_stat_from_stat(self, path, stat_result):
2139
mode = stat_result.st_mode
2140
return bool(stat.S_ISREG(mode) and stat.S_IEXEC & mode)
2142
if not supports_executable():
2143
def is_executable(self, file_id, path=None):
2144
return self._inventory[file_id].executable
2146
_is_executable_from_path_and_stat = \
2147
_is_executable_from_path_and_stat_from_basis
2149
def is_executable(self, file_id, path=None):
2151
path = self.id2path(file_id)
2152
mode = os.lstat(self.abspath(path)).st_mode
2153
return bool(stat.S_ISREG(mode) and stat.S_IEXEC & mode)
2155
_is_executable_from_path_and_stat = \
2156
_is_executable_from_path_and_stat_from_stat
2158
@needs_tree_write_lock
2159
def _add(self, files, ids, kinds):
2160
"""See MutableTree._add."""
2161
# TODO: Re-adding a file that is removed in the working copy
2162
# should probably put it back with the previous ID.
2163
# the read and write working inventory should not occur in this
2164
# function - they should be part of lock_write and unlock.
2165
inv = self.inventory
2166
for f, file_id, kind in zip(files, ids, kinds):
2168
inv.add_path(f, kind=kind)
2170
inv.add_path(f, kind=kind, file_id=file_id)
2171
self._inventory_is_modified = True
2173
def revision_tree(self, revision_id):
2174
"""See WorkingTree.revision_id."""
2175
if revision_id == self.last_revision():
2177
xml = self.read_basis_inventory()
2178
except errors.NoSuchFile:
2182
inv = xml7.serializer_v7.read_inventory_from_string(xml)
2183
# dont use the repository revision_tree api because we want
2184
# to supply the inventory.
2185
if inv.revision_id == revision_id:
2186
return revisiontree.InventoryRevisionTree(
2187
self.branch.repository, inv, revision_id)
2188
except errors.BadInventoryFormat:
2190
# raise if there was no inventory, or if we read the wrong inventory.
2191
raise errors.NoSuchRevisionInTree(self, revision_id)
2194
def annotate_iter(self, file_id, default_revision=CURRENT_REVISION):
2195
"""See Tree.annotate_iter
2197
This implementation will use the basis tree implementation if possible.
2198
Lines not in the basis are attributed to CURRENT_REVISION
2200
If there are pending merges, lines added by those merges will be
2201
incorrectly attributed to CURRENT_REVISION (but after committing, the
2202
attribution will be correct).
2204
maybe_file_parent_keys = []
2205
for parent_id in self.get_parent_ids():
2207
parent_tree = self.revision_tree(parent_id)
2208
except errors.NoSuchRevisionInTree:
2209
parent_tree = self.branch.repository.revision_tree(parent_id)
2210
parent_tree.lock_read()
2212
if file_id not in parent_tree:
2214
ie = parent_tree.inventory[file_id]
2215
if ie.kind != 'file':
2216
# Note: this is slightly unnecessary, because symlinks and
2217
# directories have a "text" which is the empty text, and we
2218
# know that won't mess up annotations. But it seems cleaner
2220
parent_text_key = (file_id, ie.revision)
2221
if parent_text_key not in maybe_file_parent_keys:
2222
maybe_file_parent_keys.append(parent_text_key)
2224
parent_tree.unlock()
2225
graph = _mod_graph.Graph(self.branch.repository.texts)
2226
heads = graph.heads(maybe_file_parent_keys)
2227
file_parent_keys = []
2228
for key in maybe_file_parent_keys:
2230
file_parent_keys.append(key)
2232
# Now we have the parents of this content
2233
annotator = self.branch.repository.texts.get_annotator()
2234
text = self.get_file_text(file_id)
2235
this_key =(file_id, default_revision)
2236
annotator.add_special_text(this_key, file_parent_keys, text)
2237
annotations = [(key[-1], line)
2238
for key, line in annotator.annotate_flat(this_key)]
2242
def merge_modified(self):
2243
"""Return a dictionary of files modified by a merge.
2245
The list is initialized by WorkingTree.set_merge_modified, which is
2246
typically called after we make some automatic updates to the tree
2249
This returns a map of file_id->sha1, containing only files which are
2250
still in the working inventory and have that text hash.
2253
hashfile = self._transport.get('merge-hashes')
2254
except errors.NoSuchFile:
2259
if hashfile.next() != MERGE_MODIFIED_HEADER_1 + '\n':
2260
raise errors.MergeModifiedFormatError()
2261
except StopIteration:
2262
raise errors.MergeModifiedFormatError()
2263
for s in _mod_rio.RioReader(hashfile):
2264
# RioReader reads in Unicode, so convert file_ids back to utf8
2265
file_id = osutils.safe_file_id(s.get("file_id"), warn=False)
2266
if file_id not in self.inventory:
2268
text_hash = s.get("hash")
2269
if text_hash == self.get_file_sha1(file_id):
2270
merge_hashes[file_id] = text_hash
2276
def subsume(self, other_tree):
2277
def add_children(inventory, entry):
2278
for child_entry in entry.children.values():
2279
inventory._byid[child_entry.file_id] = child_entry
2280
if child_entry.kind == 'directory':
2281
add_children(inventory, child_entry)
2282
if other_tree.get_root_id() == self.get_root_id():
2283
raise errors.BadSubsumeSource(self, other_tree,
2284
'Trees have the same root')
2286
other_tree_path = self.relpath(other_tree.basedir)
2287
except errors.PathNotChild:
2288
raise errors.BadSubsumeSource(self, other_tree,
2289
'Tree is not contained by the other')
2290
new_root_parent = self.path2id(osutils.dirname(other_tree_path))
2291
if new_root_parent is None:
2292
raise errors.BadSubsumeSource(self, other_tree,
2293
'Parent directory is not versioned.')
2294
# We need to ensure that the result of a fetch will have a
2295
# versionedfile for the other_tree root, and only fetching into
2296
# RepositoryKnit2 guarantees that.
2297
if not self.branch.repository.supports_rich_root():
2298
raise errors.SubsumeTargetNeedsUpgrade(other_tree)
2299
other_tree.lock_tree_write()
2301
new_parents = other_tree.get_parent_ids()
2302
other_root = other_tree.inventory.root
2303
other_root.parent_id = new_root_parent
2304
other_root.name = osutils.basename(other_tree_path)
2305
self.inventory.add(other_root)
2306
add_children(self.inventory, other_root)
2307
self._write_inventory(self.inventory)
2308
# normally we don't want to fetch whole repositories, but i think
2309
# here we really do want to consolidate the whole thing.
2310
for parent_id in other_tree.get_parent_ids():
2311
self.branch.fetch(other_tree.branch, parent_id)
2312
self.add_parent_tree_id(parent_id)
2315
other_tree.bzrdir.retire_bzrdir()
2317
@needs_tree_write_lock
2318
def extract(self, file_id, format=None):
2319
"""Extract a subtree from this tree.
2321
A new branch will be created, relative to the path for this tree.
2325
segments = osutils.splitpath(path)
2326
transport = self.branch.bzrdir.root_transport
2327
for name in segments:
2328
transport = transport.clone(name)
2329
transport.ensure_base()
2332
sub_path = self.id2path(file_id)
2333
branch_transport = mkdirs(sub_path)
2335
format = self.bzrdir.cloning_metadir()
2336
branch_transport.ensure_base()
2337
branch_bzrdir = format.initialize_on_transport(branch_transport)
2339
repo = branch_bzrdir.find_repository()
2340
except errors.NoRepositoryPresent:
2341
repo = branch_bzrdir.create_repository()
2342
if not repo.supports_rich_root():
2343
raise errors.RootNotRich()
2344
new_branch = branch_bzrdir.create_branch()
2345
new_branch.pull(self.branch)
2346
for parent_id in self.get_parent_ids():
2347
new_branch.fetch(self.branch, parent_id)
2348
tree_transport = self.bzrdir.root_transport.clone(sub_path)
2349
if tree_transport.base != branch_transport.base:
2350
tree_bzrdir = format.initialize_on_transport(tree_transport)
2351
branch.BranchReferenceFormat().initialize(tree_bzrdir,
2352
target_branch=new_branch)
2354
tree_bzrdir = branch_bzrdir
2355
wt = tree_bzrdir.create_workingtree(_mod_revision.NULL_REVISION)
2356
wt.set_parent_ids(self.get_parent_ids())
2357
my_inv = self.inventory
2358
child_inv = inventory.Inventory(root_id=None)
2359
new_root = my_inv[file_id]
2360
my_inv.remove_recursive_id(file_id)
2361
new_root.parent_id = None
2362
child_inv.add(new_root)
2363
self._write_inventory(my_inv)
2364
wt._write_inventory(child_inv)
2367
def list_files(self, include_root=False, from_dir=None, recursive=True):
2368
"""List all files as (path, class, kind, id, entry).
2370
Lists, but does not descend into unversioned directories.
2371
This does not include files that have been deleted in this
2372
tree. Skips the control directory.
2374
:param include_root: if True, return an entry for the root
2375
:param from_dir: start from this directory or None for the root
2376
:param recursive: whether to recurse into subdirectories or not
2378
# list_files is an iterator, so @needs_read_lock doesn't work properly
2379
# with it. So callers should be careful to always read_lock the tree.
2380
if not self.is_locked():
2381
raise errors.ObjectNotLocked(self)
2383
inv = self.inventory
2384
if from_dir is None and include_root is True:
2385
yield ('', 'V', 'directory', inv.root.file_id, inv.root)
2386
# Convert these into local objects to save lookup times
2387
pathjoin = osutils.pathjoin
2388
file_kind = self._kind
2390
# transport.base ends in a slash, we want the piece
2391
# between the last two slashes
2392
transport_base_dir = self.bzrdir.transport.base.rsplit('/', 2)[1]
2394
fk_entries = {'directory':TreeDirectory, 'file':TreeFile, 'symlink':TreeLink}
2396
# directory file_id, relative path, absolute path, reverse sorted children
2397
if from_dir is not None:
2398
from_dir_id = inv.path2id(from_dir)
2399
if from_dir_id is None:
2400
# Directory not versioned
2402
from_dir_abspath = pathjoin(self.basedir, from_dir)
2404
from_dir_id = inv.root.file_id
2405
from_dir_abspath = self.basedir
2406
children = os.listdir(from_dir_abspath)
2408
# jam 20060527 The kernel sized tree seems equivalent whether we
2409
# use a deque and popleft to keep them sorted, or if we use a plain
2410
# list and just reverse() them.
2411
children = collections.deque(children)
2412
stack = [(from_dir_id, u'', from_dir_abspath, children)]
2414
from_dir_id, from_dir_relpath, from_dir_abspath, children = stack[-1]
2417
f = children.popleft()
2418
## TODO: If we find a subdirectory with its own .bzr
2419
## directory, then that is a separate tree and we
2420
## should exclude it.
2422
# the bzrdir for this tree
2423
if transport_base_dir == f:
2426
# we know that from_dir_relpath and from_dir_abspath never end in a slash
2427
# and 'f' doesn't begin with one, we can do a string op, rather
2428
# than the checks of pathjoin(), all relative paths will have an extra slash
2430
fp = from_dir_relpath + '/' + f
2433
fap = from_dir_abspath + '/' + f
2435
dir_ie = inv[from_dir_id]
2436
if dir_ie.kind == 'directory':
2437
f_ie = dir_ie.children.get(f)
2442
elif self.is_ignored(fp[1:]):
2445
# we may not have found this file, because of a unicode
2446
# issue, or because the directory was actually a symlink.
2447
f_norm, can_access = osutils.normalized_filename(f)
2448
if f == f_norm or not can_access:
2449
# No change, so treat this file normally
2452
# this file can be accessed by a normalized path
2453
# check again if it is versioned
2454
# these lines are repeated here for performance
2456
fp = from_dir_relpath + '/' + f
2457
fap = from_dir_abspath + '/' + f
2458
f_ie = inv.get_child(from_dir_id, f)
2461
elif self.is_ignored(fp[1:]):
2468
# make a last minute entry
2470
yield fp[1:], c, fk, f_ie.file_id, f_ie
2473
yield fp[1:], c, fk, None, fk_entries[fk]()
2475
yield fp[1:], c, fk, None, TreeEntry()
2478
if fk != 'directory':
2481
# But do this child first if recursing down
2483
new_children = os.listdir(fap)
2485
new_children = collections.deque(new_children)
2486
stack.append((f_ie.file_id, fp, fap, new_children))
2487
# Break out of inner loop,
2488
# so that we start outer loop with child
2491
# if we finished all children, pop it off the stack
2494
@needs_tree_write_lock
2495
def move(self, from_paths, to_dir=None, after=False):
2498
to_dir must exist in the inventory.
2500
If to_dir exists and is a directory, the files are moved into
2501
it, keeping their old names.
2503
Note that to_dir is only the last component of the new name;
2504
this doesn't change the directory.
2506
For each entry in from_paths the move mode will be determined
2509
The first mode moves the file in the filesystem and updates the
2510
inventory. The second mode only updates the inventory without
2511
touching the file on the filesystem.
2513
move uses the second mode if 'after == True' and the target is not
2514
versioned but present in the working tree.
2516
move uses the second mode if 'after == False' and the source is
2517
versioned but no longer in the working tree, and the target is not
2518
versioned but present in the working tree.
2520
move uses the first mode if 'after == False' and the source is
2521
versioned and present in the working tree, and the target is not
2522
versioned and not present in the working tree.
2524
Everything else results in an error.
2526
This returns a list of (from_path, to_path) pairs for each
2527
entry that is moved.
2532
# check for deprecated use of signature
2534
raise TypeError('You must supply a target directory')
2535
# check destination directory
2536
if isinstance(from_paths, basestring):
2538
inv = self.inventory
2539
to_abs = self.abspath(to_dir)
2540
if not isdir(to_abs):
2541
raise errors.BzrMoveFailedError('',to_dir,
2542
errors.NotADirectory(to_abs))
2543
if not self.has_filename(to_dir):
2544
raise errors.BzrMoveFailedError('',to_dir,
2545
errors.NotInWorkingDirectory(to_dir))
2546
to_dir_id = inv.path2id(to_dir)
2547
if to_dir_id is None:
2548
raise errors.BzrMoveFailedError('',to_dir,
2549
errors.NotVersionedError(path=to_dir))
2551
to_dir_ie = inv[to_dir_id]
2552
if to_dir_ie.kind != 'directory':
2553
raise errors.BzrMoveFailedError('',to_dir,
2554
errors.NotADirectory(to_abs))
2556
# create rename entries and tuples
2557
for from_rel in from_paths:
2558
from_tail = splitpath(from_rel)[-1]
2559
from_id = inv.path2id(from_rel)
2561
raise errors.BzrMoveFailedError(from_rel,to_dir,
2562
errors.NotVersionedError(path=from_rel))
2564
from_entry = inv[from_id]
2565
from_parent_id = from_entry.parent_id
2566
to_rel = pathjoin(to_dir, from_tail)
2567
rename_entry = InventoryWorkingTree._RenameEntry(
2570
from_tail=from_tail,
2571
from_parent_id=from_parent_id,
2572
to_rel=to_rel, to_tail=from_tail,
2573
to_parent_id=to_dir_id)
2574
rename_entries.append(rename_entry)
2575
rename_tuples.append((from_rel, to_rel))
2577
# determine which move mode to use. checks also for movability
2578
rename_entries = self._determine_mv_mode(rename_entries, after)
2580
original_modified = self._inventory_is_modified
2583
self._inventory_is_modified = True
2584
self._move(rename_entries)
2586
# restore the inventory on error
2587
self._inventory_is_modified = original_modified
2589
self._write_inventory(inv)
2590
return rename_tuples
2592
@needs_tree_write_lock
2593
def rename_one(self, from_rel, to_rel, after=False):
2596
This can change the directory or the filename or both.
2598
rename_one has several 'modes' to work. First, it can rename a physical
2599
file and change the file_id. That is the normal mode. Second, it can
2600
only change the file_id without touching any physical file.
2602
rename_one uses the second mode if 'after == True' and 'to_rel' is not
2603
versioned but present in the working tree.
2605
rename_one uses the second mode if 'after == False' and 'from_rel' is
2606
versioned but no longer in the working tree, and 'to_rel' is not
2607
versioned but present in the working tree.
2609
rename_one uses the first mode if 'after == False' and 'from_rel' is
2610
versioned and present in the working tree, and 'to_rel' is not
2611
versioned and not present in the working tree.
2613
Everything else results in an error.
2615
inv = self.inventory
2618
# create rename entries and tuples
2619
from_tail = splitpath(from_rel)[-1]
2620
from_id = inv.path2id(from_rel)
2622
# if file is missing in the inventory maybe it's in the basis_tree
2623
basis_tree = self.branch.basis_tree()
2624
from_id = basis_tree.path2id(from_rel)
2626
raise errors.BzrRenameFailedError(from_rel,to_rel,
2627
errors.NotVersionedError(path=from_rel))
2628
# put entry back in the inventory so we can rename it
2629
from_entry = basis_tree.inventory[from_id].copy()
2632
from_entry = inv[from_id]
2633
from_parent_id = from_entry.parent_id
2634
to_dir, to_tail = os.path.split(to_rel)
2635
to_dir_id = inv.path2id(to_dir)
2636
rename_entry = InventoryWorkingTree._RenameEntry(from_rel=from_rel,
2638
from_tail=from_tail,
2639
from_parent_id=from_parent_id,
2640
to_rel=to_rel, to_tail=to_tail,
2641
to_parent_id=to_dir_id)
2642
rename_entries.append(rename_entry)
2644
# determine which move mode to use. checks also for movability
2645
rename_entries = self._determine_mv_mode(rename_entries, after)
2647
# check if the target changed directory and if the target directory is
2649
if to_dir_id is None:
2650
raise errors.BzrMoveFailedError(from_rel,to_rel,
2651
errors.NotVersionedError(path=to_dir))
2653
# all checks done. now we can continue with our actual work
2654
mutter('rename_one:\n'
2659
' to_dir_id {%s}\n',
2660
from_id, from_rel, to_rel, to_dir, to_dir_id)
2662
self._move(rename_entries)
2663
self._write_inventory(inv)
2665
class _RenameEntry(object):
2666
def __init__(self, from_rel, from_id, from_tail, from_parent_id,
2667
to_rel, to_tail, to_parent_id, only_change_inv=False):
2668
self.from_rel = from_rel
2669
self.from_id = from_id
2670
self.from_tail = from_tail
2671
self.from_parent_id = from_parent_id
2672
self.to_rel = to_rel
2673
self.to_tail = to_tail
2674
self.to_parent_id = to_parent_id
2675
self.only_change_inv = only_change_inv
2677
def _determine_mv_mode(self, rename_entries, after=False):
2678
"""Determines for each from-to pair if both inventory and working tree
2679
or only the inventory has to be changed.
2681
Also does basic plausability tests.
2683
inv = self.inventory
2685
for rename_entry in rename_entries:
2686
# store to local variables for easier reference
2687
from_rel = rename_entry.from_rel
2688
from_id = rename_entry.from_id
2689
to_rel = rename_entry.to_rel
2690
to_id = inv.path2id(to_rel)
2691
only_change_inv = False
2693
# check the inventory for source and destination
2695
raise errors.BzrMoveFailedError(from_rel,to_rel,
2696
errors.NotVersionedError(path=from_rel))
2697
if to_id is not None:
2698
raise errors.BzrMoveFailedError(from_rel,to_rel,
2699
errors.AlreadyVersionedError(path=to_rel))
2701
# try to determine the mode for rename (only change inv or change
2702
# inv and file system)
2704
if not self.has_filename(to_rel):
2705
raise errors.BzrMoveFailedError(from_id,to_rel,
2706
errors.NoSuchFile(path=to_rel,
2707
extra="New file has not been created yet"))
2708
only_change_inv = True
2709
elif not self.has_filename(from_rel) and self.has_filename(to_rel):
2710
only_change_inv = True
2711
elif self.has_filename(from_rel) and not self.has_filename(to_rel):
2712
only_change_inv = False
2713
elif (not self.case_sensitive
2714
and from_rel.lower() == to_rel.lower()
2715
and self.has_filename(from_rel)):
2716
only_change_inv = False
2718
# something is wrong, so lets determine what exactly
2719
if not self.has_filename(from_rel) and \
2720
not self.has_filename(to_rel):
2721
raise errors.BzrRenameFailedError(from_rel,to_rel,
2722
errors.PathsDoNotExist(paths=(str(from_rel),
2725
raise errors.RenameFailedFilesExist(from_rel, to_rel)
2726
rename_entry.only_change_inv = only_change_inv
2727
return rename_entries
2729
def _move(self, rename_entries):
2730
"""Moves a list of files.
2732
Depending on the value of the flag 'only_change_inv', the
2733
file will be moved on the file system or not.
2735
inv = self.inventory
2738
for entry in rename_entries:
2740
self._move_entry(entry)
2742
self._rollback_move(moved)
2746
def _rollback_move(self, moved):
2747
"""Try to rollback a previous move in case of an filesystem error."""
2748
inv = self.inventory
2751
self._move_entry(WorkingTree._RenameEntry(
2752
entry.to_rel, entry.from_id,
2753
entry.to_tail, entry.to_parent_id, entry.from_rel,
2754
entry.from_tail, entry.from_parent_id,
2755
entry.only_change_inv))
2756
except errors.BzrMoveFailedError, e:
2757
raise errors.BzrMoveFailedError( '', '', "Rollback failed."
2758
" The working tree is in an inconsistent state."
2759
" Please consider doing a 'bzr revert'."
2760
" Error message is: %s" % e)
2762
def _move_entry(self, entry):
2763
inv = self.inventory
2764
from_rel_abs = self.abspath(entry.from_rel)
2765
to_rel_abs = self.abspath(entry.to_rel)
2766
if from_rel_abs == to_rel_abs:
2767
raise errors.BzrMoveFailedError(entry.from_rel, entry.to_rel,
2768
"Source and target are identical.")
2770
if not entry.only_change_inv:
2772
osutils.rename(from_rel_abs, to_rel_abs)
2774
raise errors.BzrMoveFailedError(entry.from_rel,
2776
inv.rename(entry.from_id, entry.to_parent_id, entry.to_tail)
2778
@needs_tree_write_lock
2779
def unversion(self, file_ids):
2780
"""Remove the file ids in file_ids from the current versioned set.
2782
When a file_id is unversioned, all of its children are automatically
2785
:param file_ids: The file ids to stop versioning.
2786
:raises: NoSuchId if any fileid is not currently versioned.
2788
for file_id in file_ids:
2789
if file_id not in self._inventory:
2790
raise errors.NoSuchId(self, file_id)
2791
for file_id in file_ids:
2792
if self._inventory.has_id(file_id):
2793
self._inventory.remove_recursive_id(file_id)
2795
# in the future this should just set a dirty bit to wait for the
2796
# final unlock. However, until all methods of workingtree start
2797
# with the current in -memory inventory rather than triggering
2798
# a read, it is more complex - we need to teach read_inventory
2799
# to know when to read, and when to not read first... and possibly
2800
# to save first when the in memory one may be corrupted.
2801
# so for now, we just only write it if it is indeed dirty.
2803
self._write_inventory(self._inventory)
2805
def stored_kind(self, file_id):
2806
"""See Tree.stored_kind"""
2807
return self.inventory[file_id].kind
2810
"""Yield all unversioned files in this WorkingTree.
2812
If there are any unversioned directories then only the directory is
2813
returned, not all its children. But if there are unversioned files
2814
under a versioned subdirectory, they are returned.
2816
Currently returned depth-first, sorted by name within directories.
2817
This is the same order used by 'osutils.walkdirs'.
2819
## TODO: Work from given directory downwards
2820
for path, dir_entry in self.inventory.directories():
2821
# mutter("search for unknowns in %r", path)
2822
dirabs = self.abspath(path)
2823
if not isdir(dirabs):
2824
# e.g. directory deleted
2828
for subf in os.listdir(dirabs):
2829
if self.bzrdir.is_control_filename(subf):
2831
if subf not in dir_entry.children:
2834
can_access) = osutils.normalized_filename(subf)
2835
except UnicodeDecodeError:
2836
path_os_enc = path.encode(osutils._fs_enc)
2837
relpath = path_os_enc + '/' + subf
2838
raise errors.BadFilenameEncoding(relpath,
2840
if subf_norm != subf and can_access:
2841
if subf_norm not in dir_entry.children:
2842
fl.append(subf_norm)
2848
subp = pathjoin(path, subf)
2851
def _walkdirs(self, prefix=""):
2852
"""Walk the directories of this tree.
2854
:prefix: is used as the directrory to start with.
2855
returns a generator which yields items in the form:
2856
((curren_directory_path, fileid),
2857
[(file1_path, file1_name, file1_kind, None, file1_id,
2860
_directory = 'directory'
2861
# get the root in the inventory
2862
inv = self.inventory
2863
top_id = inv.path2id(prefix)
2867
pending = [(prefix, '', _directory, None, top_id, None)]
2870
currentdir = pending.pop()
2871
# 0 - relpath, 1- basename, 2- kind, 3- stat, 4-id, 5-kind
2872
top_id = currentdir[4]
2874
relroot = currentdir[0] + '/'
2877
# FIXME: stash the node in pending
2879
if entry.kind == 'directory':
2880
for name, child in entry.sorted_children():
2881
dirblock.append((relroot + name, name, child.kind, None,
2882
child.file_id, child.kind
2884
yield (currentdir[0], entry.file_id), dirblock
2885
# push the user specified dirs from dirblock
2886
for dir in reversed(dirblock):
2887
if dir[2] == _directory:
2891
class WorkingTree3(InventoryWorkingTree):
2892
"""This is the Format 3 working tree.
2894
This differs from the base WorkingTree by:
2895
- having its own file lock
2896
- having its own last-revision property.
2898
This is new in bzr 0.8
2902
def _last_revision(self):
2903
"""See Mutable.last_revision."""
2905
return self._transport.get_bytes('last-revision')
2906
except errors.NoSuchFile:
2907
return _mod_revision.NULL_REVISION
2909
def _change_last_revision(self, revision_id):
2910
"""See WorkingTree._change_last_revision."""
2911
if revision_id is None or revision_id == _mod_revision.NULL_REVISION:
2913
self._transport.delete('last-revision')
2914
except errors.NoSuchFile:
2918
self._transport.put_bytes('last-revision', revision_id,
2919
mode=self.bzrdir._get_file_mode())
2922
def _get_check_refs(self):
2923
"""Return the references needed to perform a check of this tree."""
2924
return [('trees', self.last_revision())]
2926
@needs_tree_write_lock
2927
def set_conflicts(self, conflicts):
2928
self._put_rio('conflicts', conflicts.to_stanzas(),
2931
@needs_tree_write_lock
2932
def add_conflicts(self, new_conflicts):
2933
conflict_set = set(self.conflicts())
2934
conflict_set.update(set(list(new_conflicts)))
2935
self.set_conflicts(_mod_conflicts.ConflictList(sorted(conflict_set,
2936
key=_mod_conflicts.Conflict.sort_key)))
2939
def conflicts(self):
2941
confile = self._transport.get('conflicts')
2942
except errors.NoSuchFile:
2943
return _mod_conflicts.ConflictList()
2946
if confile.next() != CONFLICT_HEADER_1 + '\n':
2947
raise errors.ConflictFormatError()
2948
except StopIteration:
2949
raise errors.ConflictFormatError()
2950
reader = _mod_rio.RioReader(confile)
2951
return _mod_conflicts.ConflictList.from_stanzas(reader)
2956
# do non-implementation specific cleanup
2958
if self._control_files._lock_count == 1:
2959
# _inventory_is_modified is always False during a read lock.
2960
if self._inventory_is_modified:
2962
self._write_hashcache_if_dirty()
2963
# reverse order of locking.
2965
return self._control_files.unlock()
2967
self.branch.unlock()
2970
class WorkingTreeFormatRegistry(controldir.ControlComponentFormatRegistry):
2971
"""Registry for working tree formats."""
2973
def __init__(self, other_registry=None):
2974
super(WorkingTreeFormatRegistry, self).__init__(other_registry)
2975
self._default_format = None
2977
def get_default(self):
2978
"""Return the current default format."""
2979
return self._default_format
2981
def set_default(self, format):
2982
self._default_format = format
2985
format_registry = WorkingTreeFormatRegistry()
2988
class WorkingTreeFormat(controldir.ControlComponentFormat):
2989
"""An encapsulation of the initialization and open routines for a format.
2991
Formats provide three things:
2992
* An initialization routine,
2996
Formats are placed in an dict by their format string for reference
2997
during workingtree opening. Its not required that these be instances, they
2998
can be classes themselves with class methods - it simply depends on
2999
whether state is needed for a given format or not.
3001
Once a format is deprecated, just deprecate the initialize and open
3002
methods on the format class. Do not deprecate the object, as the
3003
object will be created every time regardless.
3006
requires_rich_root = False
3008
upgrade_recommended = False
3010
requires_normalized_unicode_filenames = False
3012
case_sensitive_filename = "FoRMaT"
3014
missing_parent_conflicts = False
3015
"""If this format supports missing parent conflicts."""
3018
def find_format(klass, a_bzrdir):
3019
"""Return the format for the working tree object in a_bzrdir."""
3021
transport = a_bzrdir.get_workingtree_transport(None)
3022
format_string = transport.get_bytes("format")
3023
return format_registry.get(format_string)
3024
except errors.NoSuchFile:
3025
raise errors.NoWorkingTree(base=transport.base)
3027
raise errors.UnknownFormatError(format=format_string,
3028
kind="working tree")
3030
def initialize(self, a_bzrdir, revision_id=None, from_branch=None,
3031
accelerator_tree=None, hardlink=False):
3032
"""Initialize a new working tree in a_bzrdir.
3034
:param a_bzrdir: BzrDir to initialize the working tree in.
3035
:param revision_id: allows creating a working tree at a different
3036
revision than the branch is at.
3037
:param from_branch: Branch to checkout
3038
:param accelerator_tree: A tree which can be used for retrieving file
3039
contents more quickly than the revision tree, i.e. a workingtree.
3040
The revision tree will be used for cases where accelerator_tree's
3041
content is different.
3042
:param hardlink: If true, hard-link files from accelerator_tree,
3045
raise NotImplementedError(self.initialize)
3047
def __eq__(self, other):
3048
return self.__class__ is other.__class__
3050
def __ne__(self, other):
3051
return not (self == other)
3054
@symbol_versioning.deprecated_method(
3055
symbol_versioning.deprecated_in((2, 4, 0)))
3056
def get_default_format(klass):
3057
"""Return the current default format."""
3058
return format_registry.get_default()
3060
def get_format_string(self):
3061
"""Return the ASCII format string that identifies this format."""
3062
raise NotImplementedError(self.get_format_string)
3064
def get_format_description(self):
3065
"""Return the short description for this format."""
3066
raise NotImplementedError(self.get_format_description)
3068
def is_supported(self):
3069
"""Is this format supported?
3071
Supported formats can be initialized and opened.
3072
Unsupported formats may not support initialization or committing or
3073
some other features depending on the reason for not being supported.
3077
def supports_content_filtering(self):
3078
"""True if this format supports content filtering."""
3081
def supports_views(self):
3082
"""True if this format supports stored views."""
3086
@symbol_versioning.deprecated_method(
3087
symbol_versioning.deprecated_in((2, 4, 0)))
3088
def register_format(klass, format):
3089
format_registry.register(format)
3092
@symbol_versioning.deprecated_method(
3093
symbol_versioning.deprecated_in((2, 4, 0)))
3094
def register_extra_format(klass, format):
3095
format_registry.register_extra(format)
3098
@symbol_versioning.deprecated_method(
3099
symbol_versioning.deprecated_in((2, 4, 0)))
3100
def unregister_extra_format(klass, format):
3101
format_registry.unregister_extra(format)
3104
@symbol_versioning.deprecated_method(
3105
symbol_versioning.deprecated_in((2, 4, 0)))
3106
def get_formats(klass):
3107
return format_registry._get_all()
3110
@symbol_versioning.deprecated_method(
3111
symbol_versioning.deprecated_in((2, 4, 0)))
3112
def set_default_format(klass, format):
3113
format_registry.set_default(format)
3116
@symbol_versioning.deprecated_method(
3117
symbol_versioning.deprecated_in((2, 4, 0)))
3118
def unregister_format(klass, format):
3119
format_registry.remove(format)
3122
class WorkingTreeFormat3(WorkingTreeFormat):
3123
"""The second working tree format updated to record a format marker.
3126
- exists within a metadir controlling .bzr
3127
- includes an explicit version marker for the workingtree control
3128
files, separate from the BzrDir format
3129
- modifies the hash cache format
3131
- uses a LockDir to guard access for writes.
3134
upgrade_recommended = True
3136
missing_parent_conflicts = True
3138
def get_format_string(self):
3139
"""See WorkingTreeFormat.get_format_string()."""
3140
return "Bazaar-NG Working Tree format 3"
3142
def get_format_description(self):
3143
"""See WorkingTreeFormat.get_format_description()."""
3144
return "Working tree format 3"
3146
_lock_file_name = 'lock'
3147
_lock_class = LockDir
3149
_tree_class = WorkingTree3
3151
def __get_matchingbzrdir(self):
3152
return bzrdir.BzrDirMetaFormat1()
3154
_matchingbzrdir = property(__get_matchingbzrdir)
3156
def _open_control_files(self, a_bzrdir):
3157
transport = a_bzrdir.get_workingtree_transport(None)
3158
return LockableFiles(transport, self._lock_file_name,
3161
def initialize(self, a_bzrdir, revision_id=None, from_branch=None,
3162
accelerator_tree=None, hardlink=False):
3163
"""See WorkingTreeFormat.initialize().
3165
:param revision_id: if supplied, create a working tree at a different
3166
revision than the branch is at.
3167
:param accelerator_tree: A tree which can be used for retrieving file
3168
contents more quickly than the revision tree, i.e. a workingtree.
3169
The revision tree will be used for cases where accelerator_tree's
3170
content is different.
3171
:param hardlink: If true, hard-link files from accelerator_tree,
3174
if not isinstance(a_bzrdir.transport, LocalTransport):
3175
raise errors.NotLocalUrl(a_bzrdir.transport.base)
3176
transport = a_bzrdir.get_workingtree_transport(self)
3177
control_files = self._open_control_files(a_bzrdir)
3178
control_files.create_lock()
3179
control_files.lock_write()
3180
transport.put_bytes('format', self.get_format_string(),
3181
mode=a_bzrdir._get_file_mode())
3182
if from_branch is not None:
3183
branch = from_branch
3185
branch = a_bzrdir.open_branch()
3186
if revision_id is None:
3187
revision_id = _mod_revision.ensure_null(branch.last_revision())
3188
# WorkingTree3 can handle an inventory which has a unique root id.
3189
# as of bzr 0.12. However, bzr 0.11 and earlier fail to handle
3190
# those trees. And because there isn't a format bump inbetween, we
3191
# are maintaining compatibility with older clients.
3192
# inv = Inventory(root_id=gen_root_id())
3193
inv = self._initial_inventory()
3194
wt = self._tree_class(a_bzrdir.root_transport.local_abspath('.'),
3200
_control_files=control_files)
3201
wt.lock_tree_write()
3203
basis_tree = branch.repository.revision_tree(revision_id)
3204
# only set an explicit root id if there is one to set.
3205
if basis_tree.inventory.root is not None:
3206
wt.set_root_id(basis_tree.get_root_id())
3207
if revision_id == _mod_revision.NULL_REVISION:
3208
wt.set_parent_trees([])
3210
wt.set_parent_trees([(revision_id, basis_tree)])
3211
transform.build_tree(basis_tree, wt)
3213
# Unlock in this order so that the unlock-triggers-flush in
3214
# WorkingTree is given a chance to fire.
3215
control_files.unlock()
3219
def _initial_inventory(self):
3220
return inventory.Inventory()
3223
super(WorkingTreeFormat3, self).__init__()
3225
def open(self, a_bzrdir, _found=False):
3226
"""Return the WorkingTree object for a_bzrdir
3228
_found is a private parameter, do not use it. It is used to indicate
3229
if format probing has already been done.
3232
# we are being called directly and must probe.
3233
raise NotImplementedError
3234
if not isinstance(a_bzrdir.transport, LocalTransport):
3235
raise errors.NotLocalUrl(a_bzrdir.transport.base)
3236
wt = self._open(a_bzrdir, self._open_control_files(a_bzrdir))
3239
def _open(self, a_bzrdir, control_files):
3240
"""Open the tree itself.
3242
:param a_bzrdir: the dir for the tree.
3243
:param control_files: the control files for the tree.
3245
return self._tree_class(a_bzrdir.root_transport.local_abspath('.'),
3249
_control_files=control_files)
3252
return self.get_format_string()
3255
__default_format = WorkingTreeFormat6()
3256
format_registry.register_lazy("Bazaar Working Tree Format 4 (bzr 0.15)\n",
3257
"bzrlib.workingtree_4", "WorkingTreeFormat4")
3258
format_registry.register_lazy("Bazaar Working Tree Format 5 (bzr 1.11)\n",
3259
"bzrlib.workingtree_4", "WorkingTreeFormat5")
3260
format_registry.register_lazy("Bazaar Working Tree Format 6 (bzr 1.14)\n",
3261
"bzrlib.workingtree_4", "WorkingTreeFormat6")
3262
format_registry.register(WorkingTreeFormat3())
3263
format_registry.set_default(__default_format)
added
removed
bzrlib/workingtree.py
