~bzr-pqm/bzr/bzr.dev

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