~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/workingtree_4.py

  • Committer: Martin Pool
  • Date: 2007-07-11 06:47:30 UTC
  • mto: This revision was merged to the branch mainline in revision 2612.
  • Revision ID: mbp@sourcefrog.net-20070711064730-pwnhisgp2caf7nar
Don't show dots progress indicatiors in noninteractive mode

Show diffs side-by-side

added added

removed removed

Lines of Context:
 
1
# Copyright (C) 2005, 2006, 2007 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
    delta,
 
47
    dirstate,
 
48
    errors,
 
49
    generate_ids,
 
50
    globbing,
 
51
    hashcache,
 
52
    ignores,
 
53
    merge,
 
54
    osutils,
 
55
    revisiontree,
 
56
    textui,
 
57
    transform,
 
58
    urlutils,
 
59
    xml5,
 
60
    xml6,
 
61
    )
 
62
import bzrlib.branch
 
63
from bzrlib.transport import get_transport
 
64
import bzrlib.ui
 
65
""")
 
66
 
 
67
from bzrlib import symbol_versioning
 
68
from bzrlib.decorators import needs_read_lock, needs_write_lock
 
69
from bzrlib.inventory import InventoryEntry, Inventory, ROOT_ID, entry_factory
 
70
from bzrlib.lockable_files import LockableFiles, TransportLock
 
71
from bzrlib.lockdir import LockDir
 
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
# This is the Windows equivalent of ENOTDIR
 
100
# It is defined in pywin32.winerror, but we don't want a strong dependency for
 
101
# just an error code.
 
102
ERROR_PATH_NOT_FOUND = 3
 
103
ERROR_DIRECTORY = 267
 
104
 
 
105
 
 
106
class WorkingTree4(WorkingTree3):
 
107
    """This is the Format 4 working tree.
 
108
 
 
109
    This differs from WorkingTree3 by:
 
110
     - Having a consolidated internal dirstate, stored in a
 
111
       randomly-accessible sorted file on disk.
 
112
     - Not having a regular inventory attribute.  One can be synthesized 
 
113
       on demand but this is expensive and should be avoided.
 
114
 
 
115
    This is new in bzr 0.15.
 
116
    """
 
117
 
 
118
    def __init__(self, basedir,
 
119
                 branch,
 
120
                 _control_files=None,
 
121
                 _format=None,
 
122
                 _bzrdir=None):
 
123
        """Construct a WorkingTree for basedir.
 
124
 
 
125
        If the branch is not supplied, it is opened automatically.
 
126
        If the branch is supplied, it must be the branch for this basedir.
 
127
        (branch.base is not cross checked, because for remote branches that
 
128
        would be meaningless).
 
129
        """
 
130
        self._format = _format
 
131
        self.bzrdir = _bzrdir
 
132
        from bzrlib.trace import note, mutter
 
133
        assert isinstance(basedir, basestring), \
 
134
            "base directory %r is not a string" % basedir
 
135
        basedir = safe_unicode(basedir)
 
136
        mutter("opening working tree %r", basedir)
 
137
        self._branch = branch
 
138
        assert isinstance(self.branch, bzrlib.branch.Branch), \
 
139
            "branch %r is not a Branch" % self.branch
 
140
        self.basedir = realpath(basedir)
 
141
        # if branch is at our basedir and is a format 6 or less
 
142
        # assume all other formats have their own control files.
 
143
        assert isinstance(_control_files, LockableFiles), \
 
144
            "_control_files must be a LockableFiles, not %r" % _control_files
 
145
        self._control_files = _control_files
 
146
        self._dirty = None
 
147
        #-------------
 
148
        # during a read or write lock these objects are set, and are
 
149
        # None the rest of the time.
 
150
        self._dirstate = None
 
151
        self._inventory = None
 
152
        #-------------
 
153
 
 
154
    @needs_tree_write_lock
 
155
    def _add(self, files, ids, kinds):
 
156
        """See MutableTree._add."""
 
157
        state = self.current_dirstate()
 
158
        for f, file_id, kind in zip(files, ids, kinds):
 
159
            f = f.strip('/')
 
160
            assert '//' not in f
 
161
            assert '..' not in f
 
162
            if self.path2id(f):
 
163
                # special case tree root handling.
 
164
                if f == '' and self.path2id(f) == ROOT_ID:
 
165
                    state.set_path_id('', generate_ids.gen_file_id(f))
 
166
                continue
 
167
            if file_id is None:
 
168
                file_id = generate_ids.gen_file_id(f)
 
169
            # deliberately add the file with no cached stat or sha1
 
170
            # - on the first access it will be gathered, and we can
 
171
            # always change this once tests are all passing.
 
172
            state.add(f, file_id, kind, None, '')
 
173
        self._make_dirty(reset_inventory=True)
 
174
 
 
175
    def _make_dirty(self, reset_inventory):
 
176
        """Make the tree state dirty.
 
177
 
 
178
        :param reset_inventory: True if the cached inventory should be removed
 
179
            (presuming there is one).
 
180
        """
 
181
        self._dirty = True
 
182
        if reset_inventory and self._inventory is not None:
 
183
            self._inventory = None
 
184
 
 
185
    @needs_tree_write_lock
 
186
    def add_reference(self, sub_tree):
 
187
        # use standard implementation, which calls back to self._add
 
188
        # 
 
189
        # So we don't store the reference_revision in the working dirstate,
 
190
        # it's just recorded at the moment of commit. 
 
191
        self._add_reference(sub_tree)
 
192
 
 
193
    def break_lock(self):
 
194
        """Break a lock if one is present from another instance.
 
195
 
 
196
        Uses the ui factory to ask for confirmation if the lock may be from
 
197
        an active process.
 
198
 
 
199
        This will probe the repository for its lock as well.
 
200
        """
 
201
        # if the dirstate is locked by an active process, reject the break lock
 
202
        # call.
 
203
        try:
 
204
            if self._dirstate is None:
 
205
                clear = True
 
206
            else:
 
207
                clear = False
 
208
            state = self._current_dirstate()
 
209
            if state._lock_token is not None:
 
210
                # we already have it locked. sheese, cant break our own lock.
 
211
                raise errors.LockActive(self.basedir)
 
212
            else:
 
213
                try:
 
214
                    # try for a write lock - need permission to get one anyhow
 
215
                    # to break locks.
 
216
                    state.lock_write()
 
217
                except errors.LockContention:
 
218
                    # oslocks fail when a process is still live: fail.
 
219
                    # TODO: get the locked lockdir info and give to the user to
 
220
                    # assist in debugging.
 
221
                    raise errors.LockActive(self.basedir)
 
222
                else:
 
223
                    state.unlock()
 
224
        finally:
 
225
            if clear:
 
226
                self._dirstate = None
 
227
        self._control_files.break_lock()
 
228
        self.branch.break_lock()
 
229
 
 
230
    def _comparison_data(self, entry, path):
 
231
        kind, executable, stat_value = \
 
232
            WorkingTree3._comparison_data(self, entry, path)
 
233
        # it looks like a plain directory, but it's really a reference -- see
 
234
        # also kind()
 
235
        if (self._repo_supports_tree_reference and
 
236
            kind == 'directory' and
 
237
            self._directory_is_tree_reference(path)):
 
238
            kind = 'tree-reference'
 
239
        return kind, executable, stat_value
 
240
 
 
241
    @needs_write_lock
 
242
    def commit(self, message=None, revprops=None, *args, **kwargs):
 
243
        # mark the tree as dirty post commit - commit
 
244
        # can change the current versioned list by doing deletes.
 
245
        result = WorkingTree3.commit(self, message, revprops, *args, **kwargs)
 
246
        self._make_dirty(reset_inventory=True)
 
247
        return result
 
248
 
 
249
    def current_dirstate(self):
 
250
        """Return the current dirstate object.
 
251
 
 
252
        This is not part of the tree interface and only exposed for ease of
 
253
        testing.
 
254
 
 
255
        :raises errors.NotWriteLocked: when not in a lock.
 
256
        """
 
257
        self._must_be_locked()
 
258
        return self._current_dirstate()
 
259
 
 
260
    def _current_dirstate(self):
 
261
        """Internal function that does not check lock status.
 
262
 
 
263
        This is needed for break_lock which also needs the dirstate.
 
264
        """
 
265
        if self._dirstate is not None:
 
266
            return self._dirstate
 
267
        local_path = self.bzrdir.get_workingtree_transport(None
 
268
            ).local_abspath('dirstate')
 
269
        self._dirstate = dirstate.DirState.on_file(local_path)
 
270
        return self._dirstate
 
271
 
 
272
    def _directory_is_tree_reference(self, relpath):
 
273
        # as a special case, if a directory contains control files then 
 
274
        # it's a tree reference, except that the root of the tree is not
 
275
        return relpath and osutils.isdir(self.abspath(relpath) + u"/.bzr")
 
276
        # TODO: We could ask all the control formats whether they
 
277
        # recognize this directory, but at the moment there's no cheap api
 
278
        # to do that.  Since we probably can only nest bzr checkouts and
 
279
        # they always use this name it's ok for now.  -- mbp 20060306
 
280
        #
 
281
        # FIXME: There is an unhandled case here of a subdirectory
 
282
        # containing .bzr but not a branch; that will probably blow up
 
283
        # when you try to commit it.  It might happen if there is a
 
284
        # checkout in a subdirectory.  This can be avoided by not adding
 
285
        # it.  mbp 20070306
 
286
 
 
287
    def filter_unversioned_files(self, paths):
 
288
        """Filter out paths that are versioned.
 
289
 
 
290
        :return: set of paths.
 
291
        """
 
292
        # TODO: make a generic multi-bisect routine roughly that should list
 
293
        # the paths, then process one half at a time recursively, and feed the
 
294
        # results of each bisect in further still
 
295
        paths = sorted(paths)
 
296
        result = set()
 
297
        state = self.current_dirstate()
 
298
        # TODO we want a paths_to_dirblocks helper I think
 
299
        for path in paths:
 
300
            dirname, basename = os.path.split(path.encode('utf8'))
 
301
            _, _, _, path_is_versioned = state._get_block_entry_index(
 
302
                dirname, basename, 0)
 
303
            if not path_is_versioned:
 
304
                result.add(path)
 
305
        return result
 
306
 
 
307
    def flush(self):
 
308
        """Write all cached data to disk."""
 
309
        if self._control_files._lock_mode != 'w':
 
310
            raise errors.NotWriteLocked(self)
 
311
        self.current_dirstate().save()
 
312
        self._inventory = None
 
313
        self._dirty = False
 
314
 
 
315
    @needs_tree_write_lock
 
316
    def _gather_kinds(self, files, kinds):
 
317
        """See MutableTree._gather_kinds."""
 
318
        for pos, f in enumerate(files):
 
319
            if kinds[pos] is None:
 
320
                kinds[pos] = self._kind(f)
 
321
 
 
322
    def _generate_inventory(self):
 
323
        """Create and set self.inventory from the dirstate object.
 
324
        
 
325
        This is relatively expensive: we have to walk the entire dirstate.
 
326
        Ideally we would not, and can deprecate this function.
 
327
        """
 
328
        #: uncomment to trap on inventory requests.
 
329
        # import pdb;pdb.set_trace()
 
330
        state = self.current_dirstate()
 
331
        state._read_dirblocks_if_needed()
 
332
        root_key, current_entry = self._get_entry(path='')
 
333
        current_id = root_key[2]
 
334
        assert current_entry[0][0] == 'd' # directory
 
335
        inv = Inventory(root_id=current_id)
 
336
        # Turn some things into local variables
 
337
        minikind_to_kind = dirstate.DirState._minikind_to_kind
 
338
        factory = entry_factory
 
339
        utf8_decode = cache_utf8._utf8_decode
 
340
        inv_byid = inv._byid
 
341
        # we could do this straight out of the dirstate; it might be fast
 
342
        # and should be profiled - RBC 20070216
 
343
        parent_ies = {'' : inv.root}
 
344
        for block in state._dirblocks[1:]: # skip the root
 
345
            dirname = block[0]
 
346
            try:
 
347
                parent_ie = parent_ies[dirname]
 
348
            except KeyError:
 
349
                # all the paths in this block are not versioned in this tree
 
350
                continue
 
351
            for key, entry in block[1]:
 
352
                minikind, link_or_sha1, size, executable, stat = entry[0]
 
353
                if minikind in ('a', 'r'): # absent, relocated
 
354
                    # a parent tree only entry
 
355
                    continue
 
356
                name = key[1]
 
357
                name_unicode = utf8_decode(name)[0]
 
358
                file_id = key[2]
 
359
                kind = minikind_to_kind[minikind]
 
360
                inv_entry = factory[kind](file_id, name_unicode,
 
361
                                          parent_ie.file_id)
 
362
                if kind == 'file':
 
363
                    # This is only needed on win32, where this is the only way
 
364
                    # we know the executable bit.
 
365
                    inv_entry.executable = executable
 
366
                    # not strictly needed: working tree
 
367
                    #inv_entry.text_size = size
 
368
                    #inv_entry.text_sha1 = sha1
 
369
                elif kind == 'directory':
 
370
                    # add this entry to the parent map.
 
371
                    parent_ies[(dirname + '/' + name).strip('/')] = inv_entry
 
372
                elif kind == 'tree-reference':
 
373
                    assert self._repo_supports_tree_reference, \
 
374
                        "repository of %r " \
 
375
                        "doesn't support tree references " \
 
376
                        "required by entry %r" \
 
377
                        % (self, name)
 
378
                    inv_entry.reference_revision = link_or_sha1 or None
 
379
                elif kind != 'symlink':
 
380
                    raise AssertionError("unknown kind %r" % kind)
 
381
                # These checks cost us around 40ms on a 55k entry tree
 
382
                assert file_id not in inv_byid, ('file_id %s already in'
 
383
                    ' inventory as %s' % (file_id, inv_byid[file_id]))
 
384
                assert name_unicode not in parent_ie.children
 
385
                inv_byid[file_id] = inv_entry
 
386
                parent_ie.children[name_unicode] = inv_entry
 
387
        self._inventory = inv
 
388
 
 
389
    def _get_entry(self, file_id=None, path=None):
 
390
        """Get the dirstate row for file_id or path.
 
