~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/workingtree_4.py

  • Committer: Aaron Bentley
  • Date: 2008-12-03 05:31:27 UTC
  • mto: This revision was merged to the branch mainline in revision 3893.
  • Revision ID: aaron@aaronbentley.com-20081203053127-vozu5rmsixaadw0v
Change ls-shelf to shelve --list

Show diffs side-by-side

added added

removed removed

Lines of Context:
 
1
# Copyright (C) 2005, 2006, 2007, 2008 Canonical Ltd
 
2
#
 
3
# This program is free software; you can redistribute it and/or modify
 
4
# it under the terms of the GNU General Public License as published by
 
5
# the Free Software Foundation; either version 2 of the License, or
 
6
# (at your option) any later version.
 
7
#
 
8
# This program is distributed in the hope that it will be useful,
 
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
 
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
11
# GNU General Public License for more details.
 
12
#
 
13
# You should have received a copy of the GNU General Public License
 
14
# along with this program; if not, write to the Free Software
 
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
16
 
 
17
"""WorkingTree4 format and implementation.
 
18
 
 
19
WorkingTree4 provides the dirstate based working tree logic.
 
20
 
 
21
To get a WorkingTree, call bzrdir.open_workingtree() or
 
22
WorkingTree.open(dir).
 
23
"""
 
24
 
 
25
from cStringIO import StringIO
 
26
import os
 
27
import sys
 
28
 
 
29
from bzrlib.lazy_import import lazy_import
 
30
lazy_import(globals(), """
 
31
from bisect import bisect_left
 
32
import collections
 
33
from copy import deepcopy
 
34
import errno
 
35
import itertools
 
36
import operator
 
37
import stat
 
38
from time import time
 
39
import warnings
 
40
 
 
41
import bzrlib
 
42
from bzrlib import (
 
43
    bzrdir,
 
44
    cache_utf8,
 
45
    conflicts as _mod_conflicts,
 
46
    debug,
 
47
    delta,
 
48
    dirstate,
 
49
    errors,
 
50
    generate_ids,
 
51
    globbing,
 
52
    ignores,
 
53
    merge,
 
54
    osutils,
 
55
    revision as _mod_revision,
 
56
    revisiontree,
 
57
    textui,
 
58
    trace,
 
59
    transform,
 
60
    urlutils,
 
61
    xml5,
 
62
    xml6,
 
63
    )
 
64
import bzrlib.branch
 
65
from bzrlib.transport import get_transport
 
66
import bzrlib.ui
 
67
""")
 
68
 
 
69
from bzrlib import symbol_versioning
 
70
from bzrlib.decorators import needs_read_lock, needs_write_lock
 
71
from bzrlib.inventory import InventoryEntry, Inventory, ROOT_ID, entry_factory
 
72
import bzrlib.mutabletree
 
73
from bzrlib.mutabletree import needs_tree_write_lock
 
74
from bzrlib.osutils import (
 
75
    file_kind,
 
76
    isdir,
 
77
    normpath,
 
78
    pathjoin,
 
79
    rand_chars,
 
80
    realpath,
 
81
    safe_unicode,
 
82
    splitpath,
 
83
    )
 
84
from bzrlib.trace import mutter, note
 
85
from bzrlib.transport.local import LocalTransport
 
86
from bzrlib.tree import InterTree
 
87
from bzrlib.progress import DummyProgress, ProgressPhase
 
88
from bzrlib.revision import NULL_REVISION, CURRENT_REVISION
 
89
from bzrlib.rio import RioReader, rio_file, Stanza
 
90
from bzrlib.symbol_versioning import (deprecated_passed,
 
91
        deprecated_method,
 
92
        deprecated_function,
 
93
        DEPRECATED_PARAMETER,
 
94
        )
 
95
from bzrlib.tree import Tree
 
96
from bzrlib.workingtree import WorkingTree, WorkingTree3, WorkingTreeFormat3
 
97
 
 
98
 
 
99
class WorkingTree4(WorkingTree3):
 
100
    """This is the Format 4 working tree.
 
101
 
 
102
    This differs from WorkingTree3 by:
 
103
     - Having a consolidated internal dirstate, stored in a
 
104
       randomly-accessible sorted file on disk.
 
105
     - Not having a regular inventory attribute.  One can be synthesized 
 
106
       on demand but this is expensive and should be avoided.
 
107
 
 
108
    This is new in bzr 0.15.
 
109
    """
 
110
 
 
111
    def __init__(self, basedir,
 
112
                 branch,
 
113
                 _control_files=None,
 
114
                 _format=None,
 
115
                 _bzrdir=None):
 
116
        """Construct a WorkingTree for basedir.
 
117
 
 
118
        If the branch is not supplied, it is opened automatically.
 
119
        If the branch is supplied, it must be the branch for this basedir.
 
120
        (branch.base is not cross checked, because for remote branches that
 
121
        would be meaningless).
 
122
        """
 
123
        self._format = _format
 
124
        self.bzrdir = _bzrdir
 
125
        basedir = safe_unicode(basedir)
 
126
        mutter("opening working tree %r", basedir)
 
127
        self._branch = branch
 
128
        self.basedir = realpath(basedir)
 
129
        # if branch is at our basedir and is a format 6 or less
 
130
        # assume all other formats have their own control files.
 
131
        self._control_files = _control_files
 
132
        self._transport = self._control_files._transport
 
133
        self._dirty = None
 
134
        #-------------
 
135
        # during a read or write lock these objects are set, and are
 
136
        # None the rest of the time.
 
137
        self._dirstate = None
 
138
        self._inventory = None
 
139
        #-------------
 
140
        self._setup_directory_is_tree_reference()
 
141
        self._detect_case_handling()
 
142
        self._rules_searcher = None
 
143
        #--- allow tests to select the dirstate iter_changes implementation
 
144
        self._iter_changes = dirstate._process_entry
 
145
 
 
146
    @needs_tree_write_lock
 
147
    def _add(self, files, ids, kinds):
 
148
        """See MutableTree._add."""
 
149
        state = self.current_dirstate()
 
150
        for f, file_id, kind in zip(files, ids, kinds):
 
151
            f = f.strip('/')
 
152
            if self.path2id(f):
 
153
                # special case tree root handling.
 
154
                if f == '' and self.path2id(f) == ROOT_ID:
 
155
                    state.set_path_id('', generate_ids.gen_file_id(f))
 
156
                continue
 
157
            if file_id is None:
 
158
                file_id = generate_ids.gen_file_id(f)
 
159
            # deliberately add the file with no cached stat or sha1
 
160
            # - on the first access it will be gathered, and we can
 
161
            # always change this once tests are all passing.
 
162
            state.add(f, file_id, kind, None, '')
 
163
        self._make_dirty(reset_inventory=True)
 
164
 
 
165
    def _make_dirty(self, reset_inventory):
 
166
        """Make the tree state dirty.
 
167
 
 
168
        :param reset_inventory: True if the cached inventory should be removed
 
169
            (presuming there is one).
 
170
        """
 
171
        self._dirty = True
 
172
        if reset_inventory and self._inventory is not None:
 
173
            self._inventory = None
 
174
 
 
175
    @needs_tree_write_lock
 
176
    def add_reference(self, sub_tree):
 
177
        # use standard implementation, which calls back to self._add
 
178
        # 
 
179
        # So we don't store the reference_revision in the working dirstate,
 
180
        # it's just recorded at the moment of commit. 
 
181
        self._add_reference(sub_tree)
 
182
 
 
183
    def break_lock(self):
 
184
        """Break a lock if one is present from another instance.
 
185
 
 
186
        Uses the ui factory to ask for confirmation if the lock may be from
 
187
        an active process.
 
188
 
 
189
        This will probe the repository for its lock as well.
 
190
        """
 
191
        # if the dirstate is locked by an active process, reject the break lock
 
192
        # call.
 
193
        try:
 
194
            if self._dirstate is None:
 
195
                clear = True
 
196
            else:
 
197
                clear = False
 
198
            state = self._current_dirstate()
 
199
            if state._lock_token is not None:
 
200
                # we already have it locked. sheese, cant break our own lock.
 
201
                raise errors.LockActive(self.basedir)
 
202
            else:
 
203
                try:
 
204
                    # try for a write lock - need permission to get one anyhow
 
205
                    # to break locks.
 
206
                    state.lock_write()
 
207
                except errors.LockContention:
 
208
                    # oslocks fail when a process is still live: fail.
 
209
                    # TODO: get the locked lockdir info and give to the user to
 
210
                    # assist in debugging.
 
211
                    raise errors.LockActive(self.basedir)
 
212
                else:
 
213
                    state.unlock()
 
214
        finally:
 
215
            if clear:
 
216
                self._dirstate = None
 
217
        self._control_files.break_lock()
 
218
        self.branch.break_lock()
 
219
 
 
220
    def _comparison_data(self, entry, path):
 
221
        kind, executable, stat_value = \
 
222
            WorkingTree3._comparison_data(self, entry, path)
 
223
        # it looks like a plain directory, but it's really a reference -- see
 
224
        # also kind()
 
225
        if (self._repo_supports_tree_reference and
 
226
            kind == 'directory' and
 
227
            self._directory_is_tree_reference(path)):
 
228
            kind = 'tree-reference'
 
229
        return kind, executable, stat_value
 
230
 
 
231
    @needs_write_lock
 
232
    def commit(self, message=None, revprops=None, *args, **kwargs):
 
233
        # mark the tree as dirty post commit - commit
 
234
        # can change the current versioned list by doing deletes.
 
235
        result = WorkingTree3.commit(self, message, revprops, *args, **kwargs)
 
236
        self._make_dirty(reset_inventory=True)
 
237
        return result
 
238
 
 
239
    def current_dirstate(self):
 
240
        """Return the current dirstate object.
 
241
 
 
242
        This is not part of the tree interface and only exposed for ease of
 
243
        testing.
 
244
 
 
245
        :raises errors.NotWriteLocked: when not in a lock.
 
246
        """
 
247
        self._must_be_locked()
 
248
        return self._current_dirstate()
 
249
 
 
250
    def _current_dirstate(self):
 
251
        """Internal function that does not check lock status.
 
252
 
 
253
        This is needed for break_lock which also needs the dirstate.
 
254
        """
 
255
        if self._dirstate is not None:
 
256
            return self._dirstate
 
257
        local_path = self.bzrdir.get_workingtree_transport(None
 
258
            ).local_abspath('dirstate')
 
259
        self._dirstate = dirstate.DirState.on_file(local_path)
 
260
        return self._dirstate
 
261
 
 
262
    def filter_unversioned_files(self, paths):
 
263
        """Filter out paths that are versioned.
 
264
 
 
265
        :return: set of paths.
 
266
        """
 
267
        # TODO: make a generic multi-bisect routine roughly that should list
 
268
        # the paths, then process one half at a time recursively, and feed the
 
269
        # results of each bisect in further still
 
270
        paths = sorted(paths)
 
271
        result = set()
 
272
        state = self.current_dirstate()
 
273
        # TODO we want a paths_to_dirblocks helper I think
 
274
        for path in paths:
 
275
            dirname, basename = os.path.split(path.encode('utf8'))
 
276
            _, _, _, path_is_versioned = state._get_block_entry_index(
 
277
                dirname, basename, 0)
 
278
            if not path_is_versioned:
 
279
                result.add(path)
 
280
        return result
 
281
 
 
282
    def flush(self):
 
283
        """Write all cached data to disk."""
 
