« back to all changes in this revision
Viewing changes to bzrlib/workingtree.py
- browse files at revision 2127.1.1
- compare with another revision
- download diff
- download tarball
- view history from revision 2127.1.1
- Committer: John Arbash Meinel
- Date: 2006-11-10 15:38:16 UTC
- mto: This revision was merged to the branch mainline in revision 2129.
- Revision ID: john@arbash-meinel.com-20061110153816-46acf76fc86a512b
use try/finally to clean up a nested progress bar during weave fetching
- files added:
- NEWS.developers
- files removed:
- bzrlib/api.py
- bzrlib/repofmt
- bzrlib/smart
- bzrlib/tests/per_lock
- doc/developers
- man1
- files renamed:
- doc/developers/HACKING => HACKING
- bzrlib/deprecated_graph.py => bzrlib/graph.py
- bzrlib/tests/test_commands.py => bzrlib/tests/test_command.py
- bzrlib/tests/test_deprecated_graph.py => bzrlib/tests/test_graph.py
- bzrlib/transport/remote.py => bzrlib/transport/smart.py
- bzrlib/win32utils.py => bzrlib/win32console.py
- files modified:
- .bzrignore
- setup.py *
added
removed
bzrlib/workingtree.py
1
# Copyright (C) 2005, 2006, 2007 Canonical Ltd
1
# Copyright (C) 2005, 2006 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
38
38
39
39
from cStringIO import StringIO
40
40
import os
41
import sys
41
import re
42
42
43
43
from bzrlib.lazy_import import lazy_import
44
44
lazy_import(globals(), """
45
from bisect import bisect_left
46
45
import collections
46
from copy import deepcopy
47
47
import errno
48
import itertools
49
import operator
48
import fnmatch
50
49
import stat
51
50
from time import time
52
51
import warnings
53
import re
54
52
55
53
import bzrlib
56
54
from bzrlib import (
57
branch,
58
55
bzrdir,
59
56
conflicts as _mod_conflicts,
60
dirstate,
61
57
errors,
62
generate_ids,
63
globbing,
64
hashcache,
65
58
ignores,
66
59
merge,
67
60
osutils,
68
revisiontree,
69
repository,
70
61
textui,
71
trace,
72
62
transform,
73
ui,
74
63
urlutils,
75
64
xml5,
76
65
xml6,
77
xml7,
78
66
)
79
67
import bzrlib.branch
80
68
from bzrlib.transport import get_transport
81
69
import bzrlib.ui
82
from bzrlib.workingtree_4 import WorkingTreeFormat4
83
70
""")
84
71
85
72
from bzrlib import symbol_versioning
86
73
from bzrlib.decorators import needs_read_lock, needs_write_lock
87
from bzrlib.inventory import InventoryEntry, Inventory, ROOT_ID, TreeReference
74
from bzrlib.errors import (BzrCheckError,
75
BzrError,
76
ConflictFormatError,
77
WeaveRevisionNotPresent,
78
NotBranchError,
79
NoSuchFile,
80
NotVersionedError,
81
MergeModifiedFormatError,
82
UnsupportedOperation,
83
)
84
from bzrlib.inventory import InventoryEntry, Inventory, ROOT_ID
88
85
from bzrlib.lockable_files import LockableFiles, TransportLock
89
86
from bzrlib.lockdir import LockDir
90
87
import bzrlib.mutabletree
93
90
compact_date,
94
91
file_kind,
95
92
isdir,
96
normpath,
97
93
pathjoin,
94
safe_unicode,
95
splitpath,
98
96
rand_chars,
97
normpath,
99
98
realpath,
100
safe_unicode,
101
splitpath,
102
99
supports_executable,
103
100
)
104
101
from bzrlib.trace import mutter, note
105
102
from bzrlib.transport.local import LocalTransport
103
import bzrlib.tree
106
104
from bzrlib.progress import DummyProgress, ProgressPhase
107
from bzrlib.revision import NULL_REVISION, CURRENT_REVISION
105
from bzrlib.revision import NULL_REVISION
106
import bzrlib.revisiontree
108
107
from bzrlib.rio import RioReader, rio_file, Stanza
109
108
from bzrlib.symbol_versioning import (deprecated_passed,
110
109
deprecated_method,
112
111
DEPRECATED_PARAMETER,
113
112
zero_eight,
114
113
zero_eleven,
115
zero_thirteen,
116
114
)
117
115
118
116
119
117
MERGE_MODIFIED_HEADER_1 = "BZR merge-modified list format 1"
120
118
CONFLICT_HEADER_1 = "BZR conflict list format 1"
121
119
122
ERROR_PATH_NOT_FOUND = 3 # WindowsError errno code, equivalent to ENOENT
123
124
125
@deprecated_function(zero_thirteen)
120
# the regex removes any weird characters; we don't escape them
121
# but rather just pull them out
122
_gen_file_id_re = re.compile(r'[^\w.]')
123
_gen_id_suffix = None
124
_gen_id_serial = 0
125
126
127
def _next_id_suffix():
128
"""Create a new file id suffix that is reasonably unique.
129
130
On the first call we combine the current time with 64 bits of randomness
131
to give a highly probably globally unique number. Then each call in the same
132
process adds 1 to a serial number we append to that unique value.
133
"""
134
# XXX TODO: change bzrlib.add.smart_add to call workingtree.add() rather
135
# than having to move the id randomness out of the inner loop like this.
136
# XXX TODO: for the global randomness this uses we should add the thread-id
137
# before the serial #.
138
global _gen_id_suffix, _gen_id_serial
139
if _gen_id_suffix is None:
140
_gen_id_suffix = "-%s-%s-" % (compact_date(time()), rand_chars(16))
141
_gen_id_serial += 1
142
return _gen_id_suffix + str(_gen_id_serial)
143
144
126
145
def gen_file_id(name):
127
146
"""Return new file id for the basename 'name'.
128
147
129
Use bzrlib.generate_ids.gen_file_id() instead
148
The uniqueness is supplied from _next_id_suffix.
130
149
"""
131
return generate_ids.gen_file_id(name)
132
133
134
@deprecated_function(zero_thirteen)
150
# The real randomness is in the _next_id_suffix, the
151
# rest of the identifier is just to be nice.
152
# So we:
153
# 1) Remove non-ascii word characters to keep the ids portable
154
# 2) squash to lowercase, so the file id doesn't have to
155
# be escaped (case insensitive filesystems would bork for ids
156
# that only differred in case without escaping).
157
# 3) truncate the filename to 20 chars. Long filenames also bork on some
158
# filesystems
159
# 4) Removing starting '.' characters to prevent the file ids from
160
# being considered hidden.
161
ascii_word_only = _gen_file_id_re.sub('', name.lower())
162
short_no_dots = ascii_word_only.lstrip('.')[:20]
163
return short_no_dots + _next_id_suffix()
164
165
135
166
def gen_root_id():
136
"""Return a new tree-root file id.
137
138
This has been deprecated in favor of bzrlib.generate_ids.gen_root_id()
139
"""
140
return generate_ids.gen_root_id()
167
"""Return a new tree-root file id."""
168
return gen_file_id('tree_root')
141
169
142
170
143
171
class TreeEntry(object):
212
240
_internal=False,
213
241
_format=None,
214
242
_bzrdir=None):
215
"""Construct a WorkingTree instance. This is not a public API.
243
"""Construct a WorkingTree for basedir.
216
244
217
:param branch: A branch to override probing for the branch.
245
If the branch is not supplied, it is opened automatically.
246
If the branch is supplied, it must be the branch for this basedir.
247
(branch.base is not cross checked, because for remote branches that
248
would be meaningless).
218
249
"""
219
250
self._format = _format
220
251
self.bzrdir = _bzrdir
221
252
if not _internal:
222
raise errors.BzrError("Please use bzrdir.open_workingtree or "
223
"WorkingTree.open() to obtain a WorkingTree.")
253
# not created via open etc.
254
warnings.warn("WorkingTree() is deprecated as of bzr version 0.8. "
255
"Please use bzrdir.open_workingtree or WorkingTree.open().",
256
DeprecationWarning,
257
stacklevel=2)
258
wt = WorkingTree.open(basedir)
259
self._branch = wt.branch
260
self.basedir = wt.basedir
261
self._control_files = wt._control_files
262
self._hashcache = wt._hashcache
263
self._set_inventory(wt._inventory, dirty=False)
264
self._format = wt._format
265
self.bzrdir = wt.bzrdir
266
from bzrlib.hashcache import HashCache
267
from bzrlib.trace import note, mutter
224
268
assert isinstance(basedir, basestring), \
225
269
"base directory %r is not a string" % basedir
226
270
basedir = safe_unicode(basedir)
227
271
mutter("opening working tree %r", basedir)
228
272
if deprecated_passed(branch):
273
if not _internal:
274
warnings.warn("WorkingTree(..., branch=XXX) is deprecated as of bzr 0.8."
275
" Please use bzrdir.open_workingtree() or"
276
" WorkingTree.open().",
277
DeprecationWarning,
278
stacklevel=2
279
)
229
280
self._branch = branch
230
281
else:
231
282
self._branch = self.bzrdir.open_branch()
246
297
# if needed, or, when the cache sees a change, append it to the hash
247
298
# cache file, and have the parser take the most recent entry for a
248
299
# given path only.
249
wt_trans = self.bzrdir.get_workingtree_transport(None)
250
cache_filename = wt_trans.local_abspath('stat-cache')
251
self._hashcache = hashcache.HashCache(basedir, cache_filename,
252
self._control_files._file_mode)
253
hc = self._hashcache
300
cache_filename = self.bzrdir.get_workingtree_transport(None).local_abspath('stat-cache')
301
hc = self._hashcache = HashCache(basedir, cache_filename, self._control_files._file_mode)
254
302
hc.read()
255
303
# is this scan needed ? it makes things kinda slow.
256
304
#hc.scan()
260
308
hc.write()
261
309
262
310
if _inventory is None:
263
# This will be acquired on lock_read() or lock_write()
264
311
self._inventory_is_modified = False
265
self._inventory = None
312
self.read_working_inventory()
266
313
else:
267
314
# the caller of __init__ has provided an inventory,
268
315
# we assume they know what they are doing - as its only
289
336
self._control_files.break_lock()
290
337
self.branch.break_lock()
291
338
292
def requires_rich_root(self):
293
return self._format.requires_rich_root
294
295
def supports_tree_reference(self):
296
return False
297
298
339
def _set_inventory(self, inv, dirty):
299
340
"""Set the internal cached inventory.
300
341
346
387
"""
347
388
return WorkingTree.open(path, _unsupported=True)
348
389
349
# should be deprecated - this is slow and in any case treating them as a
350
# container is (we now know) bad style -- mbp 20070302
351
## @deprecated_method(zero_fifteen)
352
390
def __iter__(self):
353
391
"""Iterate through file_ids for this tree.
354
392
366
404
367
405
def abspath(self, filename):
368
406
return pathjoin(self.basedir, filename)
369
407
370
408
def basis_tree(self):
371
409
"""Return RevisionTree for the current last revision.
372
410
380
418
# in the future this should return the tree for
381
419
# 'empty:' - the implicit root empty tree.
382
420
return self.branch.repository.revision_tree(None)
383
try:
384
return self.revision_tree(revision_id)
385
except errors.NoSuchRevision:
386
pass
421
else:
422
try:
423
xml = self.read_basis_inventory()
424
inv = xml6.serializer_v6.read_inventory_from_string(xml)
425
if inv is not None and inv.revision_id == revision_id:
426
return bzrlib.revisiontree.RevisionTree(
427
self.branch.repository, inv, revision_id)
428
except (NoSuchFile, errors.BadInventoryFormat):
429
pass
387
430
# No cached copy available, retrieve from the repository.
388
431
# FIXME? RBC 20060403 should we cache the inventory locally
389
432
# at this point ?
448
491
return osutils.lexists(self.abspath(filename))
449
492
450
493
def get_file(self, file_id):
451
file_id = osutils.safe_file_id(file_id)
452
494
return self.get_file_byname(self.id2path(file_id))
453
495
454
496
def get_file_text(self, file_id):
455
file_id = osutils.safe_file_id(file_id)
456
497
return self.get_file(file_id).read()
457
498
458
499
def get_file_byname(self, filename):
459
500
return file(self.abspath(filename), 'rb')
460
501
461
@needs_read_lock
462
def annotate_iter(self, file_id):
463
"""See Tree.annotate_iter
464
465
This implementation will use the basis tree implementation if possible.
466
Lines not in the basis are attributed to CURRENT_REVISION
467
468
If there are pending merges, lines added by those merges will be
469
incorrectly attributed to CURRENT_REVISION (but after committing, the
470
attribution will be correct).
471
"""
472
file_id = osutils.safe_file_id(file_id)
473
basis = self.basis_tree()
474
basis.lock_read()
475
try:
476
changes = self._iter_changes(basis, True, [self.id2path(file_id)],
477
require_versioned=True).next()
478
changed_content, kind = changes[2], changes[6]
479
if not changed_content:
480
return basis.annotate_iter(file_id)
481
if kind[1] is None:
482
return None
483
import annotate
484
if kind[0] != 'file':
485
old_lines = []
486
else:
487
old_lines = list(basis.annotate_iter(file_id))
488
old = [old_lines]
489
for tree in self.branch.repository.revision_trees(
490
self.get_parent_ids()[1:]):
491
if file_id not in tree:
492
continue
493
old.append(list(tree.annotate_iter(file_id)))
494
return annotate.reannotate(old, self.get_file(file_id).readlines(),
495
CURRENT_REVISION)
496
finally:
497
basis.unlock()
498
499
502
def get_parent_ids(self):
500
503
"""See Tree.get_parent_ids.
501
504
508
511
else:
509
512
parents = [last_rev]
510
513
try:
511
merges_file = self._control_files.get('pending-merges')
512
except errors.NoSuchFile:
514
merges_file = self._control_files.get_utf8('pending-merges')
515
except NoSuchFile:
513
516
pass
514
517
else:
515
518
for l in merges_file.readlines():
516
revision_id = osutils.safe_revision_id(l.rstrip('\n'))
517
parents.append(revision_id)
519
parents.append(l.rstrip('\n'))
518
520
return parents
519
521
520
522
@needs_read_lock
524
526
525
527
def _get_store_filename(self, file_id):
526
528
## XXX: badly named; this is not in the store at all
527
file_id = osutils.safe_file_id(file_id)
528
529
return self.abspath(self.id2path(file_id))
529
530
530
531
@needs_read_lock
531
def clone(self, to_bzrdir, revision_id=None):
532
def clone(self, to_bzrdir, revision_id=None, basis=None):
532
533
"""Duplicate this working tree into to_bzr, including all state.
533
534
534
535
Specifically modified files are kept as modified, but
540
541
If not None, the cloned tree will have its last revision set to
541
542
revision, and and difference between the source trees last revision
542
543
and this one merged in.
544
545
basis
546
If not None, a closer copy of a tree which may have some files in
547
common, and which file content should be preferentially copied from.
543
548
"""
544
549
# assumes the target bzr dir format is compatible.
545
550
result = self._format.initialize(to_bzrdir)
559
564
tree.set_parent_ids([revision_id])
560
565
561
566
def id2abspath(self, file_id):
562
file_id = osutils.safe_file_id(file_id)
563
567
return self.abspath(self.id2path(file_id))
564
568
565
569
def has_id(self, file_id):
566
570
# files that have been deleted are excluded
567
file_id = osutils.safe_file_id(file_id)
568
inv = self.inventory
571
inv = self._inventory
569
572
if not inv.has_id(file_id):
570
573
return False
571
574
path = inv.id2path(file_id)
572
575
return osutils.lexists(self.abspath(path))
573
576
574
577
def has_or_had_id(self, file_id):
575
file_id = osutils.safe_file_id(file_id)
576
578
if file_id == self.inventory.root.file_id:
577
579
return True
578
580
return self.inventory.has_id(file_id)
580
582
__contains__ = has_id
581
583
582
584
def get_file_size(self, file_id):
583
file_id = osutils.safe_file_id(file_id)
584
585
return os.path.getsize(self.id2abspath(file_id))
585
586
586
587
@needs_read_lock
587
def get_file_sha1(self, file_id, path=None, stat_value=None):
588
file_id = osutils.safe_file_id(file_id)
588
def get_file_sha1(self, file_id, path=None):
589
589
if not path:
590
590
path = self._inventory.id2path(file_id)
591
return self._hashcache.get_sha1(path, stat_value)
591
return self._hashcache.get_sha1(path)
592
592
593
593
def get_file_mtime(self, file_id, path=None):
594
file_id = osutils.safe_file_id(file_id)
595
594
if not path:
596
path = self.inventory.id2path(file_id)
595
path = self._inventory.id2path(file_id)
597
596
return os.lstat(self.abspath(path)).st_mtime
598
597
599
598
if not supports_executable():
600
599
def is_executable(self, file_id, path=None):
601
file_id = osutils.safe_file_id(file_id)
602
600
return self._inventory[file_id].executable
603
601
else:
604
602
def is_executable(self, file_id, path=None):
605
603
if not path:
606
file_id = osutils.safe_file_id(file_id)
607
path = self.id2path(file_id)
604
path = self._inventory.id2path(file_id)
608
605
mode = os.lstat(self.abspath(path)).st_mode
609
606
return bool(stat.S_ISREG(mode) and stat.S_IEXEC & mode)
610
607
611
@needs_tree_write_lock
608
@needs_write_lock
612
609
def _add(self, files, ids, kinds):
613
610
"""See MutableTree._add."""
614
611
# TODO: Re-adding a file that is removed in the working copy
615
612
# should probably put it back with the previous ID.
616
613
# the read and write working inventory should not occur in this
617
614
# function - they should be part of lock_write and unlock.
618
inv = self.inventory
615
inv = self.read_working_inventory()
619
616
for f, file_id, kind in zip(files, ids, kinds):
620
617
assert kind is not None
621
618
if file_id is None:
622
619
inv.add_path(f, kind=kind)
623
620
else:
624
file_id = osutils.safe_file_id(file_id)
625
621
inv.add_path(f, kind=kind, file_id=file_id)
626
self._inventory_is_modified = True
622
self._write_inventory(inv)
627
623
628
624
@needs_tree_write_lock
629
625
def _gather_kinds(self, files, kinds):
635
631
kinds[pos] = file_kind(fullpath)
636
632
except OSError, e:
637
633
if e.errno == errno.ENOENT:
638
raise errors.NoSuchFile(fullpath)
634
raise NoSuchFile(fullpath)
639
635
640
636
@needs_write_lock
641
637
def add_parent_tree_id(self, revision_id, allow_leftmost_as_ghost=False):
650
646
:param allow_leftmost_as_ghost: Allow the first parent to be a ghost.
651
647
"""
652
648
parents = self.get_parent_ids() + [revision_id]
653
self.set_parent_ids(parents, allow_leftmost_as_ghost=len(parents) > 1
654
or allow_leftmost_as_ghost)
649
self.set_parent_ids(parents,
650
allow_leftmost_as_ghost=len(parents) > 1 or allow_leftmost_as_ghost)
655
651
656
652
@needs_tree_write_lock
657
653
def add_parent_tree(self, parent_tuple, allow_leftmost_as_ghost=False):
716
712
717
713
def _set_merges_from_parent_ids(self, parent_ids):
718
714
merges = parent_ids[1:]
719
self._control_files.put_bytes('pending-merges', '\n'.join(merges))
715
self._control_files.put_utf8('pending-merges', '\n'.join(merges))
720
716
721
717
@needs_tree_write_lock
722
718
def set_parent_ids(self, revision_ids, allow_leftmost_as_ghost=False):
731
727
:param revision_ids: The revision_ids to set as the parent ids of this
732
728
working tree. Any of these may be ghosts.
733
729
"""
734
revision_ids = [osutils.safe_revision_id(r) for r in revision_ids]
735
730
self._check_parents_for_ghosts(revision_ids,
736
731
allow_leftmost_as_ghost=allow_leftmost_as_ghost)
737
732
745
740
@needs_tree_write_lock
746
741
def set_parent_trees(self, parents_list, allow_leftmost_as_ghost=False):
747
742
"""See MutableTree.set_parent_trees."""
748
parent_ids = [osutils.safe_revision_id(rev) for (rev, tree) in parents_list]
743
parent_ids = [rev for (rev, tree) in parents_list]
749
744
750
745
self._check_parents_for_ghosts(parent_ids,
751
746
allow_leftmost_as_ghost=allow_leftmost_as_ghost)
779
774
def set_merge_modified(self, modified_hashes):
780
775
def iter_stanzas():
781
776
for file_id, hash in modified_hashes.iteritems():
782
yield Stanza(file_id=file_id.decode('utf8'), hash=hash)
777
yield Stanza(file_id=file_id, hash=hash)
783
778
self._put_rio('merge-hashes', iter_stanzas(), MERGE_MODIFIED_HEADER_1)
784
779
780
@needs_tree_write_lock
785
781
def _put_rio(self, filename, stanzas, header):
786
self._must_be_locked()
787
782
my_file = rio_file(stanzas, header)
788
783
self._control_files.put(filename, my_file)
789
784
792
787
"""Merge from a branch into this working tree.
793
788
794
789
:param branch: The branch to merge from.
795
:param to_revision: If non-None, the merge will merge to to_revision,
796
but not beyond it. to_revision does not need to be in the history
797
of the branch when it is supplied. If None, to_revision defaults to
790
:param to_revision: If non-None, the merge will merge to to_revision, but
791
not beyond it. to_revision does not need to be in the history of
792
the branch when it is supplied. If None, to_revision defaults to
798
793
branch.last_revision().
799
794
"""
800
795
from bzrlib.merge import Merger, Merge3Merger
808
803
merger.check_basis(check_clean=True, require_commits=False)
809
804
if to_revision is None:
810
805
to_revision = branch.last_revision()
811
else:
812
to_revision = osutils.safe_revision_id(to_revision)
813
806
merger.other_rev_id = to_revision
814
807
if merger.other_rev_id is None:
815
raise errors.NoCommits(branch)
808
raise error.NoCommits(branch)
816
809
self.branch.fetch(branch, last_revision=merger.other_rev_id)
817
810
merger.other_basis = merger.other_rev_id
818
811
merger.other_tree = self.branch.repository.revision_tree(
819
812
merger.other_rev_id)
820
merger.other_branch = branch
821
813
merger.pp.next_phase()
822
814
merger.find_base()
823
815
if merger.base_rev_id == merger.other_rev_id:
835
827
836
828
@needs_read_lock
837
829
def merge_modified(self):
838
"""Return a dictionary of files modified by a merge.
839
840
The list is initialized by WorkingTree.set_merge_modified, which is
841
typically called after we make some automatic updates to the tree
842
because of a merge.
843
844
This returns a map of file_id->sha1, containing only files which are
845
still in the working inventory and have that text hash.
846
"""
847
830
try:
848
831
hashfile = self._control_files.get('merge-hashes')
849
except errors.NoSuchFile:
832
except NoSuchFile:
850
833
return {}
851
834
merge_hashes = {}
852
835
try:
853
836
if hashfile.next() != MERGE_MODIFIED_HEADER_1 + '\n':
854
raise errors.MergeModifiedFormatError()
837
raise MergeModifiedFormatError()
855
838
except StopIteration:
856
raise errors.MergeModifiedFormatError()
839
raise MergeModifiedFormatError()
857
840
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)
841
file_id = s.get("file_id")
860
842
if file_id not in self.inventory:
861
843
continue
862
text_hash = s.get("hash")
863
if text_hash == self.get_file_sha1(file_id):
864
merge_hashes[file_id] = text_hash
844
hash = s.get("hash")
845
if hash == self.get_file_sha1(file_id):
846
merge_hashes[file_id] = hash
865
847
return merge_hashes
866
848
867
849
@needs_write_lock
868
850
def mkdir(self, path, file_id=None):
869
851
"""See MutableTree.mkdir()."""
870
852
if file_id is None:
871
file_id = generate_ids.gen_file_id(os.path.basename(path))
853
file_id = gen_file_id(os.path.basename(path))
872
854
os.mkdir(self.abspath(path))
873
855
self.add(path, file_id, 'directory')
874
856
return file_id
875
857
876
858
def get_symlink_target(self, file_id):
877
file_id = osutils.safe_file_id(file_id)
878
859
return os.readlink(self.id2abspath(file_id))
879
860
880
@needs_write_lock
881
def subsume(self, other_tree):
882
def add_children(inventory, entry):
883
for child_entry in entry.children.values():
884
inventory._byid[child_entry.file_id] = child_entry
885
if child_entry.kind == 'directory':
886
add_children(inventory, child_entry)
887
if other_tree.get_root_id() == self.get_root_id():
888
raise errors.BadSubsumeSource(self, other_tree,
889
'Trees have the same root')
890
try:
891
other_tree_path = self.relpath(other_tree.basedir)
892
except errors.PathNotChild:
893
raise errors.BadSubsumeSource(self, other_tree,
894
'Tree is not contained by the other')
895
new_root_parent = self.path2id(osutils.dirname(other_tree_path))
896
if new_root_parent is None:
897
raise errors.BadSubsumeSource(self, other_tree,
898
'Parent directory is not versioned.')
899
# We need to ensure that the result of a fetch will have a
900
# versionedfile for the other_tree root, and only fetching into
901
# RepositoryKnit2 guarantees that.
902
if not self.branch.repository.supports_rich_root():
903
raise errors.SubsumeTargetNeedsUpgrade(other_tree)
904
other_tree.lock_tree_write()
905
try:
906
new_parents = other_tree.get_parent_ids()
907
other_root = other_tree.inventory.root
908
other_root.parent_id = new_root_parent
909
other_root.name = osutils.basename(other_tree_path)
910
self.inventory.add(other_root)
911
add_children(self.inventory, other_root)
912
self._write_inventory(self.inventory)
913
# normally we don't want to fetch whole repositories, but i think
914
# here we really do want to consolidate the whole thing.
915
for parent_id in other_tree.get_parent_ids():
916
self.branch.fetch(other_tree.branch, parent_id)
917
self.add_parent_tree_id(parent_id)
918
finally:
919
other_tree.unlock()
920
other_tree.bzrdir.retire_bzrdir()
921
922
@needs_tree_write_lock
923
def extract(self, file_id, format=None):
924
"""Extract a subtree from this tree.
925
926
A new branch will be created, relative to the path for this tree.
927
"""
928
self.flush()
929
def mkdirs(path):
930
segments = osutils.splitpath(path)
931
transport = self.branch.bzrdir.root_transport
932
for name in segments:
933
transport = transport.clone(name)
934
transport.ensure_base()
935
return transport
936
937
sub_path = self.id2path(file_id)
938
branch_transport = mkdirs(sub_path)
939
if format is None:
940
format = bzrdir.format_registry.make_bzrdir('dirstate-with-subtree')
941
branch_transport.ensure_base()
942
branch_bzrdir = format.initialize_on_transport(branch_transport)
943
try:
944
repo = branch_bzrdir.find_repository()
945
except errors.NoRepositoryPresent:
946
repo = branch_bzrdir.create_repository()
947
assert repo.supports_rich_root()
948
else:
949
if not repo.supports_rich_root():
950
raise errors.RootNotRich()
951
new_branch = branch_bzrdir.create_branch()
952
new_branch.pull(self.branch)
953
for parent_id in self.get_parent_ids():
954
new_branch.fetch(self.branch, parent_id)
955
tree_transport = self.bzrdir.root_transport.clone(sub_path)
956
if tree_transport.base != branch_transport.base:
957
tree_bzrdir = format.initialize_on_transport(tree_transport)
958
branch.BranchReferenceFormat().initialize(tree_bzrdir, new_branch)
959
else:
960
tree_bzrdir = branch_bzrdir
961
wt = tree_bzrdir.create_workingtree(NULL_REVISION)
962
wt.set_parent_ids(self.get_parent_ids())
963
my_inv = self.inventory
964
child_inv = Inventory(root_id=None)
965
new_root = my_inv[file_id]
966
my_inv.remove_recursive_id(file_id)
967
new_root.parent_id = None
968
child_inv.add(new_root)
969
self._write_inventory(my_inv)
970
wt._write_inventory(child_inv)
971
return wt
972
973
def _serialize(self, inventory, out_file):
974
xml5.serializer_v5.write_inventory(self._inventory, out_file)
975
976
def _deserialize(selt, in_file):
977
return xml5.serializer_v5.read_inventory(in_file)
861
def file_class(self, filename):
862
if self.path2id(filename):
863
return 'V'
864
elif self.is_ignored(filename):
865
return 'I'
866
else:
867
return '?'
978
868
979
869
def flush(self):
980
870
"""Write the in memory inventory to disk."""
982
872
if self._control_files._lock_mode != 'w':
983
873
raise errors.NotWriteLocked(self)
984
874
sio = StringIO()
985
self._serialize(self._inventory, sio)
875
xml5.serializer_v5.write_inventory(self._inventory, sio)
986
876
sio.seek(0)
987
877
self._control_files.put('inventory', sio)
988
878
self._inventory_is_modified = False
989
879
990
def _kind(self, relpath):
991
return osutils.file_kind(self.abspath(relpath))
992
993
880
def list_files(self, include_root=False):
994
881
"""Recursively list all files as (path, class, kind, id, entry).
995
882
1000
887
1001
888
Skips the control directory.
1002
889
"""
1003
# list_files is an iterator, so @needs_read_lock doesn't work properly
1004
# with it. So callers should be careful to always read_lock the tree.
1005
if not self.is_locked():
1006
raise errors.ObjectNotLocked(self)
1007
1008
inv = self.inventory
890
inv = self._inventory
1009
891
if include_root is True:
1010
892
yield ('', 'V', 'directory', inv.root.file_id, inv.root)
1011
893
# Convert these into local objects to save lookup times
1012
894
pathjoin = osutils.pathjoin
1013
file_kind = self._kind
895
file_kind = osutils.file_kind
1014
896
1015
897
# transport.base ends in a slash, we want the piece
1016
898
# between the last two slashes
1076
958
1077
959
fk = file_kind(fap)
1078
960
961
if f_ie:
962
if f_ie.kind != fk:
963
raise BzrCheckError("file %r entered as kind %r id %r, "
964
"now of kind %r"
965
% (fap, f_ie.kind, f_ie.file_id, fk))
966
1079
967
# make a last minute entry
1080
968
if f_ie:
1081
969
yield fp[1:], c, fk, f_ie.file_id, f_ie
1094
982
new_children.sort()
1095
983
new_children = collections.deque(new_children)
1096
984
stack.append((f_ie.file_id, fp, fap, new_children))
1097
# Break out of inner loop,
1098
# so that we start outer loop with child
985
# Break out of inner loop, so that we start outer loop with child
1099
986
break
1100
987
else:
1101
988
# if we finished all children, pop it off the stack
1102
989
stack.pop()
1103
990
1104
991
@needs_tree_write_lock
1105
def move(self, from_paths, to_dir=None, after=False, **kwargs):
992
def move(self, from_paths, to_name):
1106
993
"""Rename files.
1107
994
1108
to_dir must exist in the inventory.
995
to_name must exist in the inventory.
1109
996
1110
If to_dir exists and is a directory, the files are moved into
997
If to_name exists and is a directory, the files are moved into
1111
998
it, keeping their old names.
1112
999
1113
Note that to_dir is only the last component of the new name;
1000
Note that to_name is only the last component of the new name;
1114
1001
this doesn't change the directory.
1115
1002
1116
For each entry in from_paths the move mode will be determined
1117
independently.
1118
1119
The first mode moves the file in the filesystem and updates the
1120
inventory. The second mode only updates the inventory without
1121
touching the file on the filesystem. This is the new mode introduced
1122
in version 0.15.
1123
1124
move uses the second mode if 'after == True' and the target is not
1125
versioned but present in the working tree.
1126
1127
move uses the second mode if 'after == False' and the source is
1128
versioned but no longer in the working tree, and the target is not
1129
versioned but present in the working tree.
1130
1131
move uses the first mode if 'after == False' and the source is
1132
versioned and present in the working tree, and the target is not
1133
versioned and not present in the working tree.
1134
1135
Everything else results in an error.
1136
1137
1003
This returns a list of (from_path, to_path) pairs for each
1138
1004
entry that is moved.
1139
1005
"""
1140
rename_entries = []
1141
rename_tuples = []
1142
1143
# check for deprecated use of signature
1144
if to_dir is None:
1145
to_dir = kwargs.get('to_name', None)
1146
if to_dir is None:
1147
raise TypeError('You must supply a target directory')
1148
else:
1149
symbol_versioning.warn('The parameter to_name was deprecated'
1150
' in version 0.13. Use to_dir instead',
1151
DeprecationWarning)
1152
1153
# check destination directory
1006
result = []
1007
## TODO: Option to move IDs only
1154
1008
assert not isinstance(from_paths, basestring)
1155
1009
inv = self.inventory
1156
to_abs = self.abspath(to_dir)
1010
to_abs = self.abspath(to_name)
1157
1011
if not isdir(to_abs):
1158
raise errors.BzrMoveFailedError('',to_dir,
1159
errors.NotADirectory(to_abs))
1160
if not self.has_filename(to_dir):
1161
raise errors.BzrMoveFailedError('',to_dir,
1162
errors.NotInWorkingDirectory(to_dir))
1163
to_dir_id = inv.path2id(to_dir)
1164
if to_dir_id is None:
1165
raise errors.BzrMoveFailedError('',to_dir,
1166
errors.NotVersionedError(path=str(to_dir)))
1167
1012
raise BzrError("destination %r is not a directory" % to_abs)
1013
if not self.has_filename(to_name):
1014
raise BzrError("destination %r not in working directory" % to_abs)
1015
to_dir_id = inv.path2id(to_name)
1016
if to_dir_id is None and to_name != '':
1017
raise BzrError("destination %r is not a versioned directory" % to_name)
1168
1018
to_dir_ie = inv[to_dir_id]
1169
1019
if to_dir_ie.kind != 'directory':
1170
raise errors.BzrMoveFailedError('',to_dir,
1171
errors.NotADirectory(to_abs))
1172
1173
# create rename entries and tuples
1174
for from_rel in from_paths:
1175
from_tail = splitpath(from_rel)[-1]
1176
from_id = inv.path2id(from_rel)
1177
if from_id is None:
1178
raise errors.BzrMoveFailedError(from_rel,to_dir,
1179
errors.NotVersionedError(path=str(from_rel)))
1180
1181
from_entry = inv[from_id]
1182
from_parent_id = from_entry.parent_id
1183
to_rel = pathjoin(to_dir, from_tail)
1184
rename_entry = WorkingTree._RenameEntry(from_rel=from_rel,
1185
from_id=from_id,
1186
from_tail=from_tail,
1187
from_parent_id=from_parent_id,
1188
to_rel=to_rel, to_tail=from_tail,
1189
to_parent_id=to_dir_id)
1190
rename_entries.append(rename_entry)
1191
rename_tuples.append((from_rel, to_rel))
1192
1193
# determine which move mode to use. checks also for movability
1194
rename_entries = self._determine_mv_mode(rename_entries, after)
1195
1020
raise BzrError("destination %r is not a directory" % to_abs)
1021
1022
to_idpath = inv.get_idpath(to_dir_id)
1023
1024
for f in from_paths:
1025
if not self.has_filename(f):
1026
raise BzrError("%r does not exist in working tree" % f)
1027
f_id = inv.path2id(f)
1028
if f_id is None:
1029
raise BzrError("%r is not versioned" % f)
1030
name_tail = splitpath(f)[-1]
1031
dest_path = pathjoin(to_name, name_tail)
1032
if self.has_filename(dest_path):
1033
raise BzrError("destination %r already exists" % dest_path)
1034
if f_id in to_idpath:
1035
raise BzrError("can't move %r to a subdirectory of itself" % f)
1036
1037
# OK, so there's a race here, it's possible that someone will
1038
# create a file in this interval and then the rename might be
1039
# left half-done. But we should have caught most problems.
1040
orig_inv = deepcopy(self.inventory)
1196
1041
original_modified = self._inventory_is_modified
1197
1042
try:
1198
1043
if len(from_paths):
1199
1044
self._inventory_is_modified = True
1200
self._move(rename_entries)
1045
for f in from_paths:
1046
name_tail = splitpath(f)[-1]
1047
dest_path = pathjoin(to_name, name_tail)
1048
result.append((f, dest_path))
1049
inv.rename(inv.path2id(f), to_dir_id, name_tail)
1050
try:
1051
osutils.rename(self.abspath(f), self.abspath(dest_path))
1052
except OSError, e:
1053
raise BzrError("failed to rename %r to %r: %s" %
1054
(f, dest_path, e[1]))
1201
1055
except:
1202
1056
# restore the inventory on error
1203
self._inventory_is_modified = original_modified
1057
self._set_inventory(orig_inv, dirty=original_modified)
1204
1058
raise
1205
1059
self._write_inventory(inv)
1206
return rename_tuples
1207
1208
def _determine_mv_mode(self, rename_entries, after=False):
1209
"""Determines for each from-to pair if both inventory and working tree
1210
or only the inventory has to be changed.
1211
1212
Also does basic plausability tests.
1213
"""
1214
inv = self.inventory
1215
1216
for rename_entry in rename_entries:
1217
# store to local variables for easier reference
1218
from_rel = rename_entry.from_rel
1219
from_id = rename_entry.from_id
1220
to_rel = rename_entry.to_rel
1221
to_id = inv.path2id(to_rel)
1222
only_change_inv = False
1223
1224
# check the inventory for source and destination
1225
if from_id is None:
1226
raise errors.BzrMoveFailedError(from_rel,to_rel,
1227
errors.NotVersionedError(path=str(from_rel)))
1228
if to_id is not None:
1229
raise errors.BzrMoveFailedError(from_rel,to_rel,
1230
errors.AlreadyVersionedError(path=str(to_rel)))
1231
1232
# try to determine the mode for rename (only change inv or change
1233
# inv and file system)
1234
if after:
1235
if not self.has_filename(to_rel):
1236
raise errors.BzrMoveFailedError(from_id,to_rel,
1237
errors.NoSuchFile(path=str(to_rel),
1238
extra="New file has not been created yet"))
1239
only_change_inv = True
1240
elif not self.has_filename(from_rel) and self.has_filename(to_rel):
1241
only_change_inv = True
1242
elif self.has_filename(from_rel) and not self.has_filename(to_rel):
1243
only_change_inv = False
1244
else:
1245
# something is wrong, so lets determine what exactly
1246
if not self.has_filename(from_rel) and \
1247
not self.has_filename(to_rel):
1248
raise errors.BzrRenameFailedError(from_rel,to_rel,
1249
errors.PathsDoNotExist(paths=(str(from_rel),
1250
str(to_rel))))
1251
else:
1252
raise errors.RenameFailedFilesExist(from_rel, to_rel,
1253
extra="(Use --after to update the Bazaar id)")
1254
rename_entry.only_change_inv = only_change_inv
1255
return rename_entries
1256
1257
def _move(self, rename_entries):
1258
"""Moves a list of files.
1259
1260
Depending on the value of the flag 'only_change_inv', the
1261
file will be moved on the file system or not.
1262
"""
1263
inv = self.inventory
1264
moved = []
1265
1266
for entry in rename_entries:
1267
try:
1268
self._move_entry(entry)
1269
except:
1270
self._rollback_move(moved)
1271
raise
1272
moved.append(entry)
1273
1274
def _rollback_move(self, moved):
1275
"""Try to rollback a previous move in case of an filesystem error."""
1276
inv = self.inventory
1277
for entry in moved:
1278
try:
1279
self._move_entry(_RenameEntry(entry.to_rel, entry.from_id,
1280
entry.to_tail, entry.to_parent_id, entry.from_rel,
1281
entry.from_tail, entry.from_parent_id,
1282
entry.only_change_inv))
1283
except errors.BzrMoveFailedError, e:
1284
raise errors.BzrMoveFailedError( '', '', "Rollback failed."
1285
" The working tree is in an inconsistent state."
1286
" Please consider doing a 'bzr revert'."
1287
" Error message is: %s" % e)
1288
1289
def _move_entry(self, entry):
1290
inv = self.inventory
1291
from_rel_abs = self.abspath(entry.from_rel)
1292
to_rel_abs = self.abspath(entry.to_rel)
1293
if from_rel_abs == to_rel_abs:
1294
raise errors.BzrMoveFailedError(entry.from_rel, entry.to_rel,
1295
"Source and target are identical.")
1296
1297
if not entry.only_change_inv:
1298
try:
1299
osutils.rename(from_rel_abs, to_rel_abs)
1300
except OSError, e:
1301
raise errors.BzrMoveFailedError(entry.from_rel,
1302
entry.to_rel, e[1])
1303
inv.rename(entry.from_id, entry.to_parent_id, entry.to_tail)
1060
return result
1304
1061
1305
1062
@needs_tree_write_lock
1306
def rename_one(self, from_rel, to_rel, after=False):
1063
def rename_one(self, from_rel, to_rel):
1307
1064
"""Rename one file.
1308
1065
1309
1066
This can change the directory or the filename or both.
1310
1311
rename_one has several 'modes' to work. First, it can rename a physical
1312
file and change the file_id. That is the normal mode. Second, it can
1313
only change the file_id without touching any physical file. This is
1314
the new mode introduced in version 0.15.
1315
1316
rename_one uses the second mode if 'after == True' and 'to_rel' is not
1317
versioned but present in the working tree.
1318
1319
rename_one uses the second mode if 'after == False' and 'from_rel' is
1320
versioned but no longer in the working tree, and 'to_rel' is not
1321
versioned but present in the working tree.
1322
1323
rename_one uses the first mode if 'after == False' and 'from_rel' is
1324
versioned and present in the working tree, and 'to_rel' is not
1325
versioned and not present in the working tree.
1326
1327
Everything else results in an error.
1328
1067
"""
1329
1068
inv = self.inventory
1330
rename_entries = []
1331
1332
# create rename entries and tuples
1333
from_tail = splitpath(from_rel)[-1]
1334
from_id = inv.path2id(from_rel)
1335
if from_id is None:
1336
raise errors.BzrRenameFailedError(from_rel,to_rel,
1337
errors.NotVersionedError(path=str(from_rel)))
1338
from_entry = inv[from_id]
1339
from_parent_id = from_entry.parent_id
1069
if not self.has_filename(from_rel):
1070
raise BzrError("can't rename: old working file %r does not exist" % from_rel)
1071
if self.has_filename(to_rel):
1072
raise BzrError("can't rename: new working file %r already exists" % to_rel)
1073
1074
file_id = inv.path2id(from_rel)
1075
if file_id is None:
1076
raise BzrError("can't rename: old name %r is not versioned" % from_rel)
1077
1078
entry = inv[file_id]
1079
from_parent = entry.parent_id
1080
from_name = entry.name
1081
1082
if inv.path2id(to_rel):
1083
raise BzrError("can't rename: new name %r is already versioned" % to_rel)
1084
1340
1085
to_dir, to_tail = os.path.split(to_rel)
1341
1086
to_dir_id = inv.path2id(to_dir)
1342
rename_entry = WorkingTree._RenameEntry(from_rel=from_rel,
1343
from_id=from_id,
1344
from_tail=from_tail,
1345
from_parent_id=from_parent_id,
1346
to_rel=to_rel, to_tail=to_tail,
1347
to_parent_id=to_dir_id)
1348
rename_entries.append(rename_entry)
1349
1350
# determine which move mode to use. checks also for movability
1351
rename_entries = self._determine_mv_mode(rename_entries, after)
1352
1353
# check if the target changed directory and if the target directory is
1354
# versioned
1355
if to_dir_id is None:
1356
raise errors.BzrMoveFailedError(from_rel,to_rel,
1357
errors.NotVersionedError(path=str(to_dir)))
1358
1359
# all checks done. now we can continue with our actual work
1360
mutter('rename_one:\n'
1361
' from_id {%s}\n'
1362
' from_rel: %r\n'
1363
' to_rel: %r\n'
1364
' to_dir %r\n'
1365
' to_dir_id {%s}\n',
1366
from_id, from_rel, to_rel, to_dir, to_dir_id)
1367
1368
self._move(rename_entries)
1087
if to_dir_id is None and to_dir != '':
1088
raise BzrError("can't determine destination directory id for %r" % to_dir)
1089
1090
mutter("rename_one:")
1091
mutter(" file_id {%s}" % file_id)
1092
mutter(" from_rel %r" % from_rel)
1093
mutter(" to_rel %r" % to_rel)
1094
mutter(" to_dir %r" % to_dir)
1095
mutter(" to_dir_id {%s}" % to_dir_id)
1096
1097
inv.rename(file_id, to_dir_id, to_tail)
1098
1099
from_abs = self.abspath(from_rel)
1100
to_abs = self.abspath(to_rel)
1101
try:
1102
osutils.rename(from_abs, to_abs)
1103
except OSError, e:
1104
inv.rename(file_id, from_parent, from_name)
1105
raise BzrError("failed to rename %r to %r: %s"
1106
% (from_abs, to_abs, e[1]))
1369
1107
self._write_inventory(inv)
1370
1108
1371
class _RenameEntry(object):
1372
def __init__(self, from_rel, from_id, from_tail, from_parent_id,
1373
to_rel, to_tail, to_parent_id, only_change_inv=False):
1374
self.from_rel = from_rel
1375
self.from_id = from_id
1376
self.from_tail = from_tail
1377
self.from_parent_id = from_parent_id
1378
self.to_rel = to_rel
1379
self.to_tail = to_tail
1380
self.to_parent_id = to_parent_id
1381
self.only_change_inv = only_change_inv
1382
1383
1109
@needs_read_lock
1384
1110
def unknowns(self):
1385
1111
"""Return all unknown files.
1387
1113
These are files in the working directory that are not versioned or
1388
1114
control files or ignored.
1389
1115
"""
1390
# force the extras method to be fully executed before returning, to
1391
# prevent race conditions with the lock
1392
return iter(
1393
[subp for subp in self.extras() if not self.is_ignored(subp)])
1394
1116
for subp in self.extras():
1117
if not self.is_ignored(subp):
1118
yield subp
1119
1395
1120
@needs_tree_write_lock
1396
1121
def unversion(self, file_ids):
1397
1122
"""Remove the file ids in file_ids from the current versioned set.
1403
1128
:raises: NoSuchId if any fileid is not currently versioned.
1404
1129
"""
1405
1130
for file_id in file_ids:
1406
file_id = osutils.safe_file_id(file_id)
1407
1131
if self._inventory.has_id(file_id):
1408
1132
self._inventory.remove_recursive_id(file_id)
1409
1133
else:
1437
1161
yield stem
1438
1162
1439
1163
@needs_write_lock
1440
def pull(self, source, overwrite=False, stop_revision=None,
1441
change_reporter=None):
1164
def pull(self, source, overwrite=False, stop_revision=None):
1442
1165
top_pb = bzrlib.ui.ui_factory.nested_progress_bar()
1443
1166
source.lock_read()
1444
1167
try:
1445
1168
pp = ProgressPhase("Pull phase", 2, top_pb)
1446
1169
pp.next_phase()
1447
old_revision_info = self.branch.last_revision_info()
1170
old_revision_history = self.branch.revision_history()
1448
1171
basis_tree = self.basis_tree()
1449
1172
count = self.branch.pull(source, overwrite, stop_revision)
1450
new_revision_info = self.branch.last_revision_info()
1451
if new_revision_info != old_revision_info:
1173
new_revision_history = self.branch.revision_history()
1174
if new_revision_history != old_revision_history:
1452
1175
pp.next_phase()
1176
if len(old_revision_history):
1177
other_revision = old_revision_history[-1]
1178
else:
1179
other_revision = None
1453
1180
repository = self.branch.repository
1454
1181
pb = bzrlib.ui.ui_factory.nested_progress_bar()
1455
basis_tree.lock_read()
1456
1182
try:
1457
1183
new_basis_tree = self.branch.basis_tree()
1458
1184
merge.merge_inner(
1460
1186
new_basis_tree,
1461
1187
basis_tree,
1462
1188
this_tree=self,
1463
pb=pb,
1464
change_reporter=change_reporter)
1189
pb=pb)
1465
1190
if (basis_tree.inventory.root is None and
1466
1191
new_basis_tree.inventory.root is not None):
1467
1192
self.set_root_id(new_basis_tree.inventory.root.file_id)
1468
1193
finally:
1469
1194
pb.finished()
1470
basis_tree.unlock()
1471
1195
# TODO - dedup parents list with things merged by pull ?
1472
1196
# reuse the revisiontree we merged against to set the new
1473
1197
# tree data.
1475
1199
# we have to pull the merge trees out again, because
1476
1200
# merge_inner has set the ids. - this corner is not yet
1477
1201
# layered well enough to prevent double handling.
1478
# XXX TODO: Fix the double handling: telling the tree about
1479
# the already known parent data is wasteful.
1480
1202
merges = self.get_parent_ids()[1:]
1481
1203
parent_trees.extend([
1482
1204
(parent, repository.revision_tree(parent)) for
1490
1212
@needs_write_lock
1491
1213
def put_file_bytes_non_atomic(self, file_id, bytes):
1492
1214
"""See MutableTree.put_file_bytes_non_atomic."""
1493
file_id = osutils.safe_file_id(file_id)
1494
1215
stream = file(self.id2abspath(file_id), 'wb')
1495
1216
try:
1496
1217
stream.write(bytes)
1499
1220
# TODO: update the hashcache here ?
1500
1221
1501
1222
def extras(self):
1502
"""Yield all unversioned files in this WorkingTree.
1223
"""Yield all unknown files in this WorkingTree.
1503
1224
1504
If there are any unversioned directories then only the directory is
1505
returned, not all its children. But if there are unversioned files
1225
If there are any unknown directories then only the directory is
1226
returned, not all its children. But if there are unknown files
1506
1227
under a versioned subdirectory, they are returned.
1507
1228
1508
1229
Currently returned depth-first, sorted by name within directories.
1509
This is the same order used by 'osutils.walkdirs'.
1510
1230
"""
1511
1231
## TODO: Work from given directory downwards
1512
1232
for path, dir_entry in self.inventory.directories():
1533
1253
subp = pathjoin(path, subf)
1534
1254
yield subp
1535
1255
1256
def _translate_ignore_rule(self, rule):
1257
"""Translate a single ignore rule to a regex.
1258
1259
There are two types of ignore rules. Those that do not contain a / are
1260
matched against the tail of the filename (that is, they do not care
1261
what directory the file is in.) Rules which do contain a slash must
1262
match the entire path. As a special case, './' at the start of the
1263
string counts as a slash in the string but is removed before matching
1264
(e.g. ./foo.c, ./src/foo.c)
1265
1266
:return: The translated regex.
1267
"""
1268
if rule[:2] in ('./', '.\\'):
1269
# rootdir rule
1270
result = fnmatch.translate(rule[2:])
1271
elif '/' in rule or '\\' in rule:
1272
# path prefix
1273
result = fnmatch.translate(rule)
1274
else:
1275
# default rule style.
1276
result = "(?:.*/)?(?!.*/)" + fnmatch.translate(rule)
1277
assert result[-1] == '$', "fnmatch.translate did not add the expected $"
1278
return "(" + result + ")"
1279
1280
def _combine_ignore_rules(self, rules):
1281
"""Combine a list of ignore rules into a single regex object.
1282
1283
Each individual rule is combined with | to form a big regex, which then
1284
has $ added to it to form something like ()|()|()$. The group index for
1285
each subregex's outermost group is placed in a dictionary mapping back
1286
to the rule. This allows quick identification of the matching rule that
1287
triggered a match.
1288
:return: a list of the compiled regex and the matching-group index
1289
dictionaries. We return a list because python complains if you try to
1290
combine more than 100 regexes.
1291
"""
1292
result = []
1293
groups = {}
1294
next_group = 0
1295
translated_rules = []
1296
for rule in rules:
1297
translated_rule = self._translate_ignore_rule(rule)
1298
compiled_rule = re.compile(translated_rule)
1299
groups[next_group] = rule
1300
next_group += compiled_rule.groups
1301
translated_rules.append(translated_rule)
1302
if next_group == 99:
1303
result.append((re.compile("|".join(translated_rules)), groups))
1304
groups = {}
1305
next_group = 0
1306
translated_rules = []
1307
if len(translated_rules):
1308
result.append((re.compile("|".join(translated_rules)), groups))
1309
return result
1310
1536
1311
def ignored_files(self):
1537
1312
"""Yield list of PATH, IGNORE_PATTERN"""
1538
1313
for subp in self.extras():
1551
1326
1552
1327
ignore_globs = set(bzrlib.DEFAULT_IGNORE)
1553
1328
ignore_globs.update(ignores.get_runtime_ignores())
1329
1554
1330
ignore_globs.update(ignores.get_user_ignores())
1331
1555
1332
if self.has_filename(bzrlib.IGNORE_FILENAME):
1556
1333
f = self.get_file_byname(bzrlib.IGNORE_FILENAME)
1557
1334
try:
1558
1335
ignore_globs.update(ignores.parse_ignore_file(f))
1559
1336
finally:
1560
1337
f.close()
1338
1561
1339
self._ignoreset = ignore_globs
1340
self._ignore_regex = self._combine_ignore_rules(ignore_globs)
1562
1341
return ignore_globs
1563
1342
1564
def _flush_ignore_list_cache(self):
1565
"""Resets the cached ignore list to force a cache rebuild."""
1566
self._ignoreset = None
1567
self._ignoreglobster = None
1343
def _get_ignore_rules_as_regex(self):
1344
"""Return a regex of the ignore rules and a mapping dict.
1345
1346
:return: (ignore rules compiled regex, dictionary mapping rule group
1347
indices to original rule.)
1348
"""
1349
if getattr(self, '_ignoreset', None) is None:
1350
self.get_ignore_list()
1351
return self._ignore_regex
1568
1352
1569
1353
def is_ignored(self, filename):
1570
1354
r"""Check whether the filename matches an ignore pattern.
1575
1359
If the file is ignored, returns the pattern which caused it to
1576
1360
be ignored, otherwise None. So this can simply be used as a
1577
1361
boolean if desired."""
1578
if getattr(self, '_ignoreglobster', None) is None:
1579
self._ignoreglobster = globbing.Globster(self.get_ignore_list())
1580
return self._ignoreglobster.match(filename)
1362
1363
# TODO: Use '**' to match directories, and other extended
1364
# globbing stuff from cvs/rsync.
1365
1366
# XXX: fnmatch is actually not quite what we want: it's only
1367
# approximately the same as real Unix fnmatch, and doesn't
1368
# treat dotfiles correctly and allows * to match /.
1369
# Eventually it should be replaced with something more
1370
# accurate.
1371
1372
rules = self._get_ignore_rules_as_regex()
1373
for regex, mapping in rules:
1374
match = regex.match(filename)
1375
if match is not None:
1376
# one or more of the groups in mapping will have a non-None
1377
# group match.
1378
groups = match.groups()
1379
rules = [mapping[group] for group in
1380
mapping if groups[group] is not None]
1381
return rules[0]
1382
return None
1581
1383
1582
1384
def kind(self, file_id):
1583
1385
return file_kind(self.id2abspath(file_id))
1584
1386
1585
def _comparison_data(self, entry, path):
1586
abspath = self.abspath(path)
1587
try:
1588
stat_value = os.lstat(abspath)
1589
except OSError, e:
1590
if getattr(e, 'errno', None) == errno.ENOENT:
1591
stat_value = None
1592
kind = None
1593
executable = False
1594
else:
1595
raise
1596
else:
1597
mode = stat_value.st_mode
1598
kind = osutils.file_kind_from_stat_mode(mode)
1599
if not supports_executable():
1600
executable = entry is not None and entry.executable
1601
else:
1602
executable = bool(stat.S_ISREG(mode) and stat.S_IEXEC & mode)
1603
return kind, executable, stat_value
1604
1605
def _file_size(self, entry, stat_value):
1606
return stat_value.st_size
1607
1608
1387
def last_revision(self):
1609
1388
"""Return the last revision of the branch for this tree.
1610
1389
1623
1402
def is_locked(self):
1624
1403
return self._control_files.is_locked()
1625
1404
1626
def _must_be_locked(self):
1627
if not self.is_locked():
1628
raise errors.ObjectNotLocked(self)
1629
1630
1405
def lock_read(self):
1631
1406
"""See Branch.lock_read, and WorkingTree.unlock."""
1632
if not self.is_locked():
1633
self._reset_data()
1634
1407
self.branch.lock_read()
1635
1408
try:
1636
1409
return self._control_files.lock_read()
1640
1413
1641
1414
def lock_tree_write(self):
1642
1415
"""See MutableTree.lock_tree_write, and WorkingTree.unlock."""
1643
if not self.is_locked():
1644
self._reset_data()
1645
1416
self.branch.lock_read()
1646
1417
try:
1647
1418
return self._control_files.lock_write()
1651
1422
1652
1423
def lock_write(self):
1653
1424
"""See MutableTree.lock_write, and WorkingTree.unlock."""
1654
if not self.is_locked():
1655
self._reset_data()
1656
1425
self.branch.lock_write()
1657
1426
try:
1658
1427
return self._control_files.lock_write()
1666
1435
def _basis_inventory_name(self):
1667
1436
return 'basis-inventory-cache'
1668
1437
1669
def _reset_data(self):
1670
"""Reset transient data that cannot be revalidated."""
1671
self._inventory_is_modified = False
1672
result = self._deserialize(self._control_files.get('inventory'))
1673
self._set_inventory(result, dirty=False)
1674
1675
1438
@needs_tree_write_lock
1676
1439
def set_last_revision(self, new_revision):
1677
1440
"""Change the last revision in the working tree."""
1678
new_revision = osutils.safe_revision_id(new_revision)
1679
1441
if self._change_last_revision(new_revision):
1680
1442
self._cache_basis_inventory(new_revision)
1681
1443
1704
1466
1705
1467
def _create_basis_xml_from_inventory(self, revision_id, inventory):
1706
1468
"""Create the text that will be saved in basis-inventory"""
1707
# TODO: jam 20070209 This should be redundant, as the revision_id
1708
# as all callers should have already converted the revision_id to
1709
# utf8
1710
inventory.revision_id = osutils.safe_revision_id(revision_id)
1711
return xml7.serializer_v7.write_inventory_to_string(inventory)
1469
inventory.revision_id = revision_id
1470
return xml6.serializer_v6.write_inventory_to_string(inventory)
1712
1471
1713
1472
def _cache_basis_inventory(self, new_revision):
1714
1473
"""Cache new_revision as the basis inventory."""
1729
1488
xml = self.branch.repository.get_inventory_xml(new_revision)
1730
1489
firstline = xml.split('\n', 1)[0]
1731
1490
if (not 'revision_id="' in firstline or
1732
'format="7"' not in firstline):
1491
'format="6"' not in firstline):
1733
1492
inv = self.branch.repository.deserialise_inventory(
1734
1493
new_revision, xml)
1735
1494
xml = self._create_basis_xml_from_inventory(new_revision, inv)
1755
1514
# binary.
1756
1515
if self._inventory_is_modified:
1757
1516
raise errors.InventoryModified(self)
1758
result = self._deserialize(self._control_files.get('inventory'))
1517
result = xml5.serializer_v5.read_inventory(
1518
self._control_files.get('inventory'))
1759
1519
self._set_inventory(result, dirty=False)
1760
1520
return result
1761
1521
1762
1522
@needs_tree_write_lock
1763
def remove(self, files, verbose=False, to_file=None, keep_files=True,
1764
force=False):
1765
"""Remove nominated files from the working inventor.
1766
1767
:files: File paths relative to the basedir.
1768
:keep_files: If true, the files will also be kept.
1769
:force: Delete files and directories, even if they are changed and
1770
even if the directories are not empty.
1523
def remove(self, files, verbose=False, to_file=None):
1524
"""Remove nominated files from the working inventory..
1525
1526
This does not remove their text. This does not run on XXX on what? RBC
1527
1528
TODO: Refuse to remove modified files unless --force is given?
1529
1530
TODO: Do something useful with directories.
1531
1532
TODO: Should this remove the text or not? Tough call; not
1533
removing may be useful and the user can just use use rm, and
1534
is the opposite of add. Removing it is consistent with most
1535
other tools. Maybe an option.
1771
1536
"""
1772
1537
## TODO: Normalize names
1773
1538
## TODO: Remove nested loops; better scalability
1774
1539
if isinstance(files, basestring):
1775
1540
files = [files]
1776
1541
1777
inv_delta = []
1778
1779
new_files=set()
1780
unknown_files_in_directory=set()
1781
1782
def recurse_directory_to_add_files(directory):
1783
# recurse directory and add all files
1784
# so we can check if they have changed.
1785
for parent_info, file_infos in\
1786
osutils.walkdirs(self.abspath(directory),
1787
directory):
1788
for relpath, basename, kind, lstat, abspath in file_infos:
1789
if kind == 'file':
1790
if self.path2id(relpath): #is it versioned?
1791
new_files.add(relpath)
1792
else:
1793
unknown_files_in_directory.add(
1794
(relpath, None, kind))
1795
1796
for filename in files:
1797
# Get file name into canonical form.
1798
abspath = self.abspath(filename)
1799
filename = self.relpath(abspath)
1800
if len(filename) > 0:
1801
new_files.add(filename)
1802
if osutils.isdir(abspath):
1803
recurse_directory_to_add_files(filename)
1804
files = [f for f in new_files]
1805
1806
# Sort needed to first handle directory content before the directory
1807
files.sort(reverse=True)
1808
if not keep_files and not force:
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
1814
or tree_delta.added
1815
or tree_delta.renamed
1816
or tree_delta.kind_changed
1817
or tree_delta.unversioned):
1818
raise errors.BzrRemoveChangedFilesError(tree_delta)
1542
inv = self.inventory
1819
1543
1820
1544
# do this before any modifications
1821
1545
for f in files:
1822
fid = self.path2id(f)
1823
message=None
1546
fid = inv.path2id(f)
1824
1547
if not fid:
1825
message="%s is not versioned." % (f,)
1826
else:
1827
if verbose:
1828
# having removed it, it must be either ignored or unknown
1829
if self.is_ignored(f):
1830
new_status = 'I'
1831
else:
1832
new_status = '?'
1833
textui.show_status(new_status, self.kind(fid), f,
1834
to_file=to_file)
1835
# unversion file
1836
inv_delta.append((f, None, fid, None))
1837
message="removed %s" % (f,)
1838
1839
if not keep_files:
1840
abs_path = self.abspath(f)
1841
if osutils.lexists(abs_path):
1842
if (osutils.isdir(abs_path) and
1843
len(os.listdir(abs_path)) > 0):
1844
message="%s is not empty directory "\
1845
"and won't be deleted." % (f,)
1846
else:
1847
osutils.delete_any(abs_path)
1848
message="deleted %s" % (f,)
1849
elif message is not None:
1850
# only care if we haven't done anything yet.
1851
message="%s does not exist." % (f,)
1852
1853
# print only one message (if any) per file.
1854
if message is not None:
1855
note(message)
1856
self.apply_inventory_delta(inv_delta)
1548
# TODO: Perhaps make this just a warning, and continue?
1549
# This tends to happen when
1550
raise NotVersionedError(path=f)
1551
if verbose:
1552
# having remove it, it must be either ignored or unknown
1553
if self.is_ignored(f):
1554
new_status = 'I'
1555
else:
1556
new_status = '?'
1557
textui.show_status(new_status, inv[fid].kind, f,
1558
to_file=to_file)
1559
del inv[fid]
1560
1561
self._write_inventory(inv)
1857
1562
1858
1563
@needs_tree_write_lock
1859
1564
def revert(self, filenames, old_tree=None, backups=True,
1860
pb=DummyProgress(), report_changes=False):
1565
pb=DummyProgress()):
1861
1566
from bzrlib.conflicts import resolve
1862
1567
if old_tree is None:
1863
1568
old_tree = self.basis_tree()
1864
conflicts = transform.revert(self, old_tree, filenames, backups, pb,
1865
report_changes)
1569
conflicts = transform.revert(self, old_tree, filenames, backups, pb)
1866
1570
if not len(filenames):
1867
1571
self.set_parent_ids(self.get_parent_ids()[:1])
1868
1572
resolve(self)
1870
1574
resolve(self, filenames, ignore_misses=True)
1871
1575
return conflicts
1872
1576
1873
def revision_tree(self, revision_id):
1874
"""See Tree.revision_tree.
1875
1876
WorkingTree can supply revision_trees for the basis revision only
1877
because there is only one cached inventory in the bzr directory.
1878
"""
1879
if revision_id == self.last_revision():
1880
try:
1881
xml = self.read_basis_inventory()
1882
except errors.NoSuchFile:
1883
pass
1884
else:
1885
try:
1886
inv = xml7.serializer_v7.read_inventory_from_string(xml)
1887
# dont use the repository revision_tree api because we want
1888
# to supply the inventory.
1889
if inv.revision_id == revision_id:
1890
return revisiontree.RevisionTree(self.branch.repository,
1891
inv, revision_id)
1892
except errors.BadInventoryFormat:
1893
pass
1894
# raise if there was no inventory, or if we read the wrong inventory.
1895
raise errors.NoSuchRevisionInTree(self, revision_id)
1896
1897
1577
# XXX: This method should be deprecated in favour of taking in a proper
1898
1578
# new Inventory object.
1899
1579
@needs_tree_write_lock
1916
1596
elif kind == 'symlink':
1917
1597
inv.add(InventoryLink(file_id, name, parent))
1918
1598
else:
1919
raise errors.BzrError("unknown kind %r" % kind)
1599
raise BzrError("unknown kind %r" % kind)
1920
1600
self._write_inventory(inv)
1921
1601
1922
1602
@needs_tree_write_lock
1929
1609
DeprecationWarning,
1930
1610
stacklevel=3)
1931
1611
file_id = ROOT_ID
1932
else:
1933
file_id = osutils.safe_file_id(file_id)
1934
self._set_root_id(file_id)
1935
1936
def _set_root_id(self, file_id):
1937
"""Set the root id for this tree, in a format specific manner.
1938
1939
:param file_id: The file id to assign to the root. It must not be
1940
present in the current inventory or an error will occur. It must
1941
not be None, but rather a valid file id.
1942
"""
1943
1612
inv = self._inventory
1944
1613
orig_root_id = inv.root.file_id
1945
1614
# TODO: it might be nice to exit early if there was nothing
1970
1639
"""
1971
1640
raise NotImplementedError(self.unlock)
1972
1641
1973
def update(self, change_reporter=None):
1642
def update(self):
1974
1643
"""Update a working tree along its branch.
1975
1644
1976
1645
This will update the branch if its bound too, which means we have
2006
1675
old_tip = self.branch.update()
2007
1676
else:
2008
1677
old_tip = None
2009
return self._update_tree(old_tip, change_reporter)
1678
return self._update_tree(old_tip)
2010
1679
finally:
2011
1680
self.unlock()
2012
1681
2013
1682
@needs_tree_write_lock
2014
def _update_tree(self, old_tip=None, change_reporter=None):
1683
def _update_tree(self, old_tip=None):
2015
1684
"""Update a tree to the master branch.
2016
1685
2017
1686
:param old_tip: if supplied, the previous tip revision the branch,
2035
1704
if last_rev != self.branch.last_revision():
2036
1705
# merge tree state up to new branch tip.
2037
1706
basis = self.basis_tree()
2038
basis.lock_read()
2039
try:
2040
to_tree = self.branch.basis_tree()
2041
if basis.inventory.root is None:
2042
self.set_root_id(to_tree.inventory.root.file_id)
2043
self.flush()
2044
result += merge.merge_inner(
2045
self.branch,
2046
to_tree,
2047
basis,
2048
this_tree=self,
2049
change_reporter=change_reporter)
2050
finally:
2051
basis.unlock()
1707
to_tree = self.branch.basis_tree()
1708
if basis.inventory.root is None:
1709
self.set_root_id(to_tree.inventory.root.file_id)
1710
result += merge.merge_inner(
1711
self.branch,
1712
to_tree,
1713
basis,
1714
this_tree=self)
2052
1715
# TODO - dedup parents list with things merged by pull ?
2053
1716
# reuse the tree we've updated to to set the basis:
2054
1717
parent_trees = [(self.branch.last_revision(), to_tree)]
2077
1740
# and we have converted that last revision to a pending merge.
2078
1741
# base is somewhere between the branch tip now
2079
1742
# and the now pending merge
2080
2081
# Since we just modified the working tree and inventory, flush out
2082
# the current state, before we modify it again.
2083
# TODO: jam 20070214 WorkingTree3 doesn't require this, dirstate
2084
# requires it only because TreeTransform directly munges the
2085
# inventory and calls tree._write_inventory(). Ultimately we
2086
# should be able to remove this extra flush.
2087
self.flush()
2088
graph = self.branch.repository.get_graph()
2089
base_rev_id = graph.find_unique_lca(self.branch.last_revision(),
2090
old_tip)
1743
from bzrlib.revision import common_ancestor
1744
try:
1745
base_rev_id = common_ancestor(self.branch.last_revision(),
1746
old_tip,
1747
self.branch.repository)
1748
except errors.NoCommonAncestor:
1749
base_rev_id = None
2091
1750
base_tree = self.branch.repository.revision_tree(base_rev_id)
2092
1751
other_tree = self.branch.repository.revision_tree(old_tip)
2093
1752
result += merge.merge_inner(
2094
1753
self.branch,
2095
1754
other_tree,
2096
1755
base_tree,
2097
this_tree=self,
2098
change_reporter=change_reporter)
1756
this_tree=self)
2099
1757
return result
2100
1758
2101
def _write_hashcache_if_dirty(self):
2102
"""Write out the hashcache if it is dirty."""
2103
if self._hashcache.needs_write:
2104
try:
2105
self._hashcache.write()
2106
except OSError, e:
2107
if e.errno not in (errno.EPERM, errno.EACCES):
2108
raise
2109
# TODO: jam 20061219 Should this be a warning? A single line
2110
# warning might be sufficient to let the user know what
2111
# is going on.
2112
mutter('Could not write hashcache for %s\nError: %s',
2113
self._hashcache.cache_file_name(), e)
2114
2115
1759
@needs_tree_write_lock
2116
1760
def _write_inventory(self, inv):
2117
1761
"""Write inventory as the current inventory."""
2119
1763
self.flush()
2120
1764
2121
1765
def set_conflicts(self, arg):
2122
raise errors.UnsupportedOperation(self.set_conflicts, self)
1766
raise UnsupportedOperation(self.set_conflicts, self)
2123
1767
2124
1768
def add_conflicts(self, arg):
2125
raise errors.UnsupportedOperation(self.add_conflicts, self)
1769
raise UnsupportedOperation(self.add_conflicts, self)
2126
1770
2127
1771
@needs_read_lock
2128
1772
def conflicts(self):
2150
1794
file_id=self.path2id(conflicted)))
2151
1795
return conflicts
2152
1796
2153
def walkdirs(self, prefix=""):
2154
"""Walk the directories of this tree.
2155
2156
returns a generator which yields items in the form:
2157
((curren_directory_path, fileid),
2158
[(file1_path, file1_name, file1_kind, (lstat), file1_id,
2159
file1_kind), ... ])
2160
2161
This API returns a generator, which is only valid during the current
2162
tree transaction - within a single lock_read or lock_write duration.
2163
2164
If the tree is not locked, it may cause an error to be raised,
2165
depending on the tree implementation.
2166
"""
2167
disk_top = self.abspath(prefix)
2168
if disk_top.endswith('/'):
2169
disk_top = disk_top[:-1]
2170
top_strip_len = len(disk_top) + 1
2171
inventory_iterator = self._walkdirs(prefix)
2172
disk_iterator = osutils.walkdirs(disk_top, prefix)
2173
try:
2174
current_disk = disk_iterator.next()
2175
disk_finished = False
2176
except OSError, e:
2177
if not (e.errno == errno.ENOENT or
2178
(sys.platform == 'win32' and e.errno == ERROR_PATH_NOT_FOUND)):
2179
raise
2180
current_disk = None
2181
disk_finished = True
2182
try:
2183
current_inv = inventory_iterator.next()
2184
inv_finished = False
2185
except StopIteration:
2186
current_inv = None
2187
inv_finished = True
2188
while not inv_finished or not disk_finished:
2189
if not disk_finished:
2190
# strip out .bzr dirs
2191
if current_disk[0][1][top_strip_len:] == '':
2192
# osutils.walkdirs can be made nicer -
2193
# yield the path-from-prefix rather than the pathjoined
2194
# value.
2195
bzrdir_loc = bisect_left(current_disk[1], ('.bzr', '.bzr'))
2196
if current_disk[1][bzrdir_loc][0] == '.bzr':
2197
# we dont yield the contents of, or, .bzr itself.
2198
del current_disk[1][bzrdir_loc]
2199
if inv_finished:
2200
# everything is unknown
2201
direction = 1
2202
elif disk_finished:
2203
# everything is missing
2204
direction = -1
2205
else:
2206
direction = cmp(current_inv[0][0], current_disk[0][0])
2207
if direction > 0:
2208
# disk is before inventory - unknown
2209
dirblock = [(relpath, basename, kind, stat, None, None) for
2210
relpath, basename, kind, stat, top_path in current_disk[1]]
2211
yield (current_disk[0][0], None), dirblock
2212
try:
2213
current_disk = disk_iterator.next()
2214
except StopIteration:
2215
disk_finished = True
2216
elif direction < 0:
2217
# inventory is before disk - missing.
2218
dirblock = [(relpath, basename, 'unknown', None, fileid, kind)
2219
for relpath, basename, dkind, stat, fileid, kind in
2220
current_inv[1]]
2221
yield (current_inv[0][0], current_inv[0][1]), dirblock
2222
try:
2223
current_inv = inventory_iterator.next()
2224
except StopIteration:
2225
inv_finished = True
2226
else:
2227
# versioned present directory
2228
# merge the inventory and disk data together
2229
dirblock = []
2230
for relpath, subiterator in itertools.groupby(sorted(
2231
current_inv[1] + current_disk[1], key=operator.itemgetter(0)), operator.itemgetter(1)):
2232
path_elements = list(subiterator)
2233
if len(path_elements) == 2:
2234
inv_row, disk_row = path_elements
2235
# versioned, present file
2236
dirblock.append((inv_row[0],
2237
inv_row[1], disk_row[2],
2238
disk_row[3], inv_row[4],
2239
inv_row[5]))
2240
elif len(path_elements[0]) == 5:
2241
# unknown disk file
2242
dirblock.append((path_elements[0][0],
2243
path_elements[0][1], path_elements[0][2],
2244
path_elements[0][3], None, None))
2245
elif len(path_elements[0]) == 6:
2246
# versioned, absent file.
2247
dirblock.append((path_elements[0][0],
2248
path_elements[0][1], 'unknown', None,
2249
path_elements[0][4], path_elements[0][5]))
2250
else:
2251
raise NotImplementedError('unreachable code')
2252
yield current_inv[0], dirblock
2253
try:
2254
current_inv = inventory_iterator.next()
2255
except StopIteration:
2256
inv_finished = True
2257
try:
2258
current_disk = disk_iterator.next()
2259
except StopIteration:
2260
disk_finished = True
2261
2262
def _walkdirs(self, prefix=""):
2263
"""Walk the directories of this tree.
2264
2265
:prefix: is used as the directrory to start with.
2266
returns a generator which yields items in the form:
2267
((curren_directory_path, fileid),
2268
[(file1_path, file1_name, file1_kind, None, file1_id,
2269
file1_kind), ... ])
2270
"""
2271
_directory = 'directory'
2272
# get the root in the inventory
2273
inv = self.inventory
2274
top_id = inv.path2id(prefix)
2275
if top_id is None:
2276
pending = []
2277
else:
2278
pending = [(prefix, '', _directory, None, top_id, None)]
2279
while pending:
2280
dirblock = []
2281
currentdir = pending.pop()
2282
# 0 - relpath, 1- basename, 2- kind, 3- stat, 4-id, 5-kind
2283
top_id = currentdir[4]
2284
if currentdir[0]:
2285
relroot = currentdir[0] + '/'
2286
else:
2287
relroot = ""
2288
# FIXME: stash the node in pending
2289
entry = inv[top_id]
2290
for name, child in entry.sorted_children():
2291
dirblock.append((relroot + name, name, child.kind, None,
2292
child.file_id, child.kind
2293
))
2294
yield (currentdir[0], entry.file_id), dirblock
2295
# push the user specified dirs from dirblock
2296
for dir in reversed(dirblock):
2297
if dir[2] == _directory:
2298
pending.append(dir)
2299
2300
@needs_tree_write_lock
2301
def auto_resolve(self):
2302
"""Automatically resolve text conflicts according to contents.
2303
2304
Only text conflicts are auto_resolvable. Files with no conflict markers
2305
are considered 'resolved', because bzr always puts conflict markers
2306
into files that have text conflicts. The corresponding .THIS .BASE and
2307
.OTHER files are deleted, as per 'resolve'.
2308
:return: a tuple of ConflictLists: (un_resolved, resolved).
2309
"""
2310
un_resolved = _mod_conflicts.ConflictList()
2311
resolved = _mod_conflicts.ConflictList()
2312
conflict_re = re.compile('^(<{7}|={7}|>{7})')
2313
for conflict in self.conflicts():
2314
if (conflict.typestring != 'text conflict' or
2315
self.kind(conflict.file_id) != 'file'):
2316
un_resolved.append(conflict)
2317
continue
2318
my_file = open(self.id2abspath(conflict.file_id), 'rb')
2319
try:
2320
for line in my_file:
2321
if conflict_re.search(line):
2322
un_resolved.append(conflict)
2323
break
2324
else:
2325
resolved.append(conflict)
2326
finally:
2327
my_file.close()
2328
resolved.remove_files(self)
2329
self.set_conflicts(un_resolved)
2330
return un_resolved, resolved
2331
2332
def _validate(self):
2333
"""Validate internal structures.
2334
2335
This is meant mostly for the test suite. To give it a chance to detect
2336
corruption after actions have occurred. The default implementation is a
2337
just a no-op.
2338
2339
:return: None. An exception should be raised if there is an error.
2340
"""
2341
return
2342
2343
1797
2344
1798
class WorkingTree2(WorkingTree):
2345
1799
"""This is the Format 2 working tree.
2349
1803
- uses the branch last-revision.
2350
1804
"""
2351
1805
2352
def __init__(self, *args, **kwargs):
2353
super(WorkingTree2, self).__init__(*args, **kwargs)
2354
# WorkingTree2 has more of a constraint that self._inventory must
2355
# exist. Because this is an older format, we don't mind the overhead
2356
# caused by the extra computation here.
2357
2358
# Newer WorkingTree's should only have self._inventory set when they
2359
# have a read lock.
2360
if self._inventory is None:
2361
self.read_working_inventory()
2362
2363
1806
def lock_tree_write(self):
2364
1807
"""See WorkingTree.lock_tree_write().
2365
1808
2379
1822
# _inventory_is_modified is always False during a read lock.
2380
1823
if self._inventory_is_modified:
2381
1824
self.flush()
2382
self._write_hashcache_if_dirty()
2383
1825
if self._hashcache.needs_write:
1826
self._hashcache.write()
2384
1827
# reverse order of locking.
2385
1828
try:
2386
1829
return self._control_files.unlock()
2402
1845
def _last_revision(self):
2403
1846
"""See Mutable.last_revision."""
2404
1847
try:
2405
return osutils.safe_revision_id(
2406
self._control_files.get('last-revision').read())
2407
except errors.NoSuchFile:
1848
return self._control_files.get_utf8('last-revision').read()
1849
except NoSuchFile:
2408
1850
return None
2409
1851
2410
1852
def _change_last_revision(self, revision_id):
2416
1858
pass
2417
1859
return False
2418
1860
else:
2419
self._control_files.put_bytes('last-revision', revision_id)
1861
self._control_files.put_utf8('last-revision', revision_id)
2420
1862
return True
2421
1863
2422
1864
@needs_tree_write_lock
2435
1877
def conflicts(self):
2436
1878
try:
2437
1879
confile = self._control_files.get('conflicts')
2438
except errors.NoSuchFile:
1880
except NoSuchFile:
2439
1881
return _mod_conflicts.ConflictList()
2440
1882
try:
2441
1883
if confile.next() != CONFLICT_HEADER_1 + '\n':
2442
raise errors.ConflictFormatError()
1884
raise ConflictFormatError()
2443
1885
except StopIteration:
2444
raise errors.ConflictFormatError()
1886
raise ConflictFormatError()
2445
1887
return _mod_conflicts.ConflictList.from_stanzas(RioReader(confile))
2446
1888
2447
1889
def unlock(self):
2449
1891
# _inventory_is_modified is always False during a read lock.
2450
1892
if self._inventory_is_modified:
2451
1893
self.flush()
2452
self._write_hashcache_if_dirty()
1894
if self._hashcache.needs_write:
1895
self._hashcache.write()
2453
1896
# reverse order of locking.
2454
1897
try:
2455
1898
return self._control_files.unlock()
2462
1905
if path.endswith(suffix):
2463
1906
return path[:-len(suffix)]
2464
1907
2465
2466
1908
@deprecated_function(zero_eight)
2467
1909
def is_control_file(filename):
2468
1910
"""See WorkingTree.is_control_filename(filename)."""
2503
1945
_formats = {}
2504
1946
"""The known formats."""
2505
1947
2506
requires_rich_root = False
2507
2508
upgrade_recommended = False
2509
2510
1948
@classmethod
2511
1949
def find_format(klass, a_bzrdir):
2512
1950
"""Return the format for the working tree object in a_bzrdir."""
2514
1952
transport = a_bzrdir.get_workingtree_transport(None)
2515
1953
format_string = transport.get("format").read()
2516
1954
return klass._formats[format_string]
2517
except errors.NoSuchFile:
1955
except NoSuchFile:
2518
1956
raise errors.NoWorkingTree(base=transport.base)
2519
1957
except KeyError:
2520
1958
raise errors.UnknownFormatError(format=format_string)
2521
1959
2522
def __eq__(self, other):
2523
return self.__class__ is other.__class__
2524
2525
def __ne__(self, other):
2526
return not (self == other)
2527
2528
1960
@classmethod
2529
1961
def get_default_format(klass):
2530
1962
"""Return the current default format."""
2561
1993
del klass._formats[format.get_format_string()]
2562
1994
2563
1995
1996
2564
1997
class WorkingTreeFormat2(WorkingTreeFormat):
2565
1998
"""The second working tree format.
2566
1999
2567
2000
This format modified the hash cache from the format 1 hash cache.
2568
2001
"""
2569
2002
2570
upgrade_recommended = True
2571
2572
2003
def get_format_description(self):
2573
2004
"""See WorkingTreeFormat.get_format_description()."""
2574
2005
return "Working tree format 2"
2586
2017
sio.seek(0)
2587
2018
control_files.put('inventory', sio)
2588
2019
2589
control_files.put_bytes('pending-merges', '')
2020
control_files.put_utf8('pending-merges', '')
2590
2021
2591
2022
2592
2023
def initialize(self, a_bzrdir, revision_id=None):
2595
2026
raise errors.NotLocalUrl(a_bzrdir.transport.base)
2596
2027
branch = a_bzrdir.open_branch()
2597
2028
if revision_id is not None:
2598
revision_id = osutils.safe_revision_id(revision_id)
2599
2029
branch.lock_write()
2600
2030
try:
2601
2031
revision_history = branch.revision_history()
2637
2067
raise NotImplementedError
2638
2068
if not isinstance(a_bzrdir.transport, LocalTransport):
2639
2069
raise errors.NotLocalUrl(a_bzrdir.transport.base)
2640
wt = WorkingTree2(a_bzrdir.root_transport.local_abspath('.'),
2070
return WorkingTree2(a_bzrdir.root_transport.local_abspath('.'),
2641
2071
_internal=True,
2642
2072
_format=self,
2643
2073
_bzrdir=a_bzrdir)
2644
return wt
2074
2645
2075
2646
2076
class WorkingTreeFormat3(WorkingTreeFormat):
2647
2077
"""The second working tree format updated to record a format marker.
2654
2084
- is new in bzr 0.8
2655
2085
- uses a LockDir to guard access for writes.
2656
2086
"""
2657
2658
upgrade_recommended = True
2659
2087
2660
2088
def get_format_string(self):
2661
2089
"""See WorkingTreeFormat.get_format_string()."""
2668
2096
_lock_file_name = 'lock'
2669
2097
_lock_class = LockDir
2670
2098
2671
_tree_class = WorkingTree3
2672
2673
def __get_matchingbzrdir(self):
2674
return bzrdir.BzrDirMetaFormat1()
2675
2676
_matchingbzrdir = property(__get_matchingbzrdir)
2677
2678
2099
def _open_control_files(self, a_bzrdir):
2679
2100
transport = a_bzrdir.get_workingtree_transport(None)
2680
2101
return LockableFiles(transport, self._lock_file_name,
2696
2117
branch = a_bzrdir.open_branch()
2697
2118
if revision_id is None:
2698
2119
revision_id = branch.last_revision()
2699
else:
2700
revision_id = osutils.safe_revision_id(revision_id)
2701
2120
# WorkingTree3 can handle an inventory which has a unique root id.
2702
2121
# as of bzr 0.12. However, bzr 0.11 and earlier fail to handle
2703
2122
# those trees. And because there isn't a format bump inbetween, we
2704
2123
# are maintaining compatibility with older clients.
2705
2124
# inv = Inventory(root_id=gen_root_id())
2706
inv = self._initial_inventory()
2707
wt = self._tree_class(a_bzrdir.root_transport.local_abspath('.'),
2125
inv = Inventory()
2126
wt = WorkingTree3(a_bzrdir.root_transport.local_abspath('.'),
2708
2127
branch,
2709
2128
inv,
2710
2129
_internal=True,
2729
2148
wt.unlock()
2730
2149
return wt
2731
2150
2732
def _initial_inventory(self):
2733
return Inventory()
2734
2735
2151
def __init__(self):
2736
2152
super(WorkingTreeFormat3, self).__init__()
2153
self._matchingbzrdir = bzrdir.BzrDirMetaFormat1()
2737
2154
2738
2155
def open(self, a_bzrdir, _found=False):
2739
2156
"""Return the WorkingTree object for a_bzrdir
2746
2163
raise NotImplementedError
2747
2164
if not isinstance(a_bzrdir.transport, LocalTransport):
2748
2165
raise errors.NotLocalUrl(a_bzrdir.transport.base)
2749
wt = self._open(a_bzrdir, self._open_control_files(a_bzrdir))
2750
return wt
2166
return self._open(a_bzrdir, self._open_control_files(a_bzrdir))
2751
2167
2752
2168
def _open(self, a_bzrdir, control_files):
2753
2169
"""Open the tree itself.
2755
2171
:param a_bzrdir: the dir for the tree.
2756
2172
:param control_files: the control files for the tree.
2757
2173
"""
2758
return self._tree_class(a_bzrdir.root_transport.local_abspath('.'),
2759
_internal=True,
2760
_format=self,
2761
_bzrdir=a_bzrdir,
2762
_control_files=control_files)
2174
return WorkingTree3(a_bzrdir.root_transport.local_abspath('.'),
2175
_internal=True,
2176
_format=self,
2177
_bzrdir=a_bzrdir,
2178
_control_files=control_files)
2763
2179
2764
2180
def __str__(self):
2765
2181
return self.get_format_string()
2766
2182
2767
2183
2768
__default_format = WorkingTreeFormat4()
2184
# formats which have no format string are not discoverable
2185
# and not independently creatable, so are not registered.
2186
__default_format = WorkingTreeFormat3()
2769
2187
WorkingTreeFormat.register_format(__default_format)
2770
WorkingTreeFormat.register_format(WorkingTreeFormat3())
2771
2188
WorkingTreeFormat.set_default_format(__default_format)
2772
# formats which have no format string are not discoverable
2773
# and not independently creatable, so are not registered.
2774
2189
_legacy_formats = [WorkingTreeFormat2(),
2775
2190
]
2191
2192
2193
class WorkingTreeTestProviderAdapter(object):
2194
"""A tool to generate a suite testing multiple workingtree formats at once.
2195
2196
This is done by copying the test once for each transport and injecting
2197
the transport_server, transport_readonly_server, and workingtree_format
2198
classes into each copy. Each copy is also given a new id() to make it
2199
easy to identify.
2200
"""
2201
2202
def __init__(self, transport_server, transport_readonly_server, formats):
2203
self._transport_server = transport_server
2204
self._transport_readonly_server = transport_readonly_server
2205
self._formats = formats
2206
2207
def _clone_test(self, test, bzrdir_format, workingtree_format, variation):
2208
"""Clone test for adaption."""
2209
new_test = deepcopy(test)
2210
new_test.transport_server = self._transport_server
2211
new_test.transport_readonly_server = self._transport_readonly_server
2212
new_test.bzrdir_format = bzrdir_format
2213
new_test.workingtree_format = workingtree_format
2214
def make_new_test_id():
2215
new_id = "%s(%s)" % (test.id(), variation)
2216
return lambda: new_id
2217
new_test.id = make_new_test_id()
2218
return new_test
2219
2220
def adapt(self, test):
2221
from bzrlib.tests import TestSuite
2222
result = TestSuite()
2223
for workingtree_format, bzrdir_format in self._formats:
2224
new_test = self._clone_test(
2225
test,
2226
bzrdir_format,
2227
workingtree_format, workingtree_format.__class__.__name__)
2228
result.addTest(new_test)
2229
return result
Loggerhead is a web-based interface for Breezy
Version: 2.0.1