391
 
 
392
        If either file_id or path is supplied, it is used as the key to lookup.
 
393
        If both are supplied, the fastest lookup is used, and an error is
 
394
        raised if they do not both point at the same row.
 
395
        
 
396
        :param file_id: An optional unicode file_id to be looked up.
 
397
        :param path: An optional unicode path to be looked up.
 
398
        :return: The dirstate row tuple for path/file_id, or (None, None)
 
399
        """
 
400
        if file_id is None and path is None:
 
401
            raise errors.BzrError('must supply file_id or path')
 
402
        state = self.current_dirstate()
 
403
        if path is not None:
 
404
            path = path.encode('utf8')
 
405
        return state._get_entry(0, fileid_utf8=file_id, path_utf8=path)
 
406
 
 
407
    def get_file_sha1(self, file_id, path=None, stat_value=None):
 
408
        # check file id is valid unconditionally.
 
409
        entry = self._get_entry(file_id=file_id, path=path)
 
410
        assert entry[0] is not None, 'what error should this raise'
 
411
        if path is None:
 
412
            path = pathjoin(entry[0][0], entry[0][1]).decode('utf8')
 
413
 
 
414
        file_abspath = self.abspath(path)
 
415
        state = self.current_dirstate()
 
416
        if stat_value is None:
 
417
            try:
 
418
                stat_value = os.lstat(file_abspath)
 
419
            except OSError, e:
 
420
                if e.errno == errno.ENOENT:
 
421
                    return None
 
422
                else:
 
423
                    raise
 
424
        link_or_sha1 = state.update_entry(entry, file_abspath,
 
425
                                          stat_value=stat_value)
 
426
        if entry[1][0][0] == 'f':
 
427
            return link_or_sha1
 
428
        return None
 
429
 
 
430
    def _get_inventory(self):
 
431
        """Get the inventory for the tree. This is only valid within a lock."""
 
432
        if self._inventory is not None:
 
433
            return self._inventory
 
434
        self._must_be_locked()
 
435
        self._generate_inventory()
 
436
        return self._inventory
 
437
 
 
438
    inventory = property(_get_inventory,
 
439
                         doc="Inventory of this Tree")
 
440
 
 
441
    @needs_read_lock
 
442
    def get_parent_ids(self):
 
443
        """See Tree.get_parent_ids.
 
444
        
 
445
        This implementation requests the ids list from the dirstate file.
 
446
        """
 
447
        return self.current_dirstate().get_parent_ids()
 
448
 
 
449
    def get_reference_revision(self, file_id, path=None):
 
450
        # referenced tree's revision is whatever's currently there
 
451
        return self.get_nested_tree(file_id, path).last_revision()
 
452
 
 
453
    def get_nested_tree(self, file_id, path=None):
 
454
        if path is None:
 
455
            path = self.id2path(file_id)
 
456
        # else: check file_id is at path?
 
457
        return WorkingTree.open(self.abspath(path))
 
458
 
 
459
    @needs_read_lock
 
460
    def get_root_id(self):
 
461
        """Return the id of this trees root"""
 
462
        return self._get_entry(path='')[0][2]
 
463
 
 
464
    def has_id(self, file_id):
 
465
        state = self.current_dirstate()
 
466
        file_id = osutils.safe_file_id(file_id)
 
467
        row, parents = self._get_entry(file_id=file_id)
 
468
        if row is None:
 
469
            return False
 
470
        return osutils.lexists(pathjoin(
 
471
                    self.basedir, row[0].decode('utf8'), row[1].decode('utf8')))
 
472
 
 
473
    @needs_read_lock
 
474
    def id2path(self, file_id):
 
475
        "Convert a file-id to a path."
 
476
        file_id = osutils.safe_file_id(file_id)
 
477
        state = self.current_dirstate()
 
478
        entry = self._get_entry(file_id=file_id)
 
479
        if entry == (None, None):
 
480
            raise errors.NoSuchId(tree=self, file_id=file_id)
 
481
        path_utf8 = osutils.pathjoin(entry[0][0], entry[0][1])
 
482
        return path_utf8.decode('utf8')
 
483
 
 
484
    if not osutils.supports_executable():
 
485
        def is_executable(self, file_id, path=None):
 
486
            """Test if a file is executable or not.
 
487
 
 
488
            Note: The caller is expected to take a read-lock before calling this.
 
489
            """
 
490
            file_id = osutils.safe_file_id(file_id)
 
491
            entry = self._get_entry(file_id=file_id, path=path)
 
492
            if entry == (None, None):
 
493
                return False
 
494
            return entry[1][0][3]
 
495
    else:
 
496
        def is_executable(self, file_id, path=None):
 
497
            """Test if a file is executable or not.
 
498
 
 
499
            Note: The caller is expected to take a read-lock before calling this.
 
500
            """
 
501
            if not path:
 
502
                file_id = osutils.safe_file_id(file_id)
 
503
                path = self.id2path(file_id)
 
504
            mode = os.lstat(self.abspath(path)).st_mode
 
505
            return bool(stat.S_ISREG(mode) and stat.S_IEXEC & mode)
 
506
 
 
507
    @needs_read_lock
 
508
    def __iter__(self):
 
509
        """Iterate through file_ids for this tree.
 
510
 
 
511
        file_ids are in a WorkingTree if they are in the working inventory
 
512
        and the working file exists.
 
513
        """
 
514
        result = []
 
515
        for key, tree_details in self.current_dirstate()._iter_entries():
 
516
            if tree_details[0][0] in ('a', 'r'): # absent, relocated
 
517
                # not relevant to the working tree
 
518
                continue
 
519
            path = pathjoin(self.basedir, key[0].decode('utf8'), key[1].decode('utf8'))
 
520
            if osutils.lexists(path):
 
521
                result.append(key[2])
 
522
        return iter(result)
 
523
 
 
524
    def iter_references(self):
 
525
        for key, tree_details in self.current_dirstate()._iter_entries():
 
526
            if tree_details[0][0] in ('a', 'r'): # absent, relocated
 
527
                # not relevant to the working tree
 
528
                continue
 
529
            if not key[1]:
 
530
                # the root is not a reference.
 
531
                continue
 
532
            path = pathjoin(self.basedir, key[0].decode('utf8'), key[1].decode('utf8'))
 
533
            try:
 
534
                if self._kind(path) == 'tree-reference':
 
535
                    yield path, key[2]
 
536
            except errors.NoSuchFile:
 
537
                # path is missing on disk.
 
538
                continue
 
539
 
 
540
    def kind(self, file_id):
 
541
        """Return the kind of a file.
 
542
 
 
543
        This is always the actual kind that's on disk, regardless of what it
 
544
        was added as.
 
545
 
 
546
        Note: The caller is expected to take a read-lock before calling this.
 