284
        if self._control_files._lock_mode != 'w':
 
285
            raise errors.NotWriteLocked(self)
 
286
        self.current_dirstate().save()
 
287
        self._inventory = None
 
288
        self._dirty = False
 
289
 
 
290
    @needs_tree_write_lock
 
291
    def _gather_kinds(self, files, kinds):
 
292
        """See MutableTree._gather_kinds."""
 
293
        for pos, f in enumerate(files):
 
294
            if kinds[pos] is None:
 
295
                kinds[pos] = self._kind(f)
 
296
 
 
297
    def _generate_inventory(self):
 
298
        """Create and set self.inventory from the dirstate object.
 
299
        
 
300
        This is relatively expensive: we have to walk the entire dirstate.
 
301
        Ideally we would not, and can deprecate this function.
 
302
        """
 
303
        #: uncomment to trap on inventory requests.
 
304
        # import pdb;pdb.set_trace()
 
305
        state = self.current_dirstate()
 
306
        state._read_dirblocks_if_needed()
 
307
        root_key, current_entry = self._get_entry(path='')
 
308
        current_id = root_key[2]
 
309
        if not (current_entry[0][0] == 'd'): # directory
 
310
            raise AssertionError(current_entry)
 
311
        inv = Inventory(root_id=current_id)
 
312
        # Turn some things into local variables
 
313
        minikind_to_kind = dirstate.DirState._minikind_to_kind
 
314
        factory = entry_factory
 
315
        utf8_decode = cache_utf8._utf8_decode
 
316
        inv_byid = inv._byid
 
317
        # we could do this straight out of the dirstate; it might be fast
 
318
        # and should be profiled - RBC 20070216
 
319
        parent_ies = {'' : inv.root}
 
320
        for block in state._dirblocks[1:]: # skip the root
 
321
            dirname = block[0]
 
322
            try:
 
323
                parent_ie = parent_ies[dirname]
 
324
            except KeyError:
 
325
                # all the paths in this block are not versioned in this tree
 
326
                continue
 
327
            for key, entry in block[1]:
 
328
                minikind, link_or_sha1, size, executable, stat = entry[0]
 
329
                if minikind in ('a', 'r'): # absent, relocated
 
330
                    # a parent tree only entry
 
331
                    continue
 
332
                name = key[1]
 
333
                name_unicode = utf8_decode(name)[0]
 
334
                file_id = key[2]
 
335
                kind = minikind_to_kind[minikind]
 
336
                inv_entry = factory[kind](file_id, name_unicode,
 
337
                                          parent_ie.file_id)
 
338
                if kind == 'file':
 
339
                    # This is only needed on win32, where this is the only way
 
340
                    # we know the executable bit.
 
341
                    inv_entry.executable = executable
 
342
                    # not strictly needed: working tree
 
343
                    #inv_entry.text_size = size
 
344
                    #inv_entry.text_sha1 = sha1
 
345
                elif kind == 'directory':
 
346
                    # add this entry to the parent map.
 
347
                    parent_ies[(dirname + '/' + name).strip('/')] = inv_entry
 
348
                elif kind == 'tree-reference':
 
349
                    if not self._repo_supports_tree_reference:
 
350
                        raise AssertionError(
 
351
                            "repository of %r "
 
352
                            "doesn't support tree references "
 
353
                            "required by entry %r"
 
354
                            % (self, name))
 
355
                    inv_entry.reference_revision = link_or_sha1 or None
 
356
                elif kind != 'symlink':
 
357
                    raise AssertionError("unknown kind %r" % kind)
 
358
                # These checks cost us around 40ms on a 55k entry tree
 
359
                if file_id in inv_byid:
 
360
                    raise AssertionError('file_id %s already in'
 
361
                        ' inventory as %s' % (file_id, inv_byid[file_id]))
 
362
                if name_unicode in parent_ie.children:
 
363
                    raise AssertionError('name %r already in parent'
 
364
                        % (name_unicode,))
 
365
                inv_byid[file_id] = inv_entry
 
366
                parent_ie.children[name_unicode] = inv_entry
 
367
        self._inventory = inv
 
368
 
 
369
    def _get_entry(self, file_id=None, path=None):
 
370
        """Get the dirstate row for file_id or path.
 
371
 
 
372
        If either file_id or path is supplied, it is used as the key to lookup.
 
373
        If both are supplied, the fastest lookup is used, and an error is
 
374
        raised if they do not both point at the same row.
 
375
        
 
376
        :param file_id: An optional unicode file_id to be looked up.
 
377
        :param path: An optional unicode path to be looked up.
 
378
        :return: The dirstate row tuple for path/file_id, or (None, None)
 
379
        """
 
380
        if file_id is None and path is None:
 
381
            raise errors.BzrError('must supply file_id or path')
 
382
        state = self.current_dirstate()
 
383
        if path is not None:
 
384
            path = path.encode('utf8')
 
385
        return state._get_entry(0, fileid_utf8=file_id, path_utf8=path)
 
386
 
 
387
    def get_file_sha1(self, file_id, path=None, stat_value=None):
 
388
        # check file id is valid unconditionally.
 
389
        entry = self._get_entry(file_id=file_id, path=path)
 
390
        if entry[0] is None:
 
391
            raise errors.NoSuchId(self, file_id)
 
392
        if path is None:
 
393
            path = pathjoin(entry[0][0], entry[0][1]).decode('utf8')
 
394
 
 
395
        file_abspath = self.abspath(path)
 
396
        state = self.current_dirstate()
 
397
        if stat_value is None:
 
398
            try:
 
399
                stat_value = os.lstat(file_abspath)
 
400
            except OSError, e:
 
401
                if e.errno == errno.ENOENT:
 
402
                    return None
 
403
                else:
 
404
                    raise
 
405
        link_or_sha1 = dirstate.update_entry(state, entry, file_abspath,
 
406
            stat_value=stat_value)
 
407
        if entry[1][0][0] == 'f':
 
408
            if link_or_sha1 is None:
 
409
                file_obj, statvalue = self.get_file_with_stat(file_id, path)
 
410
                try:
 
411
                    sha1 = osutils.sha_file(file_obj)
 
412
                finally:
 
413
                    file_obj.close()
 
414
                self._observed_sha1(file_id, path, (sha1, statvalue))
 
415
                return sha1
 
416
            else:
 
417
                return link_or_sha1
 
418
        return None
 
419
 
 
420
    def _get_inventory(self):
 
421
        """Get the inventory for the tree. This is only valid within a lock."""
 
422
        if 'evil' in debug.debug_flags:
 
423
            trace.mutter_callsite(2,
 
424
                "accessing .inventory forces a size of tree translation.")
 
425
        if self._inventory is not None:
 
426
            return self._inventory
 
427
        self._must_be_locked()
 
428
        self._generate_inventory()
 
429
        return self._inventory
 
430
 
 
431
    inventory = property(_get_inventory,
 
432
                         doc="Inventory of this Tree")
 
433
 
 
434
    @needs_read_lock
 
435
    def get_parent_ids(self):
 
436
        """See Tree.get_parent_ids.
 
437
        
 
438
        This implementation requests the ids list from the dirstate file.
 
439
        """
 
440
        return self.current_dirstate().get_parent_ids()
 
441
 
 
442
    def get_reference_revision(self, file_id, path=None):
 
443
        # referenced tree's revision is whatever's currently there
 
444
        return self.get_nested_tree(file_id, path).last_revision()
 
445
 
 
446
    def get_nested_tree(self, file_id, path=None):
 
447
        if path is None:
 
448
            path = self.id2path(file_id)
 
449
        # else: check file_id is at path?
 
450
        return WorkingTree.open(self.abspath(path))
 
451
 
 
452
    @needs_read_lock
 
453
    def get_root_id(self):
 
454
        """Return the id of this trees root"""
 
455
        return self._get_entry(path='')[0][2]
 
456
 
 
457
    def has_id(self, file_id):
 
458
        state = self.current_dirstate()
 
459
        row, parents = self._get_entry(file_id=file_id)
 
460
        if row is None:
 
461
            return False
 
462
        return osutils.lexists(pathjoin(
 
463
                    self.basedir, row[0].decode('utf8'), row[1].decode('utf8')))
 
464
 
 
465
    @needs_read_lock
 
466
    def id2path(self, file_id):
 
467
        "Convert a file-id to a path."
 
468
        state = self.current_dirstate()
 
469
        entry = self._get_entry(file_id=file_id)
 
470
        if entry == (None, None):
 
471
            raise errors.NoSuchId(tree=self, file_id=file_id)
 
472
        path_utf8 = osutils.pathjoin(entry[0][0], entry[0][1])
 
473
        return path_utf8.decode('utf8')
 
474
 
 
475
    def _is_executable_from_path_and_stat_from_basis(self, path, stat_result):
 
476
        entry = self._get_entry(path=path)
 
477
        if entry == (None, None):
 
478
            return False # Missing entries are not executable
 
479
        return entry[1][0][3] # Executable?
 
480
 
 
481
    if not osutils.supports_executable():
 
482
        def is_executable(self, file_id, path=None):
 
483
            """Test if a file is executable or not.
 
484
 
 
485
            Note: The caller is expected to take a read-lock before calling this.
 
486
            """
 
487
            entry = self._get_entry(file_id=file_id, path=path)
 
488
            if entry == (None, None):
 
489
                return False
 
490
            return entry[1][0][3]
 
491
 
 
492
        _is_executable_from_path_and_stat = \
 
493
            _is_executable_from_path_and_stat_from_basis
 
494
    else:
 
495
        def is_executable(self, file_id, path=None):
 
496
            """Test if a file is executable or not.
 
497
 
 
498
            Note: The caller is expected to take a read-lock before calling this.
 
499
            """
 
500
            self._must_be_locked()
 
501
            if not path:
 
502
                path = self.id2path(file_id)
 
503
            mode = os.lstat(self.abspath(path)).st_mode
 
504
            return bool(stat.S_ISREG(mode) and stat.S_IEXEC & mode)
 
505
 
 
506
    def all_file_ids(self):
 
507
        """See Tree.iter_all_file_ids"""
 
508
        self._must_be_locked()
 
509
        result = set()
 
510
        for key, tree_details in self.current_dirstate()._iter_entries():
 
511
            if tree_details[0][0] in ('a', 'r'): # relocated
 
512
                continue
 
513
            result.add(key[2])
 
514
        return result
 
515
 
 
516
    @needs_read_lock
 
517
    def __iter__(self):
 
518
        """Iterate through file_ids for this tree.
 
519
 
 
520
        file_ids are in a WorkingTree if they are in the working inventory
 
521
        and the working file exists.
 
522
        """
 
523
        result = []
 
524
        for key, tree_details in self.current_dirstate()._iter_entries():
 
525
            if tree_details[0][0] in ('a', 'r'): # absent, relocated
 
526
                # not relevant to the working tree
 
527
                continue
 
528
            path = pathjoin(self.basedir, key[0].decode('utf8'), key[1].decode('utf8'))
 
529
            if osutils.lexists(path):
 
530
                result.append(key[2])
 
531
        return iter(result)
 
532
 
 
533
    def iter_references(self):
 
534
        if not self._repo_supports_tree_reference:
 
535
            # When the repo doesn't support references, we will have nothing to
 
536
            # return
 
537
            return
 
538
        for key, tree_details in self.current_dirstate()._iter_entries():
 
539
            if tree_details[0][0] in ('a', 'r'): # absent, relocated
 
