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