547
        """
 
548
        relpath = self.id2path(file_id)
 
549
        assert relpath != None, \
 
550
            "path for id {%s} is None!" % file_id
 
551
        return self._kind(relpath)
 
552
 
 
553
    def _kind(self, relpath):
 
554
        abspath = self.abspath(relpath)
 
555
        kind = file_kind(abspath)
 
556
        if (self._repo_supports_tree_reference and
 
557
            kind == 'directory' and
 
558
            self._directory_is_tree_reference(relpath)):
 
559
            kind = 'tree-reference'
 
560
        return kind
 
561
 
 
562
    @needs_read_lock
 
563
    def _last_revision(self):
 
564
        """See Mutable.last_revision."""
 
565
        parent_ids = self.current_dirstate().get_parent_ids()
 
566
        if parent_ids:
 
567
            return parent_ids[0]
 
568
        else:
 
569
            return None
 
570
 
 
571
    def lock_read(self):
 
572
        """See Branch.lock_read, and WorkingTree.unlock."""
 
573
        self.branch.lock_read()
 
574
        try:
 
575
            self._control_files.lock_read()
 
576
            try:
 
577
                state = self.current_dirstate()
 
578
                if not state._lock_token:
 
579
                    state.lock_read()
 
580
                # set our support for tree references from the repository in
 
581
                # use.
 
582
                self._repo_supports_tree_reference = getattr(
 
583
                    self.branch.repository._format, "supports_tree_reference",
 
584
                    False)
 
585
            except:
 
586
                self._control_files.unlock()
 
587
                raise
 
588
        except:
 
589
            self.branch.unlock()
 
590
            raise
 
591
 
 
592
    def _lock_self_write(self):
 
593
        """This should be called after the branch is locked."""
 
594
        try:
 
595
            self._control_files.lock_write()
 
596
            try:
 
597
                state = self.current_dirstate()
 
598
                if not state._lock_token:
 
599
                    state.lock_write()
 
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_tree_write(self):
 
613
        """See MutableTree.lock_tree_write, and WorkingTree.unlock."""
 
614
        self.branch.lock_read()
 
615
        self._lock_self_write()
 
616
 
 
617
    def lock_write(self):
 
618
        """See MutableTree.lock_write, and WorkingTree.unlock."""
 
619
        self.branch.lock_write()
 
620
        self._lock_self_write()
 
621
 
 
622
    @needs_tree_write_lock
 
623
    def move(self, from_paths, to_dir, after=False):
 
624
        """See WorkingTree.move()."""
 
625
        result = []
 
626
        if not from_paths:
 
627
            return result
 
628
 
 
629
        state = self.current_dirstate()
 
630
 
 
631
        assert not isinstance(from_paths, basestring)
 
632
        to_dir_utf8 = to_dir.encode('utf8')
 
633
        to_entry_dirname, to_basename = os.path.split(to_dir_utf8)
 
634
        id_index = state._get_id_index()
 
635
        # check destination directory
 
636
        # get the details for it
 
637
        to_entry_block_index, to_entry_entry_index, dir_present, entry_present = \
 
638
            state._get_block_entry_index(to_entry_dirname, to_basename, 0)
 
639
        if not entry_present:
 
640
            raise errors.BzrMoveFailedError('', to_dir,
 
641
                errors.NotVersionedError(to_dir))
 
642
        to_entry = state._dirblocks[to_entry_block_index][1][to_entry_entry_index]
 
643
        # get a handle on the block itself.
 
644
        to_block_index = state._ensure_block(
 
645
            to_entry_block_index, to_entry_entry_index, to_dir_utf8)
 
646
        to_block = state._dirblocks[to_block_index]
 
647
        to_abs = self.abspath(to_dir)
 
648
        if not isdir(to_abs):
 
649
            raise errors.BzrMoveFailedError('',to_dir,
 
650
                errors.NotADirectory(to_abs))
 
651
 
 
652
        if to_entry[1][0][0] != 'd':
 
653
            raise errors.BzrMoveFailedError('',to_dir,
 
654
                errors.NotADirectory(to_abs))
 
655
 
 
656
        if self._inventory is not None:
 
657
            update_inventory = True
 
658
            inv = self.inventory
 
659
            to_dir_ie = inv[to_dir_id]
 
660
            to_dir_id = to_entry[0][2]
 
661
        else:
 
662
            update_inventory = False
 
663
 
 
664
        rollbacks = []
 
665
        def move_one(old_entry, from_path_utf8, minikind, executable,
 
666
                     fingerprint, packed_stat, size,
 
667
                     to_block, to_key, to_path_utf8):
 
668
            state._make_absent(old_entry)
 
669
            from_key = old_entry[0]
 
670
            rollbacks.append(
 
671
                lambda:state.update_minimal(from_key,
 
672
                    minikind,
 
673
                    executable=executable,
 
674
                    fingerprint=fingerprint,
 
675
                    packed_stat=packed_stat,
 
676
                    size=size,
 
677
                    path_utf8=from_path_utf8))
 
678
            state.update_minimal(to_key,
 
679
                    minikind,
 
680
                    executable=executable,
 
681
                    fingerprint=fingerprint,
 
682
                    packed_stat=packed_stat,
 
683
                    size=size,
 
684
                    path_utf8=to_path_utf8)
 
685
            added_entry_index, _ = state._find_entry_index(to_key, to_block[1])
 
686
            new_entry = to_block[1][added_entry_index]
 
687
            rollbacks.append(lambda:state._make_absent(new_entry))
 
688
 
 
689
        for from_rel in from_paths:
 
690
            # from_rel is 'pathinroot/foo/bar'
 
691
            from_rel_utf8 = from_rel.encode('utf8')
 
692
            from_dirname, from_tail = osutils.split(from_rel)
 
693
            from_dirname, from_tail_utf8 = osutils.split(from_rel_utf8)
 
694
            from_entry = self._get_entry(path=from_rel)
 
695
            if from_entry == (None, None):
 
696
                raise errors.BzrMoveFailedError(from_rel,to_dir,
 
697
                    errors.NotVersionedError(path=str(from_rel)))
 
698
 
 
699
            from_id = from_entry[0][2]
 
700
            to_rel = pathjoin(to_dir, from_tail)
 
701
            to_rel_utf8 = pathjoin(to_dir_utf8, from_tail_utf8)
 
702
            item_to_entry = self._get_entry(path=to_rel)
 
703
            if item_to_entry != (None, None):
 
704
                raise errors.BzrMoveFailedError(from_rel, to_rel,
 
705
                    "Target is already versioned.")
 
706
 
 
707
            if from_rel == to_rel:
 
708
                raise errors.BzrMoveFailedError(from_rel, to_rel,
 
709
                    "Source and target are identical.")
 
710
 
 
711
            from_missing = not self.has_filename(from_rel)
 
712
            to_missing = not self.has_filename(to_rel)
 
713
            if after:
 
714
                move_file = False
 
715
            else:
 
716
                move_file = True
 
717
            if to_missing:
 
718
                if not move_file:
 
719
                    raise errors.BzrMoveFailedError(from_rel, to_rel,
 
720
                        errors.NoSuchFile(path=to_rel,
 
721
                        extra="New file has not been created yet"))
 
722
                elif from_missing:
 
723
                    # neither path exists
 
724
                    raise errors.BzrRenameFailedError(from_rel, to_rel,
 
725
                        errors.PathsDoNotExist(paths=(from_rel, to_rel)))
 
726
            else:
 
727
                if from_missing: # implicitly just update our path mapping
 
728
                    move_file = False
 
729
                elif not after:
 
730
                    raise errors.RenameFailedFilesExist(from_rel, to_rel,
 
731
                        extra="(Use --after to update the Bazaar id)")
 
732
 
 
733
            rollbacks = []
 
734
            def rollback_rename():
 
735
                """A single rename has failed, roll it back."""
 
736
                # roll back everything, even if we encounter trouble doing one
 
737
                # of them.
 
738
                #
 
739
                # TODO: at least log the other exceptions rather than just
 
740
                # losing them mbp 20070307
 
741
                exc_info = None
 
742
                for rollback in reversed(rollbacks):
 
743
                    try:
 
744
                        rollback()
 
745
                    except Exception, e:
 
746
                        exc_info = sys.exc_info()
 
747
                if exc_info:
 
748
                    raise exc_info[0], exc_info[1], exc_info[2]
 
749
 
 
750
            # perform the disk move first - its the most likely failure point.
 
751
            if move_file:
 
752
                from_rel_abs = self.abspath(from_rel)
 
753
                to_rel_abs = self.abspath(to_rel)
 
754
                try:
 
755
                    osutils.rename(from_rel_abs, to_rel_abs)
 
756
                except OSError, e:
 
757
                    raise errors.BzrMoveFailedError(from_rel, to_rel, e[1])
 
758
                rollbacks.append(lambda: osutils.rename(to_rel_abs, from_rel_abs))
 
759
            try:
 
760
                # perform the rename in the inventory next if needed: its easy
 
761
                # to rollback
 
762
                if update_inventory:
 
763
                    # rename the entry
 
764
                    from_entry = inv[from_id]
 
765
                    current_parent = from_entry.parent_id
 
766
                    inv.rename(from_id, to_dir_id, from_tail)
 
767
                    rollbacks.append(
 
768
                        lambda: inv.rename(from_id, current_parent, from_tail))
 
769
                # finally do the rename in the dirstate, which is a little
 
770
                # tricky to rollback, but least likely to need it.
 
771
                old_block_index, old_entry_index, dir_present, file_present = \
 
772
                    state._get_block_entry_index(from_dirname, from_tail_utf8, 0)
 
773
                old_block = state._dirblocks[old_block_index][1]
 
774
                old_entry = old_block[old_entry_index]
 
775
                from_key, old_entry_details = old_entry
 
776
                cur_details = old_entry_details[0]
 
777
                # remove the old row
 
778
                to_key = ((to_block[0],) + from_key[1:3])
 
779
                minikind = cur_details[0]
 
780
                move_one(old_entry, from_path_utf8=from_rel_utf8,
 
781
                         minikind=minikind,
 
782
                         executable=cur_details[3],
 
783
                         fingerprint=cur_details[1],
 
784
                         packed_stat=cur_details[4],
 
785
                         size=cur_details[2],
 
786
                         to_block=to_block,
 
787
                         to_key=to_key,
 
788
                         to_path_utf8=to_rel_utf8)
 
789
 
 
790
                if minikind == 'd':
 
791
                    def update_dirblock(from_dir, to_key, to_dir_utf8):
 
792
                        """Recursively update all entries in this dirblock."""
 
793
                        assert from_dir != '', "renaming root not supported"
 
794
                        from_key = (from_dir, '')
 
795
                        from_block_idx, present = \
 
796
                            state._find_block_index_from_key(from_key)
 
797
                        if not present:
 
798
                            # This is the old record, if it isn't present, then
 
799
                            # there is theoretically nothing to update.
 
800
                            # (Unless it isn't present because of lazy loading,
 
801
                            # but we don't do that yet)
 
802
                            return
 
803
                        from_block = state._dirblocks[from_block_idx]
 
804
                        to_block_index, to_entry_index, _, _ = \
 
805
                            state._get_block_entry_index(to_key[0], to_key[1], 0)
 
806
                        to_block_index = state._ensure_block(
 
807
                            to_block_index, to_entry_index, to_dir_utf8)
 
808
                        to_block = state._dirblocks[to_block_index]
 
809
 
 
810
                        # Grab a copy since move_one may update the list.
 
811
                        for entry in from_block[1][:]:
 
812
                            assert entry[0][0] == from_dir
 
813
                            cur_details = entry[1][0]
 
814
                            to_key = (to_dir_utf8, entry[0][1], entry[0][2])
 
815
                            from_path_utf8 = osutils.pathjoin(entry[0][0], entry[0][1])
 
816
                            to_path_utf8 = osutils.pathjoin(to_dir_utf8, entry[0][1])
 
817
                            minikind = cur_details[0]
 
818
                            if minikind in 'ar':
 
819
                                # Deleted children of a renamed directory
 
820
                                # Do not need to be updated.
 
821
                                # Children that have been renamed out of this
 
822
                                # directory should also not be updated
 
823
                                continue
 
824
                            move_one(entry, from_path_utf8=from_path_utf8,
 
825
                                     minikind=minikind,
 
826
                                     executable=cur_details[3],
 
827
                                     fingerprint=cur_details[1],
 
828
                                     packed_stat=cur_details[4],
 
829
                                     size=cur_details[2],
 
830
                                     to_block=to_block,
 
831
                                     to_key=to_key,
 
832
                                     to_path_utf8=to_path_utf8)
 
833
                            if minikind == 'd':
 
834
                                # We need to move all the children of this
 
835
                                # entry
 
836
                                update_dirblock(from_path_utf8, to_key,
 
837
                                                to_path_utf8)
 
838
                    update_dirblock(from_rel_utf8, to_key, to_rel_utf8)
 
839
            except:
 
840
                rollback_rename()
 
841
                raise
 
842
            result.append((from_rel, to_rel))
 
843
            state._dirblock_state = dirstate.DirState.IN_MEMORY_MODIFIED
 
844
            self._make_dirty(reset_inventory=False)
 
845
 
 
846
        return result
 
847
 
 
848
    def _must_be_locked(self):
 
849
        if not self._control_files._lock_count:
 
850
            raise errors.ObjectNotLocked(self)
 
851
 
 
852
    def _new_tree(self):
 
853
        """Initialize the state in this tree to be a new tree."""
 
854
        self._dirty = True
 
855
 
 
856
    @needs_read_lock
 
857
    def path2id(self, path):
 
858
        """Return the id for path in this tree."""
 
859
        path = path.strip('/')
 
860
        entry = self._get_entry(path=path)
 
861
        if entry == (None, None):
 
862
            return None
 
863
        return entry[0][2]
 
864
 
 
865
    def paths2ids(self, paths, trees=[], require_versioned=True):
 
866
        """See Tree.paths2ids().
 
867
 
 
868
        This specialisation fast-paths the case where all the trees are in the
 
869
        dirstate.
 
870
        """
 
871
        if paths is None:
 
872
            return None
 
873
        parents = self.get_parent_ids()
 
874
        for tree in trees:
 
875
            if not (isinstance(tree, DirStateRevisionTree) and tree._revision_id in
 
876
                parents):
 
877
                return super(WorkingTree4, self).paths2ids(paths, trees, require_versioned)
 
878
        search_indexes = [0] + [1 + parents.index(tree._revision_id) for tree in trees]
 
879
        # -- make all paths utf8 --
 
880
        paths_utf8 = set()
 
881
        for path in paths:
 
882
            paths_utf8.add(path.encode('utf8'))
 
883
        paths = paths_utf8
 
884
        # -- paths is now a utf8 path set --
 
885
        # -- get the state object and prepare it.
 
886
        state = self.current_dirstate()
 
887
        if False and (state._dirblock_state == dirstate.DirState.NOT_IN_MEMORY
 
888
            and '' not in paths):
 
889
            paths2ids = self._paths2ids_using_bisect
 
890
        else:
 
891
            paths2ids = self._paths2ids_in_memory
 
892
        return paths2ids(paths, search_indexes,
 
893
                         require_versioned=require_versioned)
 
894
 
 
895
    def _paths2ids_in_memory(self, paths, search_indexes,
 
896
                             require_versioned=True):
 
897
        state = self.current_dirstate()
 
898
        state._read_dirblocks_if_needed()
 
899
        def _entries_for_path(path):
 
900
            """Return a list with all the entries that match path for all ids.
 
901
            """
 
902
            dirname, basename = os.path.split(path)
 
903
            key = (dirname, basename, '')
 
904
            block_index, present = state._find_block_index_from_key(key)
 
905
            if not present:
 
906
                # the block which should contain path is absent.
 
907
                return []
 
908
            result = []
 
909
            block = state._dirblocks[block_index][1]
 
910
            entry_index, _ = state._find_entry_index(key, block)
 
911
            # we may need to look at multiple entries at this path: walk while the paths match.
 
912
            while (entry_index < len(block) and
 
913
                block[entry_index][0][0:2] == key[0:2]):
 
914
                result.append(block[entry_index])
 
915
                entry_index += 1
 
916
            return result
 
917
        if require_versioned:
 
918
            # -- check all supplied paths are versioned in a search tree. --
 
919
            all_versioned = True
 
920
            for path in paths:
 
921
                path_entries = _entries_for_path(path)
 
922
                if not path_entries:
 
923
                    # this specified path is not present at all: error
 
924
                    all_versioned = False
 
925
                    break
 
926
                found_versioned = False
 
927
                # for each id at this path
 
928
                for entry in path_entries:
 
929
                    # for each tree.
 
930
                    for index in search_indexes:
 
931
                        if entry[1][index][0] != 'a': # absent
 
932
                            found_versioned = True
 
933
                            # all good: found a versioned cell
 
934
                            break
 
935
                if not found_versioned:
 
936
                    # none of the indexes was not 'absent' at all ids for this
 
937
                    # path.
 
938
                    all_versioned = False
 
939
                    break
 
940
            if not all_versioned:
 
941
                raise errors.PathsNotVersionedError(paths)
 
942
        # -- remove redundancy in supplied paths to prevent over-scanning --
 
943
        search_paths = set()
 
944
        for path in paths:
 
945
            other_paths = paths.difference(set([path]))
 
946
            if not osutils.is_inside_any(other_paths, path):
 
947
                # this is a top level path, we must check it.
 
948
                search_paths.add(path)
 
949
        # sketch: 
 
950
        # for all search_indexs in each path at or under each element of
 
951
        # search_paths, if the detail is relocated: add the id, and add the
 
952
        # relocated path as one to search if its not searched already. If the
 
953
        # detail is not relocated, add the id.
 
954
        searched_paths = set()
 
955
        found_ids = set()
 
956
        def _process_entry(entry):
 
957
            """Look at search_indexes within entry.
 
958
 
 
959
            If a specific tree's details are relocated, add the relocation
 
960
            target to search_paths if not searched already. If it is absent, do
 
961
            nothing. Otherwise add the id to found_ids.
 
962
            """
 
963
            for index in search_indexes:
 
964
                if entry[1][index][0] == 'r': # relocated
 
965
                    if not osutils.is_inside_any(searched_paths, entry[1][index][1]):
 
966
                        search_paths.add(entry[1][index][1])
 
967
                elif entry[1][index][0] != 'a': # absent
 
968
                    found_ids.add(entry[0][2])
 
969
        while search_paths:
 
970
            current_root = search_paths.pop()
 
971
            searched_paths.add(current_root)
 
972
            # process the entries for this containing directory: the rest will be
 
973
            # found by their parents recursively.
 
974
            root_entries = _entries_for_path(current_root)
 
975
            if not root_entries:
 
976
                # this specified path is not present at all, skip it.
 
977
                continue
 
978
            for entry in root_entries:
 
979
                _process_entry(entry)
 
980
            initial_key = (current_root, '', '')
 
981
            block_index, _ = state._find_block_index_from_key(initial_key)
 
982
            while (block_index < len(state._dirblocks) and
 
983
                osutils.is_inside(current_root, state._dirblocks[block_index][0])):
 
984
                for entry in state._dirblocks[block_index][1]:
 
985
                    _process_entry(entry)
 
986
                block_index += 1
 
987
        return found_ids
 
988
 
 
989
    def _paths2ids_using_bisect(self, paths, search_indexes,
 
990
                                require_versioned=True):
 
991
        state = self.current_dirstate()
 
992
        found_ids = set()
 
993
 
 
994
        split_paths = sorted(osutils.split(p) for p in paths)
 
995
        found = state._bisect_recursive(split_paths)
 
996
 
 
997
        if require_versioned:
 
998
            found_dir_names = set(dir_name_id[:2] for dir_name_id in found)
 
999
            for dir_name in split_paths:
 
1000
                if dir_name not in found_dir_names:
 
1001
                    raise errors.PathsNotVersionedError(paths)
 
1002
 
 
1003
        for dir_name_id, trees_info in found.iteritems():
 
1004
            for index in search_indexes:
 
1005
                if trees_info[index][0] not in ('r', 'a'):
 
1006
                    found_ids.add(dir_name_id[2])
 
1007
        return found_ids
 
1008
 
 
1009
    def read_working_inventory(self):
 
1010
        """Read the working inventory.
 