540
                # not relevant to the working tree
 
541
                continue
 
542
            if not key[1]:
 
543
                # the root is not a reference.
 
544
                continue
 
545
            relpath = pathjoin(key[0].decode('utf8'), key[1].decode('utf8'))
 
546
            try:
 
547
                if self._kind(relpath) == 'tree-reference':
 
548
                    yield relpath, key[2]
 
549
            except errors.NoSuchFile:
 
550
                # path is missing on disk.
 
551
                continue
 
552
 
 
553
    def _observed_sha1(self, file_id, path, (sha1, statvalue)):
 
554
        """See MutableTree._observed_sha1."""
 
555
        state = self.current_dirstate()
 
556
        entry = self._get_entry(file_id=file_id, path=path)
 
557
        state._observed_sha1(entry, sha1, statvalue)
 
558
 
 
559
    def kind(self, file_id):
 
560
        """Return the kind of a file.
 
561
 
 
562
        This is always the actual kind that's on disk, regardless of what it
 
563
        was added as.
 
564
 
 
565
        Note: The caller is expected to take a read-lock before calling this.
 
566
        """
 
567
        relpath = self.id2path(file_id)
 
568
        if relpath is None:
 
569
            raise AssertionError(
 
570
                "path for id {%s} is None!" % file_id)
 
571
        return self._kind(relpath)
 
572
 
 
573
    def _kind(self, relpath):
 
574
        abspath = self.abspath(relpath)
 
575
        kind = file_kind(abspath)
 
576
        if (self._repo_supports_tree_reference and
 
577
            kind == 'directory' and
 
578
            self._directory_is_tree_reference(relpath)):
 
579
            kind = 'tree-reference'
 
580
        return kind
 
581
 
 
582
    @needs_read_lock
 
583
    def _last_revision(self):
 
584
        """See Mutable.last_revision."""
 
585
        parent_ids = self.current_dirstate().get_parent_ids()
 
586
        if parent_ids:
 
587
            return parent_ids[0]
 
588
        else:
 
589
            return _mod_revision.NULL_REVISION
 
590
 
 
591
    def lock_read(self):
 
592
        """See Branch.lock_read, and WorkingTree.unlock."""
 
593
        self.branch.lock_read()
 
594
        try:
 
595
            self._control_files.lock_read()
 
596
            try:
 
597
                state = self.current_dirstate()
 
598
                if not state._lock_token:
 
599
                    state.lock_read()
 
600
                # set our support for tree references from the repository in
 
601
                # use.
 
602
                self._repo_supports_tree_reference = getattr(
 
603
                    self.branch.repository._format, "supports_tree_reference",
 
604
                    False)
 
605
            except:
 
606
                self._control_files.unlock()
 
607
                raise
 
608
        except:
 
609
            self.branch.unlock()
 
610
            raise
 
611
 
 
612
    def _lock_self_write(self):
 
613
        """This should be called after the branch is locked."""
 
614
        try:
 
615
            self._control_files.lock_write()
 
616
            try:
 
617
                state = self.current_dirstate()
 
618
                if not state._lock_token:
 
619
                    state.lock_write()
 
620
                # set our support for tree references from the repository in
 
621
                # use.
 
622
                self._repo_supports_tree_reference = getattr(
 
623
                    self.branch.repository._format, "supports_tree_reference",
 
624
                    False)
 
625
            except:
 
626
                self._control_files.unlock()
 
627
                raise
 
628
        except:
 
629
            self.branch.unlock()
 
630
            raise
 
631
 
 
632
    def lock_tree_write(self):
 
633
        """See MutableTree.lock_tree_write, and WorkingTree.unlock."""
 
634
        self.branch.lock_read()
 
635
        self._lock_self_write()
 
636
 
 
637
    def lock_write(self):
 
638
        """See MutableTree.lock_write, and WorkingTree.unlock."""
 
639
        self.branch.lock_write()
 
640
        self._lock_self_write()
 
641
 
 
642
    @needs_tree_write_lock
 
643
    def move(self, from_paths, to_dir, after=False):
 
644
        """See WorkingTree.move()."""
 
645
        result = []
 
646
        if not from_paths:
 
647
            return result
 
648
        state = self.current_dirstate()
 
649
        if isinstance(from_paths, basestring):
 
650
            raise ValueError()
 
651
        to_dir_utf8 = to_dir.encode('utf8')
 
652
        to_entry_dirname, to_basename = os.path.split(to_dir_utf8)
 
653
        id_index = state._get_id_index()
 
654
        # check destination directory
 
655
        # get the details for it
 
656
        to_entry_block_index, to_entry_entry_index, dir_present, entry_present = \
 
657
            state._get_block_entry_index(to_entry_dirname, to_basename, 0)
 
658
        if not entry_present:
 
659
            raise errors.BzrMoveFailedError('', to_dir,
 
660
                errors.NotVersionedError(to_dir))
 
661
        to_entry = state._dirblocks[to_entry_block_index][1][to_entry_entry_index]
 
662
        # get a handle on the block itself.
 
663
        to_block_index = state._ensure_block(
 
664
            to_entry_block_index, to_entry_entry_index, to_dir_utf8)
 
665
        to_block = state._dirblocks[to_block_index]
 
666
        to_abs = self.abspath(to_dir)
 
667
        if not isdir(to_abs):
 
668
            raise errors.BzrMoveFailedError('',to_dir,
 
669
                errors.NotADirectory(to_abs))
 
670
 
 
671
        if to_entry[1][0][0] != 'd':
 
672
            raise errors.BzrMoveFailedError('',to_dir,
 
673
                errors.NotADirectory(to_abs))
 
674
 
 
675
        if self._inventory is not None:
 
676
            update_inventory = True
 
677
            inv = self.inventory
 
678
            to_dir_id = to_entry[0][2]
 
679
            to_dir_ie = inv[to_dir_id]
 
680
        else:
 
681
            update_inventory = False
 
682
 
 
683
        rollbacks = []
 
684
        def move_one(old_entry, from_path_utf8, minikind, executable,
 
685
                     fingerprint, packed_stat, size,
 
686
                     to_block, to_key, to_path_utf8):
 
687
            state._make_absent(old_entry)
 
688
            from_key = old_entry[0]
 
689
            rollbacks.append(
 
690
                lambda:state.update_minimal(from_key,
 
691
                    minikind,
 
692
                    executable=executable,
 
693
                    fingerprint=fingerprint,
 
694
                    packed_stat=packed_stat,
 
695
                    size=size,
 
696
                    path_utf8=from_path_utf8))
 
697
            state.update_minimal(to_key,
 
698
                    minikind,
 
699
                    executable=executable,
 
700
                    fingerprint=fingerprint,
 
701
                    packed_stat=packed_stat,
 
702
                    size=size,
 
703
                    path_utf8=to_path_utf8)
 
704
            added_entry_index, _ = state._find_entry_index(to_key, to_block[1])
 
705
            new_entry = to_block[1][added_entry_index]
 
706
            rollbacks.append(lambda:state._make_absent(new_entry))
 
707
 
 
708
        for from_rel in from_paths:
 
709
            # from_rel is 'pathinroot/foo/bar'
 
710
            from_rel_utf8 = from_rel.encode('utf8')
 
711
            from_dirname, from_tail = osutils.split(from_rel)
 
712
            from_dirname, from_tail_utf8 = osutils.split(from_rel_utf8)
 
713
            from_entry = self._get_entry(path=from_rel)
 
714
            if from_entry == (None, None):
 
715
                raise errors.BzrMoveFailedError(from_rel,to_dir,
 
716
                    errors.NotVersionedError(path=str(from_rel)))
 
717
 
 
718
            from_id = from_entry[0][2]
 
719
            to_rel = pathjoin(to_dir, from_tail)
 
720
            to_rel_utf8 = pathjoin(to_dir_utf8, from_tail_utf8)
 
721
            item_to_entry = self._get_entry(path=to_rel)
 
722
            if item_to_entry != (None, None):
 
723
                raise errors.BzrMoveFailedError(from_rel, to_rel,
 
724
                    "Target is already versioned.")
 
725
 
 
726
            if from_rel == to_rel:
 
727
                raise errors.BzrMoveFailedError(from_rel, to_rel,
 
728
                    "Source and target are identical.")
 
729
 
 
730
            from_missing = not self.has_filename(from_rel)
 
731
            to_missing = not self.has_filename(to_rel)
 
732
            if after:
 
733
                move_file = False
 
734
            else:
 
735
                move_file = True
 
736
            if to_missing:
 
737
                if not move_file:
 
738
                    raise errors.BzrMoveFailedError(from_rel, to_rel,
 
739
                        errors.NoSuchFile(path=to_rel,
 
740
                        extra="New file has not been created yet"))
 
741
                elif from_missing:
 
742
                    # neither path exists
 
743
                    raise errors.BzrRenameFailedError(from_rel, to_rel,
 
744
                        errors.PathsDoNotExist(paths=(from_rel, to_rel)))
 
745
            else:
 
746
                if from_missing: # implicitly just update our path mapping
 
747
                    move_file = False
 
748
                elif not after:
 
749
                    raise errors.RenameFailedFilesExist(from_rel, to_rel)
 
750
 
 
751
            rollbacks = []
 
752
            def rollback_rename():
 
753
                """A single rename has failed, roll it back."""
 
754
                # roll back everything, even if we encounter trouble doing one
 
755
                # of them.
 
756
                #
 
757
                # TODO: at least log the other exceptions rather than just
 
758
                # losing them mbp 20070307
 
759
                exc_info = None
 
760
                for rollback in reversed(rollbacks):
 
761
                    try:
 
762
                        rollback()
 
763
                    except Exception, e:
 
764
                        exc_info = sys.exc_info()
 
765
                if exc_info:
 
766
                    raise exc_info[0], exc_info[1], exc_info[2]
 
767
 
 
768
            # perform the disk move first - its the most likely failure point.
 
769
            if move_file:
 
770
                from_rel_abs = self.abspath(from_rel)
 
771
                to_rel_abs = self.abspath(to_rel)
 
772
                try:
 
773
                    osutils.rename(from_rel_abs, to_rel_abs)
 
774
                except OSError, e:
 
775
                    raise errors.BzrMoveFailedError(from_rel, to_rel, e[1])
 
776
                rollbacks.append(lambda: osutils.rename(to_rel_abs, from_rel_abs))
 
777
            try:
 
778
                # perform the rename in the inventory next if needed: its easy
 
779
                # to rollback
 
780
                if update_inventory:
 
781
                    # rename the entry
 
782
                    from_entry = inv[from_id]
 
783
                    current_parent = from_entry.parent_id
 
784
                    inv.rename(from_id, to_dir_id, from_tail)
 
785
                    rollbacks.append(
 
786
                        lambda: inv.rename(from_id, current_parent, from_tail))
 
787
                # finally do the rename in the dirstate, which is a little
 
788
                # tricky to rollback, but least likely to need it.
 
789
                old_block_index, old_entry_index, dir_present, file_present = \
 
790
                    state._get_block_entry_index(from_dirname, from_tail_utf8, 0)
 
791
                old_block = state._dirblocks[old_block_index][1]
 
792
                old_entry = old_block[old_entry_index]
 
793
                from_key, old_entry_details = old_entry
 
794
                cur_details = old_entry_details[0]
 
795
                # remove the old row
 
796
                to_key = ((to_block[0],) + from_key[1:3])
 
797
                minikind = cur_details[0]
 
