29
29
WorkingTree.open(dir).
32
# TODO: Give the workingtree sole responsibility for the working inventory;
33
# remove the variable and references to it from the branch. This may require
34
# updating the commit code so as to update the inventory within the working
35
# copy, and making sure there's only one WorkingTree for any directory on disk.
36
# At the moment they may alias the inventory and have old copies of it in
37
# memory. (Now done? -- mbp 20060309)
33
39
from cStringIO import StringIO
78
90
from bzrlib import symbol_versioning
79
91
from bzrlib.decorators import needs_read_lock, needs_write_lock
80
from bzrlib.lock import LogicalLockResult
92
from bzrlib.inventory import InventoryEntry, Inventory, ROOT_ID, TreeReference
81
93
from bzrlib.lockable_files import LockableFiles
82
94
from bzrlib.lockdir import LockDir
83
95
import bzrlib.mutabletree
84
96
from bzrlib.mutabletree import needs_tree_write_lock
85
97
from bzrlib import osutils
86
98
from bzrlib.osutils import (
96
110
from bzrlib.filters import filtered_input_file
97
111
from bzrlib.trace import mutter, note
98
112
from bzrlib.transport.local import LocalTransport
99
from bzrlib.revision import CURRENT_REVISION
113
from bzrlib.progress import DummyProgress, ProgressPhase
114
from bzrlib.revision import NULL_REVISION, CURRENT_REVISION
100
115
from bzrlib.rio import RioReader, rio_file, Stanza
101
from bzrlib.symbol_versioning import (
103
DEPRECATED_PARAMETER,
116
from bzrlib.symbol_versioning import (deprecated_passed,
119
DEPRECATED_PARAMETER,
107
123
MERGE_MODIFIED_HEADER_1 = "BZR merge-modified list format 1"
108
# TODO: Modifying the conflict objects or their type is currently nearly
109
# impossible as there is no clear relationship between the working tree format
110
# and the conflict list file format.
111
124
CONFLICT_HEADER_1 = "BZR conflict list format 1"
113
126
ERROR_PATH_NOT_FOUND = 3 # WindowsError errno code, equivalent to ENOENT
289
290
self._control_files.break_lock()
290
291
self.branch.break_lock()
292
def _get_check_refs(self):
293
"""Return the references needed to perform a check of this tree.
295
The default implementation returns no refs, and is only suitable for
296
trees that have no local caching and can commit on ghosts at any time.
298
:seealso: bzrlib.check for details about check_refs.
302
293
def requires_rich_root(self):
303
294
return self._format.requires_rich_root
351
342
path = osutils.getcwd()
352
343
control, relpath = bzrdir.BzrDir.open_containing(path)
353
345
return control.open_workingtree(), relpath
356
def open_containing_paths(file_list, default_directory='.',
357
canonicalize=True, apply_view=True):
358
"""Open the WorkingTree that contains a set of paths.
360
Fail if the paths given are not all in a single tree.
362
This is used for the many command-line interfaces that take a list of
363
any number of files and that require they all be in the same tree.
365
# recommended replacement for builtins.internal_tree_files
366
if file_list is None or len(file_list) == 0:
367
tree = WorkingTree.open_containing(default_directory)[0]
368
# XXX: doesn't really belong here, and seems to have the strange
369
# side effect of making it return a bunch of files, not the whole
370
# tree -- mbp 20100716
371
if tree.supports_views() and apply_view:
372
view_files = tree.views.lookup_view()
374
file_list = view_files
375
view_str = views.view_display_str(view_files)
376
note("Ignoring files outside view. View is %s" % view_str)
377
return tree, file_list
378
tree = WorkingTree.open_containing(file_list[0])[0]
379
return tree, tree.safe_relpath_files(file_list, canonicalize,
380
apply_view=apply_view)
382
def safe_relpath_files(self, file_list, canonicalize=True, apply_view=True):
383
"""Convert file_list into a list of relpaths in tree.
385
:param self: A tree to operate on.
386
:param file_list: A list of user provided paths or None.
387
:param apply_view: if True and a view is set, apply it or check that
388
specified files are within it
389
:return: A list of relative paths.
390
:raises errors.PathNotChild: When a provided path is in a different self
393
if file_list is None:
395
if self.supports_views() and apply_view:
396
view_files = self.views.lookup_view()
400
# self.relpath exists as a "thunk" to osutils, but canonical_relpath
401
# doesn't - fix that up here before we enter the loop.
403
fixer = lambda p: osutils.canonical_relpath(self.basedir, p)
406
for filename in file_list:
407
relpath = fixer(osutils.dereference_path(filename))
408
if view_files and not osutils.is_inside_any(view_files, relpath):
409
raise errors.FileOutsideView(filename, view_files)
410
new_list.append(relpath)
414
348
def open_downlevel(path=None):
415
349
"""Open an unsupported working tree.
429
363
return True, None
431
365
return True, tree
432
t = transport.get_transport(location)
433
iterator = bzrdir.BzrDir.find_bzrdirs(t, evaluate=evaluate,
366
transport = get_transport(location)
367
iterator = bzrdir.BzrDir.find_bzrdirs(transport, evaluate=evaluate,
434
368
list_current=list_current)
435
return [tr for tr in iterator if tr is not None]
369
return [t for t in iterator if t is not None]
437
371
# should be deprecated - this is slow and in any case treating them as a
438
372
# container is (we now know) bad style -- mbp 20070302
513
447
def get_file_with_stat(self, file_id, path=None, filtered=True,
514
448
_fstat=os.fstat):
515
"""See Tree.get_file_with_stat."""
449
"""See MutableTree.get_file_with_stat."""
517
451
path = self.id2path(file_id)
518
452
file_obj = self.get_file_byname(path, filtered=False)
519
453
stat_value = _fstat(file_obj.fileno())
520
if filtered and self.supports_content_filtering():
454
if self.supports_content_filtering() and filtered:
521
455
filters = self._content_filter_stack(path)
522
456
file_obj = filtered_input_file(file_obj, filters)
523
457
return (file_obj, stat_value)
525
459
def get_file_text(self, file_id, path=None, filtered=True):
526
my_file = self.get_file(file_id, path=path, filtered=filtered)
528
return my_file.read()
460
return self.get_file(file_id, path=path, filtered=filtered).read()
532
462
def get_file_byname(self, filename, filtered=True):
533
463
path = self.abspath(filename)
534
464
f = file(path, 'rb')
535
if filtered and self.supports_content_filtering():
465
if self.supports_content_filtering() and filtered:
536
466
filters = self._content_filter_stack(filename)
537
467
return filtered_input_file(f, filters)
557
487
incorrectly attributed to CURRENT_REVISION (but after committing, the
558
488
attribution will be correct).
560
maybe_file_parent_keys = []
561
for parent_id in self.get_parent_ids():
563
parent_tree = self.revision_tree(parent_id)
564
except errors.NoSuchRevisionInTree:
565
parent_tree = self.branch.repository.revision_tree(parent_id)
566
parent_tree.lock_read()
568
if file_id not in parent_tree:
570
ie = parent_tree.inventory[file_id]
571
if ie.kind != 'file':
572
# Note: this is slightly unnecessary, because symlinks and
573
# directories have a "text" which is the empty text, and we
574
# know that won't mess up annotations. But it seems cleaner
576
parent_text_key = (file_id, ie.revision)
577
if parent_text_key not in maybe_file_parent_keys:
578
maybe_file_parent_keys.append(parent_text_key)
581
graph = _mod_graph.Graph(self.branch.repository.texts)
582
heads = graph.heads(maybe_file_parent_keys)
583
file_parent_keys = []
584
for key in maybe_file_parent_keys:
586
file_parent_keys.append(key)
588
# Now we have the parents of this content
589
annotator = self.branch.repository.texts.get_annotator()
590
text = self.get_file_text(file_id)
591
this_key =(file_id, default_revision)
592
annotator.add_special_text(this_key, file_parent_keys, text)
593
annotations = [(key[-1], line)
594
for key, line in annotator.annotate_flat(this_key)]
490
basis = self.basis_tree()
493
changes = self.iter_changes(basis, True, [self.id2path(file_id)],
494
require_versioned=True).next()
495
changed_content, kind = changes[2], changes[6]
496
if not changed_content:
497
return basis.annotate_iter(file_id)
501
if kind[0] != 'file':
504
old_lines = list(basis.annotate_iter(file_id))
506
for tree in self.branch.repository.revision_trees(
507
self.get_parent_ids()[1:]):
508
if file_id not in tree:
510
old.append(list(tree.annotate_iter(file_id)))
511
return annotate.reannotate(old, self.get_file(file_id).readlines(),
597
516
def _get_ancestors(self, default_revision):
598
517
ancestors = set([default_revision])
706
623
def _is_executable_from_path_and_stat_from_basis(self, path, stat_result):
707
624
file_id = self.path2id(path)
709
# For unversioned files on win32, we just assume they are not
712
625
return self._inventory[file_id].executable
714
627
def _is_executable_from_path_and_stat_from_stat(self, path, stat_result):
825
738
kind = _mapper(stat_result.st_mode)
826
739
if kind == 'file':
827
return self._file_content_summary(path, stat_result)
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(
828
745
elif kind == 'directory':
829
746
# perhaps it looks like a plain directory, but it's really a
832
749
kind = 'tree-reference'
833
750
return kind, None, None, None
834
751
elif kind == 'symlink':
835
target = osutils.readlink(abspath)
836
return ('symlink', None, None, target)
752
return ('symlink', None, None,
753
os.readlink(abspath.encode(osutils._fs_enc)
754
).decode(osutils._fs_enc))
838
756
return (kind, None, None, None)
840
def _file_content_summary(self, path, stat_result):
841
size = stat_result.st_size
842
executable = self._is_executable_from_path_and_stat(path, stat_result)
843
# try for a stat cache lookup
844
return ('file', size, executable, self._sha_from_stat(
847
758
def _check_parents_for_ghosts(self, revision_ids, allow_leftmost_as_ghost):
848
759
"""Common ghost checking functionality from set_parent_*.
970
881
@needs_write_lock # because merge pulls data into the branch.
971
882
def merge_from_branch(self, branch, to_revision=None, from_revision=None,
972
merge_type=None, force=False):
973
884
"""Merge from a branch into this working tree.
975
886
:param branch: The branch to merge from.
979
890
branch.last_revision().
981
892
from bzrlib.merge import Merger, Merge3Merger
982
merger = Merger(self.branch, this_tree=self)
983
# check that there are no local alterations
984
if not force and self.has_changes():
985
raise errors.UncommittedChanges(self)
986
if to_revision is None:
987
to_revision = _mod_revision.ensure_null(branch.last_revision())
988
merger.other_rev_id = to_revision
989
if _mod_revision.is_null(merger.other_rev_id):
990
raise errors.NoCommits(branch)
991
self.branch.fetch(branch, last_revision=merger.other_rev_id)
992
merger.other_basis = merger.other_rev_id
993
merger.other_tree = self.branch.repository.revision_tree(
995
merger.other_branch = branch
996
if from_revision is None:
999
merger.set_base_revision(from_revision, branch)
1000
if merger.base_rev_id == merger.other_rev_id:
1001
raise errors.PointlessMerge
1002
merger.backup_files = False
1003
if merge_type is None:
1004
merger.merge_type = Merge3Merger
1006
merger.merge_type = merge_type
1007
merger.set_interesting_files(None)
1008
merger.show_base = False
1009
merger.reprocess = False
1010
conflicts = merger.do_merge()
1011
merger.set_pending()
893
pb = bzrlib.ui.ui_factory.nested_progress_bar()
895
merger = Merger(self.branch, this_tree=self, pb=pb)
896
merger.pp = ProgressPhase("Merge phase", 5, pb)
897
merger.pp.next_phase()
898
# check that there are no
900
merger.check_basis(check_clean=True, require_commits=False)
901
if to_revision is None:
902
to_revision = _mod_revision.ensure_null(branch.last_revision())
903
merger.other_rev_id = to_revision
904
if _mod_revision.is_null(merger.other_rev_id):
905
raise errors.NoCommits(branch)
906
self.branch.fetch(branch, last_revision=merger.other_rev_id)
907
merger.other_basis = merger.other_rev_id
908
merger.other_tree = self.branch.repository.revision_tree(
910
merger.other_branch = branch
911
merger.pp.next_phase()
912
if from_revision is None:
915
merger.set_base_revision(from_revision, branch)
916
if merger.base_rev_id == merger.other_rev_id:
917
raise errors.PointlessMerge
918
merger.backup_files = False
919
if merge_type is None:
920
merger.merge_type = Merge3Merger
922
merger.merge_type = merge_type
923
merger.set_interesting_files(None)
924
merger.show_base = False
925
merger.reprocess = False
926
conflicts = merger.do_merge()
1012
930
return conflicts
1014
932
@needs_read_lock
1161
1078
tree_transport = self.bzrdir.root_transport.clone(sub_path)
1162
1079
if tree_transport.base != branch_transport.base:
1163
1080
tree_bzrdir = format.initialize_on_transport(tree_transport)
1164
branch.BranchReferenceFormat().initialize(tree_bzrdir,
1165
target_branch=new_branch)
1081
branch.BranchReferenceFormat().initialize(tree_bzrdir, new_branch)
1167
1083
tree_bzrdir = branch_bzrdir
1168
wt = tree_bzrdir.create_workingtree(_mod_revision.NULL_REVISION)
1084
wt = tree_bzrdir.create_workingtree(NULL_REVISION)
1169
1085
wt.set_parent_ids(self.get_parent_ids())
1170
1086
my_inv = self.inventory
1171
child_inv = inventory.Inventory(root_id=None)
1087
child_inv = Inventory(root_id=None)
1172
1088
new_root = my_inv[file_id]
1173
1089
my_inv.remove_recursive_id(file_id)
1174
1090
new_root.parent_id = None
1199
1115
def _kind(self, relpath):
1200
1116
return osutils.file_kind(self.abspath(relpath))
1202
def list_files(self, include_root=False, from_dir=None, recursive=True):
1203
"""List all files as (path, class, kind, id, entry).
1118
def list_files(self, include_root=False):
1119
"""Recursively list all files as (path, class, kind, id, entry).
1205
1121
Lists, but does not descend into unversioned directories.
1206
1123
This does not include files that have been deleted in this
1207
tree. Skips the control directory.
1209
:param include_root: if True, return an entry for the root
1210
:param from_dir: start from this directory or None for the root
1211
:param recursive: whether to recurse into subdirectories or not
1126
Skips the control directory.
1213
1128
# list_files is an iterator, so @needs_read_lock doesn't work properly
1214
1129
# with it. So callers should be careful to always read_lock the tree.
1229
1144
fk_entries = {'directory':TreeDirectory, 'file':TreeFile, 'symlink':TreeLink}
1231
1146
# directory file_id, relative path, absolute path, reverse sorted children
1232
if from_dir is not None:
1233
from_dir_id = inv.path2id(from_dir)
1234
if from_dir_id is None:
1235
# Directory not versioned
1237
from_dir_abspath = pathjoin(self.basedir, from_dir)
1239
from_dir_id = inv.root.file_id
1240
from_dir_abspath = self.basedir
1241
children = os.listdir(from_dir_abspath)
1147
children = os.listdir(self.basedir)
1242
1148
children.sort()
1243
1149
# jam 20060527 The kernel sized tree seems equivalent whether we
1244
1150
# use a deque and popleft to keep them sorted, or if we use a plain
1245
1151
# list and just reverse() them.
1246
1152
children = collections.deque(children)
1247
stack = [(from_dir_id, u'', from_dir_abspath, children)]
1153
stack = [(inv.root.file_id, u'', self.basedir, children)]
1249
1155
from_dir_id, from_dir_relpath, from_dir_abspath, children = stack[-1]
1267
1173
# absolute path
1268
1174
fap = from_dir_abspath + '/' + f
1270
dir_ie = inv[from_dir_id]
1271
if dir_ie.kind == 'directory':
1272
f_ie = dir_ie.children.get(f)
1176
f_ie = inv.get_child(from_dir_id, f)
1277
1179
elif self.is_ignored(fp[1:]):
1280
# we may not have found this file, because of a unicode
1281
# issue, or because the directory was actually a symlink.
1182
# we may not have found this file, because of a unicode issue
1282
1183
f_norm, can_access = osutils.normalized_filename(f)
1283
1184
if f == f_norm or not can_access:
1284
1185
# No change, so treat this file normally
1313
1214
if fk != 'directory':
1316
# But do this child first if recursing down
1318
new_children = os.listdir(fap)
1320
new_children = collections.deque(new_children)
1321
stack.append((f_ie.file_id, fp, fap, new_children))
1322
# Break out of inner loop,
1323
# so that we start outer loop with child
1217
# But do this child first
1218
new_children = os.listdir(fap)
1220
new_children = collections.deque(new_children)
1221
stack.append((f_ie.file_id, fp, fap, new_children))
1222
# Break out of inner loop,
1223
# so that we start outer loop with child
1326
1226
# if we finished all children, pop it off the stack
1329
1229
@needs_tree_write_lock
1330
def move(self, from_paths, to_dir=None, after=False):
1230
def move(self, from_paths, to_dir=None, after=False, **kwargs):
1331
1231
"""Rename files.
1333
1233
to_dir must exist in the inventory.
1368
1268
# check for deprecated use of signature
1369
1269
if to_dir is None:
1370
raise TypeError('You must supply a target directory')
1270
to_dir = kwargs.get('to_name', None)
1272
raise TypeError('You must supply a target directory')
1274
symbol_versioning.warn('The parameter to_name was deprecated'
1275
' in version 0.13. Use to_dir instead',
1371
1278
# check destination directory
1372
1279
if isinstance(from_paths, basestring):
1373
1280
raise ValueError()
1498
1405
inv = self.inventory
1499
1406
for entry in moved:
1501
self._move_entry(WorkingTree._RenameEntry(
1502
entry.to_rel, entry.from_id,
1408
self._move_entry(_RenameEntry(entry.to_rel, entry.from_id,
1503
1409
entry.to_tail, entry.to_parent_id, entry.from_rel,
1504
1410
entry.from_tail, entry.from_parent_id,
1505
1411
entry.only_change_inv))
1556
1462
from_tail = splitpath(from_rel)[-1]
1557
1463
from_id = inv.path2id(from_rel)
1558
1464
if from_id is None:
1559
# if file is missing in the inventory maybe it's in the basis_tree
1560
basis_tree = self.branch.basis_tree()
1561
from_id = basis_tree.path2id(from_rel)
1563
raise errors.BzrRenameFailedError(from_rel,to_rel,
1564
errors.NotVersionedError(path=str(from_rel)))
1565
# put entry back in the inventory so we can rename it
1566
from_entry = basis_tree.inventory[from_id].copy()
1569
from_entry = inv[from_id]
1465
raise errors.BzrRenameFailedError(from_rel,to_rel,
1466
errors.NotVersionedError(path=str(from_rel)))
1467
from_entry = inv[from_id]
1570
1468
from_parent_id = from_entry.parent_id
1571
1469
to_dir, to_tail = os.path.split(to_rel)
1572
1470
to_dir_id = inv.path2id(to_dir)
1664
1562
@needs_write_lock
1665
1563
def pull(self, source, overwrite=False, stop_revision=None,
1666
change_reporter=None, possible_transports=None, local=False):
1564
change_reporter=None, possible_transports=None):
1565
top_pb = bzrlib.ui.ui_factory.nested_progress_bar()
1667
1566
source.lock_read()
1568
pp = ProgressPhase("Pull phase", 2, top_pb)
1669
1570
old_revision_info = self.branch.last_revision_info()
1670
1571
basis_tree = self.basis_tree()
1671
1572
count = self.branch.pull(source, overwrite, stop_revision,
1672
possible_transports=possible_transports,
1573
possible_transports=possible_transports)
1674
1574
new_revision_info = self.branch.last_revision_info()
1675
1575
if new_revision_info != old_revision_info:
1676
1577
repository = self.branch.repository
1578
pb = bzrlib.ui.ui_factory.nested_progress_bar()
1677
1579
basis_tree.lock_read()
1679
1581
new_basis_tree = self.branch.basis_tree()
1682
1584
new_basis_tree,
1684
1586
this_tree=self,
1686
1588
change_reporter=change_reporter)
1687
basis_root_id = basis_tree.get_root_id()
1688
new_root_id = new_basis_tree.get_root_id()
1689
if basis_root_id != new_root_id:
1690
self.set_root_id(new_root_id)
1589
if (basis_tree.inventory.root is None and
1590
new_basis_tree.inventory.root is not None):
1591
self.set_root_id(new_basis_tree.get_root_id())
1692
1594
basis_tree.unlock()
1693
1595
# TODO - dedup parents list with things merged by pull ?
1694
1596
# reuse the revisiontree we merged against to set the new
1797
1700
r"""Check whether the filename matches an ignore pattern.
1799
1702
Patterns containing '/' or '\' need to match the whole path;
1800
others match against only the last component. Patterns starting
1801
with '!' are ignore exceptions. Exceptions take precedence
1802
over regular patterns and cause the filename to not be ignored.
1703
others match against only the last component.
1804
1705
If the file is ignored, returns the pattern which caused it to
1805
1706
be ignored, otherwise None. So this can simply be used as a
1806
1707
boolean if desired."""
1807
1708
if getattr(self, '_ignoreglobster', None) is None:
1808
self._ignoreglobster = globbing.ExceptionGlobster(self.get_ignore_list())
1709
self._ignoreglobster = globbing.Globster(self.get_ignore_list())
1809
1710
return self._ignoreglobster.match(filename)
1811
1712
def kind(self, file_id):
1861
1762
raise errors.ObjectNotLocked(self)
1863
1764
def lock_read(self):
1864
"""Lock the tree for reading.
1866
This also locks the branch, and can be unlocked via self.unlock().
1868
:return: A bzrlib.lock.LogicalLockResult.
1765
"""See Branch.lock_read, and WorkingTree.unlock."""
1870
1766
if not self.is_locked():
1871
1767
self._reset_data()
1872
1768
self.branch.lock_read()
1874
self._control_files.lock_read()
1875
return LogicalLockResult(self.unlock)
1770
return self._control_files.lock_read()
1877
1772
self.branch.unlock()
1880
1775
def lock_tree_write(self):
1881
"""See MutableTree.lock_tree_write, and WorkingTree.unlock.
1883
:return: A bzrlib.lock.LogicalLockResult.
1776
"""See MutableTree.lock_tree_write, and WorkingTree.unlock."""
1885
1777
if not self.is_locked():
1886
1778
self._reset_data()
1887
1779
self.branch.lock_read()
1889
self._control_files.lock_write()
1890
return LogicalLockResult(self.unlock)
1781
return self._control_files.lock_write()
1892
1783
self.branch.unlock()
1895
1786
def lock_write(self):
1896
"""See MutableTree.lock_write, and WorkingTree.unlock.
1898
:return: A bzrlib.lock.LogicalLockResult.
1787
"""See MutableTree.lock_write, and WorkingTree.unlock."""
1900
1788
if not self.is_locked():
1901
1789
self._reset_data()
1902
1790
self.branch.lock_write()
1904
self._control_files.lock_write()
1905
return LogicalLockResult(self.unlock)
1792
return self._control_files.lock_write()
1907
1794
self.branch.unlock()
1973
1856
# revision_id is set. We must check for this full string, because a
1974
1857
# root node id can legitimately look like 'revision_id' but cannot
1975
1858
# contain a '"'.
1976
xml = self.branch.repository._get_inventory_xml(new_revision)
1859
xml = self.branch.repository.get_inventory_xml(new_revision)
1977
1860
firstline = xml.split('\n', 1)[0]
1978
1861
if (not 'revision_id="' in firstline or
1979
1862
'format="7"' not in firstline):
1980
inv = self.branch.repository._serializer.read_inventory_from_string(
1863
inv = self.branch.repository.deserialise_inventory(
1982
1865
xml = self._create_basis_xml_from_inventory(new_revision, inv)
1983
1866
self._write_basis_inventory(xml)
1984
1867
except (errors.NoSuchRevision, errors.RevisionNotPresent):
2028
all_files = set() # specified and nested files
2029
1908
unknown_nested_files=set()
2031
to_file = sys.stdout
2033
files_to_backup = []
2035
1910
def recurse_directory_to_add_files(directory):
2036
1911
# Recurse directory and add all files
2037
1912
# so we can check if they have changed.
2038
for parent_info, file_infos in self.walkdirs(directory):
1913
for parent_info, file_infos in\
1914
self.walkdirs(directory):
2039
1915
for relpath, basename, kind, lstat, fileid, kind in file_infos:
2040
1916
# Is it versioned or ignored?
2041
if self.path2id(relpath):
1917
if self.path2id(relpath) or self.is_ignored(relpath):
2042
1918
# Add nested content for deletion.
2043
all_files.add(relpath)
1919
new_files.add(relpath)
2045
# Files which are not versioned
1921
# Files which are not versioned and not ignored
2046
1922
# should be treated as unknown.
2047
files_to_backup.append(relpath)
1923
unknown_nested_files.add((relpath, None, kind))
2049
1925
for filename in files:
2050
1926
# Get file name into canonical form.
2051
1927
abspath = self.abspath(filename)
2052
1928
filename = self.relpath(abspath)
2053
1929
if len(filename) > 0:
2054
all_files.add(filename)
1930
new_files.add(filename)
2055
1931
recurse_directory_to_add_files(filename)
2057
files = list(all_files)
1933
files = list(new_files)
2059
1935
if len(files) == 0:
2060
1936
return # nothing to do
2065
1941
# Bail out if we are going to delete files we shouldn't
2066
1942
if not keep_files and not force:
2067
for (file_id, path, content_change, versioned, parent_id, name,
2068
kind, executable) in self.iter_changes(self.basis_tree(),
2069
include_unchanged=True, require_versioned=False,
2070
want_unversioned=True, specific_files=files):
2071
if versioned[0] == False:
2072
# The record is unknown or newly added
2073
files_to_backup.append(path[1])
2074
elif (content_change and (kind[1] is not None) and
2075
osutils.is_inside_any(files, path[1])):
2076
# Versioned and changed, but not deleted, and still
2077
# in one of the dirs to be deleted.
2078
files_to_backup.append(path[1])
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
2080
def backup(file_to_backup):
2081
backup_name = self.bzrdir.generate_backup_name(file_to_backup)
2082
osutils.rename(abs_path, self.abspath(backup_name))
2083
return "removed %s (but kept a copy: %s)" % (file_to_backup, backup_name)
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,))
1968
raise errors.BzrRemoveChangedFilesError(tree_delta)
2085
1970
# Build inv_delta and delete files where applicable,
2086
1971
# do this before any modifications to inventory.
2096
1981
new_status = 'I'
2098
1983
new_status = '?'
2099
# XXX: Really should be a more abstract reporter interface
2100
kind_ch = osutils.kind_marker(self.kind(fid))
2101
to_file.write(new_status + ' ' + f + kind_ch + '\n')
1984
textui.show_status(new_status, self.kind(fid), f,
2102
1986
# Unversion file
2103
1987
inv_delta.append((f, None, fid, None))
2104
1988
message = "removed %s" % (f,)
2110
1994
len(os.listdir(abs_path)) > 0):
2112
1996
osutils.rmtree(abs_path)
2113
message = "deleted %s" % (f,)
1998
message = "%s is not an empty directory "\
1999
"and won't be deleted." % (f,)
2117
if f in files_to_backup:
2120
osutils.delete_any(abs_path)
2121
message = "deleted %s" % (f,)
2001
osutils.delete_any(abs_path)
2002
message = "deleted %s" % (f,)
2122
2003
elif message is not None:
2123
2004
# Only care if we haven't done anything yet.
2124
2005
message = "%s does not exist." % (f,)
2259
2141
raise NotImplementedError(self.unlock)
2263
def update(self, change_reporter=None, possible_transports=None,
2264
revision=None, old_tip=_marker):
2143
def update(self, change_reporter=None, possible_transports=None):
2265
2144
"""Update a working tree along its branch.
2267
2146
This will update the branch if its bound too, which means we have
2285
2164
- Merge current state -> basis tree of the master w.r.t. the old tree
2287
2166
- Do a 'normal' merge of the old branch basis if it is relevant.
2289
:param revision: The target revision to update to. Must be in the
2291
:param old_tip: If branch.update() has already been run, the value it
2292
returned (old tip of the branch or None). _marker is used
2295
2168
if self.branch.get_bound_location() is not None:
2296
2169
self.lock_write()
2297
update_branch = (old_tip is self._marker)
2170
update_branch = True
2299
2172
self.lock_tree_write()
2300
2173
update_branch = False
2302
2175
if update_branch:
2303
2176
old_tip = self.branch.update(possible_transports)
2305
if old_tip is self._marker:
2307
return self._update_tree(old_tip, change_reporter, revision)
2179
return self._update_tree(old_tip, change_reporter)
2311
2183
@needs_tree_write_lock
2312
def _update_tree(self, old_tip=None, change_reporter=None, revision=None):
2184
def _update_tree(self, old_tip=None, change_reporter=None):
2313
2185
"""Update a tree to the master branch.
2315
2187
:param old_tip: if supplied, the previous tip revision the branch,
2325
2197
# We MUST save it even if an error occurs, because otherwise the users
2326
2198
# local work is unreferenced and will appear to have been lost.
2330
2202
last_rev = self.get_parent_ids()[0]
2331
2203
except IndexError:
2332
2204
last_rev = _mod_revision.NULL_REVISION
2333
if revision is None:
2334
revision = self.branch.last_revision()
2336
old_tip = old_tip or _mod_revision.NULL_REVISION
2338
if not _mod_revision.is_null(old_tip) and old_tip != last_rev:
2339
# the branch we are bound to was updated
2340
# merge those changes in first
2341
base_tree = self.basis_tree()
2342
other_tree = self.branch.repository.revision_tree(old_tip)
2343
nb_conflicts = merge.merge_inner(self.branch, other_tree,
2344
base_tree, this_tree=self,
2345
change_reporter=change_reporter)
2347
self.add_parent_tree((old_tip, other_tree))
2348
trace.note('Rerun update after fixing the conflicts.')
2351
if last_rev != _mod_revision.ensure_null(revision):
2352
# the working tree is up to date with the branch
2353
# we can merge the specified revision from master
2354
to_tree = self.branch.repository.revision_tree(revision)
2355
to_root_id = to_tree.get_root_id()
2205
if last_rev != _mod_revision.ensure_null(self.branch.last_revision()):
2206
# merge tree state up to new branch tip.
2357
2207
basis = self.basis_tree()
2358
2208
basis.lock_read()
2360
if (basis.inventory.root is None
2361
or basis.inventory.root.file_id != to_root_id):
2362
self.set_root_id(to_root_id)
2210
to_tree = self.branch.basis_tree()
2211
if basis.inventory.root is None:
2212
self.set_root_id(to_tree.get_root_id())
2214
result += merge.merge_inner(
2219
change_reporter=change_reporter)
2367
# determine the branch point
2368
graph = self.branch.repository.get_graph()
2369
base_rev_id = graph.find_unique_lca(self.branch.last_revision(),
2371
base_tree = self.branch.repository.revision_tree(base_rev_id)
2373
nb_conflicts = merge.merge_inner(self.branch, to_tree, base_tree,
2375
change_reporter=change_reporter)
2376
self.set_last_revision(revision)
2377
2222
# TODO - dedup parents list with things merged by pull ?
2378
2223
# reuse the tree we've updated to to set the basis:
2379
parent_trees = [(revision, to_tree)]
2224
parent_trees = [(self.branch.last_revision(), to_tree)]
2380
2225
merges = self.get_parent_ids()[1:]
2381
2226
# Ideally we ask the tree for the trees here, that way the working
2382
2227
# tree can decide whether to give us the entire tree or give us a
2386
2231
for parent in merges:
2387
2232
parent_trees.append(
2388
2233
(parent, self.branch.repository.revision_tree(parent)))
2389
if not _mod_revision.is_null(old_tip):
2234
if (old_tip is not None and not _mod_revision.is_null(old_tip)):
2390
2235
parent_trees.append(
2391
2236
(old_tip, self.branch.repository.revision_tree(old_tip)))
2392
2237
self.set_parent_trees(parent_trees)
2393
2238
last_rev = parent_trees[0][0]
2240
# the working tree had the same last-revision as the master
2241
# branch did. We may still have pivot local work from the local
2242
# branch into old_tip:
2243
if (old_tip is not None and not _mod_revision.is_null(old_tip)):
2244
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):
2247
# our last revision was not the prior branch last revision
2248
# and we have converted that last revision to a pending merge.
2249
# base is somewhere between the branch tip now
2250
# and the now pending merge
2252
# Since we just modified the working tree and inventory, flush out
2253
# the current state, before we modify it again.
2254
# TODO: jam 20070214 WorkingTree3 doesn't require this, dirstate
2255
# requires it only because TreeTransform directly munges the
2256
# inventory and calls tree._write_inventory(). Ultimately we
2257
# should be able to remove this extra flush.
2259
graph = self.branch.repository.get_graph()
2260
base_rev_id = graph.find_unique_lca(self.branch.last_revision(),
2262
base_tree = self.branch.repository.revision_tree(base_rev_id)
2263
other_tree = self.branch.repository.revision_tree(old_tip)
2264
result += merge.merge_inner(
2269
change_reporter=change_reporter)
2396
2272
def _write_hashcache_if_dirty(self):
2397
2273
"""Write out the hashcache if it is dirty."""
2497
2373
bzrdir_loc = bisect_left(cur_disk_dir_content,
2498
2374
('.bzr', '.bzr'))
2499
2375
if (bzrdir_loc < len(cur_disk_dir_content)
2500
and self.bzrdir.is_control_filename(
2501
cur_disk_dir_content[bzrdir_loc][0])):
2376
and cur_disk_dir_content[bzrdir_loc][0] == '.bzr'):
2502
2377
# we dont yield the contents of, or, .bzr itself.
2503
2378
del cur_disk_dir_content[bzrdir_loc]
2504
2379
if inv_finished:
2638
2513
return un_resolved, resolved
2640
2515
@needs_read_lock
2641
def _check(self, references):
2642
"""Check the tree for consistency.
2644
:param references: A dict with keys matching the items returned by
2645
self._get_check_refs(), and values from looking those keys up in
2648
2517
tree_basis = self.basis_tree()
2649
2518
tree_basis.lock_read()
2651
repo_basis = references[('trees', self.last_revision())]
2520
repo_basis = self.branch.repository.revision_tree(
2521
self.last_revision())
2652
2522
if len(list(repo_basis.iter_changes(tree_basis))) > 0:
2653
2523
raise errors.BzrCheckError(
2654
2524
"Mismatched basis inventory content.")
2699
2570
if self._inventory is None:
2700
2571
self.read_working_inventory()
2702
def _get_check_refs(self):
2703
"""Return the references needed to perform a check of this tree."""
2704
return [('trees', self.last_revision())]
2706
2573
def lock_tree_write(self):
2707
2574
"""See WorkingTree.lock_tree_write().
2709
2576
In Format2 WorkingTrees we have a single lock for the branch and tree
2710
2577
so lock_tree_write() degrades to lock_write().
2712
:return: An object with an unlock method which will release the lock
2715
2579
self.branch.lock_write()
2717
self._control_files.lock_write()
2581
return self._control_files.lock_write()
2720
2583
self.branch.unlock()
2769
2632
mode=self.bzrdir._get_file_mode())
2772
def _get_check_refs(self):
2773
"""Return the references needed to perform a check of this tree."""
2774
return [('trees', self.last_revision())]
2776
2635
@needs_tree_write_lock
2777
2636
def set_conflicts(self, conflicts):
2778
2637
self._put_rio('conflicts', conflicts.to_stanzas(),
3125
2984
return self.get_format_string()
3128
__default_format = WorkingTreeFormat6()
2987
__default_format = WorkingTreeFormat4()
3129
2988
WorkingTreeFormat.register_format(__default_format)
2989
WorkingTreeFormat.register_format(WorkingTreeFormat6())
3130
2990
WorkingTreeFormat.register_format(WorkingTreeFormat5())
3131
WorkingTreeFormat.register_format(WorkingTreeFormat4())
3132
2991
WorkingTreeFormat.register_format(WorkingTreeFormat3())
3133
2992
WorkingTreeFormat.set_default_format(__default_format)
3134
2993
# formats which have no format string are not discoverable
added
removed
bzrlib/workingtree.py