1011
        
 
1012
        This is a meaningless operation for dirstate, but we obey it anyhow.
 
1013
        """
 
1014
        return self.inventory
 
1015
 
 
1016
    @needs_read_lock
 
1017
    def revision_tree(self, revision_id):
 
1018
        """See Tree.revision_tree.
 
1019
 
 
1020
        WorkingTree4 supplies revision_trees for any basis tree.
 
1021
        """
 
1022
        revision_id = osutils.safe_revision_id(revision_id)
 
1023
        dirstate = self.current_dirstate()
 
1024
        parent_ids = dirstate.get_parent_ids()
 
1025
        if revision_id not in parent_ids:
 
1026
            raise errors.NoSuchRevisionInTree(self, revision_id)
 
1027
        if revision_id in dirstate.get_ghosts():
 
1028
            raise errors.NoSuchRevisionInTree(self, revision_id)
 
1029
        return DirStateRevisionTree(dirstate, revision_id,
 
1030
            self.branch.repository)
 
1031
 
 
1032
    @needs_tree_write_lock
 
1033
    def set_last_revision(self, new_revision):
 
1034
        """Change the last revision in the working tree."""
 
1035
        new_revision = osutils.safe_revision_id(new_revision)
 
1036
        parents = self.get_parent_ids()
 
1037
        if new_revision in (NULL_REVISION, None):
 
1038
            assert len(parents) < 2, (
 
1039
                "setting the last parent to none with a pending merge is "
 
1040
                "unsupported.")
 
1041
            self.set_parent_ids([])
 
1042
        else:
 
1043
            self.set_parent_ids([new_revision] + parents[1:],
 
1044
                allow_leftmost_as_ghost=True)
 
1045
 
 
1046
    @needs_tree_write_lock
 
1047
    def set_parent_ids(self, revision_ids, allow_leftmost_as_ghost=False):
 
1048
        """Set the parent ids to revision_ids.
 
1049
        
 
1050
        See also set_parent_trees. This api will try to retrieve the tree data
 
1051
        for each element of revision_ids from the trees repository. If you have
 
1052
        tree data already available, it is more efficient to use
 
1053
        set_parent_trees rather than set_parent_ids. set_parent_ids is however
 
1054
        an easier API to use.
 
1055
 
 
1056
        :param revision_ids: The revision_ids to set as the parent ids of this
 
1057
            working tree. Any of these may be ghosts.
 
1058
        """
 
1059
        revision_ids = [osutils.safe_revision_id(r) for r in revision_ids]
 
1060
        trees = []
 
1061
        for revision_id in revision_ids:
 
1062
            try:
 
1063
                revtree = self.branch.repository.revision_tree(revision_id)
 
1064
                # TODO: jam 20070213 KnitVersionedFile raises
 
1065
                #       RevisionNotPresent rather than NoSuchRevision if a
 
1066
                #       given revision_id is not present. Should Repository be
 
1067
                #       catching it and re-raising NoSuchRevision?
 
1068
            except (errors.NoSuchRevision, errors.RevisionNotPresent):
 
1069
                revtree = None
 
1070
            trees.append((revision_id, revtree))
 
1071
        self.set_parent_trees(trees,
 
1072
            allow_leftmost_as_ghost=allow_leftmost_as_ghost)
 
1073
 
 
1074
    @needs_tree_write_lock
 
1075
    def set_parent_trees(self, parents_list, allow_leftmost_as_ghost=False):
 
1076
        """Set the parents of the working tree.
 
1077
 
 
1078
        :param parents_list: A list of (revision_id, tree) tuples.
 
1079
            If tree is None, then that element is treated as an unreachable
 
1080
            parent tree - i.e. a ghost.
 
1081
        """
 
1082
        dirstate = self.current_dirstate()
 
1083
        if len(parents_list) > 0:
 
1084
            if not allow_leftmost_as_ghost and parents_list[0][1] is None:
 
1085
                raise errors.GhostRevisionUnusableHere(parents_list[0][0])
 
1086
        real_trees = []
 
1087
        ghosts = []
 
1088
        # convert absent trees to the null tree, which we convert back to
 
1089
        # missing on access.
 
1090
        for rev_id, tree in parents_list:
 
1091
            rev_id = osutils.safe_revision_id(rev_id)
 
1092
            if tree is not None:
 
1093
                real_trees.append((rev_id, tree))
 
1094
            else:
 
1095
                real_trees.append((rev_id,
 
1096
                    self.branch.repository.revision_tree(None)))
 
1097
                ghosts.append(rev_id)
 
1098
        dirstate.set_parent_trees(real_trees, ghosts=ghosts)
 
1099
        self._make_dirty(reset_inventory=False)
 
1100
 
 
1101
    def _set_root_id(self, file_id):
 
1102
        """See WorkingTree.set_root_id."""
 
1103
        state = self.current_dirstate()
 
1104
        state.set_path_id('', file_id)
 
1105
        if state._dirblock_state == dirstate.DirState.IN_MEMORY_MODIFIED:
 
1106
            self._make_dirty(reset_inventory=True)
 
1107
 
 
1108
    @needs_read_lock
 
1109
    def supports_tree_reference(self):
 
1110
        return self._repo_supports_tree_reference
 
1111
 
 
1112
    def unlock(self):
 
1113
        """Unlock in format 4 trees needs to write the entire dirstate."""
 
1114
        if self._control_files._lock_count == 1:
 
1115
            # eventually we should do signature checking during read locks for
 
1116
            # dirstate updates.
 
1117
            if self._control_files._lock_mode == 'w':
 
1118
                if self._dirty:
 
1119
                    self.flush()
 
1120
            if self._dirstate is not None:
 
1121
                # This is a no-op if there are no modifications.
 
1122
                self._dirstate.save()
 
1123
                self._dirstate.unlock()
 
1124
            # TODO: jam 20070301 We shouldn't have to wipe the dirstate at this
 
1125
            #       point. Instead, it could check if the header has been
 
1126
            #       modified when it is locked, and if not, it can hang on to
 
1127
            #       the data it has in memory.
 
1128
            self._dirstate = None
 
1129
            self._inventory = None
 
1130
        # reverse order of locking.
 
1131
        try:
 
1132
            return self._control_files.unlock()
 
1133
        finally:
 
1134
            self.branch.unlock()
 
1135
 
 
1136
    @needs_tree_write_lock
 
1137
    def unversion(self, file_ids):
 
1138
        """Remove the file ids in file_ids from the current versioned set.
 
1139
 
 
1140
        When a file_id is unversioned, all of its children are automatically
 
1141
        unversioned.
 
1142
 
 
1143
        :param file_ids: The file ids to stop versioning.
 
1144
        :raises: NoSuchId if any fileid is not currently versioned.
 
1145
        """
 
1146
        if not file_ids:
 
1147
            return
 
1148
        state = self.current_dirstate()
 
1149
        state._read_dirblocks_if_needed()
 
1150
        ids_to_unversion = set()
 
1151
        for file_id in file_ids:
 
1152
            ids_to_unversion.add(osutils.safe_file_id(file_id))
 
1153
        paths_to_unversion = set()
 
1154
        # sketch:
 
1155
        # check if the root is to be unversioned, if so, assert for now.
 
1156
        # walk the state marking unversioned things as absent.
 
1157
        # if there are any un-unversioned ids at the end, raise
 
1158
        for key, details in state._dirblocks[0][1]:
 
1159
            if (details[0][0] not in ('a', 'r') and # absent or relocated
 
1160
                key[2] in ids_to_unversion):
 
1161
                # I haven't written the code to unversion / yet - it should be
 
1162
                # supported.
 
1163
                raise errors.BzrError('Unversioning the / is not currently supported')
 
1164
        block_index = 0
 
1165
        while block_index < len(state._dirblocks):
 
1166
            # process one directory at a time.
 
1167
            block = state._dirblocks[block_index]
 
1168
            # first check: is the path one to remove - it or its children
 
1169
            delete_block = False
 
1170
            for path in paths_to_unversion:
 
1171
                if (block[0].startswith(path) and
 
1172
                    (len(block[0]) == len(path) or
 
1173
                     block[0][len(path)] == '/')):
 
1174
                    # this entire block should be deleted - its the block for a
 
1175
                    # path to unversion; or the child of one
 
1176
                    delete_block = True
 
1177
                    break
 
1178
            # TODO: trim paths_to_unversion as we pass by paths
 
1179
            if delete_block:
 
1180
                # this block is to be deleted: process it.
 
1181
                # TODO: we can special case the no-parents case and
 
1182
                # just forget the whole block.
 
1183
                entry_index = 0
 
1184
                while entry_index < len(block[1]):
 
1185
                    # Mark this file id as having been removed
 
1186
                    entry = block[1][entry_index]
 
1187
                    ids_to_unversion.discard(entry[0][2])
 
1188
                    if (entry[1][0][0] == 'a'
 
1189
                        or not state._make_absent(entry)):
 
1190
                        entry_index += 1
 
1191
                # go to the next block. (At the moment we dont delete empty
 
1192
                # dirblocks)
 
1193
                block_index += 1
 
1194
                continue
 
1195
            entry_index = 0
 
1196
            while entry_index < len(block[1]):
 
1197
                entry = block[1][entry_index]
 
1198
                if (entry[1][0][0] in ('a', 'r') or # absent, relocated
 
1199
                    # ^ some parent row.
 
1200
                    entry[0][2] not in ids_to_unversion):
 
1201
                    # ^ not an id to unversion
 
1202
                    entry_index += 1
 
1203
                    continue
 
1204
                if entry[1][0][0] == 'd':
 
1205
                    paths_to_unversion.add(pathjoin(entry[0][0], entry[0][1]))
 
1206
                if not state._make_absent(entry):
 
1207
                    entry_index += 1
 
1208
                # we have unversioned this id
 
1209
                ids_to_unversion.remove(entry[0][2])
 
1210
            block_index += 1
 
1211
        if ids_to_unversion:
 
1212
            raise errors.NoSuchId(self, iter(ids_to_unversion).next())
 
1213
        self._make_dirty(reset_inventory=False)
 
1214
        # have to change the legacy inventory too.
 
1215
        if self._inventory is not None:
 
1216
            for file_id in file_ids:
 
1217
                self._inventory.remove_recursive_id(file_id)
 
1218
 
 
1219
    @needs_read_lock
 
1220
    def _validate(self):
 
1221
        self._dirstate._validate()
 
1222
 
 
1223
    @needs_tree_write_lock
 
1224
    def _write_inventory(self, inv):
 
1225
        """Write inventory as the current inventory."""
 
1226
        assert not self._dirty, "attempting to write an inventory when the dirstate is dirty will cause data loss"
 
1227
        self.current_dirstate().set_state_from_inventory(inv)
 
1228
        self._make_dirty(reset_inventory=False)
 
1229
        if self._inventory is not None:
 
1230
            self._inventory = inv
 
1231
        self.flush()
 
1232
 
 
1233
 
 
1234
class WorkingTreeFormat4(WorkingTreeFormat3):
 
1235
    """The first consolidated dirstate working tree format.
 
1236
 
 
1237
    This format:
 
1238
        - exists within a metadir controlling .bzr
 
1239
        - includes an explicit version marker for the workingtree control
 
1240
          files, separate from the BzrDir format
 
1241
        - modifies the hash cache format
 
1242
        - is new in bzr 0.15
 
1243
        - uses a LockDir to guard access to it.
 
1244
    """
 
1245
 
 
1246
    upgrade_recommended = False
 
1247
 
 
1248
    def get_format_string(self):
 
1249
        """See WorkingTreeFormat.get_format_string()."""
 
1250
        return "Bazaar Working Tree Format 4 (bzr 0.15)\n"
 
1251
 
 
1252
    def get_format_description(self):
 
1253
        """See WorkingTreeFormat.get_format_description()."""
 
1254
        return "Working tree format 4"
 
1255
 
 
1256
    def initialize(self, a_bzrdir, revision_id=None):
 
1257
        """See WorkingTreeFormat.initialize().
 
1258
 
 
1259
        :param revision_id: allows creating a working tree at a different
 
1260
        revision than the branch is at.
 
1261
 
 
1262
        These trees get an initial random root id, if their repository supports
 
1263
        rich root data, TREE_ROOT otherwise.
 