798
                move_one(old_entry, from_path_utf8=from_rel_utf8,
 
799
                         minikind=minikind,
 
800
                         executable=cur_details[3],
 
801
                         fingerprint=cur_details[1],
 
802
                         packed_stat=cur_details[4],
 
803
                         size=cur_details[2],
 
804
                         to_block=to_block,
 
805
                         to_key=to_key,
 
806
                         to_path_utf8=to_rel_utf8)
 
807
 
 
808
                if minikind == 'd':
 
809
                    def update_dirblock(from_dir, to_key, to_dir_utf8):
 
810
                        """Recursively update all entries in this dirblock."""
 
811
                        if from_dir == '':
 
812
                            raise AssertionError("renaming root not supported")
 
813
                        from_key = (from_dir, '')
 
814
                        from_block_idx, present = \
 
815
                            state._find_block_index_from_key(from_key)
 
816
                        if not present:
 
817
                            # This is the old record, if it isn't present, then
 
818
                            # there is theoretically nothing to update.
 
819
                            # (Unless it isn't present because of lazy loading,
 
820
                            # but we don't do that yet)
 
821
                            return
 
822
                        from_block = state._dirblocks[from_block_idx]
 
823
                        to_block_index, to_entry_index, _, _ = \
 
824
                            state._get_block_entry_index(to_key[0], to_key[1], 0)
 
825
                        to_block_index = state._ensure_block(
 
826
                            to_block_index, to_entry_index, to_dir_utf8)
 
827
                        to_block = state._dirblocks[to_block_index]
 
828
 
 
829
                        # Grab a copy since move_one may update the list.
 
830
                        for entry in from_block[1][:]:
 
831
                            if not (entry[0][0] == from_dir):
 
832
                                raise AssertionError()
 
833
                            cur_details = entry[1][0]
 
834
                            to_key = (to_dir_utf8, entry[0][1], entry[0][2])
 
835
                            from_path_utf8 = osutils.pathjoin(entry[0][0], entry[0][1])
 
836
                            to_path_utf8 = osutils.pathjoin(to_dir_utf8, entry[0][1])
 
837
                            minikind = cur_details[0]
 
838
                            if minikind in 'ar':
 
839
                                # Deleted children of a renamed directory
 
840
                                # Do not need to be updated.
 
841
                                # Children that have been renamed out of this
 
842
                                # directory should also not be updated
 
843
                                continue
 
844
                            move_one(entry, from_path_utf8=from_path_utf8,
 
845
                                     minikind=minikind,
 
846
                                     executable=cur_details[3],
 
847
                                     fingerprint=cur_details[1],
 
848
                                     packed_stat=cur_details[4],
 
849
                                     size=cur_details[2],
 
850
                                     to_block=to_block,
 
851
                                     to_key=to_key,
 
852
                                     to_path_utf8=to_path_utf8)
 
853
                            if minikind == 'd':
 
854
                                # We need to move all the children of this
 
855
                                # entry
 
856
                                update_dirblock(from_path_utf8, to_key,
 
857
                                                to_path_utf8)
 
858
                    update_dirblock(from_rel_utf8, to_key, to_rel_utf8)
 
859
            except:
 
860
                rollback_rename()
 
861
                raise
 
862
            result.append((from_rel, to_rel))
 
863
            state._dirblock_state = dirstate.DirState.IN_MEMORY_MODIFIED
 
864
            self._make_dirty(reset_inventory=False)
 
865
 
 
866
        return result
 
867
 
 
868
    def _must_be_locked(self):
 
869
        if not self._control_files._lock_count:
 
870
            raise errors.ObjectNotLocked(self)
 
871
 
 
872
    def _new_tree(self):
 
873
        """Initialize the state in this tree to be a new tree."""
 
874
        self._dirty = True
 
875
 
 
876
    @needs_read_lock
 
877
    def path2id(self, path):
 
878
        """Return the id for path in this tree."""
 
879
        path = path.strip('/')
 
880
        entry = self._get_entry(path=path)
 
881
        if entry == (None, None):
 
882
            return None
 
883
        return entry[0][2]
 
884
 
 
885
    def paths2ids(self, paths, trees=[], require_versioned=True):
 
886
        """See Tree.paths2ids().
 
887
 
 
888
        This specialisation fast-paths the case where all the trees are in the
 
889
        dirstate.
 
890
        """
 
891
        if paths is None:
 
892
            return None
 
893
        parents = self.get_parent_ids()
 
894
        for tree in trees:
 
895
            if not (isinstance(tree, DirStateRevisionTree) and tree._revision_id in
 
896
                parents):
 
897
                return super(WorkingTree4, self).paths2ids(paths, trees, require_versioned)
 
898
        search_indexes = [0] + [1 + parents.index(tree._revision_id) for tree in trees]
 
899
        # -- make all paths utf8 --
 
900
        paths_utf8 = set()
 
901
        for path in paths:
 
902
            paths_utf8.add(path.encode('utf8'))
 
903
        paths = paths_utf8
 
904
        # -- paths is now a utf8 path set --
 
905
        # -- get the state object and prepare it.
 
906
        state = self.current_dirstate()
 
907
        if False and (state._dirblock_state == dirstate.DirState.NOT_IN_MEMORY
 
908
            and '' not in paths):
 
909
            paths2ids = self._paths2ids_using_bisect
 
910
        else:
 
911
            paths2ids = self._paths2ids_in_memory
 
912
        return paths2ids(paths, search_indexes,
 
913
                         require_versioned=require_versioned)
 
914
 
 
915
    def _paths2ids_in_memory(self, paths, search_indexes,
 
916
                             require_versioned=True):
 
917
        state = self.current_dirstate()
 
918
        state._read_dirblocks_if_needed()
 
919
        def _entries_for_path(path):
 
920
            """Return a list with all the entries that match path for all ids.
 
921
            """
 
922
            dirname, basename = os.path.split(path)
 
923
            key = (dirname, basename, '')
 
924
            block_index, present = state._find_block_index_from_key(key)
 
925
            if not present:
 
926
                # the block which should contain path is absent.
 
927
                return []
 
928
            result = []
 
929
            block = state._dirblocks[block_index][1]
 
930
            entry_index, _ = state._find_entry_index(key, block)
 
931
            # we may need to look at multiple entries at this path: walk while the paths match.
 
932
            while (entry_index < len(block) and
 
933
                block[entry_index][0][0:2] == key[0:2]):
 
934
                result.append(block[entry_index])
 
935
                entry_index += 1
 
936
            return result
 
937
        if require_versioned:
 
938
            # -- check all supplied paths are versioned in a search tree. --
 
939
            all_versioned = True
 
940
            for path in paths:
 
941
                path_entries = _entries_for_path(path)
 
942
                if not path_entries:
 
943
                    # this specified path is not present at all: error
 
944
                    all_versioned = False
 
945
                    break
 
946
                found_versioned = False
 
947
                # for each id at this path
 
948
                for entry in path_entries:
 
949
                    # for each tree.
 
950
                    for index in search_indexes:
 
951
                        if entry[1][index][0] != 'a': # absent
 
952
                            found_versioned = True
 
953
                            # all good: found a versioned cell
 
954
                            break
 
955
                if not found_versioned:
 
956
                    # none of the indexes was not 'absent' at all ids for this
 
957
                    # path.
 
958
                    all_versioned = False
 
959
                    break
 
960
            if not all_versioned:
 
961
                raise errors.PathsNotVersionedError(paths)
 
962
        # -- remove redundancy in supplied paths to prevent over-scanning --
 
963
        search_paths = osutils.minimum_path_selection(paths)
 
964
        # sketch: 
 
965
        # for all search_indexs in each path at or under each element of
 
966
        # search_paths, if the detail is relocated: add the id, and add the
 
967
        # relocated path as one to search if its not searched already. If the
 
968
        # detail is not relocated, add the id.
 
969
        searched_paths = set()
 
970
        found_ids = set()
 
971
        def _process_entry(entry):
 
972
            """Look at search_indexes within entry.
 
973
 
 
974
            If a specific tree's details are relocated, add the relocation
 
975
            target to search_paths if not searched already. If it is absent, do
 
976
            nothing. Otherwise add the id to found_ids.
 
977
            """
 
978
            for index in search_indexes:
 
979
                if entry[1][index][0] == 'r': # relocated
 
980
                    if not osutils.is_inside_any(searched_paths, entry[1][index][1]):
 
981
                        search_paths.add(entry[1][index][1])
 
982
                elif entry[1][index][0] != 'a': # absent
 
983
                    found_ids.add(entry[0][2])
 
984
        while search_paths:
 
985
            current_root = search_paths.pop()
 
986
            searched_paths.add(current_root)
 
987
            # process the entries for this containing directory: the rest will be
 
988
            # found by their parents recursively.
 
989
            root_entries = _entries_for_path(current_root)
 
990
            if not root_entries:
 
991
                # this specified path is not present at all, skip it.
 
992
                continue
 
993
            for entry in root_entries:
 
994
                _process_entry(entry)
 
995
            initial_key = (current_root, '', '')
 
996
            block_index, _ = state._find_block_index_from_key(initial_key)
 
997
            while (block_index < len(state._dirblocks) and
 
998
                osutils.is_inside(current_root, state._dirblocks[block_index][0])):
 
999
                for entry in state._dirblocks[block_index][1]:
 
1000
                    _process_entry(entry)
 
1001
                block_index += 1
 
1002
        return found_ids
 
1003
 
 
1004
    def _paths2ids_using_bisect(self, paths, search_indexes,
 
1005
                                require_versioned=True):
 
1006
        state = self.current_dirstate()
 
1007
        found_ids = set()
 
1008
 
 
1009
        split_paths = sorted(osutils.split(p) for p in paths)
 
1010
        found = state._bisect_recursive(split_paths)
 
1011
 
 
1012
        if require_versioned:
 
1013
            found_dir_names = set(dir_name_id[:2] for dir_name_id in found)
 
1014
            for dir_name in split_paths:
 
1015
                if dir_name not in found_dir_names:
 
1016
                    raise errors.PathsNotVersionedError(paths)
 
1017
 
 
1018
        for dir_name_id, trees_info in found.iteritems():
 
1019
            for index in search_indexes:
 
1020
                if trees_info[index][0] not in ('r', 'a'):
 
1021
                    found_ids.add(dir_name_id[2])
 
1022
        return found_ids
 
1023
 
 
1024
    def read_working_inventory(self):
 
1025
        """Read the working inventory.
 
1026
        
 
1027
        This is a meaningless operation for dirstate, but we obey it anyhow.
 
1028
        """
 
1029
        return self.inventory
 
1030
 
 
1031
    @needs_read_lock
 
1032
    def revision_tree(self, revision_id):
 
1033
        """See Tree.revision_tree.
 
1034
 
 
1035
        WorkingTree4 supplies revision_trees for any basis tree.
 
1036
        """
 
1037
        dirstate = self.current_dirstate()
 
1038
        parent_ids = dirstate.get_parent_ids()
 
1039
        if revision_id not in parent_ids:
 
1040
            raise errors.NoSuchRevisionInTree(self, revision_id)
 
1041
        if revision_id in dirstate.get_ghosts():
 
1042
            raise errors.NoSuchRevisionInTree(self, revision_id)
 
1043
        return DirStateRevisionTree(dirstate, revision_id,
 
1044
            self.branch.repository)
 
1045
 
 
1046
    @needs_tree_write_lock
 
1047
    def set_last_revision(self, new_revision):
 
