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