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