1048
        """Change the last revision in the working tree."""
 
1049
        parents = self.get_parent_ids()
 
1050
        if new_revision in (NULL_REVISION, None):
 
1051
            if len(parents) >= 2:
 
1052
                raise AssertionError(
 
1053
                    "setting the last parent to none with a pending merge is "
 
1054
                    "unsupported.")
 
1055
            self.set_parent_ids([])
 
1056
        else:
 
1057
            self.set_parent_ids([new_revision] + parents[1:],
 
1058
                allow_leftmost_as_ghost=True)
 
1059
 
 
1060
    @needs_tree_write_lock
 
1061
    def set_parent_ids(self, revision_ids, allow_leftmost_as_ghost=False):
 
1062
        """Set the parent ids to revision_ids.
 
1063
        
 
1064
        See also set_parent_trees. This api will try to retrieve the tree data
 
1065
        for each element of revision_ids from the trees repository. If you have
 
1066
        tree data already available, it is more efficient to use
 
1067
        set_parent_trees rather than set_parent_ids. set_parent_ids is however
 
1068
        an easier API to use.
 
1069
 
 
1070
        :param revision_ids: The revision_ids to set as the parent ids of this
 
1071
            working tree. Any of these may be ghosts.
 
1072
        """
 
1073
        trees = []
 
1074
        for revision_id in revision_ids:
 
1075
            try:
 
1076
                revtree = self.branch.repository.revision_tree(revision_id)
 
1077
                # TODO: jam 20070213 KnitVersionedFile raises
 
1078
                #       RevisionNotPresent rather than NoSuchRevision if a
 
1079
                #       given revision_id is not present. Should Repository be
 
1080
                #       catching it and re-raising NoSuchRevision?
 
1081
            except (errors.NoSuchRevision, errors.RevisionNotPresent):
 
1082
                revtree = None
 
1083
            trees.append((revision_id, revtree))
 
1084
        self.set_parent_trees(trees,
 
1085
            allow_leftmost_as_ghost=allow_leftmost_as_ghost)
 
1086
 
 
1087
    @needs_tree_write_lock
 
1088
    def set_parent_trees(self, parents_list, allow_leftmost_as_ghost=False):
 
1089
        """Set the parents of the working tree.
 
1090
 
 
1091
        :param parents_list: A list of (revision_id, tree) tuples.
 
1092
            If tree is None, then that element is treated as an unreachable
 
1093
            parent tree - i.e. a ghost.
 
1094
        """
 
1095
        dirstate = self.current_dirstate()
 
1096
        if len(parents_list) > 0:
 
1097
            if not allow_leftmost_as_ghost and parents_list[0][1] is None:
 
1098
                raise errors.GhostRevisionUnusableHere(parents_list[0][0])
 
1099
        real_trees = []
 
1100
        ghosts = []
 
1101
 
 
1102
        parent_ids = [rev_id for rev_id, tree in parents_list]
 
1103
        graph = self.branch.repository.get_graph()
 
1104
        heads = graph.heads(parent_ids)
 
1105
        accepted_revisions = set()
 
1106
 
 
1107
        # convert absent trees to the null tree, which we convert back to
 
1108
        # missing on access.
 
1109
        for rev_id, tree in parents_list:
 
1110
            if len(accepted_revisions) > 0:
 
1111
                # we always accept the first tree
 
1112
                if rev_id in accepted_revisions or rev_id not in heads:
 
1113
                    # We have already included either this tree, or its
 
1114
                    # descendent, so we skip it.
 
1115
                    continue
 
1116
            _mod_revision.check_not_reserved_id(rev_id)
 
1117
            if tree is not None:
 
1118
                real_trees.append((rev_id, tree))
 
1119
            else:
 
1120
                real_trees.append((rev_id,
 
1121
                    self.branch.repository.revision_tree(
 
1122
                        _mod_revision.NULL_REVISION)))
 
1123
                ghosts.append(rev_id)
 
1124
            accepted_revisions.add(rev_id)
 
1125
        dirstate.set_parent_trees(real_trees, ghosts=ghosts)
 
1126
        self._make_dirty(reset_inventory=False)
 
1127
 
 
1128
    def _set_root_id(self, file_id):
 
1129
        """See WorkingTree.set_root_id."""
 
1130
        state = self.current_dirstate()
 
1131
        state.set_path_id('', file_id)
 
1132
        if state._dirblock_state == dirstate.DirState.IN_MEMORY_MODIFIED:
 
1133
            self._make_dirty(reset_inventory=True)
 
1134
 
 
1135
    def _sha_from_stat(self, path, stat_result):
 
1136
        """Get a sha digest from the tree's stat cache.
 
1137
 
 
1138
        The default implementation assumes no stat cache is present.
 
1139
 
 
1140
        :param path: The path.
 
1141
        :param stat_result: The stat result being looked up.
 
1142
        """
 
1143
        return self.current_dirstate().sha1_from_stat(path, stat_result)
 
1144
 
 
1145
    @needs_read_lock
 
1146
    def supports_tree_reference(self):
 
1147
        return self._repo_supports_tree_reference
 
1148
 
 
1149
    def unlock(self):
 
1150
        """Unlock in format 4 trees needs to write the entire dirstate."""
 
1151
        # do non-implementation specific cleanup
 
1152
        self._cleanup()
 
1153
 
 
1154
        if self._control_files._lock_count == 1:
 
1155
            # eventually we should do signature checking during read locks for
 
1156
            # dirstate updates.
 
1157
            if self._control_files._lock_mode == 'w':
 
1158
                if self._dirty:
 
1159
                    self.flush()
 
1160
            if self._dirstate is not None:
 
1161
                # This is a no-op if there are no modifications.
 
1162
                self._dirstate.save()
 
1163
                self._dirstate.unlock()
 
1164
            # TODO: jam 20070301 We shouldn't have to wipe the dirstate at this
 
1165
            #       point. Instead, it could check if the header has been
 
1166
            #       modified when it is locked, and if not, it can hang on to
 
1167
            #       the data it has in memory.
 
1168
            self._dirstate = None
 
1169
            self._inventory = None
 
1170
        # reverse order of locking.
 
1171
        try:
 
1172
            return self._control_files.unlock()
 
1173
        finally:
 
1174
            self.branch.unlock()
 
1175
 
 
1176
    @needs_tree_write_lock
 
1177
    def unversion(self, file_ids):
 
1178
        """Remove the file ids in file_ids from the current versioned set.
 
1179
 
 
1180
        When a file_id is unversioned, all of its children are automatically
 
1181
        unversioned.
 
1182
 
 
1183
        :param file_ids: The file ids to stop versioning.
 
1184
        :raises: NoSuchId if any fileid is not currently versioned.
 
1185
        """
 
1186
        if not file_ids:
 
1187
            return
 
1188
        state = self.current_dirstate()
 
1189
        state._read_dirblocks_if_needed()
 
1190
        ids_to_unversion = set(file_ids)
 
1191
        paths_to_unversion = set()
 
1192
        # sketch:
 
1193
        # check if the root is to be unversioned, if so, assert for now.
 
1194
        # walk the state marking unversioned things as absent.
 
1195
        # if there are any un-unversioned ids at the end, raise
 
1196
        for key, details in state._dirblocks[0][1]:
 
1197
            if (details[0][0] not in ('a', 'r') and # absent or relocated
 
1198
                key[2] in ids_to_unversion):
 
1199
                # I haven't written the code to unversion / yet - it should be
 
1200
                # supported.
 
1201
                raise errors.BzrError('Unversioning the / is not currently supported')
 
1202
        block_index = 0
 
1203
        while block_index < len(state._dirblocks):
 
1204
            # process one directory at a time.
 
1205
            block = state._dirblocks[block_index]
 
1206
            # first check: is the path one to remove - it or its children
 
1207
            delete_block = False
 
1208
            for path in paths_to_unversion:
 
1209
                if (block[0].startswith(path) and
 
1210
                    (len(block[0]) == len(path) or
 
1211
                     block[0][len(path)] == '/')):
 
1212
                    # this entire block should be deleted - its the block for a
 
1213
                    # path to unversion; or the child of one
 
1214
                    delete_block = True
 
1215
                    break
 
1216
            # TODO: trim paths_to_unversion as we pass by paths
 
1217
            if delete_block:
 
1218
                # this block is to be deleted: process it.
 
1219
                # TODO: we can special case the no-parents case and
 
1220
                # just forget the whole block.
 
1221
                entry_index = 0
 
1222
                while entry_index < len(block[1]):
 
1223
                    # Mark this file id as having been removed
 
1224
                    entry = block[1][entry_index]
 
1225
                    ids_to_unversion.discard(entry[0][2])
 
1226
                    if (entry[1][0][0] in 'ar' # don't remove absent or renamed
 
1227
                                               # entries
 
1228
                        or not state._make_absent(entry)):
 
1229
                        entry_index += 1
 
1230
                # go to the next block. (At the moment we dont delete empty
 
1231
                # dirblocks)
 
1232
                block_index += 1
 
1233
                continue
 
1234
            entry_index = 0
 
1235
            while entry_index < len(block[1]):
 
1236
                entry = block[1][entry_index]
 
1237
                if (entry[1][0][0] in ('a', 'r') or # absent, relocated
 
1238
                    # ^ some parent row.
 
1239
                    entry[0][2] not in ids_to_unversion):
 
1240
                    # ^ not an id to unversion
 
1241
                    entry_index += 1
 
1242
                    continue
 
1243
                if entry[1][0][0] == 'd':
 
1244
                    paths_to_unversion.add(pathjoin(entry[0][0], entry[0][1]))
 
1245
                if not state._make_absent(entry):
 
1246
                    entry_index += 1
 
1247
                # we have unversioned this id
 
1248
                ids_to_unversion.remove(entry[0][2])
 
1249
            block_index += 1
 
1250
        if ids_to_unversion:
 
1251
            raise errors.NoSuchId(self, iter(ids_to_unversion).next())
 
1252
        self._make_dirty(reset_inventory=False)
 
1253
        # have to change the legacy inventory too.
 
1254
        if self._inventory is not None:
 
1255
            for file_id in file_ids:
 
1256
                self._inventory.remove_recursive_id(file_id)
 
1257
 
 
1258
    @needs_tree_write_lock
 
1259
    def rename_one(self, from_rel, to_rel, after=False):
 
1260
        """See WorkingTree.rename_one"""
 
1261
        self.flush()
 
1262
        WorkingTree.rename_one(self, from_rel, to_rel, after)
 
1263
 
 
1264
    @needs_tree_write_lock
 
1265
    def apply_inventory_delta(self, changes):
 
1266
        """See MutableTree.apply_inventory_delta"""
 
1267
        state = self.current_dirstate()
 
1268
        state.update_by_delta(changes)
 
1269
        self._make_dirty(reset_inventory=True)
 
1270
 
 
1271
    def update_basis_by_delta(self, new_revid, delta):
 
1272
        """See MutableTree.update_basis_by_delta."""
 
1273
        if self.last_revision() == new_revid:
 
1274
            raise AssertionError()
 
1275
        self.current_dirstate().update_basis_by_delta(delta, new_revid)
 
1276
 
 
1277
    @needs_read_lock
 
1278
    def _validate(self):
 
1279
        self._dirstate._validate()
 
1280
 
 
1281
    @needs_tree_write_lock
 
1282
    def _write_inventory(self, inv):
 
1283
        """Write inventory as the current inventory."""
 
