To get this branch, use:
bzr branch
http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar
« back to all changes in this revision
Viewing changes to bzrlib/workingtree.py
- browse files at revision 2000.3.4
- compare with another revision
- download diff
- download tarball
- view history from revision 2000.3.4
- Committer: v.ladeuil+lp at free
- Date: 2006-10-16 15:52:57 UTC
- mfrom: (2084 +trunk)
- mto: (2157.1.1 bzr.dev) (2172.3.1 bzr.73948)
- mto: This revision was merged to the branch mainline in revision 2157.
- Revision ID: v.ladeuil+lp@free.fr-20061016155257-ff02a774a4314899
Merge bzr.dev
- files added:
- COPYING.txt
- bzrlib/benchmarks
- bzrlib/benchmarks/tree_creator
- bzrlib/bundle
- bzrlib/bundle/old
- bzrlib/bundle/serializer
- bzrlib/plugins/launchpad
- 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
- notes
- files renamed:
- bzrlib/tests/test_annotate.py => bzrlib/tests/blackbox/test_annotate.py
- bzrlib/tests/test_revprops.py => bzrlib/tests/repository_implementations/test_revision.py
- bzrlib/tests/test_basis_inventory.py => bzrlib/tests/workingtree_implementations/test_basis_inventory.py
- tutorial.txt => doc/tutorial.txt
- files modified:
- .bzrignore
- setup.py *
added
removed
bzrlib/workingtree.py
1
1
# Copyright (C) 2005, 2006 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
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
39
from cStringIO import StringIO
40
import os
41
import re
42
43
from bzrlib.lazy_import import lazy_import
44
lazy_import(globals(), """
45
import collections
42
46
from copy import deepcopy
43
from cStringIO import StringIO
44
47
import errno
45
48
import fnmatch
46
import os
47
49
import stat
48
49
50
from bzrlib.atomicfile import AtomicFile
51
from bzrlib.branch import (Branch,
52
quotefn)
53
from bzrlib.conflicts import Conflict, ConflictList, CONFLICT_SUFFIXES
54
import bzrlib.bzrdir as bzrdir
50
from time import time
51
import warnings
52
53
import bzrlib
54
from bzrlib import (
55
bzrdir,
56
conflicts as _mod_conflicts,
57
errors,
58
ignores,
59
merge,
60
osutils,
61
textui,
62
transform,
63
urlutils,
64
xml5,
65
xml6,
66
)
67
import bzrlib.branch
68
from bzrlib.transport import get_transport
69
import bzrlib.ui
70
""")
71
72
from bzrlib import symbol_versioning
55
73
from bzrlib.decorators import needs_read_lock, needs_write_lock
56
import bzrlib.errors as errors
57
74
from bzrlib.errors import (BzrCheckError,
58
75
BzrError,
59
76
ConflictFormatError,
60
DivergedBranches,
61
77
WeaveRevisionNotPresent,
62
78
NotBranchError,
63
79
NoSuchFile,
65
81
MergeModifiedFormatError,
66
82
UnsupportedOperation,
67
83
)
68
from bzrlib.inventory import InventoryEntry, Inventory
84
from bzrlib.inventory import InventoryEntry, Inventory, ROOT_ID
69
85
from bzrlib.lockable_files import LockableFiles, TransportLock
70
86
from bzrlib.lockdir import LockDir
71
from bzrlib.merge import merge_inner, transform_tree
87
import bzrlib.mutabletree
88
from bzrlib.mutabletree import needs_tree_write_lock
72
89
from bzrlib.osutils import (
73
abspath,
74
appendpath,
75
compact_date,
76
file_kind,
77
isdir,
78
getcwd,
79
pathjoin,
80
pumpfile,
81
safe_unicode,
82
splitpath,
83
rand_bytes,
84
normpath,
85
realpath,
86
relpath,
87
rename,
88
supports_executable,
89
)
90
compact_date,
91
file_kind,
92
isdir,
93
pathjoin,
94
safe_unicode,
95
splitpath,
96
rand_chars,
97
normpath,
98
realpath,
99
supports_executable,
100
)
101
from bzrlib.trace import mutter, note
102
from bzrlib.transport.local import LocalTransport
103
import bzrlib.tree
90
104
from bzrlib.progress import DummyProgress, ProgressPhase
91
105
from bzrlib.revision import NULL_REVISION
106
import bzrlib.revisiontree
92
107
from bzrlib.rio import RioReader, rio_file, Stanza
93
from bzrlib.symbol_versioning import *
94
from bzrlib.textui import show_status
95
import bzrlib.tree
96
from bzrlib.transform import build_tree
97
from bzrlib.trace import mutter, note
98
from bzrlib.transport import get_transport
99
from bzrlib.transport.local import LocalTransport
100
import bzrlib.ui
101
import bzrlib.xml5
108
from bzrlib.symbol_versioning import (deprecated_passed,
109
deprecated_method,
110
deprecated_function,
111
DEPRECATED_PARAMETER,
112
zero_eight,
113
zero_eleven,
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
# the regex removes any weird characters; we don't escape them
121
# but rather just pull them out
122
_gen_file_id_re = re.compile(r'[^\w.]')
123
_gen_id_suffix = None
124
_gen_id_serial = 0
125
126
127
def _next_id_suffix():
128
"""Create a new file id suffix that is reasonably unique.
129
130
On the first call we combine the current time with 64 bits of randomness
131
to give a highly probably globally unique number. Then each call in the same
132
process adds 1 to a serial number we append to that unique value.
133
"""
134
# XXX TODO: change bzrlib.add.smart_add to call workingtree.add() rather
135
# than having to move the id randomness out of the inner loop like this.
136
# XXX TODO: for the global randomness this uses we should add the thread-id
137
# before the serial #.
138
global _gen_id_suffix, _gen_id_serial
139
if _gen_id_suffix is None:
140
_gen_id_suffix = "-%s-%s-" % (compact_date(time()), rand_chars(16))
141
_gen_id_serial += 1
142
return _gen_id_suffix + str(_gen_id_serial)
102
143
103
144
104
145
def gen_file_id(name):
105
"""Return new file id.
106
107
This should probably generate proper UUIDs, but for the moment we
108
cope with just randomness because running uuidgen every time is
109
slow."""
110
import re
111
from binascii import hexlify
112
from time import time
113
114
# get last component
115
idx = name.rfind('/')
116
if idx != -1:
117
name = name[idx+1 : ]
118
idx = name.rfind('\\')
119
if idx != -1:
120
name = name[idx+1 : ]
121
122
# make it not a hidden file
123
name = name.lstrip('.')
124
125
# remove any wierd characters; we don't escape them but rather
126
# just pull them out
127
name = re.sub(r'[^\w.]', '', name)
128
129
s = hexlify(rand_bytes(8))
130
return '-'.join((name, compact_date(time()), s))
146
"""Return new file id for the basename 'name'.
147
148
The uniqueness is supplied from _next_id_suffix.
149
"""
150
# The real randomness is in the _next_id_suffix, the
151
# rest of the identifier is just to be nice.
152
# So we:
153
# 1) Remove non-ascii word characters to keep the ids portable
154
# 2) squash to lowercase, so the file id doesn't have to
155
# be escaped (case insensitive filesystems would bork for ids
156
# that only differred in case without escaping).
157
# 3) truncate the filename to 20 chars. Long filenames also bork on some
158
# filesystems
159
# 4) Removing starting '.' characters to prevent the file ids from
160
# being considered hidden.
161
ascii_word_only = _gen_file_id_re.sub('', name.lower())
162
short_no_dots = ascii_word_only.lstrip('.')[:20]
163
return short_no_dots + _next_id_suffix()
131
164
132
165
133
166
def gen_root_id():
134
167
"""Return a new tree-root file id."""
135
return gen_file_id('TREE_ROOT')
168
return gen_file_id('tree_root')
136
169
137
170
138
171
class TreeEntry(object):
139
"""An entry that implements the minium interface used by commands.
172
"""An entry that implements the minimum interface used by commands.
140
173
141
174
This needs further inspection, it may be better to have
142
175
InventoryEntries without ids - though that seems wrong. For now,
190
223
return ''
191
224
192
225
193
class WorkingTree(bzrlib.tree.Tree):
226
class WorkingTree(bzrlib.mutabletree.MutableTree):
194
227
"""Working copy tree.
195
228
196
229
The inventory is held in the `Branch` working-inventory, and the
218
251
self.bzrdir = _bzrdir
219
252
if not _internal:
220
253
# not created via open etc.
221
warn("WorkingTree() is deprecated as of bzr version 0.8. "
254
warnings.warn("WorkingTree() is deprecated as of bzr version 0.8. "
222
255
"Please use bzrdir.open_workingtree or WorkingTree.open().",
223
256
DeprecationWarning,
224
257
stacklevel=2)
225
258
wt = WorkingTree.open(basedir)
226
self.branch = wt.branch
259
self._branch = wt.branch
227
260
self.basedir = wt.basedir
228
261
self._control_files = wt._control_files
229
262
self._hashcache = wt._hashcache
230
self._set_inventory(wt._inventory)
263
self._set_inventory(wt._inventory, dirty=False)
231
264
self._format = wt._format
232
265
self.bzrdir = wt.bzrdir
233
266
from bzrlib.hashcache import HashCache
238
271
mutter("opening working tree %r", basedir)
239
272
if deprecated_passed(branch):
240
273
if not _internal:
241
warn("WorkingTree(..., branch=XXX) is deprecated as of bzr 0.8."
274
warnings.warn("WorkingTree(..., branch=XXX) is deprecated as of bzr 0.8."
242
275
" Please use bzrdir.open_workingtree() or"
243
276
" WorkingTree.open().",
244
277
DeprecationWarning,
245
278
stacklevel=2
246
279
)
247
self.branch = branch
280
self._branch = branch
248
281
else:
249
self.branch = self.bzrdir.open_branch()
250
assert isinstance(self.branch, Branch), \
251
"branch %r is not a Branch" % self.branch
282
self._branch = self.bzrdir.open_branch()
252
283
self.basedir = realpath(basedir)
253
284
# if branch is at our basedir and is a format 6 or less
254
285
if isinstance(self._format, WorkingTreeFormat2):
255
286
# share control object
256
287
self._control_files = self.branch.control_files
257
288
else:
258
# only ready for format 3
259
assert isinstance(self._format, WorkingTreeFormat3)
289
# assume all other formats have their own control files.
260
290
assert isinstance(_control_files, LockableFiles), \
261
291
"_control_files must be a LockableFiles, not %r" \
262
292
% _control_files
267
297
# if needed, or, when the cache sees a change, append it to the hash
268
298
# cache file, and have the parser take the most recent entry for a
269
299
# given path only.
270
cache_filename = self.bzrdir.get_workingtree_transport(None).abspath('stat-cache')
300
cache_filename = self.bzrdir.get_workingtree_transport(None).local_abspath('stat-cache')
271
301
hc = self._hashcache = HashCache(basedir, cache_filename, self._control_files._file_mode)
272
302
hc.read()
273
303
# is this scan needed ? it makes things kinda slow.
274
hc.scan()
304
#hc.scan()
275
305
276
306
if hc.needs_write:
277
307
mutter("write hc")
278
308
hc.write()
279
309
280
310
if _inventory is None:
281
self._set_inventory(self.read_working_inventory())
311
self._inventory_is_modified = False
312
self.read_working_inventory()
282
313
else:
283
self._set_inventory(_inventory)
284
285
def _set_inventory(self, inv):
314
# the caller of __init__ has provided an inventory,
315
# we assume they know what they are doing - as its only
316
# the Format factory and creation methods that are
317
# permitted to do this.
318
self._set_inventory(_inventory, dirty=False)
319
320
branch = property(
321
fget=lambda self: self._branch,
322
doc="""The branch this WorkingTree is connected to.
323
324
This cannot be set - it is reflective of the actual disk structure
325
the working tree has been constructed from.
326
""")
327
328
def break_lock(self):
329
"""Break a lock if one is present from another instance.
330
331
Uses the ui factory to ask for confirmation if the lock may be from
332
an active process.
333
334
This will probe the repository for its lock as well.
335
"""
336
self._control_files.break_lock()
337
self.branch.break_lock()
338
339
def _set_inventory(self, inv, dirty):
340
"""Set the internal cached inventory.
341
342
:param inv: The inventory to set.
343
:param dirty: A boolean indicating whether the inventory is the same
344
logical inventory as whats on disk. If True the inventory is not
345
the same and should be written to disk or data will be lost, if
346
False then the inventory is the same as that on disk and any
347
serialisation would be unneeded overhead.
348
"""
349
assert inv.root is not None
286
350
self._inventory = inv
287
self.path2id = self._inventory.path2id
288
289
def is_control_filename(self, filename):
290
"""True if filename is the name of a control file in this tree.
291
292
This is true IF and ONLY IF the filename is part of the meta data
293
that bzr controls in this tree. I.E. a random .bzr directory placed
294
on disk will not be a control file for this tree.
295
"""
296
try:
297
self.bzrdir.transport.relpath(self.abspath(filename))
298
return True
299
except errors.PathNotChild:
300
return False
351
self._inventory_is_modified = dirty
301
352
302
353
@staticmethod
303
354
def open(path=None, _unsupported=False):
319
370
run into /. If there isn't one, raises NotBranchError.
320
371
TODO: give this a new exception.
321
372
If there is one, it is returned, along with the unused portion of path.
373
374
:return: The WorkingTree that contains 'path', and the rest of path
322
375
"""
323
376
if path is None:
324
path = os.getcwdu()
377
path = osutils.getcwd()
325
378
control, relpath = bzrdir.BzrDir.open_containing(path)
379
326
380
return control.open_workingtree(), relpath
327
381
328
382
@staticmethod
341
395
"""
342
396
inv = self._inventory
343
397
for path, ie in inv.iter_entries():
344
if bzrlib.osutils.lexists(self.abspath(path)):
398
if osutils.lexists(self.abspath(path)):
345
399
yield ie.file_id
346
400
347
401
def __repr__(self):
352
406
return pathjoin(self.basedir, filename)
353
407
354
408
def basis_tree(self):
355
"""Return RevisionTree for the current last revision."""
356
revision_id = self.last_revision()
357
if revision_id is not None:
409
"""Return RevisionTree for the current last revision.
410
411
If the left most parent is a ghost then the returned tree will be an
412
empty tree - one obtained by calling repository.revision_tree(None).
413
"""
414
try:
415
revision_id = self.get_parent_ids()[0]
416
except IndexError:
417
# no parents, return an empty revision tree.
418
# in the future this should return the tree for
419
# 'empty:' - the implicit root empty tree.
420
return self.branch.repository.revision_tree(None)
421
else:
358
422
try:
359
423
xml = self.read_basis_inventory()
360
inv = bzrlib.xml5.serializer_v5.read_inventory_from_string(xml)
361
except NoSuchFile:
362
inv = None
363
if inv is not None and inv.revision_id == revision_id:
364
return bzrlib.tree.RevisionTree(self.branch.repository, inv,
365
revision_id)
366
# FIXME? RBC 20060403 should we cache the inventory here ?
367
return self.branch.repository.revision_tree(revision_id)
424
inv = xml6.serializer_v6.read_inventory_from_string(xml)
425
if inv is not None and inv.revision_id == revision_id:
426
return bzrlib.tree.RevisionTree(self.branch.repository,
427
inv, revision_id)
428
except (NoSuchFile, errors.BadInventoryFormat):
429
pass
430
# No cached copy available, retrieve from the repository.
431
# FIXME? RBC 20060403 should we cache the inventory locally
432
# at this point ?
433
try:
434
return self.branch.repository.revision_tree(revision_id)
435
except errors.RevisionNotPresent:
436
# the basis tree *may* be a ghost or a low level error may have
437
# occured. If the revision is present, its a problem, if its not
438
# its a ghost.
439
if self.branch.repository.has_revision(revision_id):
440
raise
441
# the basis tree is a ghost so return an empty tree.
442
return self.branch.repository.revision_tree(None)
368
443
369
444
@staticmethod
370
445
@deprecated_method(zero_eight)
383
458
XXX: When BzrDir is present, these should be created through that
384
459
interface instead.
385
460
"""
386
warn('delete WorkingTree.create', stacklevel=3)
461
warnings.warn('delete WorkingTree.create', stacklevel=3)
387
462
transport = get_transport(directory)
388
463
if branch.bzrdir.root_transport.base == transport.base:
389
464
# same dir
404
479
"""
405
480
return bzrdir.BzrDir.create_standalone_workingtree(directory)
406
481
407
def relpath(self, abs):
408
"""Return the local path portion from a given absolute path."""
409
return relpath(self.basedir, abs)
482
def relpath(self, path):
483
"""Return the local path portion from a given path.
484
485
The path may be absolute or relative. If its a relative path it is
486
interpreted relative to the python current working directory.
487
"""
488
return osutils.relpath(self.basedir, path)
410
489
411
490
def has_filename(self, filename):
412
return bzrlib.osutils.lexists(self.abspath(filename))
491
return osutils.lexists(self.abspath(filename))
413
492
414
493
def get_file(self, file_id):
415
494
return self.get_file_byname(self.id2path(file_id))
416
495
496
def get_file_text(self, file_id):
497
return self.get_file(file_id).read()
498
417
499
def get_file_byname(self, filename):
418
500
return file(self.abspath(filename), 'rb')
419
501
502
def get_parent_ids(self):
503
"""See Tree.get_parent_ids.
504
505
This implementation reads the pending merges list and last_revision
506
value and uses that to decide what the parents list should be.
507
"""
508
last_rev = self._last_revision()
509
if last_rev is None:
510
parents = []
511
else:
512
parents = [last_rev]
513
try:
514
merges_file = self._control_files.get_utf8('pending-merges')
515
except NoSuchFile:
516
pass
517
else:
518
for l in merges_file.readlines():
519
parents.append(l.rstrip('\n'))
520
return parents
521
522
@needs_read_lock
420
523
def get_root_id(self):
421
524
"""Return the id of this trees root"""
422
inv = self.read_working_inventory()
423
return inv.root.file_id
525
return self._inventory.root.file_id
424
526
425
527
def _get_store_filename(self, file_id):
426
528
## XXX: badly named; this is not in the store at all
452
554
@needs_read_lock
453
555
def copy_content_into(self, tree, revision_id=None):
454
556
"""Copy the current content and user files of this tree into tree."""
557
tree.set_root_id(self.get_root_id())
455
558
if revision_id is None:
456
transform_tree(tree, self)
559
merge.transform_tree(tree, self)
457
560
else:
458
# TODO now merge from tree.last_revision to revision
459
transform_tree(tree, self)
460
tree.set_last_revision(revision_id)
461
462
@needs_write_lock
463
def commit(self, message=None, revprops=None, *args, **kwargs):
464
# avoid circular imports
465
from bzrlib.commit import Commit
466
if revprops is None:
467
revprops = {}
468
if not 'branch-nick' in revprops:
469
revprops['branch-nick'] = self.branch.nick
470
# args for wt.commit start at message from the Commit.commit method,
471
# but with branch a kwarg now, passing in args as is results in the
472
#message being used for the branch
473
args = (DEPRECATED_PARAMETER, message, ) + args
474
Commit().commit(working_tree=self, revprops=revprops, *args, **kwargs)
475
self._set_inventory(self.read_working_inventory())
561
# TODO now merge from tree.last_revision to revision (to preserve
562
# user local changes)
563
merge.transform_tree(tree, self)
564
tree.set_parent_ids([revision_id])
476
565
477
566
def id2abspath(self, file_id):
478
567
return self.abspath(self.id2path(file_id))
483
572
if not inv.has_id(file_id):
484
573
return False
485
574
path = inv.id2path(file_id)
486
return bzrlib.osutils.lexists(self.abspath(path))
575
return osutils.lexists(self.abspath(path))
487
576
488
577
def has_or_had_id(self, file_id):
489
578
if file_id == self.inventory.root.file_id:
496
585
return os.path.getsize(self.id2abspath(file_id))
497
586
498
587
@needs_read_lock
499
def get_file_sha1(self, file_id):
500
path = self._inventory.id2path(file_id)
588
def get_file_sha1(self, file_id, path=None):
589
if not path:
590
path = self._inventory.id2path(file_id)
501
591
return self._hashcache.get_sha1(path)
502
592
503
def is_executable(self, file_id):
504
if not supports_executable():
593
def get_file_mtime(self, file_id, path=None):
594
if not path:
595
path = self._inventory.id2path(file_id)
596
return os.lstat(self.abspath(path)).st_mtime
597
598
if not supports_executable():
599
def is_executable(self, file_id, path=None):
505
600
return self._inventory[file_id].executable
506
else:
507
path = self._inventory.id2path(file_id)
601
else:
602
def is_executable(self, file_id, path=None):
603
if not path:
604
path = self._inventory.id2path(file_id)
508
605
mode = os.lstat(self.abspath(path)).st_mode
509
return bool(stat.S_ISREG(mode) and stat.S_IEXEC&mode)
606
return bool(stat.S_ISREG(mode) and stat.S_IEXEC & mode)
510
607
511
608
@needs_write_lock
512
def add(self, files, ids=None):
513
"""Make files versioned.
514
515
Note that the command line normally calls smart_add instead,
516
which can automatically recurse.
517
518
This adds the files to the inventory, so that they will be
519
recorded by the next commit.
520
521
files
522
List of paths to add, relative to the base of the tree.
523
524
ids
525
If set, use these instead of automatically generated ids.
526
Must be the same length as the list of files, but may
527
contain None for ids that are to be autogenerated.
528
529
TODO: Perhaps have an option to add the ids even if the files do
530
not (yet) exist.
531
532
TODO: Perhaps callback with the ids and paths as they're added.
533
"""
609
def _add(self, files, ids, kinds):
610
"""See MutableTree._add."""
534
611
# TODO: Re-adding a file that is removed in the working copy
535
612
# should probably put it back with the previous ID.
536
if isinstance(files, basestring):
537
assert(ids is None or isinstance(ids, basestring))
538
files = [files]
539
if ids is not None:
540
ids = [ids]
541
542
if ids is None:
543
ids = [None] * len(files)
544
else:
545
assert(len(ids) == len(files))
546
613
# the read and write working inventory should not occur in this
614
# function - they should be part of lock_write and unlock.
547
615
inv = self.read_working_inventory()
548
for f,file_id in zip(files, ids):
549
if self.is_control_filename(f):
550
raise BzrError("cannot add control file %s" % quotefn(f))
551
552
fp = splitpath(f)
553
554
if len(fp) == 0:
555
raise BzrError("cannot add top-level %r" % f)
556
557
fullpath = normpath(self.abspath(f))
558
559
try:
560
kind = file_kind(fullpath)
561
except OSError, e:
562
if e.errno == errno.ENOENT:
563
raise NoSuchFile(fullpath)
564
# maybe something better?
565
raise BzrError('cannot add: not a regular file, symlink or directory: %s' % quotefn(f))
566
567
if not InventoryEntry.versionable_kind(kind):
568
raise BzrError('cannot add: not a versionable file ('
569
'i.e. regular file, symlink or directory): %s' % quotefn(f))
570
616
for f, file_id, kind in zip(files, ids, kinds):
617
assert kind is not None
571
618
if file_id is None:
572
file_id = gen_file_id(f)
573
inv.add_path(f, kind=kind, file_id=file_id)
574
575
mutter("add file %s file_id:{%s} kind=%r" % (f, file_id, kind))
619
inv.add_path(f, kind=kind)
620
else:
621
inv.add_path(f, kind=kind, file_id=file_id)
576
622
self._write_inventory(inv)
577
623
624
@needs_tree_write_lock
625
def _gather_kinds(self, files, kinds):
626
"""See MutableTree._gather_kinds."""
627
for pos, f in enumerate(files):
628
if kinds[pos] is None:
629
fullpath = normpath(self.abspath(f))
630
try:
631
kinds[pos] = file_kind(fullpath)
632
except OSError, e:
633
if e.errno == errno.ENOENT:
634
raise NoSuchFile(fullpath)
635
578
636
@needs_write_lock
637
def add_parent_tree_id(self, revision_id, allow_leftmost_as_ghost=False):
638
"""Add revision_id as a parent.
639
640
This is equivalent to retrieving the current list of parent ids
641
and setting the list to its value plus revision_id.
642
643
:param revision_id: The revision id to add to the parent list. It may
644
be a ghost revision as long as its not the first parent to be added,
645
or the allow_leftmost_as_ghost parameter is set True.
646
:param allow_leftmost_as_ghost: Allow the first parent to be a ghost.
647
"""
648
parents = self.get_parent_ids() + [revision_id]
649
self.set_parent_ids(parents,
650
allow_leftmost_as_ghost=len(parents) > 1 or allow_leftmost_as_ghost)
651
652
@needs_tree_write_lock
653
def add_parent_tree(self, parent_tuple, allow_leftmost_as_ghost=False):
654
"""Add revision_id, tree tuple as a parent.
655
656
This is equivalent to retrieving the current list of parent trees
657
and setting the list to its value plus parent_tuple. See also
658
add_parent_tree_id - if you only have a parent id available it will be
659
simpler to use that api. If you have the parent already available, using
660
this api is preferred.
661
662
:param parent_tuple: The (revision id, tree) to add to the parent list.
663
If the revision_id is a ghost, pass None for the tree.
664
:param allow_leftmost_as_ghost: Allow the first parent to be a ghost.
665
"""
666
parent_ids = self.get_parent_ids() + [parent_tuple[0]]
667
if len(parent_ids) > 1:
668
# the leftmost may have already been a ghost, preserve that if it
669
# was.
670
allow_leftmost_as_ghost = True
671
self.set_parent_ids(parent_ids,
672
allow_leftmost_as_ghost=allow_leftmost_as_ghost)
673
674
@needs_tree_write_lock
579
675
def add_pending_merge(self, *revision_ids):
580
676
# TODO: Perhaps should check at this point that the
581
677
# history of the revision is actually present?
582
p = self.pending_merges()
678
parents = self.get_parent_ids()
583
679
updated = False
584
680
for rev_id in revision_ids:
585
if rev_id in p:
681
if rev_id in parents:
586
682
continue
587
p.append(rev_id)
683
parents.append(rev_id)
588
684
updated = True
589
685
if updated:
590
self.set_pending_merges(p)
686
self.set_parent_ids(parents, allow_leftmost_as_ghost=True)
591
687
688
@deprecated_method(zero_eleven)
592
689
@needs_read_lock
593
690
def pending_merges(self):
594
691
"""Return a list of pending merges.
595
692
596
693
These are revisions that have been merged into the working
597
694
directory but not yet committed.
598
"""
599
try:
600
merges_file = self._control_files.get_utf8('pending-merges')
601
except OSError, e:
602
if e.errno != errno.ENOENT:
603
raise
604
return []
605
p = []
606
for l in merges_file.readlines():
607
p.append(l.rstrip('\n'))
608
return p
609
610
@needs_write_lock
695
696
As of 0.11 this is deprecated. Please see WorkingTree.get_parent_ids()
697
instead - which is available on all tree objects.
698
"""
699
return self.get_parent_ids()[1:]
700
701
def _check_parents_for_ghosts(self, revision_ids, allow_leftmost_as_ghost):
702
"""Common ghost checking functionality from set_parent_*.
703
704
This checks that the left hand-parent exists if there are any
705
revisions present.
706
"""
707
if len(revision_ids) > 0:
708
leftmost_id = revision_ids[0]
709
if (not allow_leftmost_as_ghost and not
710
self.branch.repository.has_revision(leftmost_id)):
711
raise errors.GhostRevisionUnusableHere(leftmost_id)
712
713
def _set_merges_from_parent_ids(self, parent_ids):
714
merges = parent_ids[1:]
715
self._control_files.put_utf8('pending-merges', '\n'.join(merges))
716
717
@needs_tree_write_lock
718
def set_parent_ids(self, revision_ids, allow_leftmost_as_ghost=False):
719
"""Set the parent ids to revision_ids.
720
721
See also set_parent_trees. This api will try to retrieve the tree data
722
for each element of revision_ids from the trees repository. If you have
723
tree data already available, it is more efficient to use
724
set_parent_trees rather than set_parent_ids. set_parent_ids is however
725
an easier API to use.
726
727
:param revision_ids: The revision_ids to set as the parent ids of this
728
working tree. Any of these may be ghosts.
729
"""
730
self._check_parents_for_ghosts(revision_ids,
731
allow_leftmost_as_ghost=allow_leftmost_as_ghost)
732
733
if len(revision_ids) > 0:
734
self.set_last_revision(revision_ids[0])
735
else:
736
self.set_last_revision(None)
737
738
self._set_merges_from_parent_ids(revision_ids)
739
740
@needs_tree_write_lock
741
def set_parent_trees(self, parents_list, allow_leftmost_as_ghost=False):
742
"""See MutableTree.set_parent_trees."""
743
parent_ids = [rev for (rev, tree) in parents_list]
744
745
self._check_parents_for_ghosts(parent_ids,
746
allow_leftmost_as_ghost=allow_leftmost_as_ghost)
747
748
if len(parent_ids) == 0:
749
leftmost_parent_id = None
750
leftmost_parent_tree = None
751
else:
752
leftmost_parent_id, leftmost_parent_tree = parents_list[0]
753
754
if self._change_last_revision(leftmost_parent_id):
755
if leftmost_parent_tree is None:
756
# If we don't have a tree, fall back to reading the
757
# parent tree from the repository.
758
self._cache_basis_inventory(leftmost_parent_id)
759
else:
760
inv = leftmost_parent_tree.inventory
761
xml = self._create_basis_xml_from_inventory(
762
leftmost_parent_id, inv)
763
self._write_basis_inventory(xml)
764
self._set_merges_from_parent_ids(parent_ids)
765
766
@needs_tree_write_lock
611
767
def set_pending_merges(self, rev_list):
612
self._control_files.put_utf8('pending-merges', '\n'.join(rev_list))
768
parents = self.get_parent_ids()
769
leftmost = parents[:1]
770
new_parents = leftmost + rev_list
771
self.set_parent_ids(new_parents)
613
772
614
@needs_write_lock
773
@needs_tree_write_lock
615
774
def set_merge_modified(self, modified_hashes):
616
775
def iter_stanzas():
617
776
for file_id, hash in modified_hashes.iteritems():
618
777
yield Stanza(file_id=file_id, hash=hash)
619
778
self._put_rio('merge-hashes', iter_stanzas(), MERGE_MODIFIED_HEADER_1)
620
779
621
@needs_write_lock
780
@needs_tree_write_lock
622
781
def _put_rio(self, filename, stanzas, header):
623
782
my_file = rio_file(stanzas, header)
624
783
self._control_files.put(filename, my_file)
625
784
785
@needs_write_lock # because merge pulls data into the branch.
786
def merge_from_branch(self, branch, to_revision=None):
787
"""Merge from a branch into this working tree.
788
789
:param branch: The branch to merge from.
790
:param to_revision: If non-None, the merge will merge to to_revision, but
791
not beyond it. to_revision does not need to be in the history of
792
the branch when it is supplied. If None, to_revision defaults to
793
branch.last_revision().
794
"""
795
from bzrlib.merge import Merger, Merge3Merger
796
pb = bzrlib.ui.ui_factory.nested_progress_bar()
797
try:
798
merger = Merger(self.branch, this_tree=self, pb=pb)
799
merger.pp = ProgressPhase("Merge phase", 5, pb)
800
merger.pp.next_phase()
801
# check that there are no
802
# local alterations
803
merger.check_basis(check_clean=True, require_commits=False)
804
if to_revision is None:
805
to_revision = branch.last_revision()
806
merger.other_rev_id = to_revision
807
if merger.other_rev_id is None:
808
raise error.NoCommits(branch)
809
self.branch.fetch(branch, last_revision=merger.other_rev_id)
810
merger.other_basis = merger.other_rev_id
811
merger.other_tree = self.branch.repository.revision_tree(
812
merger.other_rev_id)
813
merger.pp.next_phase()
814
merger.find_base()
815
if merger.base_rev_id == merger.other_rev_id:
816
raise errors.PointlessMerge
817
merger.backup_files = False
818
merger.merge_type = Merge3Merger
819
merger.set_interesting_files(None)
820
merger.show_base = False
821
merger.reprocess = False
822
conflicts = merger.do_merge()
823
merger.set_pending()
824
finally:
825
pb.finished()
826
return conflicts
827
626
828
@needs_read_lock
627
829
def merge_modified(self):
628
830
try:
644
846
merge_hashes[file_id] = hash
645
847
return merge_hashes
646
848
849
@needs_write_lock
850
def mkdir(self, path, file_id=None):
851
"""See MutableTree.mkdir()."""
852
if file_id is None:
853
file_id = gen_file_id(os.path.basename(path))
854
os.mkdir(self.abspath(path))
855
self.add(path, file_id, 'directory')
856
return file_id
857
647
858
def get_symlink_target(self, file_id):
648
859
return os.readlink(self.id2abspath(file_id))
649
860
655
866
else:
656
867
return '?'
657
868
658
def list_files(self):
659
"""Recursively list all files as (path, class, kind, id).
869
def flush(self):
870
"""Write the in memory inventory to disk."""
871
# TODO: Maybe this should only write on dirty ?
872
if self._control_files._lock_mode != 'w':
873
raise errors.NotWriteLocked(self)
874
sio = StringIO()
875
xml5.serializer_v5.write_inventory(self._inventory, sio)
876
sio.seek(0)
877
self._control_files.put('inventory', sio)
878
self._inventory_is_modified = False
879
880
def list_files(self, include_root=False):
881
"""Recursively list all files as (path, class, kind, id, entry).
660
882
661
883
Lists, but does not descend into unversioned directories.
662
884
666
888
Skips the control directory.
667
889
"""
668
890
inv = self._inventory
669
670
def descend(from_dir_relpath, from_dir_id, dp):
671
ls = os.listdir(dp)
672
ls.sort()
673
for f in ls:
891
if include_root is True:
892
yield ('', 'V', 'directory', inv.root.file_id, inv.root)
893
# Convert these into local objects to save lookup times
894
pathjoin = osutils.pathjoin
895
file_kind = osutils.file_kind
896
897
# transport.base ends in a slash, we want the piece
898
# between the last two slashes
899
transport_base_dir = self.bzrdir.transport.base.rsplit('/', 2)[1]
900
901
fk_entries = {'directory':TreeDirectory, 'file':TreeFile, 'symlink':TreeLink}
902
903
# directory file_id, relative path, absolute path, reverse sorted children
904
children = os.listdir(self.basedir)
905
children.sort()
906
# jam 20060527 The kernel sized tree seems equivalent whether we
907
# use a deque and popleft to keep them sorted, or if we use a plain
908
# list and just reverse() them.
909
children = collections.deque(children)
910
stack = [(inv.root.file_id, u'', self.basedir, children)]
911
while stack:
912
from_dir_id, from_dir_relpath, from_dir_abspath, children = stack[-1]
913
914
while children:
915
f = children.popleft()
674
916
## TODO: If we find a subdirectory with its own .bzr
675
917
## directory, then that is a separate tree and we
676
918
## should exclude it.
677
919
678
920
# the bzrdir for this tree
679
if self.bzrdir.transport.base.endswith(f + '/'):
921
if transport_base_dir == f:
680
922
continue
681
923
682
# path within tree
683
fp = appendpath(from_dir_relpath, f)
924
# we know that from_dir_relpath and from_dir_abspath never end in a slash
925
# and 'f' doesn't begin with one, we can do a string op, rather
926
# than the checks of pathjoin(), all relative paths will have an extra slash
927
# at the beginning
928
fp = from_dir_relpath + '/' + f
684
929
685
930
# absolute path
686
fap = appendpath(dp, f)
931
fap = from_dir_abspath + '/' + f
687
932
688
933
f_ie = inv.get_child(from_dir_id, f)
689
934
if f_ie:
690
935
c = 'V'
691
elif self.is_ignored(fp):
936
elif self.is_ignored(fp[1:]):
692
937
c = 'I'
693
938
else:
694
c = '?'
939
# we may not have found this file, because of a unicode issue
940
f_norm, can_access = osutils.normalized_filename(f)
941
if f == f_norm or not can_access:
942
# No change, so treat this file normally
943
c = '?'
944
else:
945
# this file can be accessed by a normalized path
946
# check again if it is versioned
947
# these lines are repeated here for performance
948
f = f_norm
949
fp = from_dir_relpath + '/' + f
950
fap = from_dir_abspath + '/' + f
951
f_ie = inv.get_child(from_dir_id, f)
952
if f_ie:
953
c = 'V'
954
elif self.is_ignored(fp[1:]):
955
c = 'I'
956
else:
957
c = '?'
695
958
696
959
fk = file_kind(fap)
697
960
703
966
704
967
# make a last minute entry
705
968
if f_ie:
706
entry = f_ie
969
yield fp[1:], c, fk, f_ie.file_id, f_ie
707
970
else:
708
if fk == 'directory':
709
entry = TreeDirectory()
710
elif fk == 'file':
711
entry = TreeFile()
712
elif fk == 'symlink':
713
entry = TreeLink()
714
else:
715
entry = TreeEntry()
971
try:
972
yield fp[1:], c, fk, None, fk_entries[fk]()
973
except KeyError:
974
yield fp[1:], c, fk, None, TreeEntry()
975
continue
716
976
717
yield fp, c, fk, (f_ie and f_ie.file_id), entry
718
719
977
if fk != 'directory':
720
978
continue
721
979
722
if c != 'V':
723
# don't descend unversioned directories
724
continue
725
726
for ff in descend(fp, f_ie.file_id, fap):
727
yield ff
728
729
for f in descend(u'', inv.root.file_id, self.basedir):
730
yield f
731
732
@needs_write_lock
980
# But do this child first
981
new_children = os.listdir(fap)
982
new_children.sort()
983
new_children = collections.deque(new_children)
984
stack.append((f_ie.file_id, fp, fap, new_children))
985
# Break out of inner loop, so that we start outer loop with child
986
break
987
else:
988
# if we finished all children, pop it off the stack
989
stack.pop()
990
991
@needs_tree_write_lock
733
992
def move(self, from_paths, to_name):
734
993
"""Rename files.
735
994
754
1013
if not self.has_filename(to_name):
755
1014
raise BzrError("destination %r not in working directory" % to_abs)
756
1015
to_dir_id = inv.path2id(to_name)
757
if to_dir_id == None and to_name != '':
1016
if to_dir_id is None and to_name != '':
758
1017
raise BzrError("destination %r is not a versioned directory" % to_name)
759
1018
to_dir_ie = inv[to_dir_id]
760
if to_dir_ie.kind not in ('directory', 'root_directory'):
1019
if to_dir_ie.kind != 'directory':
761
1020
raise BzrError("destination %r is not a directory" % to_abs)
762
1021
763
1022
to_idpath = inv.get_idpath(to_dir_id)
766
1025
if not self.has_filename(f):
767
1026
raise BzrError("%r does not exist in working tree" % f)
768
1027
f_id = inv.path2id(f)
769
if f_id == None:
1028
if f_id is None:
770
1029
raise BzrError("%r is not versioned" % f)
771
1030
name_tail = splitpath(f)[-1]
772
dest_path = appendpath(to_name, name_tail)
1031
dest_path = pathjoin(to_name, name_tail)
773
1032
if self.has_filename(dest_path):
774
1033
raise BzrError("destination %r already exists" % dest_path)
775
1034
if f_id in to_idpath:
779
1038
# create a file in this interval and then the rename might be
780
1039
# left half-done. But we should have caught most problems.
781
1040
orig_inv = deepcopy(self.inventory)
1041
original_modified = self._inventory_is_modified
782
1042
try:
1043
if len(from_paths):
1044
self._inventory_is_modified = True
783
1045
for f in from_paths:
784
1046
name_tail = splitpath(f)[-1]
785
dest_path = appendpath(to_name, name_tail)
1047
dest_path = pathjoin(to_name, name_tail)
786
1048
result.append((f, dest_path))
787
1049
inv.rename(inv.path2id(f), to_dir_id, name_tail)
788
1050
try:
789
rename(self.abspath(f), self.abspath(dest_path))
1051
osutils.rename(self.abspath(f), self.abspath(dest_path))
790
1052
except OSError, e:
791
1053
raise BzrError("failed to rename %r to %r: %s" %
792
1054
(f, dest_path, e[1]),
793
1055
["rename rolled back"])
794
1056
except:
795
1057
# restore the inventory on error
796
self._set_inventory(orig_inv)
1058
self._set_inventory(orig_inv, dirty=original_modified)
797
1059
raise
798
1060
self._write_inventory(inv)
799
1061
return result
800
1062
801
@needs_write_lock
1063
@needs_tree_write_lock
802
1064
def rename_one(self, from_rel, to_rel):
803
1065
"""Rename one file.
804
1066
811
1073
raise BzrError("can't rename: new working file %r already exists" % to_rel)
812
1074
813
1075
file_id = inv.path2id(from_rel)
814
if file_id == None:
1076
if file_id is None:
815
1077
raise BzrError("can't rename: old name %r is not versioned" % from_rel)
816
1078
817
1079
entry = inv[file_id]
823
1085
824
1086
to_dir, to_tail = os.path.split(to_rel)
825
1087
to_dir_id = inv.path2id(to_dir)
826
if to_dir_id == None and to_dir != '':
1088
if to_dir_id is None and to_dir != '':
827
1089
raise BzrError("can't determine destination directory id for %r" % to_dir)
828
1090
829
1091
mutter("rename_one:")
838
1100
from_abs = self.abspath(from_rel)
839
1101
to_abs = self.abspath(to_rel)
840
1102
try:
841
rename(from_abs, to_abs)
1103
osutils.rename(from_abs, to_abs)
842
1104
except OSError, e:
843
1105
inv.rename(file_id, from_parent, from_name)
844
1106
raise BzrError("failed to rename %r to %r: %s"
852
1114
853
1115
These are files in the working directory that are not versioned or
854
1116
control files or ignored.
855
856
>>> from bzrlib.bzrdir import ScratchDir
857
>>> d = ScratchDir(files=['foo', 'foo~'])
858
>>> b = d.open_branch()
859
>>> tree = d.open_workingtree()
860
>>> map(str, tree.unknowns())
861
['foo']
862
>>> tree.add('foo')
863
>>> list(b.unknowns())
864
[]
865
>>> tree.remove('foo')
866
>>> list(b.unknowns())
867
[u'foo']
868
1117
"""
869
1118
for subp in self.extras():
870
1119
if not self.is_ignored(subp):
871
1120
yield subp
872
1121
1122
@needs_tree_write_lock
1123
def unversion(self, file_ids):
1124
"""Remove the file ids in file_ids from the current versioned set.
1125
1126
When a file_id is unversioned, all of its children are automatically
1127
unversioned.
1128
1129
:param file_ids: The file ids to stop versioning.
1130
:raises: NoSuchId if any fileid is not currently versioned.
1131
"""
1132
for file_id in file_ids:
1133
if self._inventory.has_id(file_id):
1134
self._inventory.remove_recursive_id(file_id)
1135
else:
1136
raise errors.NoSuchId(self, file_id)
1137
if len(file_ids):
1138
# in the future this should just set a dirty bit to wait for the
1139
# final unlock. However, until all methods of workingtree start
1140
# with the current in -memory inventory rather than triggering
1141
# a read, it is more complex - we need to teach read_inventory
1142
# to know when to read, and when to not read first... and possibly
1143
# to save first when the in memory one may be corrupted.
1144
# so for now, we just only write it if it is indeed dirty.
1145
# - RBC 20060907
1146
self._write_inventory(self._inventory)
1147
873
1148
@deprecated_method(zero_eight)
874
1149
def iter_conflicts(self):
875
1150
"""List all files in the tree that have text or content conflicts.
878
1153
879
1154
def _iter_conflicts(self):
880
1155
conflicted = set()
881
for path in (s[0] for s in self.list_files()):
1156
for info in self.list_files():
1157
path = info[0]
882
1158
stem = get_conflicted_stem(path)
883
1159
if stem is None:
884
1160
continue
906
1182
repository = self.branch.repository
907
1183
pb = bzrlib.ui.ui_factory.nested_progress_bar()
908
1184
try:
909
merge_inner(self.branch,
910
self.branch.basis_tree(),
911
basis_tree,
912
this_tree=self,
1185
new_basis_tree = self.branch.basis_tree()
1186
merge.merge_inner(
1187
self.branch,
1188
new_basis_tree,
1189
basis_tree,
1190
this_tree=self,
913
1191
pb=pb)
1192
if (basis_tree.inventory.root is None and
1193
new_basis_tree.inventory.root is not None):
1194
self.set_root_id(new_basis_tree.inventory.root.file_id)
914
1195
finally:
915
1196
pb.finished()
916
self.set_last_revision(self.branch.last_revision())
1197
# TODO - dedup parents list with things merged by pull ?
1198
# reuse the revisiontree we merged against to set the new
1199
# tree data.
1200
parent_trees = [(self.branch.last_revision(), new_basis_tree)]
1201
# we have to pull the merge trees out again, because
1202
# merge_inner has set the ids. - this corner is not yet
1203
# layered well enough to prevent double handling.
1204
merges = self.get_parent_ids()[1:]
1205
parent_trees.extend([
1206
(parent, repository.revision_tree(parent)) for
1207
parent in merges])
1208
self.set_parent_trees(parent_trees)
917
1209
return count
918
1210
finally:
919
1211
source.unlock()
920
1212
top_pb.finished()
921
1213
1214
@needs_write_lock
1215
def put_file_bytes_non_atomic(self, file_id, bytes):
1216
"""See MutableTree.put_file_bytes_non_atomic."""
1217
stream = file(self.id2abspath(file_id), 'wb')
1218
try:
1219
stream.write(bytes)
1220
finally:
1221
stream.close()
1222
# TODO: update the hashcache here ?
1223
922
1224
def extras(self):
923
1225
"""Yield all unknown files in this WorkingTree.
924
1226
930
1232
"""
931
1233
## TODO: Work from given directory downwards
932
1234
for path, dir_entry in self.inventory.directories():
933
mutter("search for unknowns in %r", path)
1235
# mutter("search for unknowns in %r", path)
934
1236
dirabs = self.abspath(path)
935
1237
if not isdir(dirabs):
936
1238
# e.g. directory deleted
938
1240
939
1241
fl = []
940
1242
for subf in os.listdir(dirabs):
941
if (subf != '.bzr'
942
and (subf not in dir_entry.children)):
943
fl.append(subf)
1243
if subf == '.bzr':
1244
continue
1245
if subf not in dir_entry.children:
1246
subf_norm, can_access = osutils.normalized_filename(subf)
1247
if subf_norm != subf and can_access:
1248
if subf_norm not in dir_entry.children:
1249
fl.append(subf_norm)
1250
else:
1251
fl.append(subf)
944
1252
945
1253
fl.sort()
946
1254
for subf in fl:
947
subp = appendpath(path, subf)
1255
subp = pathjoin(path, subf)
948
1256
yield subp
949
1257
1258
def _translate_ignore_rule(self, rule):
1259
"""Translate a single ignore rule to a regex.
1260
1261
There are two types of ignore rules. Those that do not contain a / are
1262
matched against the tail of the filename (that is, they do not care
1263
what directory the file is in.) Rules which do contain a slash must
1264
match the entire path. As a special case, './' at the start of the
1265
string counts as a slash in the string but is removed before matching
1266
(e.g. ./foo.c, ./src/foo.c)
1267
1268
:return: The translated regex.
1269
"""
1270
if rule[:2] in ('./', '.\\'):
1271
# rootdir rule
1272
result = fnmatch.translate(rule[2:])
1273
elif '/' in rule or '\\' in rule:
1274
# path prefix
1275
result = fnmatch.translate(rule)
1276
else:
1277
# default rule style.
1278
result = "(?:.*/)?(?!.*/)" + fnmatch.translate(rule)
1279
assert result[-1] == '$', "fnmatch.translate did not add the expected $"
1280
return "(" + result + ")"
1281
1282
def _combine_ignore_rules(self, rules):
1283
"""Combine a list of ignore rules into a single regex object.
1284
1285
Each individual rule is combined with | to form a big regex, which then
1286
has $ added to it to form something like ()|()|()$. The group index for
1287
each subregex's outermost group is placed in a dictionary mapping back
1288
to the rule. This allows quick identification of the matching rule that
1289
triggered a match.
1290
:return: a list of the compiled regex and the matching-group index
1291
dictionaries. We return a list because python complains if you try to
1292
combine more than 100 regexes.
1293
"""
1294
result = []
1295
groups = {}
1296
next_group = 0
1297
translated_rules = []
1298
for rule in rules:
1299
translated_rule = self._translate_ignore_rule(rule)
1300
compiled_rule = re.compile(translated_rule)
1301
groups[next_group] = rule
1302
next_group += compiled_rule.groups
1303
translated_rules.append(translated_rule)
1304
if next_group == 99:
1305
result.append((re.compile("|".join(translated_rules)), groups))
1306
groups = {}
1307
next_group = 0
1308
translated_rules = []
1309
if len(translated_rules):
1310
result.append((re.compile("|".join(translated_rules)), groups))
1311
return result
950
1312
951
1313
def ignored_files(self):
952
1314
"""Yield list of PATH, IGNORE_PATTERN"""
953
1315
for subp in self.extras():
954
1316
pat = self.is_ignored(subp)
955
if pat != None:
1317
if pat is not None:
956
1318
yield subp, pat
957
1319
958
959
1320
def get_ignore_list(self):
960
1321
"""Return list of ignore patterns.
961
1322
962
1323
Cached in the Tree object after the first call.
963
1324
"""
964
if hasattr(self, '_ignorelist'):
965
return self._ignorelist
966
967
l = bzrlib.DEFAULT_IGNORE[:]
1325
ignoreset = getattr(self, '_ignoreset', None)
1326
if ignoreset is not None:
1327
return ignoreset
1328
1329
ignore_globs = set(bzrlib.DEFAULT_IGNORE)
1330
ignore_globs.update(ignores.get_runtime_ignores())
1331
1332
ignore_globs.update(ignores.get_user_ignores())
1333
968
1334
if self.has_filename(bzrlib.IGNORE_FILENAME):
969
1335
f = self.get_file_byname(bzrlib.IGNORE_FILENAME)
970
l.extend([line.rstrip("\n\r") for line in f.readlines()])
971
self._ignorelist = l
972
return l
973
1336
try:
1337
ignore_globs.update(ignores.parse_ignore_file(f))
1338
finally:
1339
f.close()
1340
1341
self._ignoreset = ignore_globs
1342
self._ignore_regex = self._combine_ignore_rules(ignore_globs)
1343
return ignore_globs
1344
1345
def _get_ignore_rules_as_regex(self):
1346
"""Return a regex of the ignore rules and a mapping dict.
1347
1348
:return: (ignore rules compiled regex, dictionary mapping rule group
1349
indices to original rule.)
1350
"""
1351
if getattr(self, '_ignoreset', None) is None:
1352
self.get_ignore_list()
1353
return self._ignore_regex
974
1354
975
1355
def is_ignored(self, filename):
976
1356
r"""Check whether the filename matches an ignore pattern.
990
1370
# treat dotfiles correctly and allows * to match /.
991
1371
# Eventually it should be replaced with something more
992
1372
# accurate.
993
994
for pat in self.get_ignore_list():
995
if '/' in pat or '\\' in pat:
996
997
# as a special case, you can put ./ at the start of a
998
# pattern; this is good to match in the top-level
999
# only;
1000
1001
if (pat[:2] == './') or (pat[:2] == '.\\'):
1002
newpat = pat[2:]
1003
else:
1004
newpat = pat
1005
if fnmatch.fnmatchcase(filename, newpat):
1006
return pat
1007
else:
1008
if fnmatch.fnmatchcase(splitpath(filename)[-1], pat):
1009
return pat
1010
else:
1011
return None
1373
1374
rules = self._get_ignore_rules_as_regex()
1375
for regex, mapping in rules:
1376
match = regex.match(filename)
1377
if match is not None:
1378
# one or more of the groups in mapping will have a non-None
1379
# group match.
1380
groups = match.groups()
1381
rules = [mapping[group] for group in
1382
mapping if groups[group] is not None]
1383
return rules[0]
1384
return None
1012
1385
1013
1386
def kind(self, file_id):
1014
1387
return file_kind(self.id2abspath(file_id))
1015
1388
1016
@needs_read_lock
1017
1389
def last_revision(self):
1018
"""Return the last revision id of this working tree.
1019
1020
In early branch formats this was == the branch last_revision,
1021
but that cannot be relied upon - for working tree operations,
1022
always use tree.last_revision().
1390
"""Return the last revision of the branch for this tree.
1391
1392
This format tree does not support a separate marker for last-revision
1393
compared to the branch.
1394
1395
See MutableTree.last_revision
1023
1396
"""
1397
return self._last_revision()
1398
1399
@needs_read_lock
1400
def _last_revision(self):
1401
"""helper for get_parent_ids."""
1024
1402
return self.branch.last_revision()
1025
1403
1404
def is_locked(self):
1405
return self._control_files.is_locked()
1406
1026
1407
def lock_read(self):
1027
1408
"""See Branch.lock_read, and WorkingTree.unlock."""
1028
1409
self.branch.lock_read()
1032
1413
self.branch.unlock()
1033
1414
raise
1034
1415
1416
def lock_tree_write(self):
1417
"""See MutableTree.lock_tree_write, and WorkingTree.unlock."""
1418
self.branch.lock_read()
1419
try:
1420
return self._control_files.lock_write()
1421
except:
1422
self.branch.unlock()
1423
raise
1424
1035
1425
def lock_write(self):
1036
"""See Branch.lock_write, and WorkingTree.unlock."""
1426
"""See MutableTree.lock_write, and WorkingTree.unlock."""
1037
1427
self.branch.lock_write()
1038
1428
try:
1039
1429
return self._control_files.lock_write()
1041
1431
self.branch.unlock()
1042
1432
raise
1043
1433
1434
def get_physical_lock_status(self):
1435
return self._control_files.get_physical_lock_status()
1436
1044
1437
def _basis_inventory_name(self):
1045
return 'basis-inventory'
1438
return 'basis-inventory-cache'
1046
1439
1047
@needs_write_lock
1440
@needs_tree_write_lock
1048
1441
def set_last_revision(self, new_revision):
1049
1442
"""Change the last revision in the working tree."""
1050
1443
if self._change_last_revision(new_revision):
1059
1452
if new_revision is None:
1060
1453
self.branch.set_revision_history([])
1061
1454
return False
1062
# current format is locked in with the branch
1063
revision_history = self.branch.revision_history()
1064
1455
try:
1065
position = revision_history.index(new_revision)
1066
except ValueError:
1067
raise errors.NoSuchRevision(self.branch, new_revision)
1068
self.branch.set_revision_history(revision_history[:position + 1])
1456
self.branch.generate_revision_history(new_revision)
1457
except errors.NoSuchRevision:
1458
# not present in the repo - dont try to set it deeper than the tip
1459
self.branch.set_revision_history([new_revision])
1069
1460
return True
1070
1461
1462
def _write_basis_inventory(self, xml):
1463
"""Write the basis inventory XML to the basis-inventory file"""
1464
assert isinstance(xml, str), 'serialised xml must be bytestring.'
1465
path = self._basis_inventory_name()
1466
sio = StringIO(xml)
1467
self._control_files.put(path, sio)
1468
1469
def _create_basis_xml_from_inventory(self, revision_id, inventory):
1470
"""Create the text that will be saved in basis-inventory"""
1471
inventory.revision_id = revision_id
1472
return xml6.serializer_v6.write_inventory_to_string(inventory)
1473
1071
1474
def _cache_basis_inventory(self, new_revision):
1072
1475
"""Cache new_revision as the basis inventory."""
1476
# TODO: this should allow the ready-to-use inventory to be passed in,
1477
# as commit already has that ready-to-use [while the format is the
1478
# same, that is].
1073
1479
try:
1074
1480
# this double handles the inventory - unpack and repack -
1075
1481
# but is easier to understand. We can/should put a conditional
1076
1482
# in here based on whether the inventory is in the latest format
1077
1483
# - perhaps we should repack all inventories on a repository
1078
1484
# upgrade ?
1079
inv = self.branch.repository.get_inventory(new_revision)
1080
inv.revision_id = new_revision
1081
xml = bzrlib.xml5.serializer_v5.write_inventory_to_string(inv)
1082
1083
path = self._basis_inventory_name()
1084
self._control_files.put_utf8(path, xml)
1085
except WeaveRevisionNotPresent:
1485
# the fast path is to copy the raw xml from the repository. If the
1486
# xml contains 'revision_id="', then we assume the right
1487
# revision_id is set. We must check for this full string, because a
1488
# root node id can legitimately look like 'revision_id' but cannot
1489
# contain a '"'.
1490
xml = self.branch.repository.get_inventory_xml(new_revision)
1491
firstline = xml.split('\n', 1)[0]
1492
if (not 'revision_id="' in firstline or
1493
'format="6"' not in firstline):
1494
inv = self.branch.repository.deserialise_inventory(
1495
new_revision, xml)
1496
xml = self._create_basis_xml_from_inventory(new_revision, inv)
1497
self._write_basis_inventory(xml)
1498
except (errors.NoSuchRevision, errors.RevisionNotPresent):
1086
1499
pass
1087
1500
1088
1501
def read_basis_inventory(self):
1089
1502
"""Read the cached basis inventory."""
1090
1503
path = self._basis_inventory_name()
1091
return self._control_files.get_utf8(path).read()
1504
return self._control_files.get(path).read()
1092
1505
1093
1506
@needs_read_lock
1094
1507
def read_working_inventory(self):
1095
"""Read the working inventory."""
1508
"""Read the working inventory.
1509
1510
:raises errors.InventoryModified: read_working_inventory will fail
1511
when the current in memory inventory has been modified.
1512
"""
1513
# conceptually this should be an implementation detail of the tree.
1514
# XXX: Deprecate this.
1096
1515
# ElementTree does its own conversion from UTF-8, so open in
1097
1516
# binary.
1098
result = bzrlib.xml5.serializer_v5.read_inventory(
1517
if self._inventory_is_modified:
1518
raise errors.InventoryModified(self)
1519
result = xml5.serializer_v5.read_inventory(
1099
1520
self._control_files.get('inventory'))
1100
self._set_inventory(result)
1521
self._set_inventory(result, dirty=False)
1101
1522
return result
1102
1523
1103
@needs_write_lock
1104
def remove(self, files, verbose=False):
1524
@needs_tree_write_lock
1525
def remove(self, files, verbose=False, to_file=None):
1105
1526
"""Remove nominated files from the working inventory..
1106
1527
1107
1528
This does not remove their text. This does not run on XXX on what? RBC
1129
1550
# TODO: Perhaps make this just a warning, and continue?
1130
1551
# This tends to happen when
1131
1552
raise NotVersionedError(path=f)
1132
mutter("remove inventory entry %s {%s}", quotefn(f), fid)
1133
1553
if verbose:
1134
1554
# having remove it, it must be either ignored or unknown
1135
1555
if self.is_ignored(f):
1136
1556
new_status = 'I'
1137
1557
else:
1138
1558
new_status = '?'
1139
show_status(new_status, inv[fid].kind, quotefn(f))
1559
textui.show_status(new_status, inv[fid].kind, f,
1560
to_file=to_file)
1140
1561
del inv[fid]
1141
1562
1142
1563
self._write_inventory(inv)
1143
1564
1144
@needs_write_lock
1565
@needs_tree_write_lock
1145
1566
def revert(self, filenames, old_tree=None, backups=True,
1146
1567
pb=DummyProgress()):
1147
from transform import revert
1148
from conflicts import resolve
1568
from bzrlib.conflicts import resolve
1149
1569
if old_tree is None:
1150
1570
old_tree = self.basis_tree()
1151
conflicts = revert(self, old_tree, filenames, backups, pb)
1571
conflicts = transform.revert(self, old_tree, filenames, backups, pb)
1152
1572
if not len(filenames):
1153
self.set_pending_merges([])
1573
self.set_parent_ids(self.get_parent_ids()[:1])
1154
1574
resolve(self)
1155
1575
else:
1156
1576
resolve(self, filenames, ignore_misses=True)
1158
1578
1159
1579
# XXX: This method should be deprecated in favour of taking in a proper
1160
1580
# new Inventory object.
1161
@needs_write_lock
1581
@needs_tree_write_lock
1162
1582
def set_inventory(self, new_inventory_list):
1163
1583
from bzrlib.inventory import (Inventory,
1164
1584
InventoryDirectory,
1181
1601
raise BzrError("unknown kind %r" % kind)
1182
1602
self._write_inventory(inv)
1183
1603
1184
@needs_write_lock
1604
@needs_tree_write_lock
1185
1605
def set_root_id(self, file_id):
1186
1606
"""Set the root id for this tree."""
1187
inv = self.read_working_inventory()
1607
# for compatability
1608
if file_id is None:
1609
symbol_versioning.warn(symbol_versioning.zero_twelve
1610
% 'WorkingTree.set_root_id with fileid=None',
1611
DeprecationWarning,
1612
stacklevel=3)
1613
file_id = ROOT_ID
1614
inv = self._inventory
1188
1615
orig_root_id = inv.root.file_id
1616
# TODO: it might be nice to exit early if there was nothing
1617
# to do, saving us from trigger a sync on unlock.
1618
self._inventory_is_modified = True
1619
# we preserve the root inventory entry object, but
1620
# unlinkit from the byid index
1189
1621
del inv._byid[inv.root.file_id]
1190
1622
inv.root.file_id = file_id
1623
# and link it into the index with the new changed id.
1191
1624
inv._byid[inv.root.file_id] = inv.root
1625
# and finally update all children to reference the new id.
1626
# XXX: this should be safe to just look at the root.children
1627
# list, not the WHOLE INVENTORY.
1192
1628
for fid in inv:
1193
1629
entry = inv[fid]
1194
1630
if entry.parent_id == orig_root_id:
1195
1631
entry.parent_id = inv.root.file_id
1196
self._write_inventory(inv)
1197
1632
1198
1633
def unlock(self):
1199
1634
"""See Branch.unlock.
1204
1639
between multiple working trees, i.e. via shared storage, then we
1205
1640
would probably want to lock both the local tree, and the branch.
1206
1641
"""
1207
# FIXME: We want to write out the hashcache only when the last lock on
1208
# this working copy is released. Peeking at the lock count is a bit
1209
# of a nasty hack; probably it's better to have a transaction object,
1210
# which can do some finalization when it's either successfully or
1211
# unsuccessfully completed. (Denys's original patch did that.)
1212
# RBC 20060206 hookinhg into transaction will couple lock and transaction
1213
# wrongly. Hookinh into unllock on the control files object is fine though.
1214
1215
# TODO: split this per format so there is no ugly if block
1216
if self._hashcache.needs_write and (
1217
# dedicated lock files
1218
self._control_files._lock_count==1 or
1219
# shared lock files
1220
(self._control_files is self.branch.control_files and
1221
self._control_files._lock_count==3)):
1222
self._hashcache.write()
1223
# reverse order of locking.
1224
result = self._control_files.unlock()
1225
try:
1226
self.branch.unlock()
1227
finally:
1228
return result
1642
raise NotImplementedError(self.unlock)
1229
1643
1230
1644
@needs_write_lock
1231
1645
def update(self):
1232
1646
"""Update a working tree along its branch.
1233
1647
1234
This will update the branch if its bound too, which means we have multiple trees involved:
1235
The new basis tree of the master.
1236
The old basis tree of the branch.
1237
The old basis tree of the working tree.
1238
The current working tree state.
1239
pathologically all three may be different, and non ancestors of each other.
1240
Conceptually we want to:
1241
Preserve the wt.basis->wt.state changes
1242
Transform the wt.basis to the new master basis.
1243
Apply a merge of the old branch basis to get any 'local' changes from it into the tree.
1244
Restore the wt.basis->wt.state changes.
1648
This will update the branch if its bound too, which means we have
1649
multiple trees involved:
1650
1651
- The new basis tree of the master.
1652
- The old basis tree of the branch.
1653
- The old basis tree of the working tree.
1654
- The current working tree state.
1655
1656
Pathologically, all three may be different, and non-ancestors of each
1657
other. Conceptually we want to:
1658
1659
- Preserve the wt.basis->wt.state changes
1660
- Transform the wt.basis to the new master basis.
1661
- Apply a merge of the old branch basis to get any 'local' changes from
1662
it into the tree.
1663
- Restore the wt.basis->wt.state changes.
1245
1664
1246
1665
There isn't a single operation at the moment to do that, so we:
1247
Merge current state -> basis tree of the master w.r.t. the old tree basis.
1248
Do a 'normal' merge of the old branch basis if it is relevant.
1666
- Merge current state -> basis tree of the master w.r.t. the old tree
1667
basis.
1668
- Do a 'normal' merge of the old branch basis if it is relevant.
1249
1669
"""
1250
1670
old_tip = self.branch.update()
1251
if old_tip is not None:
1252
self.add_pending_merge(old_tip)
1253
self.branch.lock_read()
1671
1672
# here if old_tip is not None, it is the old tip of the branch before
1673
# it was updated from the master branch. This should become a pending
1674
# merge in the working tree to preserve the user existing work. we
1675
# cant set that until we update the working trees last revision to be
1676
# one from the new branch, because it will just get absorbed by the
1677
# parent de-duplication logic.
1678
#
1679
# We MUST save it even if an error occurs, because otherwise the users
1680
# local work is unreferenced and will appear to have been lost.
1681
#
1682
result = 0
1254
1683
try:
1255
result = 0
1256
if self.last_revision() != self.branch.last_revision():
1257
# merge tree state up to new branch tip.
1258
basis = self.basis_tree()
1259
to_tree = self.branch.basis_tree()
1260
result += merge_inner(self.branch,
1261
to_tree,
1262
basis,
1263
this_tree=self)
1264
self.set_last_revision(self.branch.last_revision())
1265
if old_tip and old_tip != self.last_revision():
1266
# our last revision was not the prior branch last reivison
1267
# and we have converted that last revision to a pending merge.
1268
# base is somewhere between the branch tip now
1269
# and the now pending merge
1270
from bzrlib.revision import common_ancestor
1271
try:
1272
base_rev_id = common_ancestor(self.branch.last_revision(),
1273
old_tip,
1274
self.branch.repository)
1275
except errors.NoCommonAncestor:
1276
base_rev_id = None
1277
base_tree = self.branch.repository.revision_tree(base_rev_id)
1278
other_tree = self.branch.repository.revision_tree(old_tip)
1279
result += merge_inner(self.branch,
1280
other_tree,
1281
base_tree,
1282
this_tree=self)
1283
return result
1284
finally:
1285
self.branch.unlock()
1684
last_rev = self.get_parent_ids()[0]
1685
except IndexError:
1686
last_rev = None
1687
if last_rev != self.branch.last_revision():
1688
# merge tree state up to new branch tip.
1689
basis = self.basis_tree()
1690
to_tree = self.branch.basis_tree()
1691
if basis.inventory.root is None:
1692
self.set_root_id(to_tree.inventory.root.file_id)
1693
result += merge.merge_inner(
1694
self.branch,
1695
to_tree,
1696
basis,
1697
this_tree=self)
1698
# TODO - dedup parents list with things merged by pull ?
1699
# reuse the tree we've updated to to set the basis:
1700
parent_trees = [(self.branch.last_revision(), to_tree)]
1701
merges = self.get_parent_ids()[1:]
1702
# Ideally we ask the tree for the trees here, that way the working
1703
# tree can decide whether to give us teh entire tree or give us a
1704
# lazy initialised tree. dirstate for instance will have the trees
1705
# in ram already, whereas a last-revision + basis-inventory tree
1706
# will not, but also does not need them when setting parents.
1707
for parent in merges:
1708
parent_trees.append(
1709
(parent, self.branch.repository.revision_tree(parent)))
1710
if old_tip is not None:
1711
parent_trees.append(
1712
(old_tip, self.branch.repository.revision_tree(old_tip)))
1713
self.set_parent_trees(parent_trees)
1714
last_rev = parent_trees[0][0]
1715
else:
1716
# the working tree had the same last-revision as the master
1717
# branch did. We may still have pivot local work from the local
1718
# branch into old_tip:
1719
if old_tip is not None:
1720
self.add_parent_tree_id(old_tip)
1721
if old_tip and old_tip != last_rev:
1722
# our last revision was not the prior branch last revision
1723
# and we have converted that last revision to a pending merge.
1724
# base is somewhere between the branch tip now
1725
# and the now pending merge
1726
from bzrlib.revision import common_ancestor
1727
try:
1728
base_rev_id = common_ancestor(self.branch.last_revision(),
1729
old_tip,
1730
self.branch.repository)
1731
except errors.NoCommonAncestor:
1732
base_rev_id = None
1733
base_tree = self.branch.repository.revision_tree(base_rev_id)
1734
other_tree = self.branch.repository.revision_tree(old_tip)
1735
result += merge.merge_inner(
1736
self.branch,
1737
other_tree,
1738
base_tree,
1739
this_tree=self)
1740
return result
1286
1741
1287
@needs_write_lock
1742
@needs_tree_write_lock
1288
1743
def _write_inventory(self, inv):
1289
1744
"""Write inventory as the current inventory."""
1290
sio = StringIO()
1291
bzrlib.xml5.serializer_v5.write_inventory(inv, sio)
1292
sio.seek(0)
1293
self._control_files.put('inventory', sio)
1294
self._set_inventory(inv)
1295
mutter('wrote working inventory')
1745
self._set_inventory(inv, dirty=True)
1746
self.flush()
1296
1747
1297
1748
def set_conflicts(self, arg):
1298
1749
raise UnsupportedOperation(self.set_conflicts, self)
1299
1750
1751
def add_conflicts(self, arg):
1752
raise UnsupportedOperation(self.add_conflicts, self)
1753
1300
1754
@needs_read_lock
1301
1755
def conflicts(self):
1302
conflicts = ConflictList()
1756
conflicts = _mod_conflicts.ConflictList()
1303
1757
for conflicted in self._iter_conflicts():
1304
1758
text = True
1305
1759
try:
1306
1760
if file_kind(self.abspath(conflicted)) != "file":
1307
1761
text = False
1308
except OSError, e:
1309
if e.errno == errno.ENOENT:
1310
text = False
1311
else:
1312
raise
1762
except errors.NoSuchFile:
1763
text = False
1313
1764
if text is True:
1314
1765
for suffix in ('.THIS', '.OTHER'):
1315
1766
try:
1316
1767
kind = file_kind(self.abspath(conflicted+suffix))
1317
except OSError, e:
1318
if e.errno == errno.ENOENT:
1768
if kind != "file":
1319
1769
text = False
1320
break
1321
else:
1322
raise
1323
if kind != "file":
1770
except errors.NoSuchFile:
1324
1771
text = False
1772
if text == False:
1325
1773
break
1326
1774
ctype = {True: 'text conflict', False: 'contents conflict'}[text]
1327
conflicts.append(Conflict.factory(ctype, path=conflicted,
1775
conflicts.append(_mod_conflicts.Conflict.factory(ctype,
1776
path=conflicted,
1328
1777
file_id=self.path2id(conflicted)))
1329
1778
return conflicts
1330
1779
1331
1780
1781
class WorkingTree2(WorkingTree):
1782
"""This is the Format 2 working tree.
1783
1784
This was the first weave based working tree.
1785
- uses os locks for locking.
1786
- uses the branch last-revision.
1787
"""
1788
1789
def lock_tree_write(self):
1790
"""See WorkingTree.lock_tree_write().
1791
1792
In Format2 WorkingTrees we have a single lock for the branch and tree
1793
so lock_tree_write() degrades to lock_write().
1794
"""
1795
self.branch.lock_write()
1796
try:
1797
return self._control_files.lock_write()
1798
except:
1799
self.branch.unlock()
1800
raise
1801
1802
def unlock(self):
1803
# we share control files:
1804
if self._control_files._lock_count == 3:
1805
# _inventory_is_modified is always False during a read lock.
1806
if self._inventory_is_modified:
1807
self.flush()
1808
if self._hashcache.needs_write:
1809
self._hashcache.write()
1810
# reverse order of locking.
1811
try:
1812
return self._control_files.unlock()
1813
finally:
1814
self.branch.unlock()
1815
1816
1332
1817
class WorkingTree3(WorkingTree):
1333
1818
"""This is the Format 3 working tree.
1334
1819
1340
1825
"""
1341
1826
1342
1827
@needs_read_lock
1343
def last_revision(self):
1344
"""See WorkingTree.last_revision."""
1828
def _last_revision(self):
1829
"""See Mutable.last_revision."""
1345
1830
try:
1346
1831
return self._control_files.get_utf8('last-revision').read()
1347
1832
except NoSuchFile:
1356
1841
pass
1357
1842
return False
1358
1843
else:
1359
try:
1360
self.branch.revision_history().index(revision_id)
1361
except ValueError:
1362
raise errors.NoSuchRevision(self.branch, revision_id)
1363
1844
self._control_files.put_utf8('last-revision', revision_id)
1364
1845
return True
1365
1846
1366
@needs_write_lock
1847
@needs_tree_write_lock
1367
1848
def set_conflicts(self, conflicts):
1368
1849
self._put_rio('conflicts', conflicts.to_stanzas(),
1369
1850
CONFLICT_HEADER_1)
1370
1851
1852
@needs_tree_write_lock
1853
def add_conflicts(self, new_conflicts):
1854
conflict_set = set(self.conflicts())
1855
conflict_set.update(set(list(new_conflicts)))
1856
self.set_conflicts(_mod_conflicts.ConflictList(sorted(conflict_set,
1857
key=_mod_conflicts.Conflict.sort_key)))
1858
1371
1859
@needs_read_lock
1372
1860
def conflicts(self):
1373
1861
try:
1374
1862
confile = self._control_files.get('conflicts')
1375
1863
except NoSuchFile:
1376
return ConflictList()
1864
return _mod_conflicts.ConflictList()
1377
1865
try:
1378
1866
if confile.next() != CONFLICT_HEADER_1 + '\n':
1379
1867
raise ConflictFormatError()
1380
1868
except StopIteration:
1381
1869
raise ConflictFormatError()
1382
return ConflictList.from_stanzas(RioReader(confile))
1870
return _mod_conflicts.ConflictList.from_stanzas(RioReader(confile))
1871
1872
def unlock(self):
1873
if self._control_files._lock_count == 1:
1874
# _inventory_is_modified is always False during a read lock.
1875
if self._inventory_is_modified:
1876
self.flush()
1877
if self._hashcache.needs_write:
1878
self._hashcache.write()
1879
# reverse order of locking.
1880
try:
1881
return self._control_files.unlock()
1882
finally:
1883
self.branch.unlock()
1383
1884
1384
1885
1385
1886
def get_conflicted_stem(path):
1386
for suffix in CONFLICT_SUFFIXES:
1887
for suffix in _mod_conflicts.CONFLICT_SUFFIXES:
1387
1888
if path.endswith(suffix):
1388
1889
return path[:-len(suffix)]
1389
1890
1437
1938
except NoSuchFile:
1438
1939
raise errors.NoWorkingTree(base=transport.base)
1439
1940
except KeyError:
1440
raise errors.UnknownFormatError(format_string)
1941
raise errors.UnknownFormatError(format=format_string)
1441
1942
1442
1943
@classmethod
1443
1944
def get_default_format(klass):
1486
1987
"""See WorkingTreeFormat.get_format_description()."""
1487
1988
return "Working tree format 2"
1488
1989
1990
def stub_initialize_remote(self, control_files):
1991
"""As a special workaround create critical control files for a remote working tree
1992
1993
This ensures that it can later be updated and dealt with locally,
1994
since BzrDirFormat6 and BzrDirFormat5 cannot represent dirs with
1995
no working tree. (See bug #43064).
1996
"""
1997
sio = StringIO()
1998
inv = Inventory()
1999
xml5.serializer_v5.write_inventory(inv, sio)
2000
sio.seek(0)
2001
control_files.put('inventory', sio)
2002
2003
control_files.put_utf8('pending-merges', '')
2004
2005
1489
2006
def initialize(self, a_bzrdir, revision_id=None):
1490
2007
"""See WorkingTreeFormat.initialize()."""
1491
2008
if not isinstance(a_bzrdir.transport, LocalTransport):
1503
2020
finally:
1504
2021
branch.unlock()
1505
2022
revision = branch.last_revision()
1506
inv = Inventory()
1507
wt = WorkingTree(a_bzrdir.root_transport.base,
2023
inv = Inventory()
2024
wt = WorkingTree2(a_bzrdir.root_transport.local_abspath('.'),
1508
2025
branch,
1509
2026
inv,
1510
2027
_internal=True,
1511
2028
_format=self,
1512
2029
_bzrdir=a_bzrdir)
1513
wt._write_inventory(inv)
1514
wt.set_root_id(inv.root.file_id)
1515
wt.set_last_revision(revision)
1516
wt.set_pending_merges([])
1517
build_tree(wt.basis_tree(), wt)
2030
basis_tree = branch.repository.revision_tree(revision)
2031
if basis_tree.inventory.root is not None:
2032
wt.set_root_id(basis_tree.inventory.root.file_id)
2033
# set the parent list and cache the basis tree.
2034
wt.set_parent_trees([(revision, basis_tree)])
2035
transform.build_tree(basis_tree, wt)
1518
2036
return wt
1519
2037
1520
2038
def __init__(self):
1532
2050
raise NotImplementedError
1533
2051
if not isinstance(a_bzrdir.transport, LocalTransport):
1534
2052
raise errors.NotLocalUrl(a_bzrdir.transport.base)
1535
return WorkingTree(a_bzrdir.root_transport.base,
2053
return WorkingTree2(a_bzrdir.root_transport.local_abspath('.'),
1536
2054
_internal=True,
1537
2055
_format=self,
1538
2056
_bzrdir=a_bzrdir)
1547
2065
files, separate from the BzrDir format
1548
2066
- modifies the hash cache format
1549
2067
- is new in bzr 0.8
1550
- uses a LockDir to guard access to the repository
2068
- uses a LockDir to guard access for writes.
1551
2069
"""
1552
2070
1553
2071
def get_format_string(self):
1569
2087
def initialize(self, a_bzrdir, revision_id=None):
1570
2088
"""See WorkingTreeFormat.initialize().
1571
2089
1572
revision_id allows creating a working tree at a differnet
2090
revision_id allows creating a working tree at a different
1573
2091
revision than the branch is at.
1574
2092
"""
1575
2093
if not isinstance(a_bzrdir.transport, LocalTransport):
1577
2095
transport = a_bzrdir.get_workingtree_transport(self)
1578
2096
control_files = self._open_control_files(a_bzrdir)
1579
2097
control_files.create_lock()
2098
control_files.lock_write()
1580
2099
control_files.put_utf8('format', self.get_format_string())
1581
2100
branch = a_bzrdir.open_branch()
1582
2101
if revision_id is None:
1583
2102
revision_id = branch.last_revision()
1584
inv = Inventory()
1585
wt = WorkingTree3(a_bzrdir.root_transport.base,
2103
inv = Inventory(root_id=gen_root_id())
2104
wt = WorkingTree3(a_bzrdir.root_transport.local_abspath('.'),
1586
2105
branch,
1587
2106
inv,
1588
2107
_internal=True,
1589
2108
_format=self,
1590
2109
_bzrdir=a_bzrdir,
1591
2110
_control_files=control_files)
1592
wt._write_inventory(inv)
1593
wt.set_root_id(inv.root.file_id)
1594
wt.set_last_revision(revision_id)
1595
wt.set_pending_merges([])
1596
build_tree(wt.basis_tree(), wt)
2111
wt.lock_tree_write()
2112
try:
2113
basis_tree = branch.repository.revision_tree(revision_id)
2114
# only set an explicit root id if there is one to set.
2115
if basis_tree.inventory.root is not None:
2116
wt.set_root_id(basis_tree.inventory.root.file_id)
2117
if revision_id == NULL_REVISION:
2118
wt.set_parent_trees([])
2119
else:
2120
wt.set_parent_trees([(revision_id, basis_tree)])
2121
transform.build_tree(basis_tree, wt)
2122
finally:
2123
# Unlock in this order so that the unlock-triggers-flush in
2124
# WorkingTree is given a chance to fire.
2125
control_files.unlock()
2126
wt.unlock()
1597
2127
return wt
1598
2128
1599
2129
def __init__(self):
1611
2141
raise NotImplementedError
1612
2142
if not isinstance(a_bzrdir.transport, LocalTransport):
1613
2143
raise errors.NotLocalUrl(a_bzrdir.transport.base)
1614
control_files = self._open_control_files(a_bzrdir)
1615
return WorkingTree3(a_bzrdir.root_transport.base,
2144
return self._open(a_bzrdir, self._open_control_files(a_bzrdir))
2145
2146
def _open(self, a_bzrdir, control_files):
2147
"""Open the tree itself.
2148
2149
:param a_bzrdir: the dir for the tree.
2150
:param control_files: the control files for the tree.
2151
"""
2152
return WorkingTree3(a_bzrdir.root_transport.local_abspath('.'),
1616
2153
_internal=True,
1617
2154
_format=self,
1618
2155
_bzrdir=a_bzrdir,
1645
2182
self._transport_readonly_server = transport_readonly_server
1646
2183
self._formats = formats
1647
2184
2185
def _clone_test(self, test, bzrdir_format, workingtree_format, variation):
2186
"""Clone test for adaption."""
2187
new_test = deepcopy(test)
2188
new_test.transport_server = self._transport_server
2189
new_test.transport_readonly_server = self._transport_readonly_server
2190
new_test.bzrdir_format = bzrdir_format
2191
new_test.workingtree_format = workingtree_format
2192
def make_new_test_id():
2193
new_id = "%s(%s)" % (test.id(), variation)
2194
return lambda: new_id
2195
new_test.id = make_new_test_id()
2196
return new_test
2197
1648
2198
def adapt(self, test):
1649
2199
from bzrlib.tests import TestSuite
1650
2200
result = TestSuite()
1651
2201
for workingtree_format, bzrdir_format in self._formats:
1652
new_test = deepcopy(test)
1653
new_test.transport_server = self._transport_server
1654
new_test.transport_readonly_server = self._transport_readonly_server
1655
new_test.bzrdir_format = bzrdir_format
1656
new_test.workingtree_format = workingtree_format
1657
def make_new_test_id():
1658
new_id = "%s(%s)" % (new_test.id(), workingtree_format.__class__.__name__)
1659
return lambda: new_id
1660
new_test.id = make_new_test_id()
2202
new_test = self._clone_test(
2203
test,
2204
bzrdir_format,
2205
workingtree_format, workingtree_format.__class__.__name__)
1661
2206
result.addTest(new_test)
1662
2207
return result
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0