1264
        """
 
1265
        revision_id = osutils.safe_revision_id(revision_id)
 
1266
        if not isinstance(a_bzrdir.transport, LocalTransport):
 
1267
            raise errors.NotLocalUrl(a_bzrdir.transport.base)
 
1268
        transport = a_bzrdir.get_workingtree_transport(self)
 
1269
        control_files = self._open_control_files(a_bzrdir)
 
1270
        control_files.create_lock()
 
1271
        control_files.lock_write()
 
1272
        control_files.put_utf8('format', self.get_format_string())
 
1273
        branch = a_bzrdir.open_branch()
 
1274
        if revision_id is None:
 
1275
            revision_id = branch.last_revision()
 
1276
        local_path = transport.local_abspath('dirstate')
 
1277
        # write out new dirstate (must exist when we create the tree)
 
1278
        state = dirstate.DirState.initialize(local_path)
 
1279
        state.unlock()
 
1280
        del state
 
1281
        wt = WorkingTree4(a_bzrdir.root_transport.local_abspath('.'),
 
1282
                         branch,
 
1283
                         _format=self,
 
1284
                         _bzrdir=a_bzrdir,
 
1285
                         _control_files=control_files)
 
1286
        wt._new_tree()
 
1287
        wt.lock_tree_write()
 
1288
        try:
 
1289
            if revision_id in (None, NULL_REVISION):
 
1290
                if branch.repository.supports_rich_root():
 
1291
                    wt._set_root_id(generate_ids.gen_root_id())
 
1292
                else:
 
1293
                    wt._set_root_id(ROOT_ID)
 
1294
                wt.flush()
 
1295
            wt.set_last_revision(revision_id)
 
1296
            wt.flush()
 
1297
            basis = wt.basis_tree()
 
1298
            basis.lock_read()
 
1299
            # if the basis has a root id we have to use that; otherwise we use
 
1300
            # a new random one
 
1301
            basis_root_id = basis.get_root_id()
 
1302
            if basis_root_id is not None:
 
1303
                wt._set_root_id(basis_root_id)
 
1304
                wt.flush()
 
1305
            transform.build_tree(basis, wt)
 
1306
            basis.unlock()
 
1307
        finally:
 
1308
            control_files.unlock()
 
1309
            wt.unlock()
 
1310
        return wt
 
1311
 
 
1312
    def _open(self, a_bzrdir, control_files):
 
1313
        """Open the tree itself.
 
1314
 
 
1315
        :param a_bzrdir: the dir for the tree.
 
1316
        :param control_files: the control files for the tree.
 
1317
        """
 
1318
        return WorkingTree4(a_bzrdir.root_transport.local_abspath('.'),
 
1319
                           branch=a_bzrdir.open_branch(),
 
1320
                           _format=self,
 
1321
                           _bzrdir=a_bzrdir,
 
1322
                           _control_files=control_files)
 
1323
 
 
1324
    def __get_matchingbzrdir(self):
 
1325
        # please test against something that will let us do tree references
 
1326
        return bzrdir.format_registry.make_bzrdir(
 
1327
            'dirstate-with-subtree')
 
1328
 
 
1329
    _matchingbzrdir = property(__get_matchingbzrdir)
 
1330
 
 
1331
 
 
1332
class DirStateRevisionTree(Tree):
 
1333
    """A revision tree pulling the inventory from a dirstate."""
 
1334
 
 
1335
    def __init__(self, dirstate, revision_id, repository):
 
1336
        self._dirstate = dirstate
 
1337
        self._revision_id = osutils.safe_revision_id(revision_id)
 
1338
        self._repository = repository
 
1339
        self._inventory = None
 
1340
        self._locked = 0
 
1341
        self._dirstate_locked = False
 
1342
 
 
1343
    def __repr__(self):
 
1344
        return "<%s of %s in %s>" % \
 
1345
            (self.__class__.__name__, self._revision_id, self._dirstate)
 
1346
 
 
1347
    def annotate_iter(self, file_id):
 
1348
        """See Tree.annotate_iter"""
 
1349
        w = self._repository.weave_store.get_weave(file_id,
 
1350
                           self._repository.get_transaction())
 
1351
        return w.annotate_iter(self.inventory[file_id].revision)
 
1352
 
 
1353
    def _comparison_data(self, entry, path):
 
1354
        """See Tree._comparison_data."""
 
1355
        if entry is None:
 
1356
            return None, False, None
 
1357
        # trust the entry as RevisionTree does, but this may not be
 
1358
        # sensible: the entry might not have come from us?
 
1359
        return entry.kind, entry.executable, None
 
1360
 
 
1361
    def _file_size(self, entry, stat_value):
 
1362
        return entry.text_size
 
1363
 
 
1364
    def filter_unversioned_files(self, paths):
 
1365
        """Filter out paths that are not versioned.
 
1366
 
 
1367
        :return: set of paths.
 
1368
        """
 
1369
        pred = self.has_filename
 
1370
        return set((p for p in paths if not pred(p)))
 
1371
 
 
1372
    def get_root_id(self):
 
1373
        return self.path2id('')
 
1374
 
 
1375
    def _get_parent_index(self):
 
1376
        """Return the index in the dirstate referenced by this tree."""
 
1377
        return self._dirstate.get_parent_ids().index(self._revision_id) + 1
 
1378
 
 
1379
    def _get_entry(self, file_id=None, path=None):
 
1380
        """Get the dirstate row for file_id or path.
 
1381
 
 
1382
        If either file_id or path is supplied, it is used as the key to lookup.
 
1383
        If both are supplied, the fastest lookup is used, and an error is
 
1384
        raised if they do not both point at the same row.
 
1385
        
 
1386
        :param file_id: An optional unicode file_id to be looked up.
 
1387
        :param path: An optional unicode path to be looked up.
 
1388
        :return: The dirstate row tuple for path/file_id, or (None, None)
 
1389
        """
 
1390
        if file_id is None and path is None:
 
1391
            raise errors.BzrError('must supply file_id or path')
 
1392
        file_id = osutils.safe_file_id(file_id)
 
1393
        if path is not None:
 
1394
            path = path.encode('utf8')
 
1395
        parent_index = self._get_parent_index()
 
1396
        return self._dirstate._get_entry(parent_index, fileid_utf8=file_id, path_utf8=path)
 
1397
 
 
1398
    def _generate_inventory(self):
 
1399
        """Create and set self.inventory from the dirstate object.
 