1284
        if self._dirty:
 
1285
            raise AssertionError("attempting to write an inventory when the "
 
1286
                "dirstate is dirty will lose pending changes")
 
1287
        self.current_dirstate().set_state_from_inventory(inv)
 
1288
        self._make_dirty(reset_inventory=False)
 
1289
        if self._inventory is not None:
 
1290
            self._inventory = inv
 
1291
        self.flush()
 
1292
 
 
1293
 
 
1294
class WorkingTreeFormat4(WorkingTreeFormat3):
 
1295
    """The first consolidated dirstate working tree format.
 
1296
 
 
1297
    This format:
 
1298
        - exists within a metadir controlling .bzr
 
1299
        - includes an explicit version marker for the workingtree control
 
1300
          files, separate from the BzrDir format
 
1301
        - modifies the hash cache format
 
1302
        - is new in bzr 0.15
 
1303
        - uses a LockDir to guard access to it.
 
1304
    """
 
1305
 
 
1306
    upgrade_recommended = False
 
1307
 
 
1308
    _tree_class = WorkingTree4
 
1309
 
 
1310
    def get_format_string(self):
 
1311
        """See WorkingTreeFormat.get_format_string()."""
 
1312
        return "Bazaar Working Tree Format 4 (bzr 0.15)\n"
 
1313
 
 
1314
    def get_format_description(self):
 
1315
        """See WorkingTreeFormat.get_format_description()."""
 
1316
        return "Working tree format 4"
 
1317
 
 
1318
    def initialize(self, a_bzrdir, revision_id=None, from_branch=None,
 
1319
                   accelerator_tree=None, hardlink=False):
 
1320
        """See WorkingTreeFormat.initialize().
 
1321
 
 
1322
        :param revision_id: allows creating a working tree at a different
 
1323
        revision than the branch is at.
 
1324
        :param accelerator_tree: A tree which can be used for retrieving file
 
1325
            contents more quickly than the revision tree, i.e. a workingtree.
 
1326
            The revision tree will be used for cases where accelerator_tree's
 
1327
            content is different.
 
1328
        :param hardlink: If true, hard-link files from accelerator_tree,
 
1329
            where possible.
 
1330
 
 
1331
        These trees get an initial random root id, if their repository supports
 
1332
        rich root data, TREE_ROOT otherwise.
 
1333
        """
 
1334
        if not isinstance(a_bzrdir.transport, LocalTransport):
 
1335
            raise errors.NotLocalUrl(a_bzrdir.transport.base)
 
1336
        transport = a_bzrdir.get_workingtree_transport(self)
 
1337
        control_files = self._open_control_files(a_bzrdir)
 
1338
        control_files.create_lock()
 
1339
        control_files.lock_write()
 
1340
        transport.put_bytes('format', self.get_format_string(),
 
1341
            mode=a_bzrdir._get_file_mode())
 
1342
        if from_branch is not None:
 
1343
            branch = from_branch
 
1344
        else:
 
1345
            branch = a_bzrdir.open_branch()
 
1346
        if revision_id is None:
 
1347
            revision_id = branch.last_revision()
 
1348
        local_path = transport.local_abspath('dirstate')
 
1349
        # write out new dirstate (must exist when we create the tree)
 
1350
        state = dirstate.DirState.initialize(local_path)
 
1351
        state.unlock()
 
1352
        del state
 
1353
        wt = self._tree_class(a_bzrdir.root_transport.local_abspath('.'),
 
1354
                         branch,
 
1355
                         _format=self,
 
1356
                         _bzrdir=a_bzrdir,
 
1357
                         _control_files=control_files)
 
1358
        wt._new_tree()
 
1359
        wt.lock_tree_write()
 
1360
        try:
 
1361
            self._init_custom_control_files(wt)
 
1362
            if revision_id in (None, NULL_REVISION):
 
1363
                if branch.repository.supports_rich_root():
 
1364
                    wt._set_root_id(generate_ids.gen_root_id())
 
1365
                else:
 
1366
                    wt._set_root_id(ROOT_ID)
 
1367
                wt.flush()
 
1368
            basis = None
 
1369
            # frequently, we will get here due to branching.  The accelerator
 
1370
            # tree will be the tree from the branch, so the desired basis
 
1371
            # tree will often be a parent of the accelerator tree.
 
1372
            if accelerator_tree is not None:
 
1373
                try:
 
1374
                    basis = accelerator_tree.revision_tree(revision_id)
 
1375
                except errors.NoSuchRevision:
 
1376
                    pass
 
1377
            if basis is None:
 
1378
                basis = branch.repository.revision_tree(revision_id)
 
1379
            if revision_id == NULL_REVISION:
 
1380
                parents_list = []
 
1381
            else:
 
1382
                parents_list = [(revision_id, basis)]
 
1383
            basis.lock_read()
 
1384
            try:
 
1385
                wt.set_parent_trees(parents_list, allow_leftmost_as_ghost=True)
 
1386
                wt.flush()
 
1387
                # if the basis has a root id we have to use that; otherwise we
 
1388
                # use a new random one
 
1389
                basis_root_id = basis.get_root_id()
 
1390
                if basis_root_id is not None:
 
1391
                    wt._set_root_id(basis_root_id)
 
1392
                    wt.flush()
 
1393
                # delta_from_tree is safe even for DirStateRevisionTrees,
 
1394
                # because wt4.apply_inventory_delta does not mutate the input
 
1395
                # inventory entries.
 
1396
                transform.build_tree(basis, wt, accelerator_tree,
 
1397
                                     hardlink=hardlink, delta_from_tree=True)
 
1398
            finally:
 
1399
                basis.unlock()
 
1400
        finally:
 
1401
            control_files.unlock()
 
1402
            wt.unlock()
 
1403
        return wt
 
1404
 
 
1405
    def _init_custom_control_files(self, wt):
 
1406
        """Subclasses with custom control files should override this method.
 
1407
        
 
1408
        The working tree and control files are locked for writing when this
 
1409
        method is called.
 
1410
        
 
1411
        :param wt: the WorkingTree object
 
1412
        """
 
1413
 
 
1414
    def _open(self, a_bzrdir, control_files):
 
1415
        """Open the tree itself.
 
1416
 
 
1417
        :param a_bzrdir: the dir for the tree.
 
1418
        :param control_files: the control files for the tree.
 
1419
        """
 
1420
        return self._tree_class(a_bzrdir.root_transport.local_abspath('.'),
 
1421
                           branch=a_bzrdir.open_branch(),
 
1422
                           _format=self,
 
1423
                           _bzrdir=a_bzrdir,
 
1424
                           _control_files=control_files)
 
1425
 
 
1426
    def __get_matchingbzrdir(self):
 
1427
        # please test against something that will let us do tree references
 
1428
        return bzrdir.format_registry.make_bzrdir(
 
1429
            'dirstate-with-subtree')
 
1430
 
 
1431
    _matchingbzrdir = property(__get_matchingbzrdir)
 
1432
 
 
1433
 
 
1434
class DirStateRevisionTree(Tree):
 
1435
    """A revision tree pulling the inventory from a dirstate."""
 
1436
 
 
1437
    def __init__(self, dirstate, revision_id, repository):
 
1438
        self._dirstate = dirstate
 
1439
        self._revision_id = revision_id
 
1440
        self._repository = repository
 
1441
        self._inventory = None
 
1442
        self._locked = 0
 
1443
        self._dirstate_locked = False
 
1444
        self._repo_supports_tree_reference = getattr(
 
1445
            repository._format, "supports_tree_reference",
 
1446
            False)
 
1447
 
 
1448
    def __repr__(self):
 
1449
        return "<%s of %s in %s>" % \
 
1450
            (self.__class__.__name__, self._revision_id, self._dirstate)
 
1451
 
 
1452
    def annotate_iter(self, file_id,
 
1453
                      default_revision=_mod_revision.CURRENT_REVISION):
 
1454
        """See Tree.annotate_iter"""
 
1455
        text_key = (file_id, self.inventory[file_id].revision)
 
1456
        annotations = self._repository.texts.annotate(text_key)
 
1457
        return [(key[-1], line) for (key, line) in annotations]
 
1458
 
 
1459
    def _get_ancestors(self, default_revision):
 
1460
        return set(self._repository.get_ancestry(self._revision_id,
 
1461
                                                 topo_sorted=False))
 
1462
    def _comparison_data(self, entry, path):
 
1463
        """See Tree._comparison_data."""
 
1464
        if entry is None:
 
1465
            return None, False, None
 
1466
        # trust the entry as RevisionTree does, but this may not be
 
1467
        # sensible: the entry might not have come from us?
 
1468
        return entry.kind, entry.executable, None
 
1469
 
 
1470
    def _file_size(self, entry, stat_value):
 
1471
        return entry.text_size
 
1472
 
 
1473
    def filter_unversioned_files(self, paths):
 
1474
        """Filter out paths that are not versioned.
 
1475
 
 
1476
        :return: set of paths.
 
1477
        """
 
1478
        pred = self.has_filename
 
1479
        return set((p for p in paths if not pred(p)))
 
1480
 
 
1481
    def get_root_id(self):
 
1482
        return self.path2id('')
 
1483
 
 
1484
    def id2path(self, file_id):
 
1485
        "Convert a file-id to a path."
 
1486
        entry = self._get_entry(file_id=file_id)
 
1487
        if entry == (None, None):
 
1488
            raise errors.NoSuchId(tree=self, file_id=file_id)
 
1489
        path_utf8 = osutils.pathjoin(entry[0][0], entry[0][1])
 
1490
        return path_utf8.decode('utf8')
 
1491
 
 
1492
    def iter_references(self):
 
1493
        if not self._repo_supports_tree_reference:
 
1494
            # When the repo doesn't support references, we will have nothing to
 
1495
            # return
 
1496
            return iter([])
 
1497
        # Otherwise, fall back to the default implementation
 
1498
        return super(DirStateRevisionTree, self).iter_references()
 
1499
 
 
1500
    def _get_parent_index(self):
 
1501
        """Return the index in the dirstate referenced by this tree."""
 
1502
        return self._dirstate.get_parent_ids().index(self._revision_id) + 1
 
1503
 
 
1504
    def _get_entry(self, file_id=None, path=None):
 
1505
        """Get the dirstate row for file_id or path.
 
1506
 
 
1507
        If either file_id or path is supplied, it is used as the key to lookup.
 
1508
        If both are supplied, the fastest lookup is used, and an error is
 
1509
        raised if they do not both point at the same row.
 
1510
        
 
1511
        :param file_id: An optional unicode file_id to be looked up.
 
1512
        :param path: An optional unicode path to be looked up.
 
1513
        :return: The dirstate row tuple for path/file_id, or (None, None)
 
1514
        """
 
1515
        if file_id is None and path is None:
 
1516
            raise errors.BzrError('must supply file_id or path')
 
1517
        if path is not None:
 
1518
            path = path.encode('utf8')
 
1519
        parent_index = self._get_parent_index()
 
1520
        return self._dirstate._get_entry(parent_index, fileid_utf8=file_id, path_utf8=path)
 
1521
 
 
1522
    def _generate_inventory(self):
 
1523
        """Create and set self.inventory from the dirstate object.
 
1524
 
 
1525
        (So this is only called the first time the inventory is requested for
 
1526
        this tree; it then remains in memory until it's out of date.)
 
1527
 
 
1528
        This is relatively expensive: we have to walk the entire dirstate.
 
1529
        """
 
1530
        if not self._locked:
 
