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