« back to all changes in this revision
Viewing changes to bzrlib/workingtree.py
- browse files at revision 1739.1.3
- compare with another revision
- compare with revision 5452
- download diff
- download tarball
- view history from revision 1739.1.3
- Committer: Robert Collins
- Date: 2007-03-08 04:06:06 UTC
- mfrom: (2323.1.1 integration)
- mto: This revision was merged to the branch mainline in revision 2442.
- Revision ID: robertc@robertcollins.net-20070308040606-84gsniv56huiyjt4
Merge bzr.dev.
- files added:
- COPYING.txt
- bzrlib/benchmarks/tree_creator
- bzrlib/repofmt
- bzrlib/tests/intertree_implementations
- bzrlib/tests/tree_implementations
- bzrlib/version_info_formats
- tools/win32
- files removed:
- bzrlib/util/configobj/validate.py
- bzrlib/util/urlgrabber
- files renamed:
- bzrlib/bundle/read_bundle.py => bzrlib/bundle/bundle_data.py
- bzrlib/bundle/serializer/v07.py => bzrlib/bundle/serializer/v08.py
- bzrlib/tests/test_revprops.py => bzrlib/tests/repository_implementations/test_revision.py
- bzrlib/tests/test_command.py => bzrlib/tests/test_commands.py
- bzrlib/win32console.py => bzrlib/win32utils.py
- files modified:
- .bzrignore
added
removed
bzrlib/workingtree.py
1
# Copyright (C) 2005, 2006 Canonical Ltd
2
1
# Copyright (C) 2005, 2006, 2007 Canonical Ltd
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
5
5
# the Free Software Foundation; either version 2 of the License, or
6
6
# (at your option) any later version.
7
7
#
8
8
# This program is distributed in the hope that it will be useful,
9
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11
11
# GNU General Public License for more details.
12
12
#
13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
29
29
WorkingTree.open(dir).
30
30
"""
31
31
32
MERGE_MODIFIED_HEADER_1 = "BZR merge-modified list format 1"
33
CONFLICT_HEADER_1 = "BZR conflict list format 1"
34
35
32
# TODO: Give the workingtree sole responsibility for the working inventory;
36
33
# remove the variable and references to it from the branch. This may require
37
34
# updating the commit code so as to update the inventory within the working
39
36
# At the moment they may alias the inventory and have old copies of it in
40
37
# memory. (Now done? -- mbp 20060309)
41
38
42
from binascii import hexlify
39
from cStringIO import StringIO
40
import os
41
42
from bzrlib.lazy_import import lazy_import
43
lazy_import(globals(), """
44
from bisect import bisect_left
43
45
import collections
44
46
from copy import deepcopy
45
from cStringIO import StringIO
46
47
import errno
47
import fnmatch
48
import os
49
import re
48
import itertools
49
import operator
50
50
import stat
51
51
from time import time
52
53
from bzrlib.atomicfile import AtomicFile
54
from bzrlib.branch import (Branch,
55
quotefn)
56
from bzrlib.conflicts import Conflict, ConflictList, CONFLICT_SUFFIXES
57
import bzrlib.bzrdir as bzrdir
52
import warnings
53
import re
54
55
import bzrlib
56
from bzrlib import (
57
branch,
58
bzrdir,
59
conflicts as _mod_conflicts,
60
dirstate,
61
errors,
62
generate_ids,
63
globbing,
64
hashcache,
65
ignores,
66
merge,
67
osutils,
68
revisiontree,
69
repository,
70
textui,
71
transform,
72
urlutils,
73
xml5,
74
xml6,
75
xml7,
76
)
77
import bzrlib.branch
78
from bzrlib.transport import get_transport
79
import bzrlib.ui
80
from bzrlib.workingtree_4 import WorkingTreeFormat4
81
""")
82
83
from bzrlib import symbol_versioning
58
84
from bzrlib.decorators import needs_read_lock, needs_write_lock
59
import bzrlib.errors as errors
60
from bzrlib.errors import (BzrCheckError,
61
BzrError,
62
ConflictFormatError,
63
DivergedBranches,
64
WeaveRevisionNotPresent,
65
NotBranchError,
66
NoSuchFile,
67
NotVersionedError,
68
MergeModifiedFormatError,
69
UnsupportedOperation,
70
)
71
from bzrlib.inventory import InventoryEntry, Inventory
85
from bzrlib.inventory import InventoryEntry, Inventory, ROOT_ID, TreeReference
72
86
from bzrlib.lockable_files import LockableFiles, TransportLock
73
87
from bzrlib.lockdir import LockDir
74
from bzrlib.merge import merge_inner, transform_tree
88
import bzrlib.mutabletree
89
from bzrlib.mutabletree import needs_tree_write_lock
75
90
from bzrlib.osutils import (
76
abspath,
77
compact_date,
78
file_kind,
79
isdir,
80
getcwd,
81
pathjoin,
82
pumpfile,
83
safe_unicode,
84
splitpath,
85
rand_chars,
86
normpath,
87
realpath,
88
relpath,
89
rename,
90
supports_executable,
91
)
91
compact_date,
92
file_kind,
93
isdir,
94
normpath,
95
pathjoin,
96
rand_chars,
97
realpath,
98
safe_unicode,
99
splitpath,
100
supports_executable,
101
)
102
from bzrlib.trace import mutter, note
103
from bzrlib.transport.local import LocalTransport
92
104
from bzrlib.progress import DummyProgress, ProgressPhase
93
from bzrlib.revision import NULL_REVISION
105
from bzrlib.revision import NULL_REVISION, CURRENT_REVISION
94
106
from bzrlib.rio import RioReader, rio_file, Stanza
95
from bzrlib.symbol_versioning import *
96
from bzrlib.textui import show_status
97
import bzrlib.tree
98
from bzrlib.transform import build_tree
99
from bzrlib.trace import mutter, note
100
from bzrlib.transport import get_transport
101
from bzrlib.transport.local import LocalTransport
102
import bzrlib.ui
103
import bzrlib.xml5
104
105
106
# the regex here does the following:
107
# 1) remove any weird characters; we don't escape them but rather
108
# just pull them out
109
# 2) match leading '.'s to make it not hidden
110
_gen_file_id_re = re.compile(r'[^\w.]|(^\.*)')
111
_gen_id_suffix = None
112
_gen_id_serial = 0
113
114
115
def _next_id_suffix():
116
"""Create a new file id suffix that is reasonably unique.
117
118
On the first call we combine the current time with 64 bits of randomness
119
to give a highly probably globally unique number. Then each call in the same
120
process adds 1 to a serial number we append to that unique value.
121
"""
122
# XXX TODO: change bzrlib.add.smart_add to call workingtree.add() rather
123
# than having to move the id randomness out of the inner loop like this.
124
# XXX TODO: for the global randomness this uses we should add the thread-id
125
# before the serial #.
126
global _gen_id_suffix, _gen_id_serial
127
if _gen_id_suffix is None:
128
_gen_id_suffix = "-%s-%s-" % (compact_date(time()), rand_chars(16))
129
_gen_id_serial += 1
130
return _gen_id_suffix + str(_gen_id_serial)
131
132
107
from bzrlib.symbol_versioning import (deprecated_passed,
108
deprecated_method,
109
deprecated_function,
110
DEPRECATED_PARAMETER,
111
zero_eight,
112
zero_eleven,
113
zero_thirteen,
114
)
115
116
117
MERGE_MODIFIED_HEADER_1 = "BZR merge-modified list format 1"
118
CONFLICT_HEADER_1 = "BZR conflict list format 1"
119
120
121
@deprecated_function(zero_thirteen)
133
122
def gen_file_id(name):
134
123
"""Return new file id for the basename 'name'.
135
124
136
The uniqueness is supplied from _next_id_suffix.
125
Use bzrlib.generate_ids.gen_file_id() instead
137
126
"""
138
# XXX TODO: squash the filename to lowercase.
139
# XXX TODO: truncate the filename to something like 20 or 30 chars.
140
# XXX TODO: consider what to do with ids that look like illegal filepaths
141
# on platforms we support.
142
return _gen_file_id_re.sub('', name) + _next_id_suffix()
143
144
127
return generate_ids.gen_file_id(name)
128
129
130
@deprecated_function(zero_thirteen)
145
131
def gen_root_id():
146
"""Return a new tree-root file id."""
147
return gen_file_id('TREE_ROOT')
132
"""Return a new tree-root file id.
133
134
This has been deprecated in favor of bzrlib.generate_ids.gen_root_id()
135
"""
136
return generate_ids.gen_root_id()
148
137
149
138
150
139
class TreeEntry(object):
151
"""An entry that implements the minium interface used by commands.
140
"""An entry that implements the minimum interface used by commands.
152
141
153
142
This needs further inspection, it may be better to have
154
143
InventoryEntries without ids - though that seems wrong. For now,
202
191
return ''
203
192
204
193
205
class WorkingTree(bzrlib.tree.Tree):
194
class WorkingTree(bzrlib.mutabletree.MutableTree):
206
195
"""Working copy tree.
207
196
208
197
The inventory is held in the `Branch` working-inventory, and the
230
219
self.bzrdir = _bzrdir
231
220
if not _internal:
232
221
# not created via open etc.
233
warn("WorkingTree() is deprecated as of bzr version 0.8. "
222
warnings.warn("WorkingTree() is deprecated as of bzr version 0.8. "
234
223
"Please use bzrdir.open_workingtree or WorkingTree.open().",
235
224
DeprecationWarning,
236
225
stacklevel=2)
239
228
self.basedir = wt.basedir
240
229
self._control_files = wt._control_files
241
230
self._hashcache = wt._hashcache
242
self._set_inventory(wt._inventory)
231
self._set_inventory(wt._inventory, dirty=False)
243
232
self._format = wt._format
244
233
self.bzrdir = wt.bzrdir
245
from bzrlib.hashcache import HashCache
246
from bzrlib.trace import note, mutter
247
234
assert isinstance(basedir, basestring), \
248
235
"base directory %r is not a string" % basedir
249
236
basedir = safe_unicode(basedir)
250
237
mutter("opening working tree %r", basedir)
251
238
if deprecated_passed(branch):
252
239
if not _internal:
253
warn("WorkingTree(..., branch=XXX) is deprecated as of bzr 0.8."
254
" Please use bzrdir.open_workingtree() or"
240
warnings.warn("WorkingTree(..., branch=XXX) is deprecated"
241
" as of bzr 0.8. Please use bzrdir.open_workingtree() or"
255
242
" WorkingTree.open().",
256
243
DeprecationWarning,
257
244
stacklevel=2
259
246
self._branch = branch
260
247
else:
261
248
self._branch = self.bzrdir.open_branch()
262
assert isinstance(self.branch, Branch), \
263
"branch %r is not a Branch" % self.branch
264
249
self.basedir = realpath(basedir)
265
250
# if branch is at our basedir and is a format 6 or less
266
251
if isinstance(self._format, WorkingTreeFormat2):
267
252
# share control object
268
253
self._control_files = self.branch.control_files
269
254
else:
270
# only ready for format 3
271
assert isinstance(self._format, WorkingTreeFormat3)
255
# assume all other formats have their own control files.
272
256
assert isinstance(_control_files, LockableFiles), \
273
257
"_control_files must be a LockableFiles, not %r" \
274
258
% _control_files
279
263
# if needed, or, when the cache sees a change, append it to the hash
280
264
# cache file, and have the parser take the most recent entry for a
281
265
# given path only.
282
cache_filename = self.bzrdir.get_workingtree_transport(None).abspath('stat-cache')
283
hc = self._hashcache = HashCache(basedir, cache_filename, self._control_files._file_mode)
266
wt_trans = self.bzrdir.get_workingtree_transport(None)
267
cache_filename = wt_trans.local_abspath('stat-cache')
268
self._hashcache = hashcache.HashCache(basedir, cache_filename,
269
self._control_files._file_mode)
270
hc = self._hashcache
284
271
hc.read()
285
272
# is this scan needed ? it makes things kinda slow.
286
273
#hc.scan()
290
277
hc.write()
291
278
292
279
if _inventory is None:
293
self._set_inventory(self.read_working_inventory())
280
self._inventory_is_modified = False
281
self.read_working_inventory()
294
282
else:
295
self._set_inventory(_inventory)
283
# the caller of __init__ has provided an inventory,
284
# we assume they know what they are doing - as its only
285
# the Format factory and creation methods that are
286
# permitted to do this.
287
self._set_inventory(_inventory, dirty=False)
296
288
297
289
branch = property(
298
290
fget=lambda self: self._branch,
313
305
self._control_files.break_lock()
314
306
self.branch.break_lock()
315
307
316
def _set_inventory(self, inv):
308
def requires_rich_root(self):
309
return self._format.requires_rich_root
310
311
def supports_tree_reference(self):
312
return False
313
314
def _set_inventory(self, inv, dirty):
315
"""Set the internal cached inventory.
316
317
:param inv: The inventory to set.
318
:param dirty: A boolean indicating whether the inventory is the same
319
logical inventory as whats on disk. If True the inventory is not
320
the same and should be written to disk or data will be lost, if
321
False then the inventory is the same as that on disk and any
322
serialisation would be unneeded overhead.
323
"""
324
assert inv.root is not None
317
325
self._inventory = inv
318
self.path2id = self._inventory.path2id
319
320
def is_control_filename(self, filename):
321
"""True if filename is the name of a control file in this tree.
322
323
:param filename: A filename within the tree. This is a relative path
324
from the root of this tree.
325
326
This is true IF and ONLY IF the filename is part of the meta data
327
that bzr controls in this tree. I.E. a random .bzr directory placed
328
on disk will not be a control file for this tree.
329
"""
330
return self.bzrdir.is_control_filename(filename)
326
self._inventory_is_modified = dirty
331
327
332
328
@staticmethod
333
329
def open(path=None, _unsupported=False):
349
345
run into /. If there isn't one, raises NotBranchError.
350
346
TODO: give this a new exception.
351
347
If there is one, it is returned, along with the unused portion of path.
348
349
:return: The WorkingTree that contains 'path', and the rest of path
352
350
"""
353
351
if path is None:
354
path = os.getcwdu()
352
path = osutils.getcwd()
355
353
control, relpath = bzrdir.BzrDir.open_containing(path)
354
356
355
return control.open_workingtree(), relpath
357
356
358
357
@staticmethod
363
362
"""
364
363
return WorkingTree.open(path, _unsupported=True)
365
364
365
# should be deprecated - this is slow and in any case treating them as a
366
# container is (we now know) bad style -- mbp 20070302
367
## @deprecated_method(zero_fifteen)
366
368
def __iter__(self):
367
369
"""Iterate through file_ids for this tree.
368
370
371
373
"""
372
374
inv = self._inventory
373
375
for path, ie in inv.iter_entries():
374
if bzrlib.osutils.lexists(self.abspath(path)):
376
if osutils.lexists(self.abspath(path)):
375
377
yield ie.file_id
376
378
377
379
def __repr__(self):
382
384
return pathjoin(self.basedir, filename)
383
385
384
386
def basis_tree(self):
385
"""Return RevisionTree for the current last revision."""
386
revision_id = self.last_revision()
387
if revision_id is not None:
388
try:
389
xml = self.read_basis_inventory()
390
inv = bzrlib.xml5.serializer_v5.read_inventory_from_string(xml)
391
except NoSuchFile:
392
inv = None
393
if inv is not None and inv.revision_id == revision_id:
394
return bzrlib.tree.RevisionTree(self.branch.repository, inv,
395
revision_id)
396
# FIXME? RBC 20060403 should we cache the inventory here ?
397
return self.branch.repository.revision_tree(revision_id)
387
"""Return RevisionTree for the current last revision.
388
389
If the left most parent is a ghost then the returned tree will be an
390
empty tree - one obtained by calling repository.revision_tree(None).
391
"""
392
try:
393
revision_id = self.get_parent_ids()[0]
394
except IndexError:
395
# no parents, return an empty revision tree.
396
# in the future this should return the tree for
397
# 'empty:' - the implicit root empty tree.
398
return self.branch.repository.revision_tree(None)
399
try:
400
return self.revision_tree(revision_id)
401
except errors.NoSuchRevision:
402
pass
403
# No cached copy available, retrieve from the repository.
404
# FIXME? RBC 20060403 should we cache the inventory locally
405
# at this point ?
406
try:
407
return self.branch.repository.revision_tree(revision_id)
408
except errors.RevisionNotPresent:
409
# the basis tree *may* be a ghost or a low level error may have
410
# occured. If the revision is present, its a problem, if its not
411
# its a ghost.
412
if self.branch.repository.has_revision(revision_id):
413
raise
414
# the basis tree is a ghost so return an empty tree.
415
return self.branch.repository.revision_tree(None)
398
416
399
417
@staticmethod
400
418
@deprecated_method(zero_eight)
413
431
XXX: When BzrDir is present, these should be created through that
414
432
interface instead.
415
433
"""
416
warn('delete WorkingTree.create', stacklevel=3)
434
warnings.warn('delete WorkingTree.create', stacklevel=3)
417
435
transport = get_transport(directory)
418
436
if branch.bzrdir.root_transport.base == transport.base:
419
437
# same dir
440
458
The path may be absolute or relative. If its a relative path it is
441
459
interpreted relative to the python current working directory.
442
460
"""
443
return relpath(self.basedir, path)
461
return osutils.relpath(self.basedir, path)
444
462
445
463
def has_filename(self, filename):
446
return bzrlib.osutils.lexists(self.abspath(filename))
464
return osutils.lexists(self.abspath(filename))
447
465
448
466
def get_file(self, file_id):
467
file_id = osutils.safe_file_id(file_id)
449
468
return self.get_file_byname(self.id2path(file_id))
450
469
470
def get_file_text(self, file_id):
471
file_id = osutils.safe_file_id(file_id)
472
return self.get_file(file_id).read()
473
451
474
def get_file_byname(self, filename):
452
475
return file(self.abspath(filename), 'rb')
453
476
477
@needs_read_lock
478
def annotate_iter(self, file_id):
479
"""See Tree.annotate_iter
480
481
This implementation will use the basis tree implementation if possible.
482
Lines not in the basis are attributed to CURRENT_REVISION
483
484
If there are pending merges, lines added by those merges will be
485
incorrectly attributed to CURRENT_REVISION (but after committing, the
486
attribution will be correct).
487
"""
488
file_id = osutils.safe_file_id(file_id)
489
basis = self.basis_tree()
490
basis.lock_read()
491
try:
492
changes = self._iter_changes(basis, True, [self.id2path(file_id)],
493
require_versioned=True).next()
494
changed_content, kind = changes[2], changes[6]
495
if not changed_content:
496
return basis.annotate_iter(file_id)
497
if kind[1] is None:
498
return None
499
import annotate
500
if kind[0] != 'file':
501
old_lines = []
502
else:
503
old_lines = list(basis.annotate_iter(file_id))
504
old = [old_lines]
505
for tree in self.branch.repository.revision_trees(
506
self.get_parent_ids()[1:]):
507
if file_id not in tree:
508
continue
509
old.append(list(tree.annotate_iter(file_id)))
510
return annotate.reannotate(old, self.get_file(file_id).readlines(),
511
CURRENT_REVISION)
512
finally:
513
basis.unlock()
514
515
def get_parent_ids(self):
516
"""See Tree.get_parent_ids.
517
518
This implementation reads the pending merges list and last_revision
519
value and uses that to decide what the parents list should be.
520
"""
521
last_rev = self._last_revision()
522
if last_rev is None:
523
parents = []
524
else:
525
parents = [last_rev]
526
try:
527
merges_file = self._control_files.get('pending-merges')
528
except errors.NoSuchFile:
529
pass
530
else:
531
for l in merges_file.readlines():
532
revision_id = osutils.safe_revision_id(l.rstrip('\n'))
533
parents.append(revision_id)
534
return parents
535
536
@needs_read_lock
454
537
def get_root_id(self):
455
538
"""Return the id of this trees root"""
456
inv = self.read_working_inventory()
457
return inv.root.file_id
539
return self._inventory.root.file_id
458
540
459
541
def _get_store_filename(self, file_id):
460
542
## XXX: badly named; this is not in the store at all
543
file_id = osutils.safe_file_id(file_id)
461
544
return self.abspath(self.id2path(file_id))
462
545
463
546
@needs_read_lock
486
569
@needs_read_lock
487
570
def copy_content_into(self, tree, revision_id=None):
488
571
"""Copy the current content and user files of this tree into tree."""
572
tree.set_root_id(self.get_root_id())
489
573
if revision_id is None:
490
transform_tree(tree, self)
574
merge.transform_tree(tree, self)
491
575
else:
492
# TODO now merge from tree.last_revision to revision
493
transform_tree(tree, self)
494
tree.set_last_revision(revision_id)
495
496
@needs_write_lock
497
def commit(self, message=None, revprops=None, *args, **kwargs):
498
# avoid circular imports
499
from bzrlib.commit import Commit
500
if revprops is None:
501
revprops = {}
502
if not 'branch-nick' in revprops:
503
revprops['branch-nick'] = self.branch.nick
504
# args for wt.commit start at message from the Commit.commit method,
505
# but with branch a kwarg now, passing in args as is results in the
506
#message being used for the branch
507
args = (DEPRECATED_PARAMETER, message, ) + args
508
Commit().commit(working_tree=self, revprops=revprops, *args, **kwargs)
509
self._set_inventory(self.read_working_inventory())
576
# TODO now merge from tree.last_revision to revision (to preserve
577
# user local changes)
578
merge.transform_tree(tree, self)
579
tree.set_parent_ids([revision_id])
510
580
511
581
def id2abspath(self, file_id):
582
file_id = osutils.safe_file_id(file_id)
512
583
return self.abspath(self.id2path(file_id))
513
584
514
585
def has_id(self, file_id):
515
586
# files that have been deleted are excluded
516
inv = self._inventory
587
file_id = osutils.safe_file_id(file_id)
588
inv = self.inventory
517
589
if not inv.has_id(file_id):
518
590
return False
519
591
path = inv.id2path(file_id)
520
return bzrlib.osutils.lexists(self.abspath(path))
592
return osutils.lexists(self.abspath(path))
521
593
522
594
def has_or_had_id(self, file_id):
595
file_id = osutils.safe_file_id(file_id)
523
596
if file_id == self.inventory.root.file_id:
524
597
return True
525
598
return self.inventory.has_id(file_id)
527
600
__contains__ = has_id
528
601
529
602
def get_file_size(self, file_id):
603
file_id = osutils.safe_file_id(file_id)
530
604
return os.path.getsize(self.id2abspath(file_id))
531
605
532
606
@needs_read_lock
533
def get_file_sha1(self, file_id, path=None):
607
def get_file_sha1(self, file_id, path=None, stat_value=None):
608
file_id = osutils.safe_file_id(file_id)
534
609
if not path:
535
610
path = self._inventory.id2path(file_id)
536
return self._hashcache.get_sha1(path)
611
return self._hashcache.get_sha1(path, stat_value)
612
613
def get_file_mtime(self, file_id, path=None):
614
file_id = osutils.safe_file_id(file_id)
615
if not path:
616
path = self.inventory.id2path(file_id)
617
return os.lstat(self.abspath(path)).st_mtime
537
618
538
619
if not supports_executable():
539
620
def is_executable(self, file_id, path=None):
621
file_id = osutils.safe_file_id(file_id)
540
622
return self._inventory[file_id].executable
541
623
else:
542
624
def is_executable(self, file_id, path=None):
543
625
if not path:
544
path = self._inventory.id2path(file_id)
626
file_id = osutils.safe_file_id(file_id)
627
path = self.id2path(file_id)
545
628
mode = os.lstat(self.abspath(path)).st_mode
546
return bool(stat.S_ISREG(mode) and stat.S_IEXEC&mode)
547
548
@needs_write_lock
549
def add(self, files, ids=None):
550
"""Make files versioned.
551
552
Note that the command line normally calls smart_add instead,
553
which can automatically recurse.
554
555
This adds the files to the inventory, so that they will be
556
recorded by the next commit.
557
558
files
559
List of paths to add, relative to the base of the tree.
560
561
ids
562
If set, use these instead of automatically generated ids.
563
Must be the same length as the list of files, but may
564
contain None for ids that are to be autogenerated.
565
566
TODO: Perhaps have an option to add the ids even if the files do
567
not (yet) exist.
568
569
TODO: Perhaps callback with the ids and paths as they're added.
570
"""
629
return bool(stat.S_ISREG(mode) and stat.S_IEXEC & mode)
630
631
@needs_tree_write_lock
632
def _add(self, files, ids, kinds):
633
"""See MutableTree._add."""
571
634
# TODO: Re-adding a file that is removed in the working copy
572
635
# should probably put it back with the previous ID.
573
if isinstance(files, basestring):
574
assert(ids is None or isinstance(ids, basestring))
575
files = [files]
576
if ids is not None:
577
ids = [ids]
578
579
if ids is None:
580
ids = [None] * len(files)
581
else:
582
assert(len(ids) == len(files))
583
636
# the read and write working inventory should not occur in this
637
# function - they should be part of lock_write and unlock.
584
638
inv = self.read_working_inventory()
585
for f,file_id in zip(files, ids):
586
if self.is_control_filename(f):
587
raise BzrError("cannot add control file %s" % quotefn(f))
588
589
fp = splitpath(f)
590
591
if len(fp) == 0:
592
raise BzrError("cannot add top-level %r" % f)
593
594
fullpath = normpath(self.abspath(f))
595
596
try:
597
kind = file_kind(fullpath)
598
except OSError, e:
599
if e.errno == errno.ENOENT:
600
raise NoSuchFile(fullpath)
601
# maybe something better?
602
raise BzrError('cannot add: not a regular file, symlink or directory: %s' % quotefn(f))
603
604
if not InventoryEntry.versionable_kind(kind):
605
raise BzrError('cannot add: not a versionable file ('
606
'i.e. regular file, symlink or directory): %s' % quotefn(f))
607
639
for f, file_id, kind in zip(files, ids, kinds):
640
assert kind is not None
608
641
if file_id is None:
609
642
inv.add_path(f, kind=kind)
610
643
else:
644
file_id = osutils.safe_file_id(file_id)
611
645
inv.add_path(f, kind=kind, file_id=file_id)
612
613
646
self._write_inventory(inv)
614
647
648
@needs_tree_write_lock
649
def _gather_kinds(self, files, kinds):
650
"""See MutableTree._gather_kinds."""
651
for pos, f in enumerate(files):
652
if kinds[pos] is None:
653
fullpath = normpath(self.abspath(f))
654
try:
655
kinds[pos] = file_kind(fullpath)
656
except OSError, e:
657
if e.errno == errno.ENOENT:
658
raise errors.NoSuchFile(fullpath)
659
615
660
@needs_write_lock
661
def add_parent_tree_id(self, revision_id, allow_leftmost_as_ghost=False):
662
"""Add revision_id as a parent.
663
664
This is equivalent to retrieving the current list of parent ids
665
and setting the list to its value plus revision_id.
666
667
:param revision_id: The revision id to add to the parent list. It may
668
be a ghost revision as long as its not the first parent to be added,
669
or the allow_leftmost_as_ghost parameter is set True.
670
:param allow_leftmost_as_ghost: Allow the first parent to be a ghost.
671
"""
672
parents = self.get_parent_ids() + [revision_id]
673
self.set_parent_ids(parents, allow_leftmost_as_ghost=len(parents) > 1
674
or allow_leftmost_as_ghost)
675
676
@needs_tree_write_lock
677
def add_parent_tree(self, parent_tuple, allow_leftmost_as_ghost=False):
678
"""Add revision_id, tree tuple as a parent.
679
680
This is equivalent to retrieving the current list of parent trees
681
and setting the list to its value plus parent_tuple. See also
682
add_parent_tree_id - if you only have a parent id available it will be
683
simpler to use that api. If you have the parent already available, using
684
this api is preferred.
685
686
:param parent_tuple: The (revision id, tree) to add to the parent list.
687
If the revision_id is a ghost, pass None for the tree.
688
:param allow_leftmost_as_ghost: Allow the first parent to be a ghost.
689
"""
690
parent_ids = self.get_parent_ids() + [parent_tuple[0]]
691
if len(parent_ids) > 1:
692
# the leftmost may have already been a ghost, preserve that if it
693
# was.
694
allow_leftmost_as_ghost = True
695
self.set_parent_ids(parent_ids,
696
allow_leftmost_as_ghost=allow_leftmost_as_ghost)
697
698
@needs_tree_write_lock
616
699
def add_pending_merge(self, *revision_ids):
617
700
# TODO: Perhaps should check at this point that the
618
701
# history of the revision is actually present?
619
p = self.pending_merges()
702
parents = self.get_parent_ids()
620
703
updated = False
621
704
for rev_id in revision_ids:
622
if rev_id in p:
705
if rev_id in parents:
623
706
continue
624
p.append(rev_id)
707
parents.append(rev_id)
625
708
updated = True
626
709
if updated:
627
self.set_pending_merges(p)
710
self.set_parent_ids(parents, allow_leftmost_as_ghost=True)
628
711
712
@deprecated_method(zero_eleven)
629
713
@needs_read_lock
630
714
def pending_merges(self):
631
715
"""Return a list of pending merges.
632
716
633
717
These are revisions that have been merged into the working
634
718
directory but not yet committed.
635
"""
636
try:
637
merges_file = self._control_files.get_utf8('pending-merges')
638
except OSError, e:
639
if e.errno != errno.ENOENT:
640
raise
641
return []
642
p = []
643
for l in merges_file.readlines():
644
p.append(l.rstrip('\n'))
645
return p
646
647
@needs_write_lock
719
720
As of 0.11 this is deprecated. Please see WorkingTree.get_parent_ids()
721
instead - which is available on all tree objects.
722
"""
723
return self.get_parent_ids()[1:]
724
725
def _check_parents_for_ghosts(self, revision_ids, allow_leftmost_as_ghost):
726
"""Common ghost checking functionality from set_parent_*.
727
728
This checks that the left hand-parent exists if there are any
729
revisions present.
730
"""
731
if len(revision_ids) > 0:
732
leftmost_id = revision_ids[0]
733
if (not allow_leftmost_as_ghost and not
734
self.branch.repository.has_revision(leftmost_id)):
735
raise errors.GhostRevisionUnusableHere(leftmost_id)
736
737
def _set_merges_from_parent_ids(self, parent_ids):
738
merges = parent_ids[1:]
739
self._control_files.put_bytes('pending-merges', '\n'.join(merges))
740
741
@needs_tree_write_lock
742
def set_parent_ids(self, revision_ids, allow_leftmost_as_ghost=False):
743
"""Set the parent ids to revision_ids.
744
745
See also set_parent_trees. This api will try to retrieve the tree data
746
for each element of revision_ids from the trees repository. If you have
747
tree data already available, it is more efficient to use
748
set_parent_trees rather than set_parent_ids. set_parent_ids is however
749
an easier API to use.
750
751
:param revision_ids: The revision_ids to set as the parent ids of this
752
working tree. Any of these may be ghosts.
753
"""
754
revision_ids = [osutils.safe_revision_id(r) for r in revision_ids]
755
self._check_parents_for_ghosts(revision_ids,
756
allow_leftmost_as_ghost=allow_leftmost_as_ghost)
757
758
if len(revision_ids) > 0:
759
self.set_last_revision(revision_ids[0])
760
else:
761
self.set_last_revision(None)
762
763
self._set_merges_from_parent_ids(revision_ids)
764
765
@needs_tree_write_lock
766
def set_parent_trees(self, parents_list, allow_leftmost_as_ghost=False):
767
"""See MutableTree.set_parent_trees."""
768
parent_ids = [osutils.safe_revision_id(rev) for (rev, tree) in parents_list]
769
770
self._check_parents_for_ghosts(parent_ids,
771
allow_leftmost_as_ghost=allow_leftmost_as_ghost)
772
773
if len(parent_ids) == 0:
774
leftmost_parent_id = None
775
leftmost_parent_tree = None
776
else:
777
leftmost_parent_id, leftmost_parent_tree = parents_list[0]
778
779
if self._change_last_revision(leftmost_parent_id):
780
if leftmost_parent_tree is None:
781
# If we don't have a tree, fall back to reading the
782
# parent tree from the repository.
783
self._cache_basis_inventory(leftmost_parent_id)
784
else:
785
inv = leftmost_parent_tree.inventory
786
xml = self._create_basis_xml_from_inventory(
787
leftmost_parent_id, inv)
788
self._write_basis_inventory(xml)
789
self._set_merges_from_parent_ids(parent_ids)
790
791
@needs_tree_write_lock
648
792
def set_pending_merges(self, rev_list):
649
self._control_files.put_utf8('pending-merges', '\n'.join(rev_list))
793
parents = self.get_parent_ids()
794
leftmost = parents[:1]
795
new_parents = leftmost + rev_list
796
self.set_parent_ids(new_parents)
650
797
651
@needs_write_lock
798
@needs_tree_write_lock
652
799
def set_merge_modified(self, modified_hashes):
653
800
def iter_stanzas():
654
801
for file_id, hash in modified_hashes.iteritems():
655
yield Stanza(file_id=file_id, hash=hash)
802
yield Stanza(file_id=file_id.decode('utf8'), hash=hash)
656
803
self._put_rio('merge-hashes', iter_stanzas(), MERGE_MODIFIED_HEADER_1)
657
804
658
@needs_write_lock
659
805
def _put_rio(self, filename, stanzas, header):
806
self._must_be_locked()
660
807
my_file = rio_file(stanzas, header)
661
808
self._control_files.put(filename, my_file)
662
809
810
@needs_write_lock # because merge pulls data into the branch.
811
def merge_from_branch(self, branch, to_revision=None):
812
"""Merge from a branch into this working tree.
813
814
:param branch: The branch to merge from.
815
:param to_revision: If non-None, the merge will merge to to_revision,
816
but not beyond it. to_revision does not need to be in the history
817
of the branch when it is supplied. If None, to_revision defaults to
818
branch.last_revision().
819
"""
820
from bzrlib.merge import Merger, Merge3Merger
821
pb = bzrlib.ui.ui_factory.nested_progress_bar()
822
try:
823
merger = Merger(self.branch, this_tree=self, pb=pb)
824
merger.pp = ProgressPhase("Merge phase", 5, pb)
825
merger.pp.next_phase()
826
# check that there are no
827
# local alterations
828
merger.check_basis(check_clean=True, require_commits=False)
829
if to_revision is None:
830
to_revision = branch.last_revision()
831
else:
832
to_revision = osutils.safe_revision_id(to_revision)
833
merger.other_rev_id = to_revision
834
if merger.other_rev_id is None:
835
raise error.NoCommits(branch)
836
self.branch.fetch(branch, last_revision=merger.other_rev_id)
837
merger.other_basis = merger.other_rev_id
838
merger.other_tree = self.branch.repository.revision_tree(
839
merger.other_rev_id)
840
merger.other_branch = branch
841
merger.pp.next_phase()
842
merger.find_base()
843
if merger.base_rev_id == merger.other_rev_id:
844
raise errors.PointlessMerge
845
merger.backup_files = False
846
merger.merge_type = Merge3Merger
847
merger.set_interesting_files(None)
848
merger.show_base = False
849
merger.reprocess = False
850
conflicts = merger.do_merge()
851
merger.set_pending()
852
finally:
853
pb.finished()
854
return conflicts
855
663
856
@needs_read_lock
664
857
def merge_modified(self):
858
"""Return a dictionary of files modified by a merge.
859
860
The list is initialized by WorkingTree.set_merge_modified, which is
861
typically called after we make some automatic updates to the tree
862
because of a merge.
863
864
This returns a map of file_id->sha1, containing only files which are
865
still in the working inventory and have that text hash.
866
"""
665
867
try:
666
868
hashfile = self._control_files.get('merge-hashes')
667
except NoSuchFile:
869
except errors.NoSuchFile:
668
870
return {}
669
871
merge_hashes = {}
670
872
try:
671
873
if hashfile.next() != MERGE_MODIFIED_HEADER_1 + '\n':
672
raise MergeModifiedFormatError()
874
raise errors.MergeModifiedFormatError()
673
875
except StopIteration:
674
raise MergeModifiedFormatError()
876
raise errors.MergeModifiedFormatError()
675
877
for s in RioReader(hashfile):
676
file_id = s.get("file_id")
878
# RioReader reads in Unicode, so convert file_ids back to utf8
879
file_id = osutils.safe_file_id(s.get("file_id"), warn=False)
677
880
if file_id not in self.inventory:
678
881
continue
679
hash = s.get("hash")
680
if hash == self.get_file_sha1(file_id):
681
merge_hashes[file_id] = hash
882
text_hash = s.get("hash")
883
if text_hash == self.get_file_sha1(file_id):
884
merge_hashes[file_id] = text_hash
682
885
return merge_hashes
683
886
887
@needs_write_lock
888
def mkdir(self, path, file_id=None):
889
"""See MutableTree.mkdir()."""
890
if file_id is None:
891
file_id = generate_ids.gen_file_id(os.path.basename(path))
892
os.mkdir(self.abspath(path))
893
self.add(path, file_id, 'directory')
894
return file_id
895
684
896
def get_symlink_target(self, file_id):
897
file_id = osutils.safe_file_id(file_id)
685
898
return os.readlink(self.id2abspath(file_id))
686
899
687
def file_class(self, filename):
688
if self.path2id(filename):
689
return 'V'
690
elif self.is_ignored(filename):
691
return 'I'
692
else:
693
return '?'
694
695
def list_files(self):
900
@needs_write_lock
901
def subsume(self, other_tree):
902
def add_children(inventory, entry):
903
for child_entry in entry.children.values():
904
inventory._byid[child_entry.file_id] = child_entry
905
if child_entry.kind == 'directory':
906
add_children(inventory, child_entry)
907
if other_tree.get_root_id() == self.get_root_id():
908
raise errors.BadSubsumeSource(self, other_tree,
909
'Trees have the same root')
910
try:
911
other_tree_path = self.relpath(other_tree.basedir)
912
except errors.PathNotChild:
913
raise errors.BadSubsumeSource(self, other_tree,
914
'Tree is not contained by the other')
915
new_root_parent = self.path2id(osutils.dirname(other_tree_path))
916
if new_root_parent is None:
917
raise errors.BadSubsumeSource(self, other_tree,
918
'Parent directory is not versioned.')
919
# We need to ensure that the result of a fetch will have a
920
# versionedfile for the other_tree root, and only fetching into
921
# RepositoryKnit2 guarantees that.
922
if not self.branch.repository.supports_rich_root():
923
raise errors.SubsumeTargetNeedsUpgrade(other_tree)
924
other_tree.lock_tree_write()
925
try:
926
new_parents = other_tree.get_parent_ids()
927
other_root = other_tree.inventory.root
928
other_root.parent_id = new_root_parent
929
other_root.name = osutils.basename(other_tree_path)
930
self.inventory.add(other_root)
931
add_children(self.inventory, other_root)
932
self._write_inventory(self.inventory)
933
# normally we don't want to fetch whole repositories, but i think
934
# here we really do want to consolidate the whole thing.
935
for parent_id in other_tree.get_parent_ids():
936
self.branch.fetch(other_tree.branch, parent_id)
937
self.add_parent_tree_id(parent_id)
938
finally:
939
other_tree.unlock()
940
other_tree.bzrdir.retire_bzrdir()
941
942
@needs_tree_write_lock
943
def extract(self, file_id, format=None):
944
"""Extract a subtree from this tree.
945
946
A new branch will be created, relative to the path for this tree.
947
"""
948
def mkdirs(path):
949
segments = osutils.splitpath(path)
950
transport = self.branch.bzrdir.root_transport
951
for name in segments:
952
transport = transport.clone(name)
953
try:
954
transport.mkdir('.')
955
except errors.FileExists:
956
pass
957
return transport
958
959
sub_path = self.id2path(file_id)
960
branch_transport = mkdirs(sub_path)
961
if format is None:
962
format = bzrdir.format_registry.make_bzrdir('dirstate-with-subtree')
963
try:
964
branch_transport.mkdir('.')
965
except errors.FileExists:
966
pass
967
branch_bzrdir = format.initialize_on_transport(branch_transport)
968
try:
969
repo = branch_bzrdir.find_repository()
970
except errors.NoRepositoryPresent:
971
repo = branch_bzrdir.create_repository()
972
assert repo.supports_rich_root()
973
else:
974
if not repo.supports_rich_root():
975
raise errors.RootNotRich()
976
new_branch = branch_bzrdir.create_branch()
977
new_branch.pull(self.branch)
978
for parent_id in self.get_parent_ids():
979
new_branch.fetch(self.branch, parent_id)
980
tree_transport = self.bzrdir.root_transport.clone(sub_path)
981
if tree_transport.base != branch_transport.base:
982
tree_bzrdir = format.initialize_on_transport(tree_transport)
983
branch.BranchReferenceFormat().initialize(tree_bzrdir, new_branch)
984
else:
985
tree_bzrdir = branch_bzrdir
986
wt = tree_bzrdir.create_workingtree(NULL_REVISION)
987
wt.set_parent_ids(self.get_parent_ids())
988
my_inv = self.inventory
989
child_inv = Inventory(root_id=None)
990
new_root = my_inv[file_id]
991
my_inv.remove_recursive_id(file_id)
992
new_root.parent_id = None
993
child_inv.add(new_root)
994
self._write_inventory(my_inv)
995
wt._write_inventory(child_inv)
996
return wt
997
998
def _serialize(self, inventory, out_file):
999
xml5.serializer_v5.write_inventory(self._inventory, out_file)
1000
1001
def _deserialize(selt, in_file):
1002
return xml5.serializer_v5.read_inventory(in_file)
1003
1004
def flush(self):
1005
"""Write the in memory inventory to disk."""
1006
# TODO: Maybe this should only write on dirty ?
1007
if self._control_files._lock_mode != 'w':
1008
raise errors.NotWriteLocked(self)
1009
sio = StringIO()
1010
self._serialize(self._inventory, sio)
1011
sio.seek(0)
1012
self._control_files.put('inventory', sio)
1013
self._inventory_is_modified = False
1014
1015
def list_files(self, include_root=False):
696
1016
"""Recursively list all files as (path, class, kind, id, entry).
697
1017
698
1018
Lists, but does not descend into unversioned directories.
702
1022
703
1023
Skips the control directory.
704
1024
"""
705
inv = self._inventory
1025
# list_files is an iterator, so @needs_read_lock doesn't work properly
1026
# with it. So callers should be careful to always read_lock the tree.
1027
if not self.is_locked():
1028
raise errors.ObjectNotLocked(self)
1029
1030
inv = self.inventory
1031
if include_root is True:
1032
yield ('', 'V', 'directory', inv.root.file_id, inv.root)
706
1033
# Convert these into local objects to save lookup times
707
pathjoin = bzrlib.osutils.pathjoin
708
file_kind = bzrlib.osutils.file_kind
1034
pathjoin = osutils.pathjoin
1035
file_kind = osutils.file_kind
709
1036
710
1037
# transport.base ends in a slash, we want the piece
711
1038
# between the last two slashes
749
1076
elif self.is_ignored(fp[1:]):
750
1077
c = 'I'
751
1078
else:
752
c = '?'
1079
# we may not have found this file, because of a unicode issue
1080
f_norm, can_access = osutils.normalized_filename(f)
1081
if f == f_norm or not can_access:
1082
# No change, so treat this file normally
1083
c = '?'
1084
else:
1085
# this file can be accessed by a normalized path
1086
# check again if it is versioned
1087
# these lines are repeated here for performance
1088
f = f_norm
1089
fp = from_dir_relpath + '/' + f
1090
fap = from_dir_abspath + '/' + f
1091
f_ie = inv.get_child(from_dir_id, f)
1092
if f_ie:
1093
c = 'V'
1094
elif self.is_ignored(fp[1:]):
1095
c = 'I'
1096
else:
1097
c = '?'
753
1098
754
1099
fk = file_kind(fap)
755
1100
756
1101
if f_ie:
757
1102
if f_ie.kind != fk:
758
raise BzrCheckError("file %r entered as kind %r id %r, "
759
"now of kind %r"
760
% (fap, f_ie.kind, f_ie.file_id, fk))
1103
raise errors.BzrCheckError(
1104
"file %r entered as kind %r id %r, now of kind %r"
1105
% (fap, f_ie.kind, f_ie.file_id, fk))
761
1106
762
1107
# make a last minute entry
763
1108
if f_ie:
777
1122
new_children.sort()
778
1123
new_children = collections.deque(new_children)
779
1124
stack.append((f_ie.file_id, fp, fap, new_children))
780
# Break out of inner loop, so that we start outer loop with child
1125
# Break out of inner loop,
1126
# so that we start outer loop with child
781
1127
break
782
1128
else:
783
1129
# if we finished all children, pop it off the stack
784
1130
stack.pop()
785
1131
786
787
@needs_write_lock
788
def move(self, from_paths, to_name):
1132
@needs_tree_write_lock
1133
def move(self, from_paths, to_dir=None, after=False, **kwargs):
789
1134
"""Rename files.
790
1135
791
to_name must exist in the inventory.
1136
to_dir must exist in the inventory.
792
1137
793
If to_name exists and is a directory, the files are moved into
1138
If to_dir exists and is a directory, the files are moved into
794
1139
it, keeping their old names.
795
1140
796
Note that to_name is only the last component of the new name;
1141
Note that to_dir is only the last component of the new name;
797
1142
this doesn't change the directory.
798
1143
1144
For each entry in from_paths the move mode will be determined
1145
independently.
1146
1147
The first mode moves the file in the filesystem and updates the
1148
inventory. The second mode only updates the inventory without
1149
touching the file on the filesystem. This is the new mode introduced
1150
in version 0.15.
1151
1152
move uses the second mode if 'after == True' and the target is not
1153
versioned but present in the working tree.
1154
1155
move uses the second mode if 'after == False' and the source is
1156
versioned but no longer in the working tree, and the target is not
1157
versioned but present in the working tree.
1158
1159
move uses the first mode if 'after == False' and the source is
1160
versioned and present in the working tree, and the target is not
1161
versioned and not present in the working tree.
1162
1163
Everything else results in an error.
1164
799
1165
This returns a list of (from_path, to_path) pairs for each
800
1166
entry that is moved.
801
1167
"""
802
result = []
803
## TODO: Option to move IDs only
1168
rename_entries = []
1169
rename_tuples = []
1170
1171
# check for deprecated use of signature
1172
if to_dir is None:
1173
to_dir = kwargs.get('to_name', None)
1174
if to_dir is None:
1175
raise TypeError('You must supply a target directory')
1176
else:
1177
symbol_versioning.warn('The parameter to_name was deprecated'
1178
' in version 0.13. Use to_dir instead',
1179
DeprecationWarning)
1180
1181
# check destination directory
804
1182
assert not isinstance(from_paths, basestring)
805
1183
inv = self.inventory
806
to_abs = self.abspath(to_name)
1184
to_abs = self.abspath(to_dir)
807
1185
if not isdir(to_abs):
808
raise BzrError("destination %r is not a directory" % to_abs)
809
if not self.has_filename(to_name):
810
raise BzrError("destination %r not in working directory" % to_abs)
811
to_dir_id = inv.path2id(to_name)
812
if to_dir_id == None and to_name != '':
813
raise BzrError("destination %r is not a versioned directory" % to_name)
1186
raise errors.BzrMoveFailedError('',to_dir,
1187
errors.NotADirectory(to_abs))
1188
if not self.has_filename(to_dir):
1189
raise errors.BzrMoveFailedError('',to_dir,
1190
errors.NotInWorkingDirectory(to_dir))
1191
to_dir_id = inv.path2id(to_dir)
1192
if to_dir_id is None:
1193
raise errors.BzrMoveFailedError('',to_dir,
1194
errors.NotVersionedError(path=str(to_dir)))
1195
814
1196
to_dir_ie = inv[to_dir_id]
815
if to_dir_ie.kind not in ('directory', 'root_directory'):
816
raise BzrError("destination %r is not a directory" % to_abs)
817
818
to_idpath = inv.get_idpath(to_dir_id)
819
820
for f in from_paths:
821
if not self.has_filename(f):
822
raise BzrError("%r does not exist in working tree" % f)
823
f_id = inv.path2id(f)
824
if f_id == None:
825
raise BzrError("%r is not versioned" % f)
826
name_tail = splitpath(f)[-1]
827
dest_path = pathjoin(to_name, name_tail)
828
if self.has_filename(dest_path):
829
raise BzrError("destination %r already exists" % dest_path)
830
if f_id in to_idpath:
831
raise BzrError("can't move %r to a subdirectory of itself" % f)
832
833
# OK, so there's a race here, it's possible that someone will
834
# create a file in this interval and then the rename might be
835
# left half-done. But we should have caught most problems.
836
orig_inv = deepcopy(self.inventory)
1197
if to_dir_ie.kind != 'directory':
1198
raise errors.BzrMoveFailedError('',to_dir,
1199
errors.NotADirectory(to_abs))
1200
1201
# create rename entries and tuples
1202
for from_rel in from_paths:
1203
from_tail = splitpath(from_rel)[-1]
1204
from_id = inv.path2id(from_rel)
1205
if from_id is None:
1206
raise errors.BzrMoveFailedError(from_rel,to_dir,
1207
errors.NotVersionedError(path=str(from_rel)))
1208
1209
from_entry = inv[from_id]
1210
from_parent_id = from_entry.parent_id
1211
to_rel = pathjoin(to_dir, from_tail)
1212
rename_entry = WorkingTree._RenameEntry(from_rel=from_rel,
1213
from_id=from_id,
1214
from_tail=from_tail,
1215
from_parent_id=from_parent_id,
1216
to_rel=to_rel, to_tail=from_tail,
1217
to_parent_id=to_dir_id)
1218
rename_entries.append(rename_entry)
1219
rename_tuples.append((from_rel, to_rel))
1220
1221
# determine which move mode to use. checks also for movability
1222
rename_entries = self._determine_mv_mode(rename_entries, after)
1223
1224
original_modified = self._inventory_is_modified
837
1225
try:
838
for f in from_paths:
839
name_tail = splitpath(f)[-1]
840
dest_path = pathjoin(to_name, name_tail)
841
result.append((f, dest_path))
842
inv.rename(inv.path2id(f), to_dir_id, name_tail)
843
try:
844
rename(self.abspath(f), self.abspath(dest_path))
845
except OSError, e:
846
raise BzrError("failed to rename %r to %r: %s" %
847
(f, dest_path, e[1]),
848
["rename rolled back"])
1226
if len(from_paths):
1227
self._inventory_is_modified = True
1228
self._move(rename_entries)
849
1229
except:
850
1230
# restore the inventory on error
851
self._set_inventory(orig_inv)
1231
self._inventory_is_modified = original_modified
852
1232
raise
853
1233
self._write_inventory(inv)
854
return result
855
856
@needs_write_lock
857
def rename_one(self, from_rel, to_rel):
1234
return rename_tuples
1235
1236
def _determine_mv_mode(self, rename_entries, after=False):
1237
"""Determines for each from-to pair if both inventory and working tree
1238
or only the inventory has to be changed.
1239
1240
Also does basic plausability tests.
1241
"""
1242
inv = self.inventory
1243
1244
for rename_entry in rename_entries:
1245
# store to local variables for easier reference
1246
from_rel = rename_entry.from_rel
1247
from_id = rename_entry.from_id
1248
to_rel = rename_entry.to_rel
1249
to_id = inv.path2id(to_rel)
1250
only_change_inv = False
1251
1252
# check the inventory for source and destination
1253
if from_id is None:
1254
raise errors.BzrMoveFailedError(from_rel,to_rel,
1255
errors.NotVersionedError(path=str(from_rel)))
1256
if to_id is not None:
1257
raise errors.BzrMoveFailedError(from_rel,to_rel,
1258
errors.AlreadyVersionedError(path=str(to_rel)))
1259
1260
# try to determine the mode for rename (only change inv or change
1261
# inv and file system)
1262
if after:
1263
if not self.has_filename(to_rel):
1264
raise errors.BzrMoveFailedError(from_id,to_rel,
1265
errors.NoSuchFile(path=str(to_rel),
1266
extra="New file has not been created yet"))
1267
only_change_inv = True
1268
elif not self.has_filename(from_rel) and self.has_filename(to_rel):
1269
only_change_inv = True
1270
elif self.has_filename(from_rel) and not self.has_filename(to_rel):
1271
only_change_inv = False
1272
else:
1273
# something is wrong, so lets determine what exactly
1274
if not self.has_filename(from_rel) and \
1275
not self.has_filename(to_rel):
1276
raise errors.BzrRenameFailedError(from_rel,to_rel,
1277
errors.PathsDoNotExist(paths=(str(from_rel),
1278
str(to_rel))))
1279
else:
1280
raise errors.RenameFailedFilesExist(from_rel, to_rel,
1281
extra="(Use --after to update the Bazaar id)")
1282
rename_entry.only_change_inv = only_change_inv
1283
return rename_entries
1284
1285
def _move(self, rename_entries):
1286
"""Moves a list of files.
1287
1288
Depending on the value of the flag 'only_change_inv', the
1289
file will be moved on the file system or not.
1290
"""
1291
inv = self.inventory
1292
moved = []
1293
1294
for entry in rename_entries:
1295
try:
1296
self._move_entry(entry)
1297
except:
1298
self._rollback_move(moved)
1299
raise
1300
moved.append(entry)
1301
1302
def _rollback_move(self, moved):
1303
"""Try to rollback a previous move in case of an filesystem error."""
1304
inv = self.inventory
1305
for entry in moved:
1306
try:
1307
self._move_entry(_RenameEntry(entry.to_rel, entry.from_id,
1308
entry.to_tail, entry.to_parent_id, entry.from_rel,
1309
entry.from_tail, entry.from_parent_id,
1310
entry.only_change_inv))
1311
except errors.BzrMoveFailedError, e:
1312
raise errors.BzrMoveFailedError( '', '', "Rollback failed."
1313
" The working tree is in an inconsistent state."
1314
" Please consider doing a 'bzr revert'."
1315
" Error message is: %s" % e)
1316
1317
def _move_entry(self, entry):
1318
inv = self.inventory
1319
from_rel_abs = self.abspath(entry.from_rel)
1320
to_rel_abs = self.abspath(entry.to_rel)
1321
if from_rel_abs == to_rel_abs:
1322
raise errors.BzrMoveFailedError(entry.from_rel, entry.to_rel,
1323
"Source and target are identical.")
1324
1325
if not entry.only_change_inv:
1326
try:
1327
osutils.rename(from_rel_abs, to_rel_abs)
1328
except OSError, e:
1329
raise errors.BzrMoveFailedError(entry.from_rel,
1330
entry.to_rel, e[1])
1331
inv.rename(entry.from_id, entry.to_parent_id, entry.to_tail)
1332
1333
@needs_tree_write_lock
1334
def rename_one(self, from_rel, to_rel, after=False):
858
1335
"""Rename one file.
859
1336
860
1337
This can change the directory or the filename or both.
1338
1339
rename_one has several 'modes' to work. First, it can rename a physical
1340
file and change the file_id. That is the normal mode. Second, it can
1341
only change the file_id without touching any physical file. This is
1342
the new mode introduced in version 0.15.
1343
1344
rename_one uses the second mode if 'after == True' and 'to_rel' is not
1345
versioned but present in the working tree.
1346
1347
rename_one uses the second mode if 'after == False' and 'from_rel' is
1348
versioned but no longer in the working tree, and 'to_rel' is not
1349
versioned but present in the working tree.
1350
1351
rename_one uses the first mode if 'after == False' and 'from_rel' is
1352
versioned and present in the working tree, and 'to_rel' is not
1353
versioned and not present in the working tree.
1354
1355
Everything else results in an error.
861
1356
"""
862
1357
inv = self.inventory
863
if not self.has_filename(from_rel):
864
raise BzrError("can't rename: old working file %r does not exist" % from_rel)
865
if self.has_filename(to_rel):
866
raise BzrError("can't rename: new working file %r already exists" % to_rel)
867
868
file_id = inv.path2id(from_rel)
869
if file_id == None:
870
raise BzrError("can't rename: old name %r is not versioned" % from_rel)
871
872
entry = inv[file_id]
873
from_parent = entry.parent_id
874
from_name = entry.name
875
876
if inv.path2id(to_rel):
877
raise BzrError("can't rename: new name %r is already versioned" % to_rel)
878
1358
rename_entries = []
1359
1360
# create rename entries and tuples
1361
from_tail = splitpath(from_rel)[-1]
1362
from_id = inv.path2id(from_rel)
1363
if from_id is None:
1364
raise errors.BzrRenameFailedError(from_rel,to_rel,
1365
errors.NotVersionedError(path=str(from_rel)))
1366
from_entry = inv[from_id]
1367
from_parent_id = from_entry.parent_id
879
1368
to_dir, to_tail = os.path.split(to_rel)
880
1369
to_dir_id = inv.path2id(to_dir)
881
if to_dir_id == None and to_dir != '':
882
raise BzrError("can't determine destination directory id for %r" % to_dir)
883
884
mutter("rename_one:")
885
mutter(" file_id {%s}" % file_id)
886
mutter(" from_rel %r" % from_rel)
887
mutter(" to_rel %r" % to_rel)
888
mutter(" to_dir %r" % to_dir)
889
mutter(" to_dir_id {%s}" % to_dir_id)
890
891
inv.rename(file_id, to_dir_id, to_tail)
892
893
from_abs = self.abspath(from_rel)
894
to_abs = self.abspath(to_rel)
895
try:
896
rename(from_abs, to_abs)
897
except OSError, e:
898
inv.rename(file_id, from_parent, from_name)
899
raise BzrError("failed to rename %r to %r: %s"
900
% (from_abs, to_abs, e[1]),
901
["rename rolled back"])
1370
rename_entry = WorkingTree._RenameEntry(from_rel=from_rel,
1371
from_id=from_id,
1372
from_tail=from_tail,
1373
from_parent_id=from_parent_id,
1374
to_rel=to_rel, to_tail=to_tail,
1375
to_parent_id=to_dir_id)
1376
rename_entries.append(rename_entry)
1377
1378
# determine which move mode to use. checks also for movability
1379
rename_entries = self._determine_mv_mode(rename_entries, after)
1380
1381
# check if the target changed directory and if the target directory is
1382
# versioned
1383
if to_dir_id is None:
1384
raise errors.BzrMoveFailedError(from_rel,to_rel,
1385
errors.NotVersionedError(path=str(to_dir)))
1386
1387
# all checks done. now we can continue with our actual work
1388
mutter('rename_one:\n'
1389
' from_id {%s}\n'
1390
' from_rel: %r\n'
1391
' to_rel: %r\n'
1392
' to_dir %r\n'
1393
' to_dir_id {%s}\n',
1394
from_id, from_rel, to_rel, to_dir, to_dir_id)
1395
1396
self._move(rename_entries)
902
1397
self._write_inventory(inv)
903
1398
1399
class _RenameEntry(object):
1400
def __init__(self, from_rel, from_id, from_tail, from_parent_id,
1401
to_rel, to_tail, to_parent_id, only_change_inv=False):
1402
self.from_rel = from_rel
1403
self.from_id = from_id
1404
self.from_tail = from_tail
1405
self.from_parent_id = from_parent_id
1406
self.to_rel = to_rel
1407
self.to_tail = to_tail
1408
self.to_parent_id = to_parent_id
1409
self.only_change_inv = only_change_inv
1410
904
1411
@needs_read_lock
905
1412
def unknowns(self):
906
1413
"""Return all unknown files.
907
1414
908
1415
These are files in the working directory that are not versioned or
909
1416
control files or ignored.
910
911
>>> from bzrlib.bzrdir import ScratchDir
912
>>> d = ScratchDir(files=['foo', 'foo~'])
913
>>> b = d.open_branch()
914
>>> tree = d.open_workingtree()
915
>>> map(str, tree.unknowns())
916
['foo']
917
>>> tree.add('foo')
918
>>> list(b.unknowns())
919
[]
920
>>> tree.remove('foo')
921
>>> list(b.unknowns())
922
[u'foo']
923
"""
924
for subp in self.extras():
925
if not self.is_ignored(subp):
926
yield subp
927
1417
"""
1418
# force the extras method to be fully executed before returning, to
1419
# prevent race conditions with the lock
1420
return iter(
1421
[subp for subp in self.extras() if not self.is_ignored(subp)])
1422
1423
@needs_tree_write_lock
1424
def unversion(self, file_ids):
1425
"""Remove the file ids in file_ids from the current versioned set.
1426
1427
When a file_id is unversioned, all of its children are automatically
1428
unversioned.
1429
1430
:param file_ids: The file ids to stop versioning.
1431
:raises: NoSuchId if any fileid is not currently versioned.
1432
"""
1433
for file_id in file_ids:
1434
file_id = osutils.safe_file_id(file_id)
1435
if self._inventory.has_id(file_id):
1436
self._inventory.remove_recursive_id(file_id)
1437
else:
1438
raise errors.NoSuchId(self, file_id)
1439
if len(file_ids):
1440
# in the future this should just set a dirty bit to wait for the
1441
# final unlock. However, until all methods of workingtree start
1442
# with the current in -memory inventory rather than triggering
1443
# a read, it is more complex - we need to teach read_inventory
1444
# to know when to read, and when to not read first... and possibly
1445
# to save first when the in memory one may be corrupted.
1446
# so for now, we just only write it if it is indeed dirty.
1447
# - RBC 20060907
1448
self._write_inventory(self._inventory)
1449
928
1450
@deprecated_method(zero_eight)
929
1451
def iter_conflicts(self):
930
1452
"""List all files in the tree that have text or content conflicts.
943
1465
yield stem
944
1466
945
1467
@needs_write_lock
946
def pull(self, source, overwrite=False, stop_revision=None):
1468
def pull(self, source, overwrite=False, stop_revision=None,
1469
change_reporter=None):
947
1470
top_pb = bzrlib.ui.ui_factory.nested_progress_bar()
948
1471
source.lock_read()
949
1472
try:
950
1473
pp = ProgressPhase("Pull phase", 2, top_pb)
951
1474
pp.next_phase()
952
old_revision_history = self.branch.revision_history()
1475
old_revision_info = self.branch.last_revision_info()
953
1476
basis_tree = self.basis_tree()
954
1477
count = self.branch.pull(source, overwrite, stop_revision)
955
new_revision_history = self.branch.revision_history()
956
if new_revision_history != old_revision_history:
1478
new_revision_info = self.branch.last_revision_info()
1479
if new_revision_info != old_revision_info:
957
1480
pp.next_phase()
958
if len(old_revision_history):
959
other_revision = old_revision_history[-1]
960
else:
961
other_revision = None
962
1481
repository = self.branch.repository
963
1482
pb = bzrlib.ui.ui_factory.nested_progress_bar()
1483
basis_tree.lock_read()
964
1484
try:
965
merge_inner(self.branch,
966
self.branch.basis_tree(),
967
basis_tree,
968
this_tree=self,
969
pb=pb)
1485
new_basis_tree = self.branch.basis_tree()
1486
merge.merge_inner(
1487
self.branch,
1488
new_basis_tree,
1489
basis_tree,
1490
this_tree=self,
1491
pb=pb,
1492
change_reporter=change_reporter)
1493
if (basis_tree.inventory.root is None and
1494
new_basis_tree.inventory.root is not None):
1495
self.set_root_id(new_basis_tree.inventory.root.file_id)
970
1496
finally:
971
1497
pb.finished()
972
self.set_last_revision(self.branch.last_revision())
1498
basis_tree.unlock()
1499
# TODO - dedup parents list with things merged by pull ?
1500
# reuse the revisiontree we merged against to set the new
1501
# tree data.
1502
parent_trees = [(self.branch.last_revision(), new_basis_tree)]
1503
# we have to pull the merge trees out again, because
1504
# merge_inner has set the ids. - this corner is not yet
1505
# layered well enough to prevent double handling.
1506
# XXX TODO: Fix the double handling: telling the tree about
1507
# the already known parent data is wasteful.
1508
merges = self.get_parent_ids()[1:]
1509
parent_trees.extend([
1510
(parent, repository.revision_tree(parent)) for
1511
parent in merges])
1512
self.set_parent_trees(parent_trees)
973
1513
return count
974
1514
finally:
975
1515
source.unlock()
976
1516
top_pb.finished()
977
1517
1518
@needs_write_lock
1519
def put_file_bytes_non_atomic(self, file_id, bytes):
1520
"""See MutableTree.put_file_bytes_non_atomic."""
1521
file_id = osutils.safe_file_id(file_id)
1522
stream = file(self.id2abspath(file_id), 'wb')
1523
try:
1524
stream.write(bytes)
1525
finally:
1526
stream.close()
1527
# TODO: update the hashcache here ?
1528
978
1529
def extras(self):
979
"""Yield all unknown files in this WorkingTree.
1530
"""Yield all unversioned files in this WorkingTree.
980
1531
981
If there are any unknown directories then only the directory is
982
returned, not all its children. But if there are unknown files
1532
If there are any unversioned directories then only the directory is
1533
returned, not all its children. But if there are unversioned files
983
1534
under a versioned subdirectory, they are returned.
984
1535
985
1536
Currently returned depth-first, sorted by name within directories.
1537
This is the same order used by 'osutils.walkdirs'.
986
1538
"""
987
1539
## TODO: Work from given directory downwards
988
1540
for path, dir_entry in self.inventory.directories():
989
mutter("search for unknowns in %r", path)
1541
# mutter("search for unknowns in %r", path)
990
1542
dirabs = self.abspath(path)
991
1543
if not isdir(dirabs):
992
1544
# e.g. directory deleted
994
1546
995
1547
fl = []
996
1548
for subf in os.listdir(dirabs):
997
if (subf != '.bzr'
998
and (subf not in dir_entry.children)):
999
fl.append(subf)
1549
if subf == '.bzr':
1550
continue
1551
if subf not in dir_entry.children:
1552
subf_norm, can_access = osutils.normalized_filename(subf)
1553
if subf_norm != subf and can_access:
1554
if subf_norm not in dir_entry.children:
1555
fl.append(subf_norm)
1556
else:
1557
fl.append(subf)
1000
1558
1001
1559
fl.sort()
1002
1560
for subf in fl:
1003
1561
subp = pathjoin(path, subf)
1004
1562
yield subp
1005
1563
1006
def _translate_ignore_rule(self, rule):
1007
"""Translate a single ignore rule to a regex.
1008
1009
There are two types of ignore rules. Those that do not contain a / are
1010
matched against the tail of the filename (that is, they do not care
1011
what directory the file is in.) Rules which do contain a slash must
1012
match the entire path. As a special case, './' at the start of the
1013
string counts as a slash in the string but is removed before matching
1014
(e.g. ./foo.c, ./src/foo.c)
1015
1016
:return: The translated regex.
1017
"""
1018
if rule[:2] in ('./', '.\\'):
1019
# rootdir rule
1020
result = fnmatch.translate(rule[2:])
1021
elif '/' in rule or '\\' in rule:
1022
# path prefix
1023
result = fnmatch.translate(rule)
1024
else:
1025
# default rule style.
1026
result = "(?:.*/)?(?!.*/)" + fnmatch.translate(rule)
1027
assert result[-1] == '$', "fnmatch.translate did not add the expected $"
1028
return "(" + result + ")"
1029
1030
def _combine_ignore_rules(self, rules):
1031
"""Combine a list of ignore rules into a single regex object.
1032
1033
Each individual rule is combined with | to form a big regex, which then
1034
has $ added to it to form something like ()|()|()$. The group index for
1035
each subregex's outermost group is placed in a dictionary mapping back
1036
to the rule. This allows quick identification of the matching rule that
1037
triggered a match.
1038
:return: a list of the compiled regex and the matching-group index
1039
dictionaries. We return a list because python complains if you try to
1040
combine more than 100 regexes.
1041
"""
1042
result = []
1043
groups = {}
1044
next_group = 0
1045
translated_rules = []
1046
for rule in rules:
1047
translated_rule = self._translate_ignore_rule(rule)
1048
compiled_rule = re.compile(translated_rule)
1049
groups[next_group] = rule
1050
next_group += compiled_rule.groups
1051
translated_rules.append(translated_rule)
1052
if next_group == 99:
1053
result.append((re.compile("|".join(translated_rules)), groups))
1054
groups = {}
1055
next_group = 0
1056
translated_rules = []
1057
if len(translated_rules):
1058
result.append((re.compile("|".join(translated_rules)), groups))
1059
return result
1060
1061
1564
def ignored_files(self):
1062
1565
"""Yield list of PATH, IGNORE_PATTERN"""
1063
1566
for subp in self.extras():
1064
1567
pat = self.is_ignored(subp)
1065
if pat != None:
1568
if pat is not None:
1066
1569
yield subp, pat
1067
1570
1068
1571
def get_ignore_list(self):
1070
1573
1071
1574
Cached in the Tree object after the first call.
1072
1575
"""
1073
if hasattr(self, '_ignorelist'):
1074
return self._ignorelist
1576
ignoreset = getattr(self, '_ignoreset', None)
1577
if ignoreset is not None:
1578
return ignoreset
1075
1579
1076
l = bzrlib.DEFAULT_IGNORE[:]
1580
ignore_globs = set(bzrlib.DEFAULT_IGNORE)
1581
ignore_globs.update(ignores.get_runtime_ignores())
1582
ignore_globs.update(ignores.get_user_ignores())
1077
1583
if self.has_filename(bzrlib.IGNORE_FILENAME):
1078
1584
f = self.get_file_byname(bzrlib.IGNORE_FILENAME)
1079
l.extend([line.rstrip("\n\r") for line in f.readlines()])
1080
self._ignorelist = l
1081
self._ignore_regex = self._combine_ignore_rules(l)
1082
return l
1083
1084
def _get_ignore_rules_as_regex(self):
1085
"""Return a regex of the ignore rules and a mapping dict.
1086
1087
:return: (ignore rules compiled regex, dictionary mapping rule group
1088
indices to original rule.)
1089
"""
1090
if getattr(self, '_ignorelist', None) is None:
1091
self.get_ignore_list()
1092
return self._ignore_regex
1585
try:
1586
ignore_globs.update(ignores.parse_ignore_file(f))
1587
finally:
1588
f.close()
1589
self._ignoreset = ignore_globs
1590
return ignore_globs
1591
1592
def _flush_ignore_list_cache(self):
1593
"""Resets the cached ignore list to force a cache rebuild."""
1594
self._ignoreset = None
1595
self._ignoreglobster = None
1093
1596
1094
1597
def is_ignored(self, filename):
1095
1598
r"""Check whether the filename matches an ignore pattern.
1100
1603
If the file is ignored, returns the pattern which caused it to
1101
1604
be ignored, otherwise None. So this can simply be used as a
1102
1605
boolean if desired."""
1103
1104
# TODO: Use '**' to match directories, and other extended
1105
# globbing stuff from cvs/rsync.
1106
1107
# XXX: fnmatch is actually not quite what we want: it's only
1108
# approximately the same as real Unix fnmatch, and doesn't
1109
# treat dotfiles correctly and allows * to match /.
1110
# Eventually it should be replaced with something more
1111
# accurate.
1112
1113
rules = self._get_ignore_rules_as_regex()
1114
for regex, mapping in rules:
1115
match = regex.match(filename)
1116
if match is not None:
1117
# one or more of the groups in mapping will have a non-None group
1118
# match.
1119
groups = match.groups()
1120
rules = [mapping[group] for group in
1121
mapping if groups[group] is not None]
1122
return rules[0]
1123
return None
1606
if getattr(self, '_ignoreglobster', None) is None:
1607
self._ignoreglobster = globbing.Globster(self.get_ignore_list())
1608
return self._ignoreglobster.match(filename)
1124
1609
1125
1610
def kind(self, file_id):
1126
1611
return file_kind(self.id2abspath(file_id))
1127
1612
1128
@needs_read_lock
1613
def _comparison_data(self, entry, path):
1614
abspath = self.abspath(path)
1615
try:
1616
stat_value = os.lstat(abspath)
1617
except OSError, e:
1618
if getattr(e, 'errno', None) == errno.ENOENT:
1619
stat_value = None
1620
kind = None
1621
executable = False
1622
else:
1623
raise
1624
else:
1625
mode = stat_value.st_mode
1626
kind = osutils.file_kind_from_stat_mode(mode)
1627
if not supports_executable():
1628
executable = entry.executable
1629
else:
1630
executable = bool(stat.S_ISREG(mode) and stat.S_IEXEC & mode)
1631
return kind, executable, stat_value
1632
1633
def _file_size(self, entry, stat_value):
1634
return stat_value.st_size
1635
1129
1636
def last_revision(self):
1130
"""Return the last revision id of this working tree.
1131
1132
In early branch formats this was == the branch last_revision,
1133
but that cannot be relied upon - for working tree operations,
1134
always use tree.last_revision().
1637
"""Return the last revision of the branch for this tree.
1638
1639
This format tree does not support a separate marker for last-revision
1640
compared to the branch.
1641
1642
See MutableTree.last_revision
1135
1643
"""
1644
return self._last_revision()
1645
1646
@needs_read_lock
1647
def _last_revision(self):
1648
"""helper for get_parent_ids."""
1136
1649
return self.branch.last_revision()
1137
1650
1138
1651
def is_locked(self):
1139
1652
return self._control_files.is_locked()
1140
1653
1654
def _must_be_locked(self):
1655
if not self.is_locked():
1656
raise errors.ObjectNotLocked(self)
1657
1141
1658
def lock_read(self):
1142
1659
"""See Branch.lock_read, and WorkingTree.unlock."""
1660
if not self.is_locked():
1661
self._reset_data()
1143
1662
self.branch.lock_read()
1144
1663
try:
1145
1664
return self._control_files.lock_read()
1147
1666
self.branch.unlock()
1148
1667
raise
1149
1668
1669
def lock_tree_write(self):
1670
"""See MutableTree.lock_tree_write, and WorkingTree.unlock."""
1671
if not self.is_locked():
1672
self._reset_data()
1673
self.branch.lock_read()
1674
try:
1675
return self._control_files.lock_write()
1676
except:
1677
self.branch.unlock()
1678
raise
1679
1150
1680
def lock_write(self):
1151
"""See Branch.lock_write, and WorkingTree.unlock."""
1681
"""See MutableTree.lock_write, and WorkingTree.unlock."""
1682
if not self.is_locked():
1683
self._reset_data()
1152
1684
self.branch.lock_write()
1153
1685
try:
1154
1686
return self._control_files.lock_write()
1160
1692
return self._control_files.get_physical_lock_status()
1161
1693
1162
1694
def _basis_inventory_name(self):
1163
return 'basis-inventory'
1164
1165
@needs_write_lock
1695
return 'basis-inventory-cache'
1696
1697
def _reset_data(self):
1698
"""Reset transient data that cannot be revalidated."""
1699
self._inventory_is_modified = False
1700
result = self._deserialize(self._control_files.get('inventory'))
1701
self._set_inventory(result, dirty=False)
1702
1703
@needs_tree_write_lock
1166
1704
def set_last_revision(self, new_revision):
1167
1705
"""Change the last revision in the working tree."""
1706
new_revision = osutils.safe_revision_id(new_revision)
1168
1707
if self._change_last_revision(new_revision):
1169
1708
self._cache_basis_inventory(new_revision)
1170
1709
1177
1716
if new_revision is None:
1178
1717
self.branch.set_revision_history([])
1179
1718
return False
1180
# current format is locked in with the branch
1181
revision_history = self.branch.revision_history()
1182
1719
try:
1183
position = revision_history.index(new_revision)
1184
except ValueError:
1185
raise errors.NoSuchRevision(self.branch, new_revision)
1186
self.branch.set_revision_history(revision_history[:position + 1])
1720
self.branch.generate_revision_history(new_revision)
1721
except errors.NoSuchRevision:
1722
# not present in the repo - dont try to set it deeper than the tip
1723
self.branch.set_revision_history([new_revision])
1187
1724
return True
1188
1725
1726
def _write_basis_inventory(self, xml):
1727
"""Write the basis inventory XML to the basis-inventory file"""
1728
assert isinstance(xml, str), 'serialised xml must be bytestring.'
1729
path = self._basis_inventory_name()
1730
sio = StringIO(xml)
1731
self._control_files.put(path, sio)
1732
1733
def _create_basis_xml_from_inventory(self, revision_id, inventory):
1734
"""Create the text that will be saved in basis-inventory"""
1735
# TODO: jam 20070209 This should be redundant, as the revision_id
1736
# as all callers should have already converted the revision_id to
1737
# utf8
1738
inventory.revision_id = osutils.safe_revision_id(revision_id)
1739
return xml7.serializer_v7.write_inventory_to_string(inventory)
1740
1189
1741
def _cache_basis_inventory(self, new_revision):
1190
1742
"""Cache new_revision as the basis inventory."""
1743
# TODO: this should allow the ready-to-use inventory to be passed in,
1744
# as commit already has that ready-to-use [while the format is the
1745
# same, that is].
1191
1746
try:
1192
1747
# this double handles the inventory - unpack and repack -
1193
1748
# but is easier to understand. We can/should put a conditional
1194
1749
# in here based on whether the inventory is in the latest format
1195
1750
# - perhaps we should repack all inventories on a repository
1196
1751
# upgrade ?
1197
inv = self.branch.repository.get_inventory(new_revision)
1198
inv.revision_id = new_revision
1199
xml = bzrlib.xml5.serializer_v5.write_inventory_to_string(inv)
1200
1201
path = self._basis_inventory_name()
1202
self._control_files.put_utf8(path, xml)
1203
except WeaveRevisionNotPresent:
1752
# the fast path is to copy the raw xml from the repository. If the
1753
# xml contains 'revision_id="', then we assume the right
1754
# revision_id is set. We must check for this full string, because a
1755
# root node id can legitimately look like 'revision_id' but cannot
1756
# contain a '"'.
1757
xml = self.branch.repository.get_inventory_xml(new_revision)
1758
firstline = xml.split('\n', 1)[0]
1759
if (not 'revision_id="' in firstline or
1760
'format="7"' not in firstline):
1761
inv = self.branch.repository.deserialise_inventory(
1762
new_revision, xml)
1763
xml = self._create_basis_xml_from_inventory(new_revision, inv)
1764
self._write_basis_inventory(xml)
1765
except (errors.NoSuchRevision, errors.RevisionNotPresent):
1204
1766
pass
1205
1767
1206
1768
def read_basis_inventory(self):
1207
1769
"""Read the cached basis inventory."""
1208
1770
path = self._basis_inventory_name()
1209
return self._control_files.get_utf8(path).read()
1771
return self._control_files.get(path).read()
1210
1772
1211
1773
@needs_read_lock
1212
1774
def read_working_inventory(self):
1213
"""Read the working inventory."""
1775
"""Read the working inventory.
1776
1777
:raises errors.InventoryModified: read_working_inventory will fail
1778
when the current in memory inventory has been modified.
1779
"""
1780
# conceptually this should be an implementation detail of the tree.
1781
# XXX: Deprecate this.
1214
1782
# ElementTree does its own conversion from UTF-8, so open in
1215
1783
# binary.
1216
result = bzrlib.xml5.serializer_v5.read_inventory(
1217
self._control_files.get('inventory'))
1218
self._set_inventory(result)
1784
if self._inventory_is_modified:
1785
raise errors.InventoryModified(self)
1786
result = self._deserialize(self._control_files.get('inventory'))
1787
self._set_inventory(result, dirty=False)
1219
1788
return result
1220
1789
1221
@needs_write_lock
1222
def remove(self, files, verbose=False):
1790
@needs_tree_write_lock
1791
def remove(self, files, verbose=False, to_file=None):
1223
1792
"""Remove nominated files from the working inventory..
1224
1793
1225
1794
This does not remove their text. This does not run on XXX on what? RBC
1244
1813
for f in files:
1245
1814
fid = inv.path2id(f)
1246
1815
if not fid:
1247
# TODO: Perhaps make this just a warning, and continue?
1248
# This tends to happen when
1249
raise NotVersionedError(path=f)
1250
mutter("remove inventory entry %s {%s}", quotefn(f), fid)
1251
if verbose:
1252
# having remove it, it must be either ignored or unknown
1253
if self.is_ignored(f):
1254
new_status = 'I'
1255
else:
1256
new_status = '?'
1257
show_status(new_status, inv[fid].kind, quotefn(f))
1258
del inv[fid]
1816
note("%s is not versioned."%f)
1817
else:
1818
if verbose:
1819
# having remove it, it must be either ignored or unknown
1820
if self.is_ignored(f):
1821
new_status = 'I'
1822
else:
1823
new_status = '?'
1824
textui.show_status(new_status, inv[fid].kind, f,
1825
to_file=to_file)
1826
del inv[fid]
1259
1827
1260
1828
self._write_inventory(inv)
1261
1829
1262
@needs_write_lock
1830
@needs_tree_write_lock
1263
1831
def revert(self, filenames, old_tree=None, backups=True,
1264
pb=DummyProgress()):
1265
from transform import revert
1266
from conflicts import resolve
1832
pb=DummyProgress(), report_changes=False):
1833
from bzrlib.conflicts import resolve
1267
1834
if old_tree is None:
1268
1835
old_tree = self.basis_tree()
1269
conflicts = revert(self, old_tree, filenames, backups, pb)
1836
conflicts = transform.revert(self, old_tree, filenames, backups, pb,
1837
report_changes)
1270
1838
if not len(filenames):
1271
self.set_pending_merges([])
1839
self.set_parent_ids(self.get_parent_ids()[:1])
1272
1840
resolve(self)
1273
1841
else:
1274
1842
resolve(self, filenames, ignore_misses=True)
1275
1843
return conflicts
1276
1844
1845
def revision_tree(self, revision_id):
1846
"""See Tree.revision_tree.
1847
1848
WorkingTree can supply revision_trees for the basis revision only
1849
because there is only one cached inventory in the bzr directory.
1850
"""
1851
if revision_id == self.last_revision():
1852
try:
1853
xml = self.read_basis_inventory()
1854
except errors.NoSuchFile:
1855
pass
1856
else:
1857
try:
1858
inv = xml7.serializer_v7.read_inventory_from_string(xml)
1859
# dont use the repository revision_tree api because we want
1860
# to supply the inventory.
1861
if inv.revision_id == revision_id:
1862
return revisiontree.RevisionTree(self.branch.repository,
1863
inv, revision_id)
1864
except errors.BadInventoryFormat:
1865
pass
1866
# raise if there was no inventory, or if we read the wrong inventory.
1867
raise errors.NoSuchRevisionInTree(self, revision_id)
1868
1277
1869
# XXX: This method should be deprecated in favour of taking in a proper
1278
1870
# new Inventory object.
1279
@needs_write_lock
1871
@needs_tree_write_lock
1280
1872
def set_inventory(self, new_inventory_list):
1281
1873
from bzrlib.inventory import (Inventory,
1282
1874
InventoryDirectory,
1296
1888
elif kind == 'symlink':
1297
1889
inv.add(InventoryLink(file_id, name, parent))
1298
1890
else:
1299
raise BzrError("unknown kind %r" % kind)
1891
raise errors.BzrError("unknown kind %r" % kind)
1300
1892
self._write_inventory(inv)
1301
1893
1302
@needs_write_lock
1894
@needs_tree_write_lock
1303
1895
def set_root_id(self, file_id):
1304
1896
"""Set the root id for this tree."""
1305
inv = self.read_working_inventory()
1897
# for compatability
1898
if file_id is None:
1899
symbol_versioning.warn(symbol_versioning.zero_twelve
1900
% 'WorkingTree.set_root_id with fileid=None',
1901
DeprecationWarning,
1902
stacklevel=3)
1903
file_id = ROOT_ID
1904
else:
1905
file_id = osutils.safe_file_id(file_id)
1906
self._set_root_id(file_id)
1907
1908
def _set_root_id(self, file_id):
1909
"""Set the root id for this tree, in a format specific manner.
1910
1911
:param file_id: The file id to assign to the root. It must not be
1912
present in the current inventory or an error will occur. It must
1913
not be None, but rather a valid file id.
1914
"""
1915
inv = self._inventory
1306
1916
orig_root_id = inv.root.file_id
1917
# TODO: it might be nice to exit early if there was nothing
1918
# to do, saving us from trigger a sync on unlock.
1919
self._inventory_is_modified = True
1920
# we preserve the root inventory entry object, but
1921
# unlinkit from the byid index
1307
1922
del inv._byid[inv.root.file_id]
1308
1923
inv.root.file_id = file_id
1924
# and link it into the index with the new changed id.
1309
1925
inv._byid[inv.root.file_id] = inv.root
1926
# and finally update all children to reference the new id.
1927
# XXX: this should be safe to just look at the root.children
1928
# list, not the WHOLE INVENTORY.
1310
1929
for fid in inv:
1311
1930
entry = inv[fid]
1312
1931
if entry.parent_id == orig_root_id:
1313
1932
entry.parent_id = inv.root.file_id
1314
self._write_inventory(inv)
1315
1933
1316
1934
def unlock(self):
1317
1935
"""See Branch.unlock.
1322
1940
between multiple working trees, i.e. via shared storage, then we
1323
1941
would probably want to lock both the local tree, and the branch.
1324
1942
"""
1325
# FIXME: We want to write out the hashcache only when the last lock on
1326
# this working copy is released. Peeking at the lock count is a bit
1327
# of a nasty hack; probably it's better to have a transaction object,
1328
# which can do some finalization when it's either successfully or
1329
# unsuccessfully completed. (Denys's original patch did that.)
1330
# RBC 20060206 hookinhg into transaction will couple lock and transaction
1331
# wrongly. Hookinh into unllock on the control files object is fine though.
1332
1333
# TODO: split this per format so there is no ugly if block
1334
if self._hashcache.needs_write and (
1335
# dedicated lock files
1336
self._control_files._lock_count==1 or
1337
# shared lock files
1338
(self._control_files is self.branch.control_files and
1339
self._control_files._lock_count==3)):
1340
self._hashcache.write()
1341
# reverse order of locking.
1342
try:
1343
return self._control_files.unlock()
1344
finally:
1345
self.branch.unlock()
1943
raise NotImplementedError(self.unlock)
1346
1944
1347
@needs_write_lock
1348
1945
def update(self):
1349
1946
"""Update a working tree along its branch.
1350
1947
1351
This will update the branch if its bound too, which means we have multiple trees involved:
1352
The new basis tree of the master.
1353
The old basis tree of the branch.
1354
The old basis tree of the working tree.
1355
The current working tree state.
1356
pathologically all three may be different, and non ancestors of each other.
1357
Conceptually we want to:
1358
Preserve the wt.basis->wt.state changes
1359
Transform the wt.basis to the new master basis.
1360
Apply a merge of the old branch basis to get any 'local' changes from it into the tree.
1361
Restore the wt.basis->wt.state changes.
1948
This will update the branch if its bound too, which means we have
1949
multiple trees involved:
1950
1951
- The new basis tree of the master.
1952
- The old basis tree of the branch.
1953
- The old basis tree of the working tree.
1954
- The current working tree state.
1955
1956
Pathologically, all three may be different, and non-ancestors of each
1957
other. Conceptually we want to:
1958
1959
- Preserve the wt.basis->wt.state changes
1960
- Transform the wt.basis to the new master basis.
1961
- Apply a merge of the old branch basis to get any 'local' changes from
1962
it into the tree.
1963
- Restore the wt.basis->wt.state changes.
1362
1964
1363
1965
There isn't a single operation at the moment to do that, so we:
1364
Merge current state -> basis tree of the master w.r.t. the old tree basis.
1365
Do a 'normal' merge of the old branch basis if it is relevant.
1366
"""
1367
old_tip = self.branch.update()
1368
if old_tip is not None:
1369
self.add_pending_merge(old_tip)
1370
self.branch.lock_read()
1371
try:
1372
result = 0
1373
if self.last_revision() != self.branch.last_revision():
1374
# merge tree state up to new branch tip.
1375
basis = self.basis_tree()
1966
- Merge current state -> basis tree of the master w.r.t. the old tree
1967
basis.
1968
- Do a 'normal' merge of the old branch basis if it is relevant.
1969
"""
1970
if self.branch.get_master_branch() is not None:
1971
self.lock_write()
1972
update_branch = True
1973
else:
1974
self.lock_tree_write()
1975
update_branch = False
1976
try:
1977
if update_branch:
1978
old_tip = self.branch.update()
1979
else:
1980
old_tip = None
1981
return self._update_tree(old_tip)
1982
finally:
1983
self.unlock()
1984
1985
@needs_tree_write_lock
1986
def _update_tree(self, old_tip=None):
1987
"""Update a tree to the master branch.
1988
1989
:param old_tip: if supplied, the previous tip revision the branch,
1990
before it was changed to the master branch's tip.
1991
"""
1992
# here if old_tip is not None, it is the old tip of the branch before
1993
# it was updated from the master branch. This should become a pending
1994
# merge in the working tree to preserve the user existing work. we
1995
# cant set that until we update the working trees last revision to be
1996
# one from the new branch, because it will just get absorbed by the
1997
# parent de-duplication logic.
1998
#
1999
# We MUST save it even if an error occurs, because otherwise the users
2000
# local work is unreferenced and will appear to have been lost.
2001
#
2002
result = 0
2003
try:
2004
last_rev = self.get_parent_ids()[0]
2005
except IndexError:
2006
last_rev = None
2007
if last_rev != self.branch.last_revision():
2008
# merge tree state up to new branch tip.
2009
basis = self.basis_tree()
2010
basis.lock_read()
2011
try:
1376
2012
to_tree = self.branch.basis_tree()
1377
result += merge_inner(self.branch,
2013
if basis.inventory.root is None:
2014
self.set_root_id(to_tree.inventory.root.file_id)
2015
self.flush()
2016
result += merge.merge_inner(
2017
self.branch,
1378
2018
to_tree,
1379
2019
basis,
1380
2020
this_tree=self)
1381
self.set_last_revision(self.branch.last_revision())
1382
if old_tip and old_tip != self.last_revision():
1383
# our last revision was not the prior branch last reivison
1384
# and we have converted that last revision to a pending merge.
1385
# base is somewhere between the branch tip now
1386
# and the now pending merge
1387
from bzrlib.revision import common_ancestor
1388
try:
1389
base_rev_id = common_ancestor(self.branch.last_revision(),
1390
old_tip,
1391
self.branch.repository)
1392
except errors.NoCommonAncestor:
1393
base_rev_id = None
1394
base_tree = self.branch.repository.revision_tree(base_rev_id)
1395
other_tree = self.branch.repository.revision_tree(old_tip)
1396
result += merge_inner(self.branch,
1397
other_tree,
1398
base_tree,
1399
this_tree=self)
1400
return result
1401
finally:
1402
self.branch.unlock()
1403
1404
@needs_write_lock
2021
finally:
2022
basis.unlock()
2023
# TODO - dedup parents list with things merged by pull ?
2024
# reuse the tree we've updated to to set the basis:
2025
parent_trees = [(self.branch.last_revision(), to_tree)]
2026
merges = self.get_parent_ids()[1:]
2027
# Ideally we ask the tree for the trees here, that way the working
2028
# tree can decide whether to give us teh entire tree or give us a
2029
# lazy initialised tree. dirstate for instance will have the trees
2030
# in ram already, whereas a last-revision + basis-inventory tree
2031
# will not, but also does not need them when setting parents.
2032
for parent in merges:
2033
parent_trees.append(
2034
(parent, self.branch.repository.revision_tree(parent)))
2035
if old_tip is not None:
2036
parent_trees.append(
2037
(old_tip, self.branch.repository.revision_tree(old_tip)))
2038
self.set_parent_trees(parent_trees)
2039
last_rev = parent_trees[0][0]
2040
else:
2041
# the working tree had the same last-revision as the master
2042
# branch did. We may still have pivot local work from the local
2043
# branch into old_tip:
2044
if old_tip is not None:
2045
self.add_parent_tree_id(old_tip)
2046
if old_tip and old_tip != last_rev:
2047
# our last revision was not the prior branch last revision
2048
# and we have converted that last revision to a pending merge.
2049
# base is somewhere between the branch tip now
2050
# and the now pending merge
2051
2052
# Since we just modified the working tree and inventory, flush out
2053
# the current state, before we modify it again.
2054
# TODO: jam 20070214 WorkingTree3 doesn't require this, dirstate
2055
# requires it only because TreeTransform directly munges the
2056
# inventory and calls tree._write_inventory(). Ultimately we
2057
# should be able to remove this extra flush.
2058
self.flush()
2059
from bzrlib.revision import common_ancestor
2060
try:
2061
base_rev_id = common_ancestor(self.branch.last_revision(),
2062
old_tip,
2063
self.branch.repository)
2064
except errors.NoCommonAncestor:
2065
base_rev_id = None
2066
base_tree = self.branch.repository.revision_tree(base_rev_id)
2067
other_tree = self.branch.repository.revision_tree(old_tip)
2068
result += merge.merge_inner(
2069
self.branch,
2070
other_tree,
2071
base_tree,
2072
this_tree=self)
2073
return result
2074
2075
def _write_hashcache_if_dirty(self):
2076
"""Write out the hashcache if it is dirty."""
2077
if self._hashcache.needs_write:
2078
try:
2079
self._hashcache.write()
2080
except OSError, e:
2081
if e.errno not in (errno.EPERM, errno.EACCES):
2082
raise
2083
# TODO: jam 20061219 Should this be a warning? A single line
2084
# warning might be sufficient to let the user know what
2085
# is going on.
2086
mutter('Could not write hashcache for %s\nError: %s',
2087
self._hashcache.cache_file_name(), e)
2088
2089
@needs_tree_write_lock
1405
2090
def _write_inventory(self, inv):
1406
2091
"""Write inventory as the current inventory."""
1407
sio = StringIO()
1408
bzrlib.xml5.serializer_v5.write_inventory(inv, sio)
1409
sio.seek(0)
1410
self._control_files.put('inventory', sio)
1411
self._set_inventory(inv)
1412
mutter('wrote working inventory')
2092
self._set_inventory(inv, dirty=True)
2093
self.flush()
1413
2094
1414
2095
def set_conflicts(self, arg):
1415
raise UnsupportedOperation(self.set_conflicts, self)
2096
raise errors.UnsupportedOperation(self.set_conflicts, self)
2097
2098
def add_conflicts(self, arg):
2099
raise errors.UnsupportedOperation(self.add_conflicts, self)
1416
2100
1417
2101
@needs_read_lock
1418
2102
def conflicts(self):
1419
conflicts = ConflictList()
2103
conflicts = _mod_conflicts.ConflictList()
1420
2104
for conflicted in self._iter_conflicts():
1421
2105
text = True
1422
2106
try:
1423
2107
if file_kind(self.abspath(conflicted)) != "file":
1424
2108
text = False
1425
except OSError, e:
1426
if e.errno == errno.ENOENT:
1427
text = False
1428
else:
1429
raise
2109
except errors.NoSuchFile:
2110
text = False
1430
2111
if text is True:
1431
2112
for suffix in ('.THIS', '.OTHER'):
1432
2113
try:
1433
2114
kind = file_kind(self.abspath(conflicted+suffix))
1434
except OSError, e:
1435
if e.errno == errno.ENOENT:
2115
if kind != "file":
1436
2116
text = False
1437
break
1438
else:
1439
raise
1440
if kind != "file":
2117
except errors.NoSuchFile:
1441
2118
text = False
2119
if text == False:
1442
2120
break
1443
2121
ctype = {True: 'text conflict', False: 'contents conflict'}[text]
1444
conflicts.append(Conflict.factory(ctype, path=conflicted,
2122
conflicts.append(_mod_conflicts.Conflict.factory(ctype,
2123
path=conflicted,
1445
2124
file_id=self.path2id(conflicted)))
1446
2125
return conflicts
1447
2126
2127
def walkdirs(self, prefix=""):
2128
"""Walk the directories of this tree.
2129
2130
This API returns a generator, which is only valid during the current
2131
tree transaction - within a single lock_read or lock_write duration.
2132
2133
If the tree is not locked, it may cause an error to be raised, depending
2134
on the tree implementation.
2135
"""
2136
disk_top = self.abspath(prefix)
2137
if disk_top.endswith('/'):
2138
disk_top = disk_top[:-1]
2139
top_strip_len = len(disk_top) + 1
2140
inventory_iterator = self._walkdirs(prefix)
2141
disk_iterator = osutils.walkdirs(disk_top, prefix)
2142
try:
2143
current_disk = disk_iterator.next()
2144
disk_finished = False
2145
except OSError, e:
2146
if e.errno != errno.ENOENT:
2147
raise
2148
current_disk = None
2149
disk_finished = True
2150
try:
2151
current_inv = inventory_iterator.next()
2152
inv_finished = False
2153
except StopIteration:
2154
current_inv = None
2155
inv_finished = True
2156
while not inv_finished or not disk_finished:
2157
if not disk_finished:
2158
# strip out .bzr dirs
2159
if current_disk[0][1][top_strip_len:] == '':
2160
# osutils.walkdirs can be made nicer -
2161
# yield the path-from-prefix rather than the pathjoined
2162
# value.
2163
bzrdir_loc = bisect_left(current_disk[1], ('.bzr', '.bzr'))
2164
if current_disk[1][bzrdir_loc][0] == '.bzr':
2165
# we dont yield the contents of, or, .bzr itself.
2166
del current_disk[1][bzrdir_loc]
2167
if inv_finished:
2168
# everything is unknown
2169
direction = 1
2170
elif disk_finished:
2171
# everything is missing
2172
direction = -1
2173
else:
2174
direction = cmp(current_inv[0][0], current_disk[0][0])
2175
if direction > 0:
2176
# disk is before inventory - unknown
2177
dirblock = [(relpath, basename, kind, stat, None, None) for
2178
relpath, basename, kind, stat, top_path in current_disk[1]]
2179
yield (current_disk[0][0], None), dirblock
2180
try:
2181
current_disk = disk_iterator.next()
2182
except StopIteration:
2183
disk_finished = True
2184
elif direction < 0:
2185
# inventory is before disk - missing.
2186
dirblock = [(relpath, basename, 'unknown', None, fileid, kind)
2187
for relpath, basename, dkind, stat, fileid, kind in
2188
current_inv[1]]
2189
yield (current_inv[0][0], current_inv[0][1]), dirblock
2190
try:
2191
current_inv = inventory_iterator.next()
2192
except StopIteration:
2193
inv_finished = True
2194
else:
2195
# versioned present directory
2196
# merge the inventory and disk data together
2197
dirblock = []
2198
for relpath, subiterator in itertools.groupby(sorted(
2199
current_inv[1] + current_disk[1], key=operator.itemgetter(0)), operator.itemgetter(1)):
2200
path_elements = list(subiterator)
2201
if len(path_elements) == 2:
2202
inv_row, disk_row = path_elements
2203
# versioned, present file
2204
dirblock.append((inv_row[0],
2205
inv_row[1], disk_row[2],
2206
disk_row[3], inv_row[4],
2207
inv_row[5]))
2208
elif len(path_elements[0]) == 5:
2209
# unknown disk file
2210
dirblock.append((path_elements[0][0],
2211
path_elements[0][1], path_elements[0][2],
2212
path_elements[0][3], None, None))
2213
elif len(path_elements[0]) == 6:
2214
# versioned, absent file.
2215
dirblock.append((path_elements[0][0],
2216
path_elements[0][1], 'unknown', None,
2217
path_elements[0][4], path_elements[0][5]))
2218
else:
2219
raise NotImplementedError('unreachable code')
2220
yield current_inv[0], dirblock
2221
try:
2222
current_inv = inventory_iterator.next()
2223
except StopIteration:
2224
inv_finished = True
2225
try:
2226
current_disk = disk_iterator.next()
2227
except StopIteration:
2228
disk_finished = True
2229
2230
def _walkdirs(self, prefix=""):
2231
_directory = 'directory'
2232
# get the root in the inventory
2233
inv = self.inventory
2234
top_id = inv.path2id(prefix)
2235
if top_id is None:
2236
pending = []
2237
else:
2238
pending = [(prefix, '', _directory, None, top_id, None)]
2239
while pending:
2240
dirblock = []
2241
currentdir = pending.pop()
2242
# 0 - relpath, 1- basename, 2- kind, 3- stat, 4-id, 5-kind
2243
top_id = currentdir[4]
2244
if currentdir[0]:
2245
relroot = currentdir[0] + '/'
2246
else:
2247
relroot = ""
2248
# FIXME: stash the node in pending
2249
entry = inv[top_id]
2250
for name, child in entry.sorted_children():
2251
dirblock.append((relroot + name, name, child.kind, None,
2252
child.file_id, child.kind
2253
))
2254
yield (currentdir[0], entry.file_id), dirblock
2255
# push the user specified dirs from dirblock
2256
for dir in reversed(dirblock):
2257
if dir[2] == _directory:
2258
pending.append(dir)
2259
2260
@needs_tree_write_lock
2261
def auto_resolve(self):
2262
"""Automatically resolve text conflicts according to contents.
2263
2264
Only text conflicts are auto_resolvable. Files with no conflict markers
2265
are considered 'resolved', because bzr always puts conflict markers
2266
into files that have text conflicts. The corresponding .THIS .BASE and
2267
.OTHER files are deleted, as per 'resolve'.
2268
:return: a tuple of ConflictLists: (un_resolved, resolved).
2269
"""
2270
un_resolved = _mod_conflicts.ConflictList()
2271
resolved = _mod_conflicts.ConflictList()
2272
conflict_re = re.compile('^(<{7}|={7}|>{7})')
2273
for conflict in self.conflicts():
2274
if (conflict.typestring != 'text conflict' or
2275
self.kind(conflict.file_id) != 'file'):
2276
un_resolved.append(conflict)
2277
continue
2278
my_file = open(self.id2abspath(conflict.file_id), 'rb')
2279
try:
2280
for line in my_file:
2281
if conflict_re.search(line):
2282
un_resolved.append(conflict)
2283
break
2284
else:
2285
resolved.append(conflict)
2286
finally:
2287
my_file.close()
2288
resolved.remove_files(self)
2289
self.set_conflicts(un_resolved)
2290
return un_resolved, resolved
2291
2292
2293
class WorkingTree2(WorkingTree):
2294
"""This is the Format 2 working tree.
2295
2296
This was the first weave based working tree.
2297
- uses os locks for locking.
2298
- uses the branch last-revision.
2299
"""
2300
2301
def lock_tree_write(self):
2302
"""See WorkingTree.lock_tree_write().
2303
2304
In Format2 WorkingTrees we have a single lock for the branch and tree
2305
so lock_tree_write() degrades to lock_write().
2306
"""
2307
self.branch.lock_write()
2308
try:
2309
return self._control_files.lock_write()
2310
except:
2311
self.branch.unlock()
2312
raise
2313
2314
def unlock(self):
2315
# we share control files:
2316
if self._control_files._lock_count == 3:
2317
# _inventory_is_modified is always False during a read lock.
2318
if self._inventory_is_modified:
2319
self.flush()
2320
self._write_hashcache_if_dirty()
2321
2322
# reverse order of locking.
2323
try:
2324
return self._control_files.unlock()
2325
finally:
2326
self.branch.unlock()
2327
1448
2328
1449
2329
class WorkingTree3(WorkingTree):
1450
2330
"""This is the Format 3 working tree.
1457
2337
"""
1458
2338
1459
2339
@needs_read_lock
1460
def last_revision(self):
1461
"""See WorkingTree.last_revision."""
2340
def _last_revision(self):
2341
"""See Mutable.last_revision."""
1462
2342
try:
1463
return self._control_files.get_utf8('last-revision').read()
1464
except NoSuchFile:
2343
return osutils.safe_revision_id(
2344
self._control_files.get('last-revision').read())
2345
except errors.NoSuchFile:
1465
2346
return None
1466
2347
1467
2348
def _change_last_revision(self, revision_id):
1473
2354
pass
1474
2355
return False
1475
2356
else:
1476
try:
1477
self.branch.revision_history().index(revision_id)
1478
except ValueError:
1479
raise errors.NoSuchRevision(self.branch, revision_id)
1480
self._control_files.put_utf8('last-revision', revision_id)
2357
self._control_files.put_bytes('last-revision', revision_id)
1481
2358
return True
1482
2359
1483
@needs_write_lock
2360
@needs_tree_write_lock
1484
2361
def set_conflicts(self, conflicts):
1485
2362
self._put_rio('conflicts', conflicts.to_stanzas(),
1486
2363
CONFLICT_HEADER_1)
1487
2364
2365
@needs_tree_write_lock
2366
def add_conflicts(self, new_conflicts):
2367
conflict_set = set(self.conflicts())
2368
conflict_set.update(set(list(new_conflicts)))
2369
self.set_conflicts(_mod_conflicts.ConflictList(sorted(conflict_set,
2370
key=_mod_conflicts.Conflict.sort_key)))
2371
1488
2372
@needs_read_lock
1489
2373
def conflicts(self):
1490
2374
try:
1491
2375
confile = self._control_files.get('conflicts')
1492
except NoSuchFile:
1493
return ConflictList()
2376
except errors.NoSuchFile:
2377
return _mod_conflicts.ConflictList()
1494
2378
try:
1495
2379
if confile.next() != CONFLICT_HEADER_1 + '\n':
1496
raise ConflictFormatError()
2380
raise errors.ConflictFormatError()
1497
2381
except StopIteration:
1498
raise ConflictFormatError()
1499
return ConflictList.from_stanzas(RioReader(confile))
2382
raise errors.ConflictFormatError()
2383
return _mod_conflicts.ConflictList.from_stanzas(RioReader(confile))
2384
2385
def unlock(self):
2386
if self._control_files._lock_count == 1:
2387
# _inventory_is_modified is always False during a read lock.
2388
if self._inventory_is_modified:
2389
self.flush()
2390
self._write_hashcache_if_dirty()
2391
# reverse order of locking.
2392
try:
2393
return self._control_files.unlock()
2394
finally:
2395
self.branch.unlock()
1500
2396
1501
2397
1502
2398
def get_conflicted_stem(path):
1503
for suffix in CONFLICT_SUFFIXES:
2399
for suffix in _mod_conflicts.CONFLICT_SUFFIXES:
1504
2400
if path.endswith(suffix):
1505
2401
return path[:-len(suffix)]
1506
2402
2403
1507
2404
@deprecated_function(zero_eight)
1508
2405
def is_control_file(filename):
1509
2406
"""See WorkingTree.is_control_filename(filename)."""
1544
2441
_formats = {}
1545
2442
"""The known formats."""
1546
2443
2444
requires_rich_root = False
2445
1547
2446
@classmethod
1548
2447
def find_format(klass, a_bzrdir):
1549
2448
"""Return the format for the working tree object in a_bzrdir."""
1551
2450
transport = a_bzrdir.get_workingtree_transport(None)
1552
2451
format_string = transport.get("format").read()
1553
2452
return klass._formats[format_string]
1554
except NoSuchFile:
2453
except errors.NoSuchFile:
1555
2454
raise errors.NoWorkingTree(base=transport.base)
1556
2455
except KeyError:
1557
raise errors.UnknownFormatError(format_string)
2456
raise errors.UnknownFormatError(format=format_string)
2457
2458
def __eq__(self, other):
2459
return self.__class__ is other.__class__
2460
2461
def __ne__(self, other):
2462
return not (self == other)
1558
2463
1559
2464
@classmethod
1560
2465
def get_default_format(klass):
1612
2517
"""
1613
2518
sio = StringIO()
1614
2519
inv = Inventory()
1615
bzrlib.xml5.serializer_v5.write_inventory(inv, sio)
2520
xml5.serializer_v5.write_inventory(inv, sio)
1616
2521
sio.seek(0)
1617
2522
control_files.put('inventory', sio)
1618
2523
1619
control_files.put_utf8('pending-merges', '')
2524
control_files.put_bytes('pending-merges', '')
1620
2525
1621
2526
1622
2527
def initialize(self, a_bzrdir, revision_id=None):
1625
2530
raise errors.NotLocalUrl(a_bzrdir.transport.base)
1626
2531
branch = a_bzrdir.open_branch()
1627
2532
if revision_id is not None:
2533
revision_id = osutils.safe_revision_id(revision_id)
1628
2534
branch.lock_write()
1629
2535
try:
1630
2536
revision_history = branch.revision_history()
1636
2542
finally:
1637
2543
branch.unlock()
1638
2544
revision = branch.last_revision()
1639
inv = Inventory()
1640
wt = WorkingTree(a_bzrdir.root_transport.base,
2545
inv = Inventory()
2546
wt = WorkingTree2(a_bzrdir.root_transport.local_abspath('.'),
1641
2547
branch,
1642
2548
inv,
1643
2549
_internal=True,
1644
2550
_format=self,
1645
2551
_bzrdir=a_bzrdir)
1646
wt._write_inventory(inv)
1647
wt.set_root_id(inv.root.file_id)
1648
wt.set_last_revision(revision)
1649
wt.set_pending_merges([])
1650
build_tree(wt.basis_tree(), wt)
2552
basis_tree = branch.repository.revision_tree(revision)
2553
if basis_tree.inventory.root is not None:
2554
wt.set_root_id(basis_tree.inventory.root.file_id)
2555
# set the parent list and cache the basis tree.
2556
wt.set_parent_trees([(revision, basis_tree)])
2557
transform.build_tree(basis_tree, wt)
1651
2558
return wt
1652
2559
1653
2560
def __init__(self):
1665
2572
raise NotImplementedError
1666
2573
if not isinstance(a_bzrdir.transport, LocalTransport):
1667
2574
raise errors.NotLocalUrl(a_bzrdir.transport.base)
1668
return WorkingTree(a_bzrdir.root_transport.base,
2575
return WorkingTree2(a_bzrdir.root_transport.local_abspath('.'),
1669
2576
_internal=True,
1670
2577
_format=self,
1671
2578
_bzrdir=a_bzrdir)
1680
2587
files, separate from the BzrDir format
1681
2588
- modifies the hash cache format
1682
2589
- is new in bzr 0.8
1683
- uses a LockDir to guard access to the repository
2590
- uses a LockDir to guard access for writes.
1684
2591
"""
1685
2592
1686
2593
def get_format_string(self):
1694
2601
_lock_file_name = 'lock'
1695
2602
_lock_class = LockDir
1696
2603
2604
_tree_class = WorkingTree3
2605
2606
def __get_matchingbzrdir(self):
2607
return bzrdir.BzrDirMetaFormat1()
2608
2609
_matchingbzrdir = property(__get_matchingbzrdir)
2610
1697
2611
def _open_control_files(self, a_bzrdir):
1698
2612
transport = a_bzrdir.get_workingtree_transport(None)
1699
2613
return LockableFiles(transport, self._lock_file_name,
1702
2616
def initialize(self, a_bzrdir, revision_id=None):
1703
2617
"""See WorkingTreeFormat.initialize().
1704
2618
1705
revision_id allows creating a working tree at a differnet
2619
revision_id allows creating a working tree at a different
1706
2620
revision than the branch is at.
1707
2621
"""
1708
2622
if not isinstance(a_bzrdir.transport, LocalTransport):
1715
2629
branch = a_bzrdir.open_branch()
1716
2630
if revision_id is None:
1717
2631
revision_id = branch.last_revision()
1718
inv = Inventory()
1719
wt = WorkingTree3(a_bzrdir.root_transport.base,
2632
else:
2633
revision_id = osutils.safe_revision_id(revision_id)
2634
# WorkingTree3 can handle an inventory which has a unique root id.
2635
# as of bzr 0.12. However, bzr 0.11 and earlier fail to handle
2636
# those trees. And because there isn't a format bump inbetween, we
2637
# are maintaining compatibility with older clients.
2638
# inv = Inventory(root_id=gen_root_id())
2639
inv = self._initial_inventory()
2640
wt = self._tree_class(a_bzrdir.root_transport.local_abspath('.'),
1720
2641
branch,
1721
2642
inv,
1722
2643
_internal=True,
1723
2644
_format=self,
1724
2645
_bzrdir=a_bzrdir,
1725
2646
_control_files=control_files)
1726
wt.lock_write()
2647
wt.lock_tree_write()
1727
2648
try:
1728
wt._write_inventory(inv)
1729
wt.set_root_id(inv.root.file_id)
1730
wt.set_last_revision(revision_id)
1731
wt.set_pending_merges([])
1732
build_tree(wt.basis_tree(), wt)
2649
basis_tree = branch.repository.revision_tree(revision_id)
2650
# only set an explicit root id if there is one to set.
2651
if basis_tree.inventory.root is not None:
2652
wt.set_root_id(basis_tree.inventory.root.file_id)
2653
if revision_id == NULL_REVISION:
2654
wt.set_parent_trees([])
2655
else:
2656
wt.set_parent_trees([(revision_id, basis_tree)])
2657
transform.build_tree(basis_tree, wt)
1733
2658
finally:
2659
# Unlock in this order so that the unlock-triggers-flush in
2660
# WorkingTree is given a chance to fire.
2661
control_files.unlock()
1734
2662
wt.unlock()
1735
control_files.unlock()
1736
2663
return wt
1737
2664
2665
def _initial_inventory(self):
2666
return Inventory()
2667
1738
2668
def __init__(self):
1739
2669
super(WorkingTreeFormat3, self).__init__()
1740
self._matchingbzrdir = bzrdir.BzrDirMetaFormat1()
1741
2670
1742
2671
def open(self, a_bzrdir, _found=False):
1743
2672
"""Return the WorkingTree object for a_bzrdir
1750
2679
raise NotImplementedError
1751
2680
if not isinstance(a_bzrdir.transport, LocalTransport):
1752
2681
raise errors.NotLocalUrl(a_bzrdir.transport.base)
1753
control_files = self._open_control_files(a_bzrdir)
1754
return WorkingTree3(a_bzrdir.root_transport.base,
1755
_internal=True,
1756
_format=self,
1757
_bzrdir=a_bzrdir,
1758
_control_files=control_files)
2682
return self._open(a_bzrdir, self._open_control_files(a_bzrdir))
2683
2684
def _open(self, a_bzrdir, control_files):
2685
"""Open the tree itself.
2686
2687
:param a_bzrdir: the dir for the tree.
2688
:param control_files: the control files for the tree.
2689
"""
2690
return self._tree_class(a_bzrdir.root_transport.local_abspath('.'),
2691
_internal=True,
2692
_format=self,
2693
_bzrdir=a_bzrdir,
2694
_control_files=control_files)
1759
2695
1760
2696
def __str__(self):
1761
2697
return self.get_format_string()
1762
2698
1763
2699
2700
__default_format = WorkingTreeFormat4()
2701
WorkingTreeFormat.register_format(__default_format)
2702
WorkingTreeFormat.register_format(WorkingTreeFormat3())
2703
WorkingTreeFormat.set_default_format(__default_format)
1764
2704
# formats which have no format string are not discoverable
1765
2705
# and not independently creatable, so are not registered.
1766
__default_format = WorkingTreeFormat3()
1767
WorkingTreeFormat.register_format(__default_format)
1768
WorkingTreeFormat.set_default_format(__default_format)
1769
2706
_legacy_formats = [WorkingTreeFormat2(),
1770
2707
]
1771
2708
1784
2721
self._transport_readonly_server = transport_readonly_server
1785
2722
self._formats = formats
1786
2723
2724
def _clone_test(self, test, bzrdir_format, workingtree_format, variation):
2725
"""Clone test for adaption."""
2726
new_test = deepcopy(test)
2727
new_test.transport_server = self._transport_server
2728
new_test.transport_readonly_server = self._transport_readonly_server
2729
new_test.bzrdir_format = bzrdir_format
2730
new_test.workingtree_format = workingtree_format
2731
def make_new_test_id():
2732
new_id = "%s(%s)" % (test.id(), variation)
2733
return lambda: new_id
2734
new_test.id = make_new_test_id()
2735
return new_test
2736
1787
2737
def adapt(self, test):
1788
2738
from bzrlib.tests import TestSuite
1789
2739
result = TestSuite()
1790
2740
for workingtree_format, bzrdir_format in self._formats:
1791
new_test = deepcopy(test)
1792
new_test.transport_server = self._transport_server
1793
new_test.transport_readonly_server = self._transport_readonly_server
1794
new_test.bzrdir_format = bzrdir_format
1795
new_test.workingtree_format = workingtree_format
1796
def make_new_test_id():
1797
new_id = "%s(%s)" % (new_test.id(), workingtree_format.__class__.__name__)
1798
return lambda: new_id
1799
new_test.id = make_new_test_id()
2741
new_test = self._clone_test(
2742
test,
2743
bzrdir_format,
2744
workingtree_format, workingtree_format.__class__.__name__)
1800
2745
result.addTest(new_test)
1801
2746
return result
Loggerhead is a web-based interface for Breezy
Version: 2.0.1