1531
            raise AssertionError(
 
1532
                'cannot generate inventory of an unlocked '
 
1533
                'dirstate revision tree')
 
1534
        # separate call for profiling - makes it clear where the costs are.
 
1535
        self._dirstate._read_dirblocks_if_needed()
 
1536
        if self._revision_id not in self._dirstate.get_parent_ids():
 
1537
            raise AssertionError(
 
1538
                'parent %s has disappeared from %s' % (
 
1539
                self._revision_id, self._dirstate.get_parent_ids()))
 
1540
        parent_index = self._dirstate.get_parent_ids().index(self._revision_id) + 1
 
1541
        # This is identical now to the WorkingTree _generate_inventory except
 
1542
        # for the tree index use.
 
1543
        root_key, current_entry = self._dirstate._get_entry(parent_index, path_utf8='')
 
1544
        current_id = root_key[2]
 
1545
        if current_entry[parent_index][0] != 'd':
 
1546
            raise AssertionError()
 
1547
        inv = Inventory(root_id=current_id, revision_id=self._revision_id)
 
1548
        inv.root.revision = current_entry[parent_index][4]
 
1549
        # Turn some things into local variables
 
1550
        minikind_to_kind = dirstate.DirState._minikind_to_kind
 
1551
        factory = entry_factory
 
1552
        utf8_decode = cache_utf8._utf8_decode
 
1553
        inv_byid = inv._byid
 
1554
        # we could do this straight out of the dirstate; it might be fast
 
1555
        # and should be profiled - RBC 20070216
 
1556
        parent_ies = {'' : inv.root}
 
1557
        for block in self._dirstate._dirblocks[1:]: #skip root
 
1558
            dirname = block[0]
 
1559
            try:
 
1560
                parent_ie = parent_ies[dirname]
 
1561
            except KeyError:
 
1562
                # all the paths in this block are not versioned in this tree
 
1563
                continue
 
1564
            for key, entry in block[1]:
 
1565
                minikind, fingerprint, size, executable, revid = entry[parent_index]
 
1566
                if minikind in ('a', 'r'): # absent, relocated
 
1567
                    # not this tree
 
1568
                    continue
 
1569
                name = key[1]
 
1570
                name_unicode = utf8_decode(name)[0]
 
1571
                file_id = key[2]
 
1572
                kind = minikind_to_kind[minikind]
 
1573
                inv_entry = factory[kind](file_id, name_unicode,
 
1574
                                          parent_ie.file_id)
 
1575
                inv_entry.revision = revid
 
1576
                if kind == 'file':
 
1577
                    inv_entry.executable = executable
 
1578
                    inv_entry.text_size = size
 
1579
                    inv_entry.text_sha1 = fingerprint
 
1580
                elif kind == 'directory':
 
1581
                    parent_ies[(dirname + '/' + name).strip('/')] = inv_entry
 
1582
                elif kind == 'symlink':
 
1583
                    inv_entry.executable = False
 
1584
                    inv_entry.text_size = None
 
1585
                    inv_entry.symlink_target = utf8_decode(fingerprint)[0]
 
1586
                elif kind == 'tree-reference':
 
1587
                    inv_entry.reference_revision = fingerprint or None
 
1588
                else:
 
1589
                    raise AssertionError("cannot convert entry %r into an InventoryEntry"
 
1590
                            % entry)
 
1591
                # These checks cost us around 40ms on a 55k entry tree
 
1592
                if file_id in inv_byid:
 
1593
                    raise AssertionError('file_id %s already in'
 
1594
                        ' inventory as %s' % (file_id, inv_byid[file_id]))
 
1595
                if name_unicode in parent_ie.children:
 
1596
                    raise AssertionError('name %r already in parent'
 
1597
                        % (name_unicode,))
 
1598
                inv_byid[file_id] = inv_entry
 
1599
                parent_ie.children[name_unicode] = inv_entry
 
1600
        self._inventory = inv
 
1601
 
 
1602
    def get_file_mtime(self, file_id, path=None):
 
1603
        """Return the modification time for this record.
 
1604
 
 
1605
        We return the timestamp of the last-changed revision.
 
1606
        """
 
1607
        # Make sure the file exists
 
1608
        entry = self._get_entry(file_id, path=path)
 
1609
        if entry == (None, None): # do we raise?
 
1610
            return None
 
1611
        parent_index = self._get_parent_index()
 
1612
        last_changed_revision = entry[1][parent_index][4]
 
1613
        return self._repository.get_revision(last_changed_revision).timestamp
 
1614
 
 
1615
    def get_file_sha1(self, file_id, path=None, stat_value=None):
 
1616
        entry = self._get_entry(file_id=file_id, path=path)
 
1617
        parent_index = self._get_parent_index()
 
1618
        parent_details = entry[1][parent_index]
 
1619
        if parent_details[0] == 'f':
 
1620
            return parent_details[1]
 
1621
        return None
 
1622
 
 
1623
    def get_file(self, file_id, path=None):
 
1624
        return StringIO(self.get_file_text(file_id))
 
1625
 
 
1626
    def get_file_size(self, file_id):
 
1627
        """See Tree.get_file_size"""
 
1628
        return self.inventory[file_id].text_size
 
1629
 
 
1630
    def get_file_text(self, file_id, path=None):
 
1631
        return list(self.iter_files_bytes([(file_id, None)]))[0][1]
 
1632
 
 
1633
    def get_reference_revision(self, file_id, path=None):
 
1634
        return self.inventory[file_id].reference_revision
 
1635
 
 
1636
    def iter_files_bytes(self, desired_files):
 
1637
        """See Tree.iter_files_bytes.
 
1638
 
 
1639
        This version is implemented on top of Repository.iter_files_bytes"""
 
1640
        parent_index = self._get_parent_index()
 
1641
        repo_desired_files = []
 
1642
        for file_id, identifier in desired_files:
 
1643
            entry = self._get_entry(file_id)
 
1644
            if entry == (None, None):
 
1645
                raise errors.NoSuchId(self, file_id)
 
1646
            repo_desired_files.append((file_id, entry[1][parent_index][4],
 
1647
                                       identifier))
 
1648
        return self._repository.iter_files_bytes(repo_desired_files)
 
1649
 
 
1650
    def get_symlink_target(self, file_id):
 
1651
        entry = self._get_entry(file_id=file_id)
 
1652
        parent_index = self._get_parent_index()
 
1653
        if entry[1][parent_index][0] != 'l':
 
1654
            return None
 
1655
        else:
 
1656
            # At present, none of the tree implementations supports non-ascii
 
1657
            # symlink targets. So we will just assume that the dirstate path is
 
1658
            # correct.
 
1659
            return entry[1][parent_index][1]
 
1660
 
 
1661
    def get_revision_id(self):
 
1662
        """Return the revision id for this tree."""
 
1663
        return self._revision_id
 
1664
 
 
1665
    def _get_inventory(self):
 
1666
        if self._inventory is not None:
 
1667
            return self._inventory
 
1668
        self._must_be_locked()
 
1669
        self._generate_inventory()
 
1670
        return self._inventory
 
1671
 
 
1672
    inventory = property(_get_inventory,
 
1673
                         doc="Inventory of this Tree")
 
1674
 
 
1675
    def get_parent_ids(self):
 
1676
        """The parents of a tree in the dirstate are not cached."""
 
1677
        return self._repository.get_revision(self._revision_id).parent_ids
 
1678
 
 
1679
    def has_filename(self, filename):
 
1680
        return bool(self.path2id(filename))
 
1681
 
 
1682
    def kind(self, file_id):
 
1683
        entry = self._get_entry(file_id=file_id)[1]
 
1684
        if entry is None:
 
1685
            raise errors.NoSuchId(tree=self, file_id=file_id)
 
1686
        return dirstate.DirState._minikind_to_kind[entry[1][0]]
 
1687
 
 
1688
    def stored_kind(self, file_id):
 
1689
        """See Tree.stored_kind"""
 
1690
        return self.kind(file_id)
 
1691
 
 
1692
    def path_content_summary(self, path):
 
1693
        """See Tree.path_content_summary."""
 
1694
        id = self.inventory.path2id(path)
 
1695
        if id is None:
 
1696
            return ('missing', None, None, None)
 
1697
        entry = self._inventory[id]
 
1698
        kind = entry.kind
 
1699
        if kind == 'file':
 
1700
            return (kind, entry.text_size, entry.executable, entry.text_sha1)
 
1701
        elif kind == 'symlink':
 
1702
            return (kind, None, None, entry.symlink_target)
 
1703
        else:
 
1704
            return (kind, None, None, None)
 
1705
 
 
1706
    def is_executable(self, file_id, path=None):
 
1707
        ie = self.inventory[file_id]
 
1708
        if ie.kind != "file":
 
1709
            return None
 
1710
        return ie.executable
 
1711
 
 
1712
    def list_files(self, include_root=False):
 
1713
        # We use a standard implementation, because DirStateRevisionTree is
 
1714
        # dealing with one of the parents of the current state
 
1715
        inv = self._get_inventory()
 
1716
        entries = inv.iter_entries()
 
1717
        if self.inventory.root is not None and not include_root:
 
1718
            entries.next()
 
1719
        for path, entry in entries:
 
1720
            yield path, 'V', entry.kind, entry.file_id, entry
 
1721
 
 
1722
    def lock_read(self):
 
1723
        """Lock the tree for a set of operations."""
 
1724
        if not self._locked:
 
1725
            self._repository.lock_read()
 
1726
            if self._dirstate._lock_token is None:
 
1727
                self._dirstate.lock_read()
 
1728
                self._dirstate_locked = True
 
1729
        self._locked += 1
 
1730
 
 
1731
    def _must_be_locked(self):
 
1732
        if not self._locked:
 
1733
            raise errors.ObjectNotLocked(self)
 
1734
 
 
1735
    @needs_read_lock
 
1736
    def path2id(self, path):
 
1737
        """Return the id for path in this tree."""
 
1738
        # lookup by path: faster than splitting and walking the ivnentory.
 
1739
        entry = self._get_entry(path=path)
 
1740
        if entry == (None, None):
 
1741
            return None
 
1742
        return entry[0][2]
 
1743
 
 
1744
    def unlock(self):
 
1745
        """Unlock, freeing any cache memory used during the lock."""
 
1746
        # outside of a lock, the inventory is suspect: release it.
 
1747
        self._locked -=1
 
1748
        if not self._locked:
 
1749
            self._inventory = None
 
1750
            self._locked = 0
 
1751
            if self._dirstate_locked:
 
1752
                self._dirstate.unlock()
 
1753
                self._dirstate_locked = False
 
1754
            self._repository.unlock()
 
1755
 
 
1756
    @needs_read_lock
 
1757
    def supports_tree_reference(self):
 
1758
        return self._repo_supports_tree_reference
 
1759
 
 
1760
    def walkdirs(self, prefix=""):
 
1761
        # TODO: jam 20070215 This is the lazy way by using the RevisionTree
 
1762
        # implementation based on an inventory.  
 
1763
        # This should be cleaned up to use the much faster Dirstate code
 
1764
        # So for now, we just build up the parent inventory, and extract
 
1765
        # it the same way RevisionTree does.
 
1766
        _directory = 'directory'
 
1767
        inv = self._get_inventory()
 
1768
        top_id = inv.path2id(prefix)
 
1769
        if top_id is None:
 
1770
            pending = []
 
1771
        else:
 
1772
            pending = [(prefix, top_id)]
 
