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