1400
 
 
1401
        (So this is only called the first time the inventory is requested for
 
1402
        this tree; it then remains in memory until it's out of date.)
 
1403
 
 
1404
        This is relatively expensive: we have to walk the entire dirstate.
 
1405
        """
 
1406
        assert self._locked, 'cannot generate inventory of an unlocked '\
 
1407
            'dirstate revision tree'
 
1408
        # separate call for profiling - makes it clear where the costs are.
 
1409
        self._dirstate._read_dirblocks_if_needed()
 
1410
        assert self._revision_id in self._dirstate.get_parent_ids(), \
 
1411
            'parent %s has disappeared from %s' % (
 
1412
            self._revision_id, self._dirstate.get_parent_ids())
 
1413
        parent_index = self._dirstate.get_parent_ids().index(self._revision_id) + 1
 
1414
        # This is identical now to the WorkingTree _generate_inventory except
 
1415
        # for the tree index use.
 
1416
        root_key, current_entry = self._dirstate._get_entry(parent_index, path_utf8='')
 
1417
        current_id = root_key[2]
 
1418
        assert current_entry[parent_index][0] == 'd'
 
1419
        inv = Inventory(root_id=current_id, revision_id=self._revision_id)
 
1420
        inv.root.revision = current_entry[parent_index][4]
 
1421
        # Turn some things into local variables
 
1422
        minikind_to_kind = dirstate.DirState._minikind_to_kind
 
1423
        factory = entry_factory
 
1424
        utf8_decode = cache_utf8._utf8_decode
 
1425
        inv_byid = inv._byid
 
1426
        # we could do this straight out of the dirstate; it might be fast
 
1427
        # and should be profiled - RBC 20070216
 
1428
        parent_ies = {'' : inv.root}
 
1429
        for block in self._dirstate._dirblocks[1:]: #skip root
 
1430
            dirname = block[0]
 
1431
            try:
 
1432
                parent_ie = parent_ies[dirname]
 
1433
            except KeyError:
 
1434
                # all the paths in this block are not versioned in this tree
 
1435
                continue
 
1436
            for key, entry in block[1]:
 
1437
                minikind, fingerprint, size, executable, revid = entry[parent_index]
 
1438
                if minikind in ('a', 'r'): # absent, relocated
 
1439
                    # not this tree
 
1440
                    continue
 
1441
                name = key[1]
 
1442
                name_unicode = utf8_decode(name)[0]
 
1443
                file_id = key[2]
 
1444
                kind = minikind_to_kind[minikind]
 
1445
                inv_entry = factory[kind](file_id, name_unicode,
 
1446
                                          parent_ie.file_id)
 
1447
                inv_entry.revision = revid
 
1448
                if kind == 'file':
 
1449
                    inv_entry.executable = executable
 
1450
                    inv_entry.text_size = size
 
1451
                    inv_entry.text_sha1 = fingerprint
 
1452
                elif kind == 'directory':
 
1453
                    parent_ies[(dirname + '/' + name).strip('/')] = inv_entry
 
1454
                elif kind == 'symlink':
 
1455
                    inv_entry.executable = False
 
1456
                    inv_entry.text_size = None
 
1457
                    inv_entry.symlink_target = utf8_decode(fingerprint)[0]
 
1458
                elif kind == 'tree-reference':
 
1459
                    inv_entry.reference_revision = fingerprint or None
 
1460
                else:
 
1461
                    raise AssertionError("cannot convert entry %r into an InventoryEntry"
 
1462
                            % entry)
 
1463
                # These checks cost us around 40ms on a 55k entry tree
 
1464
                assert file_id not in inv_byid
 
1465
                assert name_unicode not in parent_ie.children
 
1466
                inv_byid[file_id] = inv_entry
 
1467
                parent_ie.children[name_unicode] = inv_entry
 
1468
        self._inventory = inv
 
1469
 
 
1470
    def get_file_mtime(self, file_id, path=None):
 
1471
        """Return the modification time for this record.
 
1472
 
 
1473
        We return the timestamp of the last-changed revision.
 
1474
        """
 
1475
        # Make sure the file exists
 
1476
        entry = self._get_entry(file_id, path=path)
 
1477
        if entry == (None, None): # do we raise?
 
1478
            return None
 
1479
        parent_index = self._get_parent_index()
 
1480
        last_changed_revision = entry[1][parent_index][4]
 
1481
        return self._repository.get_revision(last_changed_revision).timestamp
 
1482
 
 
1483
    def get_file_sha1(self, file_id, path=None, stat_value=None):
 
1484
        entry = self._get_entry(file_id=file_id, path=path)
 
1485
        parent_index = self._get_parent_index()
 
1486
        parent_details = entry[1][parent_index]
 
1487
        if parent_details[0] == 'f':
 
1488
            return parent_details[1]
 
1489
        return None
 
1490
 
 
1491
    def get_file(self, file_id):
 
1492
        return StringIO(self.get_file_text(file_id))
 
1493
 
 
1494
    def get_file_lines(self, file_id):
 
1495
        ie = self.inventory[file_id]
 
1496
        return self._repository.weave_store.get_weave(file_id,
 
1497
                self._repository.get_transaction()).get_lines(ie.revision)
 
1498
 
 
1499
    def get_file_size(self, file_id):
 
1500
        return self.inventory[file_id].text_size
 
1501
 
 
1502
    def get_file_text(self, file_id):
 
1503
        return ''.join(self.get_file_lines(file_id))
 
1504
 
 
1505
    def get_reference_revision(self, file_id, path=None):
 
1506
        return self.inventory[file_id].reference_revision
 
1507
 
 
1508
    def get_symlink_target(self, file_id):
 
1509
        entry = self._get_entry(file_id=file_id)
 
1510
        parent_index = self._get_parent_index()
 
1511
        if entry[1][parent_index][0] != 'l':
 
1512
            return None
 
1513
        else:
 
1514
            # At present, none of the tree implementations supports non-ascii
 
1515
            # symlink targets. So we will just assume that the dirstate path is
 
1516
            # correct.
 
1517
            return entry[1][parent_index][1]
 
1518
 
 
1519
    def get_revision_id(self):
 
1520
        """Return the revision id for this tree."""
 
1521
        return self._revision_id
 
1522
 
 
1523
    def _get_inventory(self):
 
1524
        if self._inventory is not None:
 
1525
            return self._inventory
 
1526
        self._must_be_locked()
 
1527
        self._generate_inventory()
 
1528
        return self._inventory
 
1529
 
 
1530
    inventory = property(_get_inventory,
 
1531
                         doc="Inventory of this Tree")
 
1532
 
 
1533
    def get_parent_ids(self):
 
1534
        """The parents of a tree in the dirstate are not cached."""
 
1535
        return self._repository.get_revision(self._revision_id).parent_ids
 
1536
 
 
1537
    def has_filename(self, filename):
 
1538
        return bool(self.path2id(filename))
 
1539
 
 
1540
    def kind(self, file_id):
 
1541
        return self.inventory[file_id].kind
 
1542
 
 
1543
    def is_executable(self, file_id, path=None):
 
1544
        ie = self.inventory[file_id]
 
1545
        if ie.kind != "file":
 
1546
            return None
 
1547
        return ie.executable
 
1548
 
 
1549
    def list_files(self, include_root=False):
 
1550
        # We use a standard implementation, because DirStateRevisionTree is
 
1551
        # dealing with one of the parents of the current state
 
1552
        inv = self._get_inventory()
 
1553
        entries = inv.iter_entries()
 
1554
        if self.inventory.root is not None and not include_root:
 
1555
            entries.next()
 
1556
        for path, entry in entries:
 
1557
            yield path, 'V', entry.kind, entry.file_id, entry
 
1558
 
 
1559
    def lock_read(self):
 
1560
        """Lock the tree for a set of operations."""
 
1561
        if not self._locked:
 
1562
            self._repository.lock_read()
 
1563
            if self._dirstate._lock_token is None:
 
1564
                self._dirstate.lock_read()
 
1565
                self._dirstate_locked = True
 
1566
        self._locked += 1
 
1567
 
 
1568
    def _must_be_locked(self):
 
1569
        if not self._locked:
 
1570
            raise errors.ObjectNotLocked(self)
 
1571
 
 
1572
    @needs_read_lock
 
1573
    def path2id(self, path):
 
1574
        """Return the id for path in this tree."""
 
1575
        # lookup by path: faster than splitting and walking the ivnentory.
 
1576
        entry = self._get_entry(path=path)
 
1577
        if entry == (None, None):
 
1578
            return None
 
1579
        return entry[0][2]
 
1580
 
 
1581
    def unlock(self):
 
1582
        """Unlock, freeing any cache memory used during the lock."""
 
1583
        # outside of a lock, the inventory is suspect: release it.
 
1584
        self._locked -=1
 
1585
        if not self._locked:
 
1586
            self._inventory = None
 
1587
            self._locked = 0
 
1588
            if self._dirstate_locked:
 
1589
                self._dirstate.unlock()
 
1590
                self._dirstate_locked = False
 
1591
            self._repository.unlock()
 
1592
 
 
1593
    def walkdirs(self, prefix=""):
 
1594
        # TODO: jam 20070215 This is the lazy way by using the RevisionTree
 
1595
        # implementation based on an inventory.  
 
1596
        # This should be cleaned up to use the much faster Dirstate code
 
1597
        # So for now, we just build up the parent inventory, and extract
 
1598
        # it the same way RevisionTree does.
 
1599
        _directory = 'directory'
 
1600
        inv = self._get_inventory()
 
1601
        top_id = inv.path2id(prefix)
 
1602
        if top_id is None:
 
1603
            pending = []
 
1604
        else:
 
1605
            pending = [(prefix, top_id)]
 
1606
        while pending:
 
1607
            dirblock = []
 
1608
            relpath, file_id = pending.pop()
 
1609
            # 0 - relpath, 1- file-id
 
1610
            if relpath:
 
1611
                relroot = relpath + '/'
 
1612
            else:
 
1613
                relroot = ""
 
1614
            # FIXME: stash the node in pending
 
1615
            entry = inv[file_id]
 
1616
            for name, child in entry.sorted_children():
 
1617
                toppath = relroot + name
 
1618
                dirblock.append((toppath, name, child.kind, None,
 
1619
                    child.file_id, child.kind
 
1620
                    ))
 
1621
            yield (relpath, entry.file_id), dirblock
 
1622
            # push the user specified dirs from dirblock
 
1623
            for dir in reversed(dirblock):
 
1624
                if dir[2] == _directory:
 
1625
                    pending.append((dir[0], dir[4]))
 
1626
 
 
1627
 
 
1628
class InterDirStateTree(InterTree):
 
1629
    """Fast path optimiser for changes_from with dirstate trees.
 
1630
    
 
1631
    This is used only when both trees are in the dirstate working file, and 
 
1632
    the source is any parent within the dirstate, and the destination is 
 
1633
    the current working tree of the same dirstate.
 
1634
    """
 
1635
    # this could be generalized to allow comparisons between any trees in the
 
1636
    # dirstate, and possibly between trees stored in different dirstates.
 
1637
 
 
1638
    def __init__(self, source, target):
 
1639
        super(InterDirStateTree, self).__init__(source, target)
 
1640
        if not InterDirStateTree.is_compatible(source, target):
 
1641
            raise Exception, "invalid source %r and target %r" % (source, target)
 
1642
 
 
1643
    @staticmethod
 
1644
    def make_source_parent_tree(source, target):
 
1645
        """Change the source tree into a parent of the target."""
 
1646
        revid = source.commit('record tree')
 
1647
        target.branch.repository.fetch(source.branch.repository, revid)
 
1648
        target.set_parent_ids([revid])
 
1649
        return target.basis_tree(), target
 
1650
 
 
1651
    _matching_from_tree_format = WorkingTreeFormat4()
 
1652
    _matching_to_tree_format = WorkingTreeFormat4()
 
1653
    _test_mutable_trees_to_test_trees = make_source_parent_tree
 
1654
 
 
1655
    def _iter_changes(self, include_unchanged=False,
 
1656
                      specific_files=None, pb=None, extra_trees=[],
 
1657
                      require_versioned=True, want_unversioned=False):
 
1658
        """Return the changes from source to target.
 
1659
 
 
1660
        :return: An iterator that yields tuples. See InterTree._iter_changes
 
1661
            for details.
 
1662
        :param specific_files: An optional list of file paths to restrict the
 
1663
            comparison to. When mapping filenames to ids, all matches in all
 
1664
            trees (including optional extra_trees) are used, and all children of
 
1665
            matched directories are included.
 
1666
        :param include_unchanged: An optional boolean requesting the inclusion of
 
1667
            unchanged entries in the result.
 
1668
        :param extra_trees: An optional list of additional trees to use when
 
1669
            mapping the contents of specific_files (paths) to file_ids.
 
1670
        :param require_versioned: If True, all files in specific_files must be
 
1671
            versioned in one of source, target, extra_trees or
 
1672
            PathsNotVersionedError is raised.
 
1673
        :param want_unversioned: Should unversioned files be returned in the
 
1674
            output. An unversioned file is defined as one with (False, False)
 
1675
            for the versioned pair.
 
1676
        """
 
1677
        utf8_decode = cache_utf8._utf8_decode
 
1678
        _minikind_to_kind = dirstate.DirState._minikind_to_kind
 
1679
        # NB: show_status depends on being able to pass in non-versioned files
 
1680
        # and report them as unknown
 
1681
        # TODO: handle extra trees in the dirstate.
 
1682
        # TODO: handle comparisons as an empty tree as a different special
 
1683
        # case? mbp 20070226
 
1684
        if extra_trees or (self.source._revision_id == NULL_REVISION):
 
1685
            # we can't fast-path these cases (yet)
 
1686
            for f in super(InterDirStateTree, self)._iter_changes(
 
1687
                include_unchanged, specific_files, pb, extra_trees,
 
1688
                require_versioned, want_unversioned=want_unversioned):
 
1689
                yield f
 
1690
            return
 
1691
        parent_ids = self.target.get_parent_ids()
 
1692
        assert (self.source._revision_id in parent_ids), \
 
1693
                "revision {%s} is not stored in {%s}, but %s " \
 
1694
                "can only be used for trees stored in the dirstate" \
 
1695
                % (self.source._revision_id, self.target, self._iter_changes)
 
1696
        target_index = 0
 
1697
        if self.source._revision_id == NULL_REVISION:
 
1698
            source_index = None
 
1699
            indices = (target_index,)
 
1700
        else:
 
1701
            assert (self.source._revision_id in parent_ids), \
 
1702
                "Failure: source._revision_id: %s not in target.parent_ids(%s)" % (
 
1703
                self.source._revision_id, parent_ids)
 
1704
            source_index = 1 + parent_ids.index(self.source._revision_id)
 
1705
            indices = (source_index,target_index)
 
1706
        # -- make all specific_files utf8 --
 
1707
        if specific_files:
 
1708
            specific_files_utf8 = set()
 
1709
            for path in specific_files:
 
1710
                specific_files_utf8.add(path.encode('utf8'))
 
1711
            specific_files = specific_files_utf8
 
1712
        else:
 
1713
            specific_files = set([''])
 
1714
        # -- specific_files is now a utf8 path set --
 
1715
        # -- get the state object and prepare it.
 
1716
        state = self.target.current_dirstate()
 
1717
        state._read_dirblocks_if_needed()
 
1718
        def _entries_for_path(path):
 
1719
            """Return a list with all the entries that match path for all ids.
 
1720
            """
 
1721
            dirname, basename = os.path.split(path)
 
1722
            key = (dirname, basename, '')
 
1723
            block_index, present = state._find_block_index_from_key(key)
 
1724
            if not present:
 
1725
                # the block which should contain path is absent.
 
1726
                return []
 
1727
            result = []
 
1728
            block = state._dirblocks[block_index][1]
 
1729
            entry_index, _ = state._find_entry_index(key, block)
 
1730
            # we may need to look at multiple entries at this path: walk while the specific_files match.
 
1731
            while (entry_index < len(block) and
 
1732
                block[entry_index][0][0:2] == key[0:2]):
 
1733
                result.append(block[entry_index])
 
1734
                entry_index += 1
 
1735
            return result
 
1736
        if require_versioned:
 
1737
            # -- check all supplied paths are versioned in a search tree. --
 
1738
            all_versioned = True
 
1739
            for path in specific_files:
 
1740
                path_entries = _entries_for_path(path)
 
1741
                if not path_entries:
 
1742
                    # this specified path is not present at all: error
 
1743
                    all_versioned = False
 
1744
                    break
 
1745
                found_versioned = False
 
1746
                # for each id at this path
 
1747
                for entry in path_entries:
 
1748
                    # for each tree.
 
1749
                    for index in indices:
 
1750
                        if entry[1][index][0] != 'a': # absent
 
1751
                            found_versioned = True
 
1752
                            # all good: found a versioned cell
 
1753
                            break
 
1754
                if not found_versioned:
 
1755
                    # none of the indexes was not 'absent' at all ids for this
 
1756
                    # path.
 
1757
                    all_versioned = False
 
1758
                    break
 
1759
            if not all_versioned:
 
1760
                raise errors.PathsNotVersionedError(specific_files)
 
1761
        # -- remove redundancy in supplied specific_files to prevent over-scanning --
 
1762
        search_specific_files = set()
 
1763
        for path in specific_files:
 
1764
            other_specific_files = specific_files.difference(set([path]))
 
1765
            if not osutils.is_inside_any(other_specific_files, path):
 
1766
                # this is a top level path, we must check it.
 
1767
                search_specific_files.add(path)
 
1768
        # sketch: 
 
1769
        # compare source_index and target_index at or under each element of search_specific_files.
 
1770
        # follow the following comparison table. Note that we only want to do diff operations when
 
1771
        # the target is fdl because thats when the walkdirs logic will have exposed the pathinfo 
 
1772
        # for the target.
 
1773
        # cases:
 
1774
        # 
 
1775
        # Source | Target | disk | action
 
1776
        #   r    | fdlt   |      | add source to search, add id path move and perform
 
1777
        #        |        |      | diff check on source-target
 
1778
        #   r    | fdlt   |  a   | dangling file that was present in the basis. 
 
1779
        #        |        |      | ???
 
1780
        #   r    |  a     |      | add source to search
 
1781
        #   r    |  a     |  a   | 
 
1782
        #   r    |  r     |      | this path is present in a non-examined tree, skip.
 
1783
        #   r    |  r     |  a   | this path is present in a non-examined tree, skip.
 
1784
        #   a    | fdlt   |      | add new id
 
1785
        #   a    | fdlt   |  a   | dangling locally added file, skip
 
1786
        #   a    |  a     |      | not present in either tree, skip
 
1787
        #   a    |  a     |  a   | not present in any tree, skip
 
1788
        #   a    |  r     |      | not present in either tree at this path, skip as it
 
1789
        #        |        |      | may not be selected by the users list of paths.
 
1790
        #   a    |  r     |  a   | not present in either tree at this path, skip as it
 
1791
        #        |        |      | may not be selected by the users list of paths.
 
1792
        #  fdlt  | fdlt   |      | content in both: diff them
 
1793
        #  fdlt  | fdlt   |  a   | deleted locally, but not unversioned - show as deleted ?
 
1794
        #  fdlt  |  a     |      | unversioned: output deleted id for now
 
1795
        #  fdlt  |  a     |  a   | unversioned and deleted: output deleted id
 
1796
        #  fdlt  |  r     |      | relocated in this tree, so add target to search.
 
1797
        #        |        |      | Dont diff, we will see an r,fd; pair when we reach
 
1798
        #        |        |      | this id at the other path.
 
1799
        #  fdlt  |  r     |  a   | relocated in this tree, so add target to search.
 
1800
        #        |        |      | Dont diff, we will see an r,fd; pair when we reach
 
1801
        #        |        |      | this id at the other path.
 
1802
 
 
1803
        # for all search_indexs in each path at or under each element of
 
1804
        # search_specific_files, if the detail is relocated: add the id, and add the
 
1805
        # relocated path as one to search if its not searched already. If the
 
1806
        # detail is not relocated, add the id.
 
1807
        searched_specific_files = set()
 
1808
        NULL_PARENT_DETAILS = dirstate.DirState.NULL_PARENT_DETAILS
 
1809
        # Using a list so that we can access the values and change them in
 
1810
        # nested scope. Each one is [path, file_id, entry]
 
1811
        last_source_parent = [None, None]
 
1812
        last_target_parent = [None, None]
 
1813
 
 
1814
        use_filesystem_for_exec = (sys.platform != 'win32')
 
1815
 
 
1816
        # Just a sentry, so that _process_entry can say that this
 
1817
        # record is handled, but isn't interesting to process (unchanged)
 
1818
        uninteresting = object()
 
1819
 
 
1820
 
 
1821
        old_dirname_to_file_id = {}
 
1822
        new_dirname_to_file_id = {}
 
1823
        # TODO: jam 20070516 - Avoid the _get_entry lookup overhead by
 
1824
        #       keeping a cache of directories that we have seen.
 
1825
 
 
1826
        def _process_entry(entry, path_info):
 
1827
            """Compare an entry and real disk to generate delta information.
 
1828
 
 
1829
            :param path_info: top_relpath, basename, kind, lstat, abspath for
 
1830
                the path of entry. If None, then the path is considered absent.
 
1831
                (Perhaps we should pass in a concrete entry for this ?)
 
1832
                Basename is returned as a utf8 string because we expect this
 
1833
                tuple will be ignored, and don't want to take the time to
 
1834
                decode.
 
1835
            :return: None if these don't match
 
1836
                     A tuple of information about the change, or
 
1837
                     the object 'uninteresting' if these match, but are
 
1838
                     basically identical.
 
1839
            """
 
1840
            if source_index is None:
 
1841
                source_details = NULL_PARENT_DETAILS
 
1842
            else:
 
1843
                source_details = entry[1][source_index]
 
1844
            target_details = entry[1][target_index]
 
1845
            target_minikind = target_details[0]
 
1846
            if path_info is not None and target_minikind in 'fdlt':
 
1847
                assert target_index == 0
 
1848
                link_or_sha1 = state.update_entry(entry, abspath=path_info[4],
 
1849
                                                  stat_value=path_info[3])
 
1850
                # The entry may have been modified by update_entry
 
1851
                target_details = entry[1][target_index]
 
1852
                target_minikind = target_details[0]
 
1853
            else:
 
1854
                link_or_sha1 = None
 
1855
            file_id = entry[0][2]
 
1856
            source_minikind = source_details[0]
 
1857
            if source_minikind in 'fdltr' and target_minikind in 'fdlt':
 
1858
                # claimed content in both: diff
 
1859
                #   r    | fdlt   |      | add source to search, add id path move and perform
 
1860
                #        |        |      | diff check on source-target
 
1861
                #   r    | fdlt   |  a   | dangling file that was present in the basis.
 
1862
                #        |        |      | ???
 
1863
                if source_minikind in 'r':
 
1864
                    # add the source to the search path to find any children it
 
1865
                    # has.  TODO ? : only add if it is a container ?
 
1866
                    if not osutils.is_inside_any(searched_specific_files,
 
1867
                                                 source_details[1]):
 
1868
                        search_specific_files.add(source_details[1])
 
1869
                    # generate the old path; this is needed for stating later
 
1870
                    # as well.
 
1871
                    old_path = source_details[1]
 
1872
                    old_dirname, old_basename = os.path.split(old_path)
 
1873
                    path = pathjoin(entry[0][0], entry[0][1])
 
1874
                    old_entry = state._get_entry(source_index,
 
1875
                                                 path_utf8=old_path)
 
1876
                    # update the source details variable to be the real
 
1877
                    # location.
 
1878
                    source_details = old_entry[1][source_index]
 
1879
                    source_minikind = source_details[0]
 
1880
                else:
 
1881
                    old_dirname = entry[0][0]
 
1882
                    old_basename = entry[0][1]
 
1883
                    old_path = path = None
 
1884
                if path_info is None:
 
1885
                    # the file is missing on disk, show as removed.
 
1886
                    content_change = True
 
1887
                    target_kind = None
 
1888
                    target_exec = False
 
1889
                else:
 
1890
                    # source and target are both versioned and disk file is present.
 
1891
                    target_kind = path_info[2]
 
1892
                    if target_kind == 'directory':
 
1893
                        if path is None:
 
1894
                            old_path = path = pathjoin(old_dirname, old_basename)
 
1895
                        new_dirname_to_file_id[path] = file_id
 
1896
                        if source_minikind != 'd':
 
1897
                            content_change = True
 
1898
                        else:
 
1899
                            # directories have no fingerprint
 
1900
                            content_change = False
 
1901
                        target_exec = False
 
1902
                    elif target_kind == 'file':
 
1903
                        if source_minikind != 'f':
 
1904
                            content_change = True
 
1905
                        else:
 
1906
                            # We could check the size, but we already have the
 
1907
                            # sha1 hash.
 
1908
                            content_change = (link_or_sha1 != source_details[1])
 
1909
                        # Target details is updated at update_entry time
 
1910
                        if use_filesystem_for_exec:
 
1911
                            # We don't need S_ISREG here, because we are sure
 
1912
                            # we are dealing with a file.
 
1913
                            target_exec = bool(stat.S_IEXEC & path_info[3].st_mode)
 
1914
                        else:
 
1915
                            target_exec = target_details[3]
 
1916
                    elif target_kind == 'symlink':
 
1917
                        if source_minikind != 'l':
 
1918
                            content_change = True
 
1919
                        else:
 
1920
                            content_change = (link_or_sha1 != source_details[1])
 
1921
                        target_exec = False
 
1922
                    elif target_kind == 'tree-reference':
 
1923
                        if source_minikind != 't':
 
1924
                            content_change = True
 
1925
                        else:
 
1926
                            content_change = False
 
1927
                        target_exec = False
 
1928
                    else:
 
1929
                        raise Exception, "unknown kind %s" % path_info[2]
 
1930
                if source_minikind == 'd':
 
1931
                    if path is None:
 
1932
                        old_path = path = pathjoin(old_dirname, old_basename)
 
1933
                    old_dirname_to_file_id[old_path] = file_id
 
1934
                # parent id is the entry for the path in the target tree
 
1935
                if old_dirname == last_source_parent[0]:
 
1936
                    source_parent_id = last_source_parent[1]
 
1937
                else:
 
1938
                    try:
 
1939
                        source_parent_id = old_dirname_to_file_id[old_dirname]
 
1940
                    except KeyError:
 
1941
                        source_parent_entry = state._get_entry(source_index,
 
1942
                                                               path_utf8=old_dirname)
 
1943
                        source_parent_id = source_parent_entry[0][2]
 
1944
                    if source_parent_id == entry[0][2]:
 
1945
                        # This is the root, so the parent is None
 
1946
                        source_parent_id = None
 
1947
                    else:
 
1948
                        last_source_parent[0] = old_dirname
 
1949
                        last_source_parent[1] = source_parent_id
 
1950
                new_dirname = entry[0][0]
 
1951
                if new_dirname == last_target_parent[0]:
 
1952
                    target_parent_id = last_target_parent[1]
 
1953
                else:
 
1954
                    try:
 
1955
                        target_parent_id = new_dirname_to_file_id[new_dirname]
 
1956
                    except KeyError:
 
1957
                        # TODO: We don't always need to do the lookup, because the
 
1958
                        #       parent entry will be the same as the source entry.
 
1959
                        target_parent_entry = state._get_entry(target_index,
 
1960
                                                               path_utf8=new_dirname)
 
1961
                        assert target_parent_entry != (None, None), (
 
1962
                            "Could not find target parent in wt: %s\nparent of: %s"
 
1963
                            % (new_dirname, entry))
 
1964
                        target_parent_id = target_parent_entry[0][2]
 
1965
                    if target_parent_id == entry[0][2]:
 
1966
                        # This is the root, so the parent is None
 
1967
                        target_parent_id = None
 
1968
                    else:
 
1969
                        last_target_parent[0] = new_dirname
 
1970
                        last_target_parent[1] = target_parent_id
 
1971
 
 
1972
                source_exec = source_details[3]
 
1973
                if (include_unchanged
 
1974
                    or content_change
 
1975
                    or source_parent_id != target_parent_id
 
1976
                    or old_basename != entry[0][1]
 
1977
                    or source_exec != target_exec
 
1978
                    ):
 
1979
                    if old_path is None:
 
1980
                        old_path = path = pathjoin(old_dirname, old_basename)
 
1981
                        old_path_u = utf8_decode(old_path)[0]
 
1982
                        path_u = old_path_u
 
1983
                    else:
 
1984
                        old_path_u = utf8_decode(old_path)[0]
 
1985
                        if old_path == path:
 
1986
                            path_u = old_path_u
 
1987
                        else:
 
1988
                            path_u = utf8_decode(path)[0]
 
1989
                    source_kind = _minikind_to_kind[source_minikind]
 
1990
                    return (entry[0][2],
 
1991
                           (old_path_u, path_u),
 
1992
                           content_change,
 
1993
                           (True, True),
 
1994
                           (source_parent_id, target_parent_id),
 
1995
                           (utf8_decode(old_basename)[0], utf8_decode(entry[0][1])[0]),
 
1996
                           (source_kind, target_kind),
 
1997
                           (source_exec, target_exec))
 
1998
                else:
 
1999
                    return uninteresting
 
2000
            elif source_minikind in 'a' and target_minikind in 'fdlt':
 
2001
                # looks like a new file
 
2002
                if path_info is not None:
 
2003
                    path = pathjoin(entry[0][0], entry[0][1])
 
2004
                    # parent id is the entry for the path in the target tree
 
2005
                    # TODO: these are the same for an entire directory: cache em.
 
2006
                    parent_id = state._get_entry(target_index,
 
2007
                                                 path_utf8=entry[0][0])[0][2]
 
2008
                    if parent_id == entry[0][2]:
 
2009
                        parent_id = None
 
2010
                    if use_filesystem_for_exec:
 
2011
                        # We need S_ISREG here, because we aren't sure if this
 
2012
                        # is a file or not.
 
2013
                        target_exec = bool(
 
2014
                            stat.S_ISREG(path_info[3].st_mode)
 
2015
                            and stat.S_IEXEC & path_info[3].st_mode)
 
2016
                    else:
 
2017
                        target_exec = target_details[3]
 
2018
                    return (entry[0][2],
 
2019
                           (None, utf8_decode(path)[0]),
 
2020
                           True,
 
2021
                           (False, True),
 
2022
                           (None, parent_id),
 
2023
                           (None, utf8_decode(entry[0][1])[0]),
 
2024
                           (None, path_info[2]),
 
2025
                           (None, target_exec))
 
2026
                else:
 
2027
                    # but its not on disk: we deliberately treat this as just
 
2028
                    # never-present. (Why ?! - RBC 20070224)
 
2029
                    pass
 
2030
            elif source_minikind in 'fdlt' and target_minikind in 'a':
 
2031
                # unversioned, possibly, or possibly not deleted: we dont care.
 
2032
                # if its still on disk, *and* theres no other entry at this
 
2033
                # path [we dont know this in this routine at the moment -
 
2034
                # perhaps we should change this - then it would be an unknown.
 
2035
                old_path = pathjoin(entry[0][0], entry[0][1])
 
2036
                # parent id is the entry for the path in the target tree
 
2037
                parent_id = state._get_entry(source_index, path_utf8=entry[0][0])[0][2]
 
2038
                if parent_id == entry[0][2]:
 
2039
                    parent_id = None
 
2040
                return (entry[0][2],
 
2041
                       (utf8_decode(old_path)[0], None),
 
2042
                       True,
 
2043
                       (True, False),
 
2044
                       (parent_id, None),
 
2045
                       (utf8_decode(entry[0][1])[0], None),
 
2046
                       (_minikind_to_kind[source_minikind], None),
 
2047
                       (source_details[3], None))
 
2048
            elif source_minikind in 'fdlt' and target_minikind in 'r':
 
2049
                # a rename; could be a true rename, or a rename inherited from
 
2050
                # a renamed parent. TODO: handle this efficiently. Its not
 
2051
                # common case to rename dirs though, so a correct but slow
 
2052
                # implementation will do.
 
2053
                if not osutils.is_inside_any(searched_specific_files, target_details[1]):
 
2054
                    search_specific_files.add(target_details[1])
 
2055
            elif source_minikind in 'ra' and target_minikind in 'ra':
 
2056
                # neither of the selected trees contain this file,
 
2057
                # so skip over it. This is not currently directly tested, but
 
2058
                # is indirectly via test_too_much.TestCommands.test_conflicts.
 
2059
                pass
 
2060
            else:
 
2061
                raise AssertionError("don't know how to compare "
 
2062
                    "source_minikind=%r, target_minikind=%r"
 
2063
                    % (source_minikind, target_minikind))
 
2064
                ## import pdb;pdb.set_trace()
 
2065
            return None
 
2066
 
 
2067
        while search_specific_files:
 
2068
            # TODO: the pending list should be lexically sorted?  the
 
2069
            # interface doesn't require it.
 
2070
            current_root = search_specific_files.pop()
 
2071
            current_root_unicode = current_root.decode('utf8')
 
2072
            searched_specific_files.add(current_root)
 
2073
            # process the entries for this containing directory: the rest will be
 
2074
            # found by their parents recursively.
 
2075
            root_entries = _entries_for_path(current_root)
 
2076
            root_abspath = self.target.abspath(current_root_unicode)
 
2077
            try:
 
2078
                root_stat = os.lstat(root_abspath)
 
2079
            except OSError, e:
 
2080
                if e.errno == errno.ENOENT:
 
2081
                    # the path does not exist: let _process_entry know that.
 
2082
                    root_dir_info = None
 
2083
                else:
 
2084
                    # some other random error: hand it up.
 
2085
                    raise
 
2086
            else:
 
2087
                root_dir_info = ('', current_root,
 
2088
                    osutils.file_kind_from_stat_mode(root_stat.st_mode), root_stat,
 
2089
                    root_abspath)
 
2090
                if root_dir_info[2] == 'directory':
 
2091
                    if self.target._directory_is_tree_reference(
 
2092
                        current_root.decode('utf8')):
 
2093
                        root_dir_info = root_dir_info[:2] + \
 
2094
                            ('tree-reference',) + root_dir_info[3:]
 
2095
 
 
2096
            if not root_entries and not root_dir_info:
 
2097
                # this specified path is not present at all, skip it.
 
2098
                continue
 
2099
            path_handled = False
 
2100
            for entry in root_entries:
 
2101
                result = _process_entry(entry, root_dir_info)
 
2102
                if result is not None:
 
2103
                    path_handled = True
 
2104
                    if result is not uninteresting:
 
2105
                        yield result
 
2106
            if want_unversioned and not path_handled and root_dir_info:
 
2107
                new_executable = bool(
 
2108
                    stat.S_ISREG(root_dir_info[3].st_mode)
 
2109
                    and stat.S_IEXEC & root_dir_info[3].st_mode)
 
2110
                yield (None,
 
2111
                       (None, current_root_unicode),
 
2112
                       True,
 
2113
                       (False, False),
 
2114
                       (None, None),
 
2115
                       (None, splitpath(current_root_unicode)[-1]),
 
2116
                       (None, root_dir_info[2]),
 
2117
                       (None, new_executable)
 
2118
                      )
 
2119
            initial_key = (current_root, '', '')
 
2120
            block_index, _ = state._find_block_index_from_key(initial_key)
 
2121
            if block_index == 0:
 
2122
                # we have processed the total root already, but because the
 
2123
                # initial key matched it we should skip it here.
 
2124
                block_index +=1
 
2125
            if root_dir_info and root_dir_info[2] == 'tree-reference':
 
2126
                current_dir_info = None
 
2127
            else:
 
2128
                dir_iterator = osutils._walkdirs_utf8(root_abspath, prefix=current_root)
 
2129
                try:
 
2130
                    current_dir_info = dir_iterator.next()
 
2131
                except OSError, e:
 
2132
                    # on win32, python2.4 has e.errno == ERROR_DIRECTORY, but
 
2133
                    # python 2.5 has e.errno == EINVAL,
 
2134
                    #            and e.winerror == ERROR_DIRECTORY
 
2135
                    e_winerror = getattr(e, 'winerror', None)
 
2136
                    win_errors = (ERROR_DIRECTORY, ERROR_PATH_NOT_FOUND)
 
2137
                    # there may be directories in the inventory even though
 
2138
                    # this path is not a file on disk: so mark it as end of
 
2139
                    # iterator
 
2140
                    if e.errno in (errno.ENOENT, errno.ENOTDIR, errno.EINVAL):
 
2141
                        current_dir_info = None
 
2142
                    elif (sys.platform == 'win32'
 
2143
                          and (e.errno in win_errors
 
2144
                               or e_winerror in win_errors)):
 
2145
                        current_dir_info = None
 
2146
                    else:
 
2147
                        raise
 
2148
                else:
 
2149
                    if current_dir_info[0][0] == '':
 
2150
                        # remove .bzr from iteration
 
2151
                        bzr_index = bisect_left(current_dir_info[1], ('.bzr',))
 
2152
                        assert current_dir_info[1][bzr_index][0] == '.bzr'
 
2153
                        del current_dir_info[1][bzr_index]
 
2154
            # walk until both the directory listing and the versioned metadata
 
2155
            # are exhausted. 
 
2156
            if (block_index < len(state._dirblocks) and
 
2157
                osutils.is_inside(current_root, state._dirblocks[block_index][0])):
 
2158
                current_block = state._dirblocks[block_index]
 
2159
            else:
 
2160
                current_block = None
 
2161
            while (current_dir_info is not None or
 
2162
                   current_block is not None):
 
2163
                if (current_dir_info and current_block
 
2164
                    and current_dir_info[0][0] != current_block[0]):
 
2165
                    if current_dir_info[0][0].split('/') < current_block[0].split('/'):
 
2166
                        # filesystem data refers to paths not covered by the dirblock.
 
2167
                        # this has two possibilities:
 
2168
                        # A) it is versioned but empty, so there is no block for it
 
2169
                        # B) it is not versioned.
 
2170
 
 
2171
                        # if (A) then we need to recurse into it to check for
 
2172
                        # new unknown files or directories.
 
2173
                        # if (B) then we should ignore it, because we don't
 
2174
                        # recurse into unknown directories.
 
2175
                        path_index = 0
 
2176
                        while path_index < len(current_dir_info[1]):
 
2177
                                current_path_info = current_dir_info[1][path_index]
 
2178
                                if want_unversioned:
 
2179
                                    if current_path_info[2] == 'directory':
 
2180
                                        if self.target._directory_is_tree_reference(
 
2181
                                            current_path_info[0].decode('utf8')):
 
2182
                                            current_path_info = current_path_info[:2] + \
 
2183
                                                ('tree-reference',) + current_path_info[3:]
 
2184
                                    new_executable = bool(
 
2185
                                        stat.S_ISREG(current_path_info[3].st_mode)
 
2186
                                        and stat.S_IEXEC & current_path_info[3].st_mode)
 
2187
                                    yield (None,
 
2188
                                        (None, utf8_decode(current_path_info[0])[0]),
 
2189
                                        True,
 
2190
                                        (False, False),
 
2191
                                        (None, None),
 
2192
                                        (None, utf8_decode(current_path_info[1])[0]),
 
2193
                                        (None, current_path_info[2]),
 
2194
                                        (None, new_executable))
 
2195
                                # dont descend into this unversioned path if it is
 
2196
                                # a dir
 
2197
                                if current_path_info[2] in ('directory',
 
2198
                                                            'tree-reference'):
 
2199
                                    del current_dir_info[1][path_index]
 
2200
                                    path_index -= 1
 
2201
                                path_index += 1
 
2202
 
 
2203
                        # This dir info has been handled, go to the next
 
2204
                        try:
 
2205
                            current_dir_info = dir_iterator.next()
 
2206
                        except StopIteration:
 
2207
                            current_dir_info = None
 
2208
                    else:
 
2209
                        # We have a dirblock entry for this location, but there
 
2210
                        # is no filesystem path for this. This is most likely
 
2211
                        # because a directory was removed from the disk.
 
2212
                        # We don't have to report the missing directory,
 
2213
                        # because that should have already been handled, but we
 
2214
                        # need to handle all of the files that are contained
 
2215
                        # within.
 
2216
                        for current_entry in current_block[1]:
 
2217
                            # entry referring to file not present on disk.
 
2218
                            # advance the entry only, after processing.
 
2219
                            result = _process_entry(current_entry, None)
 
2220
                            if result is not None:
 
2221
                                if result is not uninteresting:
 
2222
                                    yield result
 
2223
                        block_index +=1
 
2224
                        if (block_index < len(state._dirblocks) and
 
2225
                            osutils.is_inside(current_root,
 
2226
                                              state._dirblocks[block_index][0])):
 
2227
                            current_block = state._dirblocks[block_index]
 
2228
                        else:
 
2229
                            current_block = None
 
2230
                    continue
 
2231
                entry_index = 0
 
2232
                if current_block and entry_index < len(current_block[1]):
 
2233
                    current_entry = current_block[1][entry_index]
 
2234
                else:
 
2235
                    current_entry = None
 
2236
                advance_entry = True
 
2237
                path_index = 0
 
2238
                if current_dir_info and path_index < len(current_dir_info[1]):
 
2239
                    current_path_info = current_dir_info[1][path_index]
 
2240
                    if current_path_info[2] == 'directory':
 
2241
                        if self.target._directory_is_tree_reference(
 
2242
                            current_path_info[0].decode('utf8')):
 
2243
                            current_path_info = current_path_info[:2] + \
 
2244
                                ('tree-reference',) + current_path_info[3:]
 
2245
                else:
 
2246
                    current_path_info = None
 
2247
                advance_path = True
 
2248
                path_handled = False
 
2249
                while (current_entry is not None or
 
2250
                    current_path_info is not None):
 
2251
                    if current_entry is None:
 
2252
                        # the check for path_handled when the path is adnvaced
 
2253
                        # will yield this path if needed.
 
2254
                        pass
 
2255
                    elif current_path_info is None:
 
2256
                        # no path is fine: the per entry code will handle it.
 
2257
                        result = _process_entry(current_entry, current_path_info)
 
2258
                        if result is not None:
 
2259
                            if result is not uninteresting:
 
2260
                                yield result
 
2261
                    elif (current_entry[0][1] != current_path_info[1]
 
2262
                          or current_entry[1][target_index][0] in 'ar'):
 
2263
                        # The current path on disk doesn't match the dirblock
 
2264
                        # record. Either the dirblock is marked as absent, or
 
2265
                        # the file on disk is not present at all in the
 
2266
                        # dirblock. Either way, report about the dirblock
 
2267
                        # entry, and let other code handle the filesystem one.
 
2268
                        if current_path_info[1].split('/') < current_entry[0][1].split('/'):
 
2269
                            # extra file on disk: pass for now, but only
 
2270
                            # increment the path, not the entry
 
2271
                            advance_entry = False
 
2272
                        else:
 
2273
                            # entry referring to file not present on disk.
 
2274
                            # advance the entry only, after processing.
 
2275
                            result = _process_entry(current_entry, None)
 
2276
                            if result is not None:
 
2277
                                if result is not uninteresting:
 
2278
                                    yield result
 
2279
                            advance_path = False
 
2280
                    else:
 
2281
                        result = _process_entry(current_entry, current_path_info)
 
2282
                        if result is not None:
 
2283
                            path_handled = True
 
2284
                            if result is not uninteresting:
 
2285
                                yield result
 
2286
                    if advance_entry and current_entry is not None:
 
2287
                        entry_index += 1
 
2288
                        if entry_index < len(current_block[1]):
 
2289
                            current_entry = current_block[1][entry_index]
 
2290
                        else:
 
2291
                            current_entry = None
 
2292
                    else:
 
2293
                        advance_entry = True # reset the advance flaga
 
2294
                    if advance_path and current_path_info is not None:
 
2295
                        if not path_handled:
 
2296
                            # unversioned in all regards
 
2297
                            if want_unversioned:
 
2298
                                new_executable = bool(
 
2299
                                    stat.S_ISREG(current_path_info[3].st_mode)
 
2300
                                    and stat.S_IEXEC & current_path_info[3].st_mode)
 
2301
                                yield (None,
 
2302
                                    (None, utf8_decode(current_path_info[0])[0]),
 
2303
                                    True,
 
2304
                                    (False, False),
 
2305
                                    (None, None),
 
2306
                                    (None, utf8_decode(current_path_info[1])[0]),
 
2307
                                    (None, current_path_info[2]),
 
2308
                                    (None, new_executable))
 
2309
                            # dont descend into this unversioned path if it is
 
2310
                            # a dir
 
2311
                            if current_path_info[2] in ('directory'):
 
2312
                                del current_dir_info[1][path_index]
 
2313
                                path_index -= 1
 
2314
                        # dont descend the disk iterator into any tree 
 
2315
                        # paths.
 
2316
                        if current_path_info[2] == 'tree-reference':
 
2317
                            del current_dir_info[1][path_index]
 
2318
                            path_index -= 1
 
2319
                        path_index += 1
 
2320
                        if path_index < len(current_dir_info[1]):
 
2321
                            current_path_info = current_dir_info[1][path_index]
 
2322
                            if current_path_info[2] == 'directory':
 
2323
                                if self.target._directory_is_tree_reference(
 
2324
                                    current_path_info[0].decode('utf8')):
 
2325
                                    current_path_info = current_path_info[:2] + \
 
2326
                                        ('tree-reference',) + current_path_info[3:]
 
2327
                        else:
 
2328
                            current_path_info = None
 
2329
                        path_handled = False
 
2330
                    else:
 
2331
                        advance_path = True # reset the advance flagg.
 
2332
                if current_block is not None:
 
2333
                    block_index += 1
 
2334
                    if (block_index < len(state._dirblocks) and
 
2335
                        osutils.is_inside(current_root, state._dirblocks[block_index][0])):
 
2336
                        current_block = state._dirblocks[block_index]
 
2337
                    else:
 
2338
                        current_block = None
 
2339
                if current_dir_info is not None:
 
2340
                    try:
 
2341
                        current_dir_info = dir_iterator.next()
 
2342
                    except StopIteration:
 
2343
                        current_dir_info = None
 
2344
 
 
2345
 
 
2346
    @staticmethod
 
2347
    def is_compatible(source, target):
 
2348
        # the target must be a dirstate working tree
 
2349
        if not isinstance(target, WorkingTree4):
 
2350
            return False
 
2351
        # the source must be a revtreee or dirstate rev tree.
 
2352
        if not isinstance(source,
 
2353
            (revisiontree.RevisionTree, DirStateRevisionTree)):
 
2354
            return False
 
2355
        # the source revid must be in the target dirstate
 
2356
        if not (source._revision_id == NULL_REVISION or
 
2357
            source._revision_id in target.get_parent_ids()):
 
2358
            # TODO: what about ghosts? it may well need to 
 
2359
            # check for them explicitly.
 
2360
            return False
 
2361
        return True
 
2362
 
 
2363
InterTree.register_optimiser(InterDirStateTree)
 
2364
 
 
2365
 
 
2366
class Converter3to4(object):
 
2367
    """Perform an in-place upgrade of format 3 to format 4 trees."""
 
2368
 
 
2369
    def __init__(self):
 
2370
        self.target_format = WorkingTreeFormat4()
 
2371
 
 
2372
    def convert(self, tree):
 
2373
        # lock the control files not the tree, so that we dont get tree
 
2374
        # on-unlock behaviours, and so that noone else diddles with the 
 
2375
        # tree during upgrade.
 
2376
        tree._control_files.lock_write()
 
2377
        try:
 
2378
            tree.read_working_inventory()
 
2379
            self.create_dirstate_data(tree)
 
2380
            self.update_format(tree)
 
2381
            self.remove_xml_files(tree)
 
2382
        finally:
 
2383
            tree._control_files.unlock()
 
2384
 
 
2385
    def create_dirstate_data(self, tree):
 
2386
        """Create the dirstate based data for tree."""
 
2387
        local_path = tree.bzrdir.get_workingtree_transport(None
 
2388
            ).local_abspath('dirstate')
 
2389
        state = dirstate.DirState.from_tree(tree, local_path)
 
2390
        state.save()
 
2391
        state.unlock()
 
2392
 
 
2393
    def remove_xml_files(self, tree):
 
2394
        """Remove the oldformat 3 data."""
 
2395
        transport = tree.bzrdir.get_workingtree_transport(None)
 
2396
        for path in ['basis-inventory-cache', 'inventory', 'last-revision',
 
2397
            'pending-merges', 'stat-cache']:
 
2398
            try:
 
2399
                transport.delete(path)
 
2400
            except errors.NoSuchFile:
 
2401
                # some files are optional - just deal.
 
2402
                pass
 
2403
 
 
2404
    def update_format(self, tree):
 
2405
        """Change the format marker."""
 
2406
        tree._control_files.put_utf8('format',
 
2407
            self.target_format.get_format_string())