1773
        while pending:
 
1774
            dirblock = []
 
1775
            relpath, file_id = pending.pop()
 
1776
            # 0 - relpath, 1- file-id
 
1777
            if relpath:
 
1778
                relroot = relpath + '/'
 
1779
            else:
 
1780
                relroot = ""
 
1781
            # FIXME: stash the node in pending
 
1782
            entry = inv[file_id]
 
1783
            for name, child in entry.sorted_children():
 
1784
                toppath = relroot + name
 
1785
                dirblock.append((toppath, name, child.kind, None,
 
1786
                    child.file_id, child.kind
 
1787
                    ))
 
1788
            yield (relpath, entry.file_id), dirblock
 
1789
            # push the user specified dirs from dirblock
 
1790
            for dir in reversed(dirblock):
 
1791
                if dir[2] == _directory:
 
1792
                    pending.append((dir[0], dir[4]))
 
1793
 
 
1794
 
 
1795
class InterDirStateTree(InterTree):
 
1796
    """Fast path optimiser for changes_from with dirstate trees.
 
1797
    
 
1798
    This is used only when both trees are in the dirstate working file, and 
 
1799
    the source is any parent within the dirstate, and the destination is 
 
1800
    the current working tree of the same dirstate.
 
1801
    """
 
1802
    # this could be generalized to allow comparisons between any trees in the
 
1803
    # dirstate, and possibly between trees stored in different dirstates.
 
1804
 
 
1805
    def __init__(self, source, target):
 
1806
        super(InterDirStateTree, self).__init__(source, target)
 
1807
        if not InterDirStateTree.is_compatible(source, target):
 
1808
            raise Exception, "invalid source %r and target %r" % (source, target)
 
1809
 
 
1810
    @staticmethod
 
1811
    def make_source_parent_tree(source, target):
 
1812
        """Change the source tree into a parent of the target."""
 
1813
        revid = source.commit('record tree')
 
1814
        target.branch.repository.fetch(source.branch.repository, revid)
 
1815
        target.set_parent_ids([revid])
 
1816
        return target.basis_tree(), target
 
1817
 
 
1818
    @classmethod
 
1819
    def make_source_parent_tree_python_dirstate(klass, test_case, source, target):
 
1820
        result = klass.make_source_parent_tree(source, target)
 
1821
        result[1]._iter_changes = dirstate.ProcessEntryPython
 
1822
        return result
 
1823
 
 
1824
    @classmethod
 
1825
    def make_source_parent_tree_compiled_dirstate(klass, test_case, source, target):
 
1826
        from bzrlib.tests.test__dirstate_helpers import \
 
1827
            CompiledDirstateHelpersFeature
 
1828
        if not CompiledDirstateHelpersFeature.available():
 
1829
            from bzrlib.tests import UnavailableFeature
 
1830
            raise UnavailableFeature(CompiledDirstateHelpersFeature)
 
1831
        from bzrlib._dirstate_helpers_c import ProcessEntryC
 
1832
        result = klass.make_source_parent_tree(source, target)
 
1833
        result[1]._iter_changes = ProcessEntryC
 
1834
        return result
 
1835
 
 
1836
    _matching_from_tree_format = WorkingTreeFormat4()
 
1837
    _matching_to_tree_format = WorkingTreeFormat4()
 
1838
 
 
1839
    @classmethod
 
1840
    def _test_mutable_trees_to_test_trees(klass, test_case, source, target):
 
1841
        # This method shouldn't be called, because we have python and C
 
1842
        # specific flavours.
 
1843
        raise NotImplementedError
 
1844
 
 
1845
    def iter_changes(self, include_unchanged=False,
 
1846
                      specific_files=None, pb=None, extra_trees=[],
 
1847
                      require_versioned=True, want_unversioned=False):
 
1848
        """Return the changes from source to target.
 
1849
 
 
1850
        :return: An iterator that yields tuples. See InterTree.iter_changes
 
1851
            for details.
 
1852
        :param specific_files: An optional list of file paths to restrict the
 
1853
            comparison to. When mapping filenames to ids, all matches in all
 
1854
            trees (including optional extra_trees) are used, and all children of
 
1855
            matched directories are included.
 
1856
        :param include_unchanged: An optional boolean requesting the inclusion of
 
1857
            unchanged entries in the result.
 
1858
        :param extra_trees: An optional list of additional trees to use when
 
1859
            mapping the contents of specific_files (paths) to file_ids.
 
1860
        :param require_versioned: If True, all files in specific_files must be
 
1861
            versioned in one of source, target, extra_trees or
 
1862
            PathsNotVersionedError is raised.
 
1863
        :param want_unversioned: Should unversioned files be returned in the
 
1864
            output. An unversioned file is defined as one with (False, False)
 
1865
            for the versioned pair.
 
1866
        """
 
1867
        # NB: show_status depends on being able to pass in non-versioned files
 
1868
        # and report them as unknown
 
1869
        # TODO: handle extra trees in the dirstate.
 
1870
        if (extra_trees or specific_files == []):
 
1871
            # we can't fast-path these cases (yet)
 
1872
            return super(InterDirStateTree, self).iter_changes(
 
1873
                include_unchanged, specific_files, pb, extra_trees,
 
1874
                require_versioned, want_unversioned=want_unversioned)
 
1875
        parent_ids = self.target.get_parent_ids()
 
1876
        if not (self.source._revision_id in parent_ids
 
1877
                or self.source._revision_id == NULL_REVISION):
 
1878
            raise AssertionError(
 
1879
                "revision {%s} is not stored in {%s}, but %s "
 
1880
                "can only be used for trees stored in the dirstate"
 
1881
                % (self.source._revision_id, self.target, self.iter_changes))
 
1882
        target_index = 0
 
1883
        if self.source._revision_id == NULL_REVISION:
 
1884
            source_index = None
 
1885
            indices = (target_index,)
 
1886
        else:
 
1887
            if not (self.source._revision_id in parent_ids):
 
1888
                raise AssertionError(
 
1889
                    "Failure: source._revision_id: %s not in target.parent_ids(%s)" % (
 
1890
                    self.source._revision_id, parent_ids))
 
1891
            source_index = 1 + parent_ids.index(self.source._revision_id)
 
1892
            indices = (source_index, target_index)
 
1893
        # -- make all specific_files utf8 --
 
1894
        if specific_files:
 
1895
            specific_files_utf8 = set()
 
1896
            for path in specific_files:
 
1897
                # Note, if there are many specific files, using cache_utf8
 
1898
                # would be good here.
 
1899
                specific_files_utf8.add(path.encode('utf8'))
 
1900
            specific_files = specific_files_utf8
 
1901
        else:
 
1902
            specific_files = set([''])
 
1903
        # -- specific_files is now a utf8 path set --
 
1904
        search_specific_files = set()
 
1905
        # -- get the state object and prepare it.
 
1906
        state = self.target.current_dirstate()
 
1907
        state._read_dirblocks_if_needed()
 
1908
        if require_versioned:
 
1909
            # -- check all supplied paths are versioned in a search tree. --
 
1910
            all_versioned = True
 
1911
            for path in specific_files:
 
1912
                path_entries = state._entries_for_path(path)
 
1913
                if not path_entries:
 
1914
                    # this specified path is not present at all: error
 
1915
                    all_versioned = False
 
1916
                    break
 
1917
                found_versioned = False
 
1918
                # for each id at this path
 
1919
                for entry in path_entries:
 
1920
                    # for each tree.
 
1921
                    for index in indices:
 
1922
                        if entry[1][index][0] != 'a': # absent
 
1923
                            found_versioned = True
 
1924
                            # all good: found a versioned cell
 
1925
                            break
 
1926
                if not found_versioned:
 
1927
                    # none of the indexes was not 'absent' at all ids for this
 
1928
                    # path.
 
1929
                    all_versioned = False
 
1930
                    break
 
1931
            if not all_versioned:
 
1932
                raise errors.PathsNotVersionedError(specific_files)
 
1933
        # -- remove redundancy in supplied specific_files to prevent over-scanning --
 
1934
        for path in specific_files:
 
1935
            other_specific_files = specific_files.difference(set([path]))
 
1936
            if not osutils.is_inside_any(other_specific_files, path):
 
1937
                # this is a top level path, we must check it.
 
1938
                search_specific_files.add(path)
 
1939
 
 
1940
        use_filesystem_for_exec = (sys.platform != 'win32')
 
1941
        iter_changes = self.target._iter_changes(include_unchanged,
 
1942
            use_filesystem_for_exec, search_specific_files, state,
 
1943
            source_index, target_index, want_unversioned, self.target)
 
1944
        return iter_changes.iter_changes()
 
1945
 
 
1946
    @staticmethod
 
1947
    def is_compatible(source, target):
 
1948
        # the target must be a dirstate working tree
 
1949
        if not isinstance(target, WorkingTree4):
 
1950
            return False
 
1951
        # the source must be a revtreee or dirstate rev tree.
 
1952
        if not isinstance(source,
 
1953
            (revisiontree.RevisionTree, DirStateRevisionTree)):
 
1954
            return False
 
1955
        # the source revid must be in the target dirstate
 
1956
        if not (source._revision_id == NULL_REVISION or
 
1957
            source._revision_id in target.get_parent_ids()):
 
1958
            # TODO: what about ghosts? it may well need to 
 
1959
            # check for them explicitly.
 
1960
            return False
 
1961
        return True
 
1962
 
 
1963
InterTree.register_optimiser(InterDirStateTree)
 
1964
 
 
1965
 
 
1966
class Converter3to4(object):
 
1967
    """Perform an in-place upgrade of format 3 to format 4 trees."""
 
1968
 
 
1969
    def __init__(self):
 
1970
        self.target_format = WorkingTreeFormat4()
 
1971
 
 
1972
    def convert(self, tree):
 
1973
        # lock the control files not the tree, so that we dont get tree
 
1974
        # on-unlock behaviours, and so that noone else diddles with the 
 
1975
        # tree during upgrade.
 
1976
        tree._control_files.lock_write()
 
1977
        try:
 
1978
            tree.read_working_inventory()
 
1979
            self.create_dirstate_data(tree)
 
1980
            self.update_format(tree)
 
1981
            self.remove_xml_files(tree)
 
1982
        finally:
 
1983
            tree._control_files.unlock()
 
1984
 
 
1985
    def create_dirstate_data(self, tree):
 
1986
        """Create the dirstate based data for tree."""
 
1987
        local_path = tree.bzrdir.get_workingtree_transport(None
 
1988
            ).local_abspath('dirstate')
 
1989
        state = dirstate.DirState.from_tree(tree, local_path)
 
1990
        state.save()
 
1991
        state.unlock()
 
1992
 
 
1993
    def remove_xml_files(self, tree):
 
1994
        """Remove the oldformat 3 data."""
 
1995
        transport = tree.bzrdir.get_workingtree_transport(None)
 
1996
        for path in ['basis-inventory-cache', 'inventory', 'last-revision',
 
1997
            'pending-merges', 'stat-cache']:
 
1998
            try:
 
1999
                transport.delete(path)
 
2000
            except errors.NoSuchFile:
 
2001
                # some files are optional - just deal.
 
2002
                pass
 
2003
 
 
2004
    def update_format(self, tree):
 
2005
        """Change the format marker."""
 
2006
        tree._transport.put_bytes('format',
 
2007
            self.target_format.get_format_string(),
 
2008
            mode=tree.bzrdir._get_file_mode())