13
13
# You should have received a copy of the GNU General Public License
14
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
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
17
17
"""WorkingTree object and friends.
19
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
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
23
new revision based on the workingtree and its inventory.
25
25
At the moment every WorkingTree has its own branch. Remote
80
79
import bzrlib.branch
81
80
from bzrlib.transport import get_transport
83
from bzrlib.workingtree_4 import (
82
from bzrlib.workingtree_4 import WorkingTreeFormat4
90
85
from bzrlib import symbol_versioning
91
86
from bzrlib.decorators import needs_read_lock, needs_write_lock
92
87
from bzrlib.inventory import InventoryEntry, Inventory, ROOT_ID, TreeReference
93
from bzrlib.lockable_files import LockableFiles
88
from bzrlib.lockable_files import LockableFiles, TransportLock
94
89
from bzrlib.lockdir import LockDir
95
90
import bzrlib.mutabletree
96
91
from bzrlib.mutabletree import needs_tree_write_lock
97
from bzrlib import osutils
98
92
from bzrlib.osutils import (
126
122
ERROR_PATH_NOT_FOUND = 3 # WindowsError errno code, equivalent to ENOENT
125
@deprecated_function(zero_thirteen)
126
def gen_file_id(name):
127
"""Return new file id for the basename 'name'.
129
Use bzrlib.generate_ids.gen_file_id() instead
131
return generate_ids.gen_file_id(name)
134
@deprecated_function(zero_thirteen)
136
"""Return a new tree-root file id.
138
This has been deprecated in favor of bzrlib.generate_ids.gen_root_id()
140
return generate_ids.gen_root_id()
129
143
class TreeEntry(object):
130
144
"""An entry that implements the minimum interface used by commands.
132
This needs further inspection, it may be better to have
146
This needs further inspection, it may be better to have
133
147
InventoryEntries without ids - though that seems wrong. For now,
134
148
this is a parallel hierarchy to InventoryEntry, and needs to become
135
149
one of several things: decorates to that hierarchy, children of, or
224
236
self._control_files = self.branch.control_files
226
238
# assume all other formats have their own control files.
239
assert isinstance(_control_files, LockableFiles), \
240
"_control_files must be a LockableFiles, not %r" \
227
242
self._control_files = _control_files
228
self._transport = self._control_files._transport
229
243
# update the whole cache up front and write to disk if anything changed;
230
244
# in the future we might want to do this more selectively
231
245
# two possible ways offer themselves : in self._unlock, write the cache
256
269
# the Format factory and creation methods that are
257
270
# permitted to do this.
258
271
self._set_inventory(_inventory, dirty=False)
259
self._detect_case_handling()
260
self._rules_searcher = None
261
self.views = self._make_views()
263
def _detect_case_handling(self):
264
wt_trans = self.bzrdir.get_workingtree_transport(None)
266
wt_trans.stat("FoRMaT")
267
except errors.NoSuchFile:
268
self.case_sensitive = True
270
self.case_sensitive = False
272
self._setup_directory_is_tree_reference()
274
273
branch = property(
275
274
fget=lambda self: self._branch,
353
347
return WorkingTree.open(path, _unsupported=True)
356
def find_trees(location):
357
def list_current(transport):
358
return [d for d in transport.list_dir('') if d != '.bzr']
359
def evaluate(bzrdir):
361
tree = bzrdir.open_workingtree()
362
except errors.NoWorkingTree:
366
transport = get_transport(location)
367
iterator = bzrdir.BzrDir.find_bzrdirs(transport, evaluate=evaluate,
368
list_current=list_current)
369
return [t for t in iterator if t is not None]
371
349
# should be deprecated - this is slow and in any case treating them as a
372
350
# container is (we now know) bad style -- mbp 20070302
373
351
## @deprecated_method(zero_fifteen)
417
389
# at this point ?
419
391
return self.branch.repository.revision_tree(revision_id)
420
except (errors.RevisionNotPresent, errors.NoSuchRevision):
392
except errors.RevisionNotPresent:
421
393
# the basis tree *may* be a ghost or a low level error may have
422
# occurred. If the revision is present, its a problem, if its not
394
# occured. If the revision is present, its a problem, if its not
424
396
if self.branch.repository.has_revision(revision_id):
426
398
# the basis tree is a ghost so return an empty tree.
427
return self.branch.repository.revision_tree(
428
_mod_revision.NULL_REVISION)
431
self._flush_ignore_list_cache()
399
return self.branch.repository.revision_tree(None)
402
@deprecated_method(zero_eight)
403
def create(branch, directory):
404
"""Create a workingtree for branch at directory.
406
If existing_directory already exists it must have a .bzr directory.
407
If it does not exist, it will be created.
409
This returns a new WorkingTree object for the new checkout.
411
TODO FIXME RBC 20060124 when we have checkout formats in place this
412
should accept an optional revisionid to checkout [and reject this if
413
checking out into the same dir as a pre-checkout-aware branch format.]
415
XXX: When BzrDir is present, these should be created through that
418
warnings.warn('delete WorkingTree.create', stacklevel=3)
419
transport = get_transport(directory)
420
if branch.bzrdir.root_transport.base == transport.base:
422
return branch.bzrdir.create_workingtree()
423
# different directory,
424
# create a branch reference
425
# and now a working tree.
426
raise NotImplementedError
429
@deprecated_method(zero_eight)
430
def create_standalone(directory):
431
"""Create a checkout and a branch and a repo at directory.
433
Directory must exist and be empty.
435
please use BzrDir.create_standalone_workingtree
437
return bzrdir.BzrDir.create_standalone_workingtree(directory)
433
439
def relpath(self, path):
434
440
"""Return the local path portion from a given path.
436
The path may be absolute or relative. If its a relative path it is
442
The path may be absolute or relative. If its a relative path it is
437
443
interpreted relative to the python current working directory.
439
445
return osutils.relpath(self.basedir, path)
441
447
def has_filename(self, filename):
442
448
return osutils.lexists(self.abspath(filename))
444
def get_file(self, file_id, path=None, filtered=True):
445
return self.get_file_with_stat(file_id, path, filtered=filtered)[0]
447
def get_file_with_stat(self, file_id, path=None, filtered=True,
449
"""See MutableTree.get_file_with_stat."""
451
path = self.id2path(file_id)
452
file_obj = self.get_file_byname(path, filtered=False)
453
stat_value = _fstat(file_obj.fileno())
454
if self.supports_content_filtering() and filtered:
455
filters = self._content_filter_stack(path)
456
file_obj = filtered_input_file(file_obj, filters)
457
return (file_obj, stat_value)
459
def get_file_text(self, file_id, path=None, filtered=True):
460
return self.get_file(file_id, path=path, filtered=filtered).read()
462
def get_file_byname(self, filename, filtered=True):
463
path = self.abspath(filename)
465
if self.supports_content_filtering() and filtered:
466
filters = self._content_filter_stack(filename)
467
return filtered_input_file(f, filters)
471
def get_file_lines(self, file_id, path=None, filtered=True):
472
"""See Tree.get_file_lines()"""
473
file = self.get_file(file_id, path, filtered=filtered)
475
return file.readlines()
450
def get_file(self, file_id):
451
file_id = osutils.safe_file_id(file_id)
452
return self.get_file_byname(self.id2path(file_id))
454
def get_file_text(self, file_id):
455
file_id = osutils.safe_file_id(file_id)
456
return self.get_file(file_id).read()
458
def get_file_byname(self, filename):
459
return file(self.abspath(filename), 'rb')
480
def annotate_iter(self, file_id, default_revision=CURRENT_REVISION):
462
def annotate_iter(self, file_id):
481
463
"""See Tree.annotate_iter
483
465
This implementation will use the basis tree implementation if possible.
487
469
incorrectly attributed to CURRENT_REVISION (but after committing, the
488
470
attribution will be correct).
472
file_id = osutils.safe_file_id(file_id)
490
473
basis = self.basis_tree()
491
474
basis.lock_read()
493
changes = self.iter_changes(basis, True, [self.id2path(file_id)],
476
changes = self._iter_changes(basis, True, [self.id2path(file_id)],
494
477
require_versioned=True).next()
495
478
changed_content, kind = changes[2], changes[6]
496
479
if not changed_content:
510
493
old.append(list(tree.annotate_iter(file_id)))
511
494
return annotate.reannotate(old, self.get_file(file_id).readlines(),
516
def _get_ancestors(self, default_revision):
517
ancestors = set([default_revision])
518
for parent_id in self.get_parent_ids():
519
ancestors.update(self.branch.repository.get_ancestry(
520
parent_id, topo_sorted=False))
523
499
def get_parent_ids(self):
524
500
"""See Tree.get_parent_ids.
526
502
This implementation reads the pending merges list and last_revision
527
503
value and uses that to decide what the parents list should be.
529
last_rev = _mod_revision.ensure_null(self._last_revision())
530
if _mod_revision.NULL_REVISION == last_rev:
505
last_rev = self._last_revision()
533
509
parents = [last_rev]
535
merges_file = self._transport.get('pending-merges')
511
merges_file = self._control_files.get('pending-merges')
536
512
except errors.NoSuchFile:
539
515
for l in merges_file.readlines():
540
revision_id = l.rstrip('\n')
516
revision_id = osutils.safe_revision_id(l.rstrip('\n'))
541
517
parents.append(revision_id)
545
521
def get_root_id(self):
546
522
"""Return the id of this trees root"""
547
523
return self._inventory.root.file_id
549
525
def _get_store_filename(self, file_id):
550
526
## XXX: badly named; this is not in the store at all
527
file_id = osutils.safe_file_id(file_id)
551
528
return self.abspath(self.id2path(file_id))
554
531
def clone(self, to_bzrdir, revision_id=None):
555
532
"""Duplicate this working tree into to_bzr, including all state.
557
534
Specifically modified files are kept as modified, but
558
535
ignored and unknown files are discarded.
560
537
If you want to make a new line of development, see bzrdir.sprout()
563
If not None, the cloned tree will have its last revision set to
564
revision, and difference between the source trees last revision
540
If not None, the cloned tree will have its last revision set to
541
revision, and and difference between the source trees last revision
565
542
and this one merged in.
567
544
# assumes the target bzr dir format is compatible.
568
result = to_bzrdir.create_workingtree()
545
result = self._format.initialize(to_bzrdir)
569
546
self.copy_content_into(result, revision_id)
600
580
__contains__ = has_id
602
582
def get_file_size(self, file_id):
603
"""See Tree.get_file_size"""
605
return os.path.getsize(self.id2abspath(file_id))
607
if e.errno != errno.ENOENT:
583
file_id = osutils.safe_file_id(file_id)
584
return os.path.getsize(self.id2abspath(file_id))
613
587
def get_file_sha1(self, file_id, path=None, stat_value=None):
588
file_id = osutils.safe_file_id(file_id)
615
590
path = self._inventory.id2path(file_id)
616
591
return self._hashcache.get_sha1(path, stat_value)
618
593
def get_file_mtime(self, file_id, path=None):
594
file_id = osutils.safe_file_id(file_id)
620
596
path = self.inventory.id2path(file_id)
621
597
return os.lstat(self.abspath(path)).st_mtime
623
def _is_executable_from_path_and_stat_from_basis(self, path, stat_result):
624
file_id = self.path2id(path)
625
return self._inventory[file_id].executable
627
def _is_executable_from_path_and_stat_from_stat(self, path, stat_result):
628
mode = stat_result.st_mode
629
return bool(stat.S_ISREG(mode) and stat.S_IEXEC & mode)
631
599
if not supports_executable():
632
600
def is_executable(self, file_id, path=None):
601
file_id = osutils.safe_file_id(file_id)
633
602
return self._inventory[file_id].executable
635
_is_executable_from_path_and_stat = \
636
_is_executable_from_path_and_stat_from_basis
638
604
def is_executable(self, file_id, path=None):
606
file_id = osutils.safe_file_id(file_id)
640
607
path = self.id2path(file_id)
641
608
mode = os.lstat(self.abspath(path)).st_mode
642
609
return bool(stat.S_ISREG(mode) and stat.S_IEXEC & mode)
644
_is_executable_from_path_and_stat = \
645
_is_executable_from_path_and_stat_from_stat
647
611
@needs_tree_write_lock
648
612
def _add(self, files, ids, kinds):
649
613
"""See MutableTree._add."""
650
614
# TODO: Re-adding a file that is removed in the working copy
651
615
# should probably put it back with the previous ID.
652
# the read and write working inventory should not occur in this
616
# the read and write working inventory should not occur in this
653
617
# function - they should be part of lock_write and unlock.
654
618
inv = self.inventory
655
619
for f, file_id, kind in zip(files, ids, kinds):
620
assert kind is not None
656
621
if file_id is None:
657
622
inv.add_path(f, kind=kind)
624
file_id = osutils.safe_file_id(file_id)
659
625
inv.add_path(f, kind=kind, file_id=file_id)
660
626
self._inventory_is_modified = True
724
690
self.set_parent_ids(parents, allow_leftmost_as_ghost=True)
726
def path_content_summary(self, path, _lstat=os.lstat,
727
_mapper=osutils.file_kind_from_stat_mode):
728
"""See Tree.path_content_summary."""
729
abspath = self.abspath(path)
731
stat_result = _lstat(abspath)
733
if getattr(e, 'errno', None) == errno.ENOENT:
735
return ('missing', None, None, None)
736
# propagate other errors
738
kind = _mapper(stat_result.st_mode)
740
size = stat_result.st_size
741
# try for a stat cache lookup
742
executable = self._is_executable_from_path_and_stat(path, stat_result)
743
return (kind, size, executable, self._sha_from_stat(
745
elif kind == 'directory':
746
# perhaps it looks like a plain directory, but it's really a
748
if self._directory_is_tree_reference(path):
749
kind = 'tree-reference'
750
return kind, None, None, None
751
elif kind == 'symlink':
752
return ('symlink', None, None,
753
os.readlink(abspath.encode(osutils._fs_enc)
754
).decode(osutils._fs_enc))
756
return (kind, None, None, None)
692
@deprecated_method(zero_eleven)
694
def pending_merges(self):
695
"""Return a list of pending merges.
697
These are revisions that have been merged into the working
698
directory but not yet committed.
700
As of 0.11 this is deprecated. Please see WorkingTree.get_parent_ids()
701
instead - which is available on all tree objects.
703
return self.get_parent_ids()[1:]
758
705
def _check_parents_for_ghosts(self, revision_ids, allow_leftmost_as_ghost):
759
706
"""Common ghost checking functionality from set_parent_*.
770
717
def _set_merges_from_parent_ids(self, parent_ids):
771
718
merges = parent_ids[1:]
772
self._transport.put_bytes('pending-merges', '\n'.join(merges),
773
mode=self.bzrdir._get_file_mode())
775
def _filter_parent_ids_by_ancestry(self, revision_ids):
776
"""Check that all merged revisions are proper 'heads'.
778
This will always return the first revision_id, and any merged revisions
781
if len(revision_ids) == 0:
783
graph = self.branch.repository.get_graph()
784
heads = graph.heads(revision_ids)
785
new_revision_ids = revision_ids[:1]
786
for revision_id in revision_ids[1:]:
787
if revision_id in heads and revision_id not in new_revision_ids:
788
new_revision_ids.append(revision_id)
789
if new_revision_ids != revision_ids:
790
trace.mutter('requested to set revision_ids = %s,'
791
' but filtered to %s', revision_ids, new_revision_ids)
792
return new_revision_ids
719
self._control_files.put_bytes('pending-merges', '\n'.join(merges))
794
721
@needs_tree_write_lock
795
722
def set_parent_ids(self, revision_ids, allow_leftmost_as_ghost=False):
796
723
"""Set the parent ids to revision_ids.
798
725
See also set_parent_trees. This api will try to retrieve the tree data
799
726
for each element of revision_ids from the trees repository. If you have
800
727
tree data already available, it is more efficient to use
804
731
:param revision_ids: The revision_ids to set as the parent ids of this
805
732
working tree. Any of these may be ghosts.
734
revision_ids = [osutils.safe_revision_id(r) for r in revision_ids]
807
735
self._check_parents_for_ghosts(revision_ids,
808
736
allow_leftmost_as_ghost=allow_leftmost_as_ghost)
809
for revision_id in revision_ids:
810
_mod_revision.check_not_reserved_id(revision_id)
812
revision_ids = self._filter_parent_ids_by_ancestry(revision_ids)
814
738
if len(revision_ids) > 0:
815
739
self.set_last_revision(revision_ids[0])
817
self.set_last_revision(_mod_revision.NULL_REVISION)
741
self.set_last_revision(None)
819
743
self._set_merges_from_parent_ids(revision_ids)
821
745
@needs_tree_write_lock
822
746
def set_parent_trees(self, parents_list, allow_leftmost_as_ghost=False):
823
747
"""See MutableTree.set_parent_trees."""
824
parent_ids = [rev for (rev, tree) in parents_list]
825
for revision_id in parent_ids:
826
_mod_revision.check_not_reserved_id(revision_id)
748
parent_ids = [osutils.safe_revision_id(rev) for (rev, tree) in parents_list]
828
750
self._check_parents_for_ghosts(parent_ids,
829
751
allow_leftmost_as_ghost=allow_leftmost_as_ghost)
831
parent_ids = self._filter_parent_ids_by_ancestry(parent_ids)
833
753
if len(parent_ids) == 0:
834
leftmost_parent_id = _mod_revision.NULL_REVISION
754
leftmost_parent_id = None
835
755
leftmost_parent_tree = None
837
757
leftmost_parent_id, leftmost_parent_tree = parents_list[0]
862
782
yield Stanza(file_id=file_id.decode('utf8'), hash=hash)
863
783
self._put_rio('merge-hashes', iter_stanzas(), MERGE_MODIFIED_HEADER_1)
865
def _sha_from_stat(self, path, stat_result):
866
"""Get a sha digest from the tree's stat cache.
868
The default implementation assumes no stat cache is present.
870
:param path: The path.
871
:param stat_result: The stat result being looked up.
875
785
def _put_rio(self, filename, stanzas, header):
876
786
self._must_be_locked()
877
787
my_file = rio_file(stanzas, header)
878
self._transport.put_file(filename, my_file,
879
mode=self.bzrdir._get_file_mode())
788
self._control_files.put(filename, my_file)
881
790
@needs_write_lock # because merge pulls data into the branch.
882
def merge_from_branch(self, branch, to_revision=None, from_revision=None,
791
def merge_from_branch(self, branch, to_revision=None):
884
792
"""Merge from a branch into this working tree.
886
794
:param branch: The branch to merge from.
899
807
# local alterations
900
808
merger.check_basis(check_clean=True, require_commits=False)
901
809
if to_revision is None:
902
to_revision = _mod_revision.ensure_null(branch.last_revision())
810
to_revision = branch.last_revision()
812
to_revision = osutils.safe_revision_id(to_revision)
903
813
merger.other_rev_id = to_revision
904
if _mod_revision.is_null(merger.other_rev_id):
814
if merger.other_rev_id is None:
905
815
raise errors.NoCommits(branch)
906
816
self.branch.fetch(branch, last_revision=merger.other_rev_id)
907
817
merger.other_basis = merger.other_rev_id
909
819
merger.other_rev_id)
910
820
merger.other_branch = branch
911
821
merger.pp.next_phase()
912
if from_revision is None:
915
merger.set_base_revision(from_revision, branch)
916
823
if merger.base_rev_id == merger.other_rev_id:
917
824
raise errors.PointlessMerge
918
825
merger.backup_files = False
919
if merge_type is None:
920
merger.merge_type = Merge3Merger
922
merger.merge_type = merge_type
826
merger.merge_type = Merge3Merger
923
827
merger.set_interesting_files(None)
924
828
merger.show_base = False
925
829
merger.reprocess = False
941
845
still in the working inventory and have that text hash.
944
hashfile = self._transport.get('merge-hashes')
848
hashfile = self._control_files.get('merge-hashes')
945
849
except errors.NoSuchFile:
950
if hashfile.next() != MERGE_MODIFIED_HEADER_1 + '\n':
951
raise errors.MergeModifiedFormatError()
952
except StopIteration:
853
if hashfile.next() != MERGE_MODIFIED_HEADER_1 + '\n':
953
854
raise errors.MergeModifiedFormatError()
954
for s in RioReader(hashfile):
955
# RioReader reads in Unicode, so convert file_ids back to utf8
956
file_id = osutils.safe_file_id(s.get("file_id"), warn=False)
957
if file_id not in self.inventory:
959
text_hash = s.get("hash")
960
if text_hash == self.get_file_sha1(file_id):
961
merge_hashes[file_id] = text_hash
855
except StopIteration:
856
raise errors.MergeModifiedFormatError()
857
for s in RioReader(hashfile):
858
# RioReader reads in Unicode, so convert file_ids back to utf8
859
file_id = osutils.safe_file_id(s.get("file_id"), warn=False)
860
if file_id not in self.inventory:
862
text_hash = s.get("hash")
863
if text_hash == self.get_file_sha1(file_id):
864
merge_hashes[file_id] = text_hash
966
867
@needs_write_lock
967
868
def mkdir(self, path, file_id=None):
1018
919
other_tree.unlock()
1019
920
other_tree.bzrdir.retire_bzrdir()
1021
def _setup_directory_is_tree_reference(self):
1022
if self._branch.repository._format.supports_tree_reference:
1023
self._directory_is_tree_reference = \
1024
self._directory_may_be_tree_reference
1026
self._directory_is_tree_reference = \
1027
self._directory_is_never_tree_reference
1029
def _directory_is_never_tree_reference(self, relpath):
1032
def _directory_may_be_tree_reference(self, relpath):
1033
# as a special case, if a directory contains control files then
1034
# it's a tree reference, except that the root of the tree is not
1035
return relpath and osutils.isdir(self.abspath(relpath) + u"/.bzr")
1036
# TODO: We could ask all the control formats whether they
1037
# recognize this directory, but at the moment there's no cheap api
1038
# to do that. Since we probably can only nest bzr checkouts and
1039
# they always use this name it's ok for now. -- mbp 20060306
1041
# FIXME: There is an unhandled case here of a subdirectory
1042
# containing .bzr but not a branch; that will probably blow up
1043
# when you try to commit it. It might happen if there is a
1044
# checkout in a subdirectory. This can be avoided by not adding
1047
922
@needs_tree_write_lock
1048
923
def extract(self, file_id, format=None):
1049
924
"""Extract a subtree from this tree.
1051
926
A new branch will be created, relative to the path for this tree.
1058
933
transport = transport.clone(name)
1059
934
transport.ensure_base()
1060
935
return transport
1062
937
sub_path = self.id2path(file_id)
1063
938
branch_transport = mkdirs(sub_path)
1064
939
if format is None:
1065
format = self.bzrdir.cloning_metadir()
940
format = bzrdir.format_registry.make_bzrdir('dirstate-with-subtree')
1066
941
branch_transport.ensure_base()
1067
942
branch_bzrdir = format.initialize_on_transport(branch_transport)
1069
944
repo = branch_bzrdir.find_repository()
1070
945
except errors.NoRepositoryPresent:
1071
946
repo = branch_bzrdir.create_repository()
1072
if not repo.supports_rich_root():
1073
raise errors.RootNotRich()
947
assert repo.supports_rich_root()
949
if not repo.supports_rich_root():
950
raise errors.RootNotRich()
1074
951
new_branch = branch_bzrdir.create_branch()
1075
952
new_branch.pull(self.branch)
1076
953
for parent_id in self.get_parent_ids():
1532
1403
:raises: NoSuchId if any fileid is not currently versioned.
1534
1405
for file_id in file_ids:
1535
if file_id not in self._inventory:
1536
raise errors.NoSuchId(self, file_id)
1537
for file_id in file_ids:
1406
file_id = osutils.safe_file_id(file_id)
1538
1407
if self._inventory.has_id(file_id):
1539
1408
self._inventory.remove_recursive_id(file_id)
1410
raise errors.NoSuchId(self, file_id)
1540
1411
if len(file_ids):
1541
# in the future this should just set a dirty bit to wait for the
1412
# in the future this should just set a dirty bit to wait for the
1542
1413
# final unlock. However, until all methods of workingtree start
1543
# with the current in -memory inventory rather than triggering
1414
# with the current in -memory inventory rather than triggering
1544
1415
# a read, it is more complex - we need to teach read_inventory
1545
1416
# to know when to read, and when to not read first... and possibly
1546
1417
# to save first when the in memory one may be corrupted.
1547
1418
# so for now, we just only write it if it is indeed dirty.
1548
1419
# - RBC 20060907
1549
1420
self._write_inventory(self._inventory)
1422
@deprecated_method(zero_eight)
1423
def iter_conflicts(self):
1424
"""List all files in the tree that have text or content conflicts.
1425
DEPRECATED. Use conflicts instead."""
1426
return self._iter_conflicts()
1551
1428
def _iter_conflicts(self):
1552
1429
conflicted = set()
1569
1446
pp.next_phase()
1570
1447
old_revision_info = self.branch.last_revision_info()
1571
1448
basis_tree = self.basis_tree()
1572
count = self.branch.pull(source, overwrite, stop_revision,
1573
possible_transports=possible_transports)
1449
count = self.branch.pull(source, overwrite, stop_revision)
1574
1450
new_revision_info = self.branch.last_revision_info()
1575
1451
if new_revision_info != old_revision_info:
1576
1452
pp.next_phase()
1596
1472
# reuse the revisiontree we merged against to set the new
1598
1474
parent_trees = [(self.branch.last_revision(), new_basis_tree)]
1599
# we have to pull the merge trees out again, because
1600
# merge_inner has set the ids. - this corner is not yet
1475
# we have to pull the merge trees out again, because
1476
# merge_inner has set the ids. - this corner is not yet
1601
1477
# layered well enough to prevent double handling.
1602
1478
# XXX TODO: Fix the double handling: telling the tree about
1603
1479
# the already known parent data is wasteful.
1644
1521
if subf == '.bzr':
1646
1523
if subf not in dir_entry.children:
1649
can_access) = osutils.normalized_filename(subf)
1650
except UnicodeDecodeError:
1651
path_os_enc = path.encode(osutils._fs_enc)
1652
relpath = path_os_enc + '/' + subf
1653
raise errors.BadFilenameEncoding(relpath,
1524
subf_norm, can_access = osutils.normalized_filename(subf)
1655
1525
if subf_norm != subf and can_access:
1656
1526
if subf_norm not in dir_entry.children:
1657
1527
fl.append(subf_norm)
1659
1529
fl.append(subf)
1662
1532
for subf in fl:
1663
1533
subp = pathjoin(path, subf)
1803
1669
def _reset_data(self):
1804
1670
"""Reset transient data that cannot be revalidated."""
1805
1671
self._inventory_is_modified = False
1806
result = self._deserialize(self._transport.get('inventory'))
1672
result = self._deserialize(self._control_files.get('inventory'))
1807
1673
self._set_inventory(result, dirty=False)
1809
1675
@needs_tree_write_lock
1810
1676
def set_last_revision(self, new_revision):
1811
1677
"""Change the last revision in the working tree."""
1678
new_revision = osutils.safe_revision_id(new_revision)
1812
1679
if self._change_last_revision(new_revision):
1813
1680
self._cache_basis_inventory(new_revision)
1815
1682
def _change_last_revision(self, new_revision):
1816
1683
"""Template method part of set_last_revision to perform the change.
1818
1685
This is used to allow WorkingTree3 instances to not affect branch
1819
1686
when their last revision is set.
1821
if _mod_revision.is_null(new_revision):
1688
if new_revision is None:
1822
1689
self.branch.set_revision_history([])
1831
1698
def _write_basis_inventory(self, xml):
1832
1699
"""Write the basis inventory XML to the basis-inventory file"""
1700
assert isinstance(xml, str), 'serialised xml must be bytestring.'
1833
1701
path = self._basis_inventory_name()
1834
1702
sio = StringIO(xml)
1835
self._transport.put_file(path, sio,
1836
mode=self.bzrdir._get_file_mode())
1703
self._control_files.put(path, sio)
1838
1705
def _create_basis_xml_from_inventory(self, revision_id, inventory):
1839
1706
"""Create the text that will be saved in basis-inventory"""
1840
inventory.revision_id = revision_id
1707
# TODO: jam 20070209 This should be redundant, as the revision_id
1708
# as all callers should have already converted the revision_id to
1710
inventory.revision_id = osutils.safe_revision_id(revision_id)
1841
1711
return xml7.serializer_v7.write_inventory_to_string(inventory)
1843
1713
def _cache_basis_inventory(self, new_revision):
1846
1716
# as commit already has that ready-to-use [while the format is the
1847
1717
# same, that is].
1849
# this double handles the inventory - unpack and repack -
1719
# this double handles the inventory - unpack and repack -
1850
1720
# but is easier to understand. We can/should put a conditional
1851
1721
# in here based on whether the inventory is in the latest format
1852
1722
# - perhaps we should repack all inventories on a repository
1854
1724
# the fast path is to copy the raw xml from the repository. If the
1855
# xml contains 'revision_id="', then we assume the right
1725
# xml contains 'revision_id="', then we assume the right
1856
1726
# revision_id is set. We must check for this full string, because a
1857
1727
# root node id can legitimately look like 'revision_id' but cannot
1858
1728
# contain a '"'.
1859
1729
xml = self.branch.repository.get_inventory_xml(new_revision)
1860
1730
firstline = xml.split('\n', 1)[0]
1861
if (not 'revision_id="' in firstline or
1731
if (not 'revision_id="' in firstline or
1862
1732
'format="7"' not in firstline):
1863
1733
inv = self.branch.repository.deserialise_inventory(
1864
1734
new_revision, xml)
1870
1740
def read_basis_inventory(self):
1871
1741
"""Read the cached basis inventory."""
1872
1742
path = self._basis_inventory_name()
1873
return self._transport.get_bytes(path)
1743
return self._control_files.get(path).read()
1875
1745
@needs_read_lock
1876
1746
def read_working_inventory(self):
1877
1747
"""Read the working inventory.
1879
1749
:raises errors.InventoryModified: read_working_inventory will fail
1880
1750
when the current in memory inventory has been modified.
1882
# conceptually this should be an implementation detail of the tree.
1752
# conceptually this should be an implementation detail of the tree.
1883
1753
# XXX: Deprecate this.
1884
1754
# ElementTree does its own conversion from UTF-8, so open in
1886
1756
if self._inventory_is_modified:
1887
1757
raise errors.InventoryModified(self)
1888
result = self._deserialize(self._transport.get('inventory'))
1758
result = self._deserialize(self._control_files.get('inventory'))
1889
1759
self._set_inventory(result, dirty=False)
1892
1762
@needs_tree_write_lock
1893
1763
def remove(self, files, verbose=False, to_file=None, keep_files=True,
1895
"""Remove nominated files from the working inventory.
1765
"""Remove nominated files from the working inventor.
1897
1767
:files: File paths relative to the basedir.
1898
1768
:keep_files: If true, the files will also be kept.
1899
1769
:force: Delete files and directories, even if they are changed and
1900
1770
even if the directories are not empty.
1772
## TODO: Normalize names
1902
1774
if isinstance(files, basestring):
1903
1775
files = [files]
1907
1779
new_files=set()
1908
unknown_nested_files=set()
1780
unknown_files_in_directory=set()
1910
1782
def recurse_directory_to_add_files(directory):
1911
# Recurse directory and add all files
1783
# recurse directory and add all files
1912
1784
# so we can check if they have changed.
1913
1785
for parent_info, file_infos in\
1914
self.walkdirs(directory):
1915
for relpath, basename, kind, lstat, fileid, kind in file_infos:
1916
# Is it versioned or ignored?
1917
if self.path2id(relpath) or self.is_ignored(relpath):
1918
# Add nested content for deletion.
1919
new_files.add(relpath)
1921
# Files which are not versioned and not ignored
1922
# should be treated as unknown.
1923
unknown_nested_files.add((relpath, None, kind))
1786
osutils.walkdirs(self.abspath(directory),
1788
for relpath, basename, kind, lstat, abspath in file_infos:
1790
if self.path2id(relpath): #is it versioned?
1791
new_files.add(relpath)
1793
unknown_files_in_directory.add(
1794
(relpath, None, kind))
1925
1796
for filename in files:
1926
1797
# Get file name into canonical form.
1928
1799
filename = self.relpath(abspath)
1929
1800
if len(filename) > 0:
1930
1801
new_files.add(filename)
1931
recurse_directory_to_add_files(filename)
1933
files = list(new_files)
1936
return # nothing to do
1802
if osutils.isdir(abspath):
1803
recurse_directory_to_add_files(filename)
1804
files = [f for f in new_files]
1938
1806
# Sort needed to first handle directory content before the directory
1939
1807
files.sort(reverse=True)
1941
# Bail out if we are going to delete files we shouldn't
1942
1808
if not keep_files and not force:
1943
has_changed_files = len(unknown_nested_files) > 0
1944
if not has_changed_files:
1945
for (file_id, path, content_change, versioned, parent_id, name,
1946
kind, executable) in self.iter_changes(self.basis_tree(),
1947
include_unchanged=True, require_versioned=False,
1948
want_unversioned=True, specific_files=files):
1949
if versioned == (False, False):
1950
# The record is unknown ...
1951
if not self.is_ignored(path[1]):
1952
# ... but not ignored
1953
has_changed_files = True
1955
elif content_change and (kind[1] is not None):
1956
# Versioned and changed, but not deleted
1957
has_changed_files = True
1960
if has_changed_files:
1961
# Make delta show ALL applicable changes in error message.
1962
tree_delta = self.changes_from(self.basis_tree(),
1963
require_versioned=False, want_unversioned=True,
1964
specific_files=files)
1965
for unknown_file in unknown_nested_files:
1966
if unknown_file not in tree_delta.unversioned:
1967
tree_delta.unversioned.extend((unknown_file,))
1809
tree_delta = self.changes_from(self.basis_tree(),
1810
specific_files=files)
1811
for unknown_file in unknown_files_in_directory:
1812
tree_delta.unversioned.extend((unknown_file,))
1813
if bool(tree_delta.modified
1815
or tree_delta.renamed
1816
or tree_delta.kind_changed
1817
or tree_delta.unversioned):
1968
1818
raise errors.BzrRemoveChangedFilesError(tree_delta)
1970
# Build inv_delta and delete files where applicable,
1971
# do this before any modifications to inventory.
1820
# do this before any modifications
1972
1821
for f in files:
1973
1822
fid = self.path2id(f)
1976
message = "%s is not versioned." % (f,)
1825
message="%s is not versioned." % (f,)
1979
1828
# having removed it, it must be either ignored or unknown
1983
1832
new_status = '?'
1984
1833
textui.show_status(new_status, self.kind(fid), f,
1985
1834
to_file=to_file)
1987
1836
inv_delta.append((f, None, fid, None))
1988
message = "removed %s" % (f,)
1837
message="removed %s" % (f,)
1990
1839
if not keep_files:
1991
1840
abs_path = self.abspath(f)
1992
1841
if osutils.lexists(abs_path):
1993
1842
if (osutils.isdir(abs_path) and
1994
1843
len(os.listdir(abs_path)) > 0):
1996
osutils.rmtree(abs_path)
1998
message = "%s is not an empty directory "\
1999
"and won't be deleted." % (f,)
1844
message="%s is not empty directory "\
1845
"and won't be deleted." % (f,)
2001
1847
osutils.delete_any(abs_path)
2002
message = "deleted %s" % (f,)
1848
message="deleted %s" % (f,)
2003
1849
elif message is not None:
2004
# Only care if we haven't done anything yet.
2005
message = "%s does not exist." % (f,)
1850
# only care if we haven't done anything yet.
1851
message="%s does not exist." % (f,)
2007
# Print only one message (if any) per file.
1853
# print only one message (if any) per file.
2008
1854
if message is not None:
2010
1856
self.apply_inventory_delta(inv_delta)
2012
1858
@needs_tree_write_lock
2013
def revert(self, filenames=None, old_tree=None, backups=True,
1859
def revert(self, filenames, old_tree=None, backups=True,
2014
1860
pb=DummyProgress(), report_changes=False):
2015
1861
from bzrlib.conflicts import resolve
2018
symbol_versioning.warn('Using [] to revert all files is deprecated'
2019
' as of bzr 0.91. Please use None (the default) instead.',
2020
DeprecationWarning, stacklevel=2)
2021
1862
if old_tree is None:
2022
basis_tree = self.basis_tree()
2023
basis_tree.lock_read()
2024
old_tree = basis_tree
1863
old_tree = self.basis_tree()
1864
conflicts = transform.revert(self, old_tree, filenames, backups, pb,
1866
if not len(filenames):
1867
self.set_parent_ids(self.get_parent_ids()[:1])
2028
conflicts = transform.revert(self, old_tree, filenames, backups, pb,
2030
if filenames is None and len(self.get_parent_ids()) > 1:
2032
last_revision = self.last_revision()
2033
if last_revision != NULL_REVISION:
2034
if basis_tree is None:
2035
basis_tree = self.basis_tree()
2036
basis_tree.lock_read()
2037
parent_trees.append((last_revision, basis_tree))
2038
self.set_parent_trees(parent_trees)
2041
resolve(self, filenames, ignore_misses=True, recursive=True)
2043
if basis_tree is not None:
1870
resolve(self, filenames, ignore_misses=True)
2045
1871
return conflicts
2047
1873
def revision_tree(self, revision_id):
2096
1922
@needs_tree_write_lock
2097
1923
def set_root_id(self, file_id):
2098
1924
"""Set the root id for this tree."""
2100
1926
if file_id is None:
2102
'WorkingTree.set_root_id with fileid=None')
2103
file_id = osutils.safe_file_id(file_id)
1927
symbol_versioning.warn(symbol_versioning.zero_twelve
1928
% 'WorkingTree.set_root_id with fileid=None',
1933
file_id = osutils.safe_file_id(file_id)
2104
1934
self._set_root_id(file_id)
2106
1936
def _set_root_id(self, file_id):
2107
1937
"""Set the root id for this tree, in a format specific manner.
2109
:param file_id: The file id to assign to the root. It must not be
1939
:param file_id: The file id to assign to the root. It must not be
2110
1940
present in the current inventory or an error will occur. It must
2111
1941
not be None, but rather a valid file id.
2132
1962
def unlock(self):
2133
1963
"""See Branch.unlock.
2135
1965
WorkingTree locking just uses the Branch locking facilities.
2136
1966
This is current because all working trees have an embedded branch
2137
1967
within them. IF in the future, we were to make branch data shareable
2138
between multiple working trees, i.e. via shared storage, then we
1968
between multiple working trees, i.e. via shared storage, then we
2139
1969
would probably want to lock both the local tree, and the branch.
2141
1971
raise NotImplementedError(self.unlock)
2143
def update(self, change_reporter=None, possible_transports=None):
1973
def update(self, change_reporter=None):
2144
1974
"""Update a working tree along its branch.
2146
1976
This will update the branch if its bound too, which means we have
2193
2023
# cant set that until we update the working trees last revision to be
2194
2024
# one from the new branch, because it will just get absorbed by the
2195
2025
# parent de-duplication logic.
2197
2027
# We MUST save it even if an error occurs, because otherwise the users
2198
2028
# local work is unreferenced and will appear to have been lost.
2202
2032
last_rev = self.get_parent_ids()[0]
2203
2033
except IndexError:
2204
last_rev = _mod_revision.NULL_REVISION
2205
if last_rev != _mod_revision.ensure_null(self.branch.last_revision()):
2035
if last_rev != self.branch.last_revision():
2206
2036
# merge tree state up to new branch tip.
2207
2037
basis = self.basis_tree()
2208
2038
basis.lock_read()
2210
2040
to_tree = self.branch.basis_tree()
2211
2041
if basis.inventory.root is None:
2212
self.set_root_id(to_tree.get_root_id())
2042
self.set_root_id(to_tree.inventory.root.file_id)
2214
2044
result += merge.merge_inner(
2224
2054
parent_trees = [(self.branch.last_revision(), to_tree)]
2225
2055
merges = self.get_parent_ids()[1:]
2226
2056
# Ideally we ask the tree for the trees here, that way the working
2227
# tree can decide whether to give us the entire tree or give us a
2057
# tree can decide whether to give us teh entire tree or give us a
2228
2058
# lazy initialised tree. dirstate for instance will have the trees
2229
2059
# in ram already, whereas a last-revision + basis-inventory tree
2230
2060
# will not, but also does not need them when setting parents.
2231
2061
for parent in merges:
2232
2062
parent_trees.append(
2233
2063
(parent, self.branch.repository.revision_tree(parent)))
2234
if (old_tip is not None and not _mod_revision.is_null(old_tip)):
2064
if old_tip is not None:
2235
2065
parent_trees.append(
2236
2066
(old_tip, self.branch.repository.revision_tree(old_tip)))
2237
2067
self.set_parent_trees(parent_trees)
2240
2070
# the working tree had the same last-revision as the master
2241
2071
# branch did. We may still have pivot local work from the local
2242
2072
# branch into old_tip:
2243
if (old_tip is not None and not _mod_revision.is_null(old_tip)):
2073
if old_tip is not None:
2244
2074
self.add_parent_tree_id(old_tip)
2245
if (old_tip is not None and not _mod_revision.is_null(old_tip)
2246
and old_tip != last_rev):
2075
if old_tip and old_tip != last_rev:
2247
2076
# our last revision was not the prior branch last revision
2248
2077
# and we have converted that last revision to a pending merge.
2249
2078
# base is somewhere between the branch tip now
2357
2186
current_inv = None
2358
2187
inv_finished = True
2359
2188
while not inv_finished or not disk_finished:
2361
((cur_disk_dir_relpath, cur_disk_dir_path_from_top),
2362
cur_disk_dir_content) = current_disk
2364
((cur_disk_dir_relpath, cur_disk_dir_path_from_top),
2365
cur_disk_dir_content) = ((None, None), None)
2366
2189
if not disk_finished:
2367
2190
# strip out .bzr dirs
2368
if (cur_disk_dir_path_from_top[top_strip_len:] == '' and
2369
len(cur_disk_dir_content) > 0):
2370
# osutils.walkdirs can be made nicer -
2191
if current_disk[0][1][top_strip_len:] == '':
2192
# osutils.walkdirs can be made nicer -
2371
2193
# yield the path-from-prefix rather than the pathjoined
2373
bzrdir_loc = bisect_left(cur_disk_dir_content,
2375
if (bzrdir_loc < len(cur_disk_dir_content)
2376
and cur_disk_dir_content[bzrdir_loc][0] == '.bzr'):
2195
bzrdir_loc = bisect_left(current_disk[1], ('.bzr', '.bzr'))
2196
if current_disk[1][bzrdir_loc][0] == '.bzr':
2377
2197
# we dont yield the contents of, or, .bzr itself.
2378
del cur_disk_dir_content[bzrdir_loc]
2198
del current_disk[1][bzrdir_loc]
2379
2199
if inv_finished:
2380
2200
# everything is unknown
2383
2203
# everything is missing
2386
direction = cmp(current_inv[0][0], cur_disk_dir_relpath)
2206
direction = cmp(current_inv[0][0], current_disk[0][0])
2387
2207
if direction > 0:
2388
2208
# disk is before inventory - unknown
2389
2209
dirblock = [(relpath, basename, kind, stat, None, None) for
2390
relpath, basename, kind, stat, top_path in
2391
cur_disk_dir_content]
2392
yield (cur_disk_dir_relpath, None), dirblock
2210
relpath, basename, kind, stat, top_path in current_disk[1]]
2211
yield (current_disk[0][0], None), dirblock
2394
2213
current_disk = disk_iterator.next()
2395
2214
except StopIteration:
2397
2216
elif direction < 0:
2398
2217
# inventory is before disk - missing.
2399
2218
dirblock = [(relpath, basename, 'unknown', None, fileid, kind)
2400
for relpath, basename, dkind, stat, fileid, kind in
2219
for relpath, basename, dkind, stat, fileid, kind in
2401
2220
current_inv[1]]
2402
2221
yield (current_inv[0][0], current_inv[0][1]), dirblock
2409
2228
# merge the inventory and disk data together
2411
2230
for relpath, subiterator in itertools.groupby(sorted(
2412
current_inv[1] + cur_disk_dir_content,
2413
key=operator.itemgetter(0)), operator.itemgetter(1)):
2231
current_inv[1] + current_disk[1], key=operator.itemgetter(0)), operator.itemgetter(1)):
2414
2232
path_elements = list(subiterator)
2415
2233
if len(path_elements) == 2:
2416
2234
inv_row, disk_row = path_elements
2470
2288
# FIXME: stash the node in pending
2471
2289
entry = inv[top_id]
2472
if entry.kind == 'directory':
2473
for name, child in entry.sorted_children():
2474
dirblock.append((relroot + name, name, child.kind, None,
2475
child.file_id, child.kind
2290
for name, child in entry.sorted_children():
2291
dirblock.append((relroot + name, name, child.kind, None,
2292
child.file_id, child.kind
2477
2294
yield (currentdir[0], entry.file_id), dirblock
2478
2295
# push the user specified dirs from dirblock
2479
2296
for dir in reversed(dirblock):
2541
def _get_rules_searcher(self, default_searcher):
2542
"""See Tree._get_rules_searcher."""
2543
if self._rules_searcher is None:
2544
self._rules_searcher = super(WorkingTree,
2545
self)._get_rules_searcher(default_searcher)
2546
return self._rules_searcher
2548
def get_shelf_manager(self):
2549
"""Return the ShelfManager for this WorkingTree."""
2550
from bzrlib.shelf import ShelfManager
2551
return ShelfManager(self, self._transport)
2554
2344
class WorkingTree2(WorkingTree):
2555
2345
"""This is the Format 2 working tree.
2557
This was the first weave based working tree.
2347
This was the first weave based working tree.
2558
2348
- uses os locks for locking.
2559
2349
- uses the branch last-revision.
2615
2402
def _last_revision(self):
2616
2403
"""See Mutable.last_revision."""
2618
return self._transport.get_bytes('last-revision')
2405
return osutils.safe_revision_id(
2406
self._control_files.get('last-revision').read())
2619
2407
except errors.NoSuchFile:
2620
return _mod_revision.NULL_REVISION
2622
2410
def _change_last_revision(self, revision_id):
2623
2411
"""See WorkingTree._change_last_revision."""
2624
2412
if revision_id is None or revision_id == NULL_REVISION:
2626
self._transport.delete('last-revision')
2414
self._control_files._transport.delete('last-revision')
2627
2415
except errors.NoSuchFile:
2631
self._transport.put_bytes('last-revision', revision_id,
2632
mode=self.bzrdir._get_file_mode())
2419
self._control_files.put_bytes('last-revision', revision_id)
2635
2422
@needs_tree_write_lock
2636
2423
def set_conflicts(self, conflicts):
2637
self._put_rio('conflicts', conflicts.to_stanzas(),
2424
self._put_rio('conflicts', conflicts.to_stanzas(),
2638
2425
CONFLICT_HEADER_1)
2640
2427
@needs_tree_write_lock
2647
2434
@needs_read_lock
2648
2435
def conflicts(self):
2650
confile = self._transport.get('conflicts')
2437
confile = self._control_files.get('conflicts')
2651
2438
except errors.NoSuchFile:
2652
2439
return _mod_conflicts.ConflictList()
2655
if confile.next() != CONFLICT_HEADER_1 + '\n':
2656
raise errors.ConflictFormatError()
2657
except StopIteration:
2441
if confile.next() != CONFLICT_HEADER_1 + '\n':
2658
2442
raise errors.ConflictFormatError()
2659
return _mod_conflicts.ConflictList.from_stanzas(RioReader(confile))
2443
except StopIteration:
2444
raise errors.ConflictFormatError()
2445
return _mod_conflicts.ConflictList.from_stanzas(RioReader(confile))
2663
2447
def unlock(self):
2664
# do non-implementation specific cleanup
2666
2448
if self._control_files._lock_count == 1:
2667
2449
# _inventory_is_modified is always False during a read lock.
2668
2450
if self._inventory_is_modified:
2681
2463
return path[:-len(suffix)]
2466
@deprecated_function(zero_eight)
2467
def is_control_file(filename):
2468
"""See WorkingTree.is_control_filename(filename)."""
2469
## FIXME: better check
2470
filename = normpath(filename)
2471
while filename != '':
2472
head, tail = os.path.split(filename)
2473
## mutter('check %r for control file' % ((head, tail),))
2476
if filename == head:
2684
2482
class WorkingTreeFormat(object):
2685
2483
"""An encapsulation of the initialization and open routines for a format.
2689
2487
* a format string,
2690
2488
* an open routine.
2692
Formats are placed in an dict by their format string for reference
2490
Formats are placed in an dict by their format string for reference
2693
2491
during workingtree opening. Its not required that these be instances, they
2694
can be classes themselves with class methods - it simply depends on
2492
can be classes themselves with class methods - it simply depends on
2695
2493
whether state is needed for a given format or not.
2697
2495
Once a format is deprecated, just deprecate the initialize and open
2698
methods on the format class. Do not deprecate the object, as the
2496
methods on the format class. Do not deprecate the object, as the
2699
2497
object will be created every time regardless.
2745
2542
"""Is this format supported?
2747
2544
Supported formats can be initialized and opened.
2748
Unsupported formats may not support initialization or committing or
2545
Unsupported formats may not support initialization or committing or
2749
2546
some other features depending on the reason for not being supported.
2753
def supports_content_filtering(self):
2754
"""True if this format supports content filtering."""
2757
def supports_views(self):
2758
"""True if this format supports stored views."""
2762
2551
def register_format(klass, format):
2763
2552
klass._formats[format.get_format_string()] = format
2783
2573
"""See WorkingTreeFormat.get_format_description()."""
2784
2574
return "Working tree format 2"
2786
def _stub_initialize_on_transport(self, transport, file_mode):
2787
"""Workaround: create control files for a remote working tree.
2576
def stub_initialize_remote(self, control_files):
2577
"""As a special workaround create critical control files for a remote working tree
2789
2579
This ensures that it can later be updated and dealt with locally,
2790
since BzrDirFormat6 and BzrDirFormat5 cannot represent dirs with
2580
since BzrDirFormat6 and BzrDirFormat5 cannot represent dirs with
2791
2581
no working tree. (See bug #43064).
2793
2583
sio = StringIO()
2794
2584
inv = Inventory()
2795
xml5.serializer_v5.write_inventory(inv, sio, working=True)
2585
xml5.serializer_v5.write_inventory(inv, sio)
2797
transport.put_file('inventory', sio, file_mode)
2798
transport.put_bytes('pending-merges', '', file_mode)
2800
def initialize(self, a_bzrdir, revision_id=None, from_branch=None,
2801
accelerator_tree=None, hardlink=False):
2587
control_files.put('inventory', sio)
2589
control_files.put_bytes('pending-merges', '')
2592
def initialize(self, a_bzrdir, revision_id=None):
2802
2593
"""See WorkingTreeFormat.initialize()."""
2803
2594
if not isinstance(a_bzrdir.transport, LocalTransport):
2804
2595
raise errors.NotLocalUrl(a_bzrdir.transport.base)
2805
if from_branch is not None:
2806
branch = from_branch
2808
branch = a_bzrdir.open_branch()
2809
if revision_id is None:
2810
revision_id = _mod_revision.ensure_null(branch.last_revision())
2813
branch.generate_revision_history(revision_id)
2596
branch = a_bzrdir.open_branch()
2597
if revision_id is not None:
2598
revision_id = osutils.safe_revision_id(revision_id)
2601
revision_history = branch.revision_history()
2603
position = revision_history.index(revision_id)
2605
raise errors.NoSuchRevision(branch, revision_id)
2606
branch.set_revision_history(revision_history[:position + 1])
2609
revision = branch.last_revision()
2816
2610
inv = Inventory()
2817
2611
wt = WorkingTree2(a_bzrdir.root_transport.local_abspath('.'),
2820
2614
_internal=True,
2822
2616
_bzrdir=a_bzrdir)
2823
basis_tree = branch.repository.revision_tree(revision_id)
2617
basis_tree = branch.repository.revision_tree(revision)
2824
2618
if basis_tree.inventory.root is not None:
2825
wt.set_root_id(basis_tree.get_root_id())
2619
wt.set_root_id(basis_tree.inventory.root.file_id)
2826
2620
# set the parent list and cache the basis tree.
2827
if _mod_revision.is_null(revision_id):
2830
parent_trees = [(revision_id, basis_tree)]
2831
wt.set_parent_trees(parent_trees)
2621
wt.set_parent_trees([(revision, basis_tree)])
2832
2622
transform.build_tree(basis_tree, wt)
2888
2678
def _open_control_files(self, a_bzrdir):
2889
2679
transport = a_bzrdir.get_workingtree_transport(None)
2890
return LockableFiles(transport, self._lock_file_name,
2680
return LockableFiles(transport, self._lock_file_name,
2891
2681
self._lock_class)
2893
def initialize(self, a_bzrdir, revision_id=None, from_branch=None,
2894
accelerator_tree=None, hardlink=False):
2683
def initialize(self, a_bzrdir, revision_id=None):
2895
2684
"""See WorkingTreeFormat.initialize().
2897
:param revision_id: if supplied, create a working tree at a different
2898
revision than the branch is at.
2899
:param accelerator_tree: A tree which can be used for retrieving file
2900
contents more quickly than the revision tree, i.e. a workingtree.
2901
The revision tree will be used for cases where accelerator_tree's
2902
content is different.
2903
:param hardlink: If true, hard-link files from accelerator_tree,
2686
revision_id allows creating a working tree at a different
2687
revision than the branch is at.
2906
2689
if not isinstance(a_bzrdir.transport, LocalTransport):
2907
2690
raise errors.NotLocalUrl(a_bzrdir.transport.base)
2909
2692
control_files = self._open_control_files(a_bzrdir)
2910
2693
control_files.create_lock()
2911
2694
control_files.lock_write()
2912
transport.put_bytes('format', self.get_format_string(),
2913
mode=a_bzrdir._get_file_mode())
2914
if from_branch is not None:
2915
branch = from_branch
2695
control_files.put_utf8('format', self.get_format_string())
2696
branch = a_bzrdir.open_branch()
2697
if revision_id is None:
2698
revision_id = branch.last_revision()
2917
branch = a_bzrdir.open_branch()
2918
if revision_id is None:
2919
revision_id = _mod_revision.ensure_null(branch.last_revision())
2700
revision_id = osutils.safe_revision_id(revision_id)
2920
2701
# WorkingTree3 can handle an inventory which has a unique root id.
2921
2702
# as of bzr 0.12. However, bzr 0.11 and earlier fail to handle
2922
2703
# those trees. And because there isn't a format bump inbetween, we
added
removed
bzrlib/workingtree.py
