/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/workingtree_4.py

  • Committer: John Arbash Meinel
  • Date: 2008-07-09 21:42:24 UTC
  • mto: This revision was merged to the branch mainline in revision 3543.
  • Revision ID: john@arbash-meinel.com-20080709214224-r75k87r6a01pfc3h
Restore a real weave merge to 'bzr merge --weave'.

To do so efficiently, we only add the simple LCAs to the final weave
object, unless we run into complexities with the merge graph.
This gives the same effective result as adding all the texts,
with the advantage of not having to extract all of them.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/workingtree_4.py
1
 
# Copyright (C) 2007-2010 Canonical Ltd
 
1
# Copyright (C) 2005, 2006, 2007, 2008 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
12
12
#
13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
 
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
16
 
17
17
"""WorkingTree4 format and implementation.
18
18
 
28
28
 
29
29
from bzrlib.lazy_import import lazy_import
30
30
lazy_import(globals(), """
 
31
from bisect import bisect_left
 
32
import collections
 
33
from copy import deepcopy
31
34
import errno
 
35
import itertools
 
36
import operator
32
37
import stat
 
38
from time import time
 
39
import warnings
33
40
 
34
41
import bzrlib
35
42
from bzrlib import (
36
43
    bzrdir,
37
44
    cache_utf8,
 
45
    conflicts as _mod_conflicts,
38
46
    debug,
 
47
    delta,
39
48
    dirstate,
40
49
    errors,
41
50
    generate_ids,
 
51
    globbing,
 
52
    ignores,
 
53
    merge,
42
54
    osutils,
43
55
    revision as _mod_revision,
44
56
    revisiontree,
 
57
    textui,
45
58
    trace,
46
59
    transform,
47
 
    views,
 
60
    urlutils,
 
61
    xml5,
 
62
    xml6,
48
63
    )
49
64
import bzrlib.branch
 
65
from bzrlib.transport import get_transport
50
66
import bzrlib.ui
51
67
""")
52
68
 
 
69
from bzrlib import symbol_versioning
53
70
from bzrlib.decorators import needs_read_lock, needs_write_lock
54
 
from bzrlib.filters import filtered_input_file, internal_size_sha_file_byname
55
 
from bzrlib.inventory import Inventory, ROOT_ID, entry_factory
 
71
from bzrlib.inventory import InventoryEntry, Inventory, ROOT_ID, entry_factory
 
72
from bzrlib.lockable_files import LockableFiles, TransportLock
 
73
from bzrlib.lockdir import LockDir
 
74
import bzrlib.mutabletree
56
75
from bzrlib.mutabletree import needs_tree_write_lock
57
76
from bzrlib.osutils import (
58
77
    file_kind,
59
78
    isdir,
 
79
    normpath,
60
80
    pathjoin,
 
81
    rand_chars,
61
82
    realpath,
62
83
    safe_unicode,
 
84
    splitpath,
63
85
    )
64
 
from bzrlib.trace import mutter
 
86
from bzrlib.trace import mutter, note
65
87
from bzrlib.transport.local import LocalTransport
66
88
from bzrlib.tree import InterTree
 
89
from bzrlib.progress import DummyProgress, ProgressPhase
 
90
from bzrlib.revision import NULL_REVISION, CURRENT_REVISION
 
91
from bzrlib.rio import RioReader, rio_file, Stanza
 
92
from bzrlib.symbol_versioning import (deprecated_passed,
 
93
        deprecated_method,
 
94
        deprecated_function,
 
95
        DEPRECATED_PARAMETER,
 
96
        )
67
97
from bzrlib.tree import Tree
68
98
from bzrlib.workingtree import WorkingTree, WorkingTree3, WorkingTreeFormat3
69
99
 
70
100
 
71
 
class DirStateWorkingTree(WorkingTree3):
 
101
# This is the Windows equivalent of ENOTDIR
 
102
# It is defined in pywin32.winerror, but we don't want a strong dependency for
 
103
# just an error code.
 
104
ERROR_PATH_NOT_FOUND = 3
 
105
ERROR_DIRECTORY = 267
 
106
 
 
107
 
 
108
class WorkingTree4(WorkingTree3):
 
109
    """This is the Format 4 working tree.
 
110
 
 
111
    This differs from WorkingTree3 by:
 
112
     - Having a consolidated internal dirstate, stored in a
 
113
       randomly-accessible sorted file on disk.
 
114
     - Not having a regular inventory attribute.  One can be synthesized 
 
115
       on demand but this is expensive and should be avoided.
 
116
 
 
117
    This is new in bzr 0.15.
 
118
    """
 
119
 
72
120
    def __init__(self, basedir,
73
121
                 branch,
74
122
                 _control_files=None,
100
148
        #-------------
101
149
        self._setup_directory_is_tree_reference()
102
150
        self._detect_case_handling()
103
 
        self._rules_searcher = None
104
 
        self.views = self._make_views()
105
 
        #--- allow tests to select the dirstate iter_changes implementation
106
 
        self._iter_changes = dirstate._process_entry
107
151
 
108
152
    @needs_tree_write_lock
109
153
    def _add(self, files, ids, kinds):
137
181
    @needs_tree_write_lock
138
182
    def add_reference(self, sub_tree):
139
183
        # use standard implementation, which calls back to self._add
140
 
        #
 
184
        # 
141
185
        # So we don't store the reference_revision in the working dirstate,
142
 
        # it's just recorded at the moment of commit.
 
186
        # it's just recorded at the moment of commit. 
143
187
        self._add_reference(sub_tree)
144
188
 
145
189
    def break_lock(self):
184
228
            WorkingTree3._comparison_data(self, entry, path)
185
229
        # it looks like a plain directory, but it's really a reference -- see
186
230
        # also kind()
187
 
        if (self._repo_supports_tree_reference and kind == 'directory'
188
 
            and entry is not None and entry.kind == 'tree-reference'):
 
231
        if (self._repo_supports_tree_reference and
 
232
            kind == 'directory' and
 
233
            self._directory_is_tree_reference(path)):
189
234
            kind = 'tree-reference'
190
235
        return kind, executable, stat_value
191
236
 
217
262
            return self._dirstate
218
263
        local_path = self.bzrdir.get_workingtree_transport(None
219
264
            ).local_abspath('dirstate')
220
 
        self._dirstate = dirstate.DirState.on_file(local_path,
221
 
            self._sha1_provider())
 
265
        self._dirstate = dirstate.DirState.on_file(local_path)
222
266
        return self._dirstate
223
267
 
224
 
    def _sha1_provider(self):
225
 
        """A function that returns a SHA1Provider suitable for this tree.
226
 
 
227
 
        :return: None if content filtering is not supported by this tree.
228
 
          Otherwise, a SHA1Provider is returned that sha's the canonical
229
 
          form of files, i.e. after read filters are applied.
230
 
        """
231
 
        if self.supports_content_filtering():
232
 
            return ContentFilterAwareSHA1Provider(self)
233
 
        else:
234
 
            return None
235
 
 
236
268
    def filter_unversioned_files(self, paths):
237
269
        """Filter out paths that are versioned.
238
270
 
270
302
 
271
303
    def _generate_inventory(self):
272
304
        """Create and set self.inventory from the dirstate object.
273
 
 
 
305
        
274
306
        This is relatively expensive: we have to walk the entire dirstate.
275
307
        Ideally we would not, and can deprecate this function.
276
308
        """
321
353
                    parent_ies[(dirname + '/' + name).strip('/')] = inv_entry
322
354
                elif kind == 'tree-reference':
323
355
                    if not self._repo_supports_tree_reference:
324
 
                        raise errors.UnsupportedOperation(
325
 
                            self._generate_inventory,
326
 
                            self.branch.repository)
 
356
                        raise AssertionError(
 
357
                            "repository of %r "
 
358
                            "doesn't support tree references "
 
359
                            "required by entry %r"
 
360
                            % (self, name))
327
361
                    inv_entry.reference_revision = link_or_sha1 or None
328
362
                elif kind != 'symlink':
329
363
                    raise AssertionError("unknown kind %r" % kind)
344
378
        If either file_id or path is supplied, it is used as the key to lookup.
345
379
        If both are supplied, the fastest lookup is used, and an error is
346
380
        raised if they do not both point at the same row.
347
 
 
 
381
        
348
382
        :param file_id: An optional unicode file_id to be looked up.
349
383
        :param path: An optional unicode path to be looked up.
350
384
        :return: The dirstate row tuple for path/file_id, or (None, None)
374
408
                    return None
375
409
                else:
376
410
                    raise
377
 
        link_or_sha1 = dirstate.update_entry(state, entry, file_abspath,
378
 
            stat_value=stat_value)
 
411
        link_or_sha1 = state.update_entry(entry, file_abspath,
 
412
                                          stat_value=stat_value)
379
413
        if entry[1][0][0] == 'f':
380
 
            if link_or_sha1 is None:
381
 
                file_obj, statvalue = self.get_file_with_stat(file_id, path)
382
 
                try:
383
 
                    sha1 = osutils.sha_file(file_obj)
384
 
                finally:
385
 
                    file_obj.close()
386
 
                self._observed_sha1(file_id, path, (sha1, statvalue))
387
 
                return sha1
388
 
            else:
389
 
                return link_or_sha1
 
414
            return link_or_sha1
390
415
        return None
391
416
 
392
417
    def _get_inventory(self):
406
431
    @needs_read_lock
407
432
    def get_parent_ids(self):
408
433
        """See Tree.get_parent_ids.
409
 
 
 
434
        
410
435
        This implementation requests the ids list from the dirstate file.
411
436
        """
412
437
        return self.current_dirstate().get_parent_ids()
434
459
        return osutils.lexists(pathjoin(
435
460
                    self.basedir, row[0].decode('utf8'), row[1].decode('utf8')))
436
461
 
437
 
    def has_or_had_id(self, file_id):
438
 
        state = self.current_dirstate()
439
 
        row, parents = self._get_entry(file_id=file_id)
440
 
        return row is not None
441
 
 
442
462
    @needs_read_lock
443
463
    def id2path(self, file_id):
444
464
        "Convert a file-id to a path."
527
547
                # path is missing on disk.
528
548
                continue
529
549
 
530
 
    def _observed_sha1(self, file_id, path, (sha1, statvalue)):
531
 
        """See MutableTree._observed_sha1."""
532
 
        state = self.current_dirstate()
533
 
        entry = self._get_entry(file_id=file_id, path=path)
534
 
        state._observed_sha1(entry, sha1, statvalue)
535
 
 
536
550
    def kind(self, file_id):
537
551
        """Return the kind of a file.
538
552
 
550
564
    def _kind(self, relpath):
551
565
        abspath = self.abspath(relpath)
552
566
        kind = file_kind(abspath)
553
 
        if (self._repo_supports_tree_reference and kind == 'directory'):
554
 
            entry = self._get_entry(path=relpath)
555
 
            if entry[1] is not None:
556
 
                if entry[1][0][0] == 't':
557
 
                    kind = 'tree-reference'
 
567
        if (self._repo_supports_tree_reference and
 
568
            kind == 'directory' and
 
569
            self._directory_is_tree_reference(relpath)):
 
570
            kind = 'tree-reference'
558
571
        return kind
559
572
 
560
573
    @needs_read_lock
691
704
            from_entry = self._get_entry(path=from_rel)
692
705
            if from_entry == (None, None):
693
706
                raise errors.BzrMoveFailedError(from_rel,to_dir,
694
 
                    errors.NotVersionedError(path=from_rel))
 
707
                    errors.NotVersionedError(path=str(from_rel)))
695
708
 
696
709
            from_id = from_entry[0][2]
697
710
            to_rel = pathjoin(to_dir, from_tail)
872
885
        for tree in trees:
873
886
            if not (isinstance(tree, DirStateRevisionTree) and tree._revision_id in
874
887
                parents):
875
 
                return super(DirStateWorkingTree, self).paths2ids(paths,
876
 
                    trees, require_versioned)
 
888
                return super(WorkingTree4, self).paths2ids(paths, trees, require_versioned)
877
889
        search_indexes = [0] + [1 + parents.index(tree._revision_id) for tree in trees]
878
890
        # -- make all paths utf8 --
879
891
        paths_utf8 = set()
940
952
                raise errors.PathsNotVersionedError(paths)
941
953
        # -- remove redundancy in supplied paths to prevent over-scanning --
942
954
        search_paths = osutils.minimum_path_selection(paths)
943
 
        # sketch:
 
955
        # sketch: 
944
956
        # for all search_indexs in each path at or under each element of
945
957
        # search_paths, if the detail is relocated: add the id, and add the
946
958
        # relocated path as one to search if its not searched already. If the
1002
1014
 
1003
1015
    def read_working_inventory(self):
1004
1016
        """Read the working inventory.
1005
 
 
 
1017
        
1006
1018
        This is a meaningless operation for dirstate, but we obey it anyhow.
1007
1019
        """
1008
1020
        return self.inventory
1026
1038
    def set_last_revision(self, new_revision):
1027
1039
        """Change the last revision in the working tree."""
1028
1040
        parents = self.get_parent_ids()
1029
 
        if new_revision in (_mod_revision.NULL_REVISION, None):
 
1041
        if new_revision in (NULL_REVISION, None):
1030
1042
            if len(parents) >= 2:
1031
1043
                raise AssertionError(
1032
1044
                    "setting the last parent to none with a pending merge is "
1039
1051
    @needs_tree_write_lock
1040
1052
    def set_parent_ids(self, revision_ids, allow_leftmost_as_ghost=False):
1041
1053
        """Set the parent ids to revision_ids.
1042
 
 
 
1054
        
1043
1055
        See also set_parent_trees. This api will try to retrieve the tree data
1044
1056
        for each element of revision_ids from the trees repository. If you have
1045
1057
        tree data already available, it is more efficient to use
1097
1109
                real_trees.append((rev_id, tree))
1098
1110
            else:
1099
1111
                real_trees.append((rev_id,
1100
 
                    self.branch.repository.revision_tree(
1101
 
                        _mod_revision.NULL_REVISION)))
 
1112
                    self.branch.repository.revision_tree(None)))
1102
1113
                ghosts.append(rev_id)
1103
1114
            accepted_revisions.add(rev_id)
1104
1115
        dirstate.set_parent_trees(real_trees, ghosts=ghosts)
1199
1210
                # just forget the whole block.
1200
1211
                entry_index = 0
1201
1212
                while entry_index < len(block[1]):
 
1213
                    # Mark this file id as having been removed
1202
1214
                    entry = block[1][entry_index]
1203
 
                    if entry[1][0][0] in 'ar':
1204
 
                        # don't remove absent or renamed entries
 
1215
                    ids_to_unversion.discard(entry[0][2])
 
1216
                    if (entry[1][0][0] in 'ar' # don't remove absent or renamed
 
1217
                                               # entries
 
1218
                        or not state._make_absent(entry)):
1205
1219
                        entry_index += 1
1206
 
                    else:
1207
 
                        # Mark this file id as having been removed
1208
 
                        ids_to_unversion.discard(entry[0][2])
1209
 
                        if not state._make_absent(entry):
1210
 
                            # The block has not shrunk.
1211
 
                            entry_index += 1
1212
1220
                # go to the next block. (At the moment we dont delete empty
1213
1221
                # dirblocks)
1214
1222
                block_index += 1
1266
1274
        if self._dirty:
1267
1275
            raise AssertionError("attempting to write an inventory when the "
1268
1276
                "dirstate is dirty will lose pending changes")
1269
 
        had_inventory = self._inventory is not None
1270
 
        # Setting self._inventory = None forces the dirstate to regenerate the
1271
 
        # working inventory. We do this because self.inventory may be inv, or
1272
 
        # may have been modified, and either case would prevent a clean delta
1273
 
        # being created.
1274
 
        self._inventory = None
1275
 
        # generate a delta,
1276
 
        delta = inv._make_delta(self.inventory)
1277
 
        # and apply it.
1278
 
        self.apply_inventory_delta(delta)
1279
 
        if had_inventory:
 
1277
        self.current_dirstate().set_state_from_inventory(inv)
 
1278
        self._make_dirty(reset_inventory=False)
 
1279
        if self._inventory is not None:
1280
1280
            self._inventory = inv
1281
1281
        self.flush()
1282
1282
 
1283
1283
 
1284
 
class ContentFilterAwareSHA1Provider(dirstate.SHA1Provider):
1285
 
 
1286
 
    def __init__(self, tree):
1287
 
        self.tree = tree
1288
 
 
1289
 
    def sha1(self, abspath):
1290
 
        """See dirstate.SHA1Provider.sha1()."""
1291
 
        filters = self.tree._content_filter_stack(
1292
 
            self.tree.relpath(osutils.safe_unicode(abspath)))
1293
 
        return internal_size_sha_file_byname(abspath, filters)[1]
1294
 
 
1295
 
    def stat_and_sha1(self, abspath):
1296
 
        """See dirstate.SHA1Provider.stat_and_sha1()."""
1297
 
        filters = self.tree._content_filter_stack(
1298
 
            self.tree.relpath(osutils.safe_unicode(abspath)))
1299
 
        file_obj = file(abspath, 'rb', 65000)
1300
 
        try:
1301
 
            statvalue = os.fstat(file_obj.fileno())
1302
 
            if filters:
1303
 
                file_obj = filtered_input_file(file_obj, filters)
1304
 
            sha1 = osutils.size_sha_file(file_obj)[1]
1305
 
        finally:
1306
 
            file_obj.close()
1307
 
        return statvalue, sha1
1308
 
 
1309
 
 
1310
 
class ContentFilteringDirStateWorkingTree(DirStateWorkingTree):
1311
 
    """Dirstate working tree that supports content filtering.
1312
 
 
1313
 
    The dirstate holds the hash and size of the canonical form of the file, 
1314
 
    and most methods must return that.
1315
 
    """
1316
 
 
1317
 
    def _file_content_summary(self, path, stat_result):
1318
 
        # This is to support the somewhat obsolete path_content_summary method
1319
 
        # with content filtering: see
1320
 
        # <https://bugs.edge.launchpad.net/bzr/+bug/415508>.
1321
 
        #
1322
 
        # If the dirstate cache is up to date and knows the hash and size,
1323
 
        # return that.
1324
 
        # Otherwise if there are no content filters, return the on-disk size
1325
 
        # and leave the hash blank.
1326
 
        # Otherwise, read and filter the on-disk file and use its size and
1327
 
        # hash.
1328
 
        #
1329
 
        # The dirstate doesn't store the size of the canonical form so we
1330
 
        # can't trust it for content-filtered trees.  We just return None.
1331
 
        dirstate_sha1 = self._dirstate.sha1_from_stat(path, stat_result)
1332
 
        executable = self._is_executable_from_path_and_stat(path, stat_result)
1333
 
        return ('file', None, executable, dirstate_sha1)
1334
 
 
1335
 
 
1336
 
class WorkingTree4(DirStateWorkingTree):
1337
 
    """This is the Format 4 working tree.
1338
 
 
1339
 
    This differs from WorkingTree3 by:
1340
 
     - Having a consolidated internal dirstate, stored in a
1341
 
       randomly-accessible sorted file on disk.
1342
 
     - Not having a regular inventory attribute.  One can be synthesized
1343
 
       on demand but this is expensive and should be avoided.
1344
 
 
1345
 
    This is new in bzr 0.15.
1346
 
    """
1347
 
 
1348
 
 
1349
 
class WorkingTree5(ContentFilteringDirStateWorkingTree):
1350
 
    """This is the Format 5 working tree.
1351
 
 
1352
 
    This differs from WorkingTree4 by:
1353
 
     - Supporting content filtering.
1354
 
 
1355
 
    This is new in bzr 1.11.
1356
 
    """
1357
 
 
1358
 
 
1359
 
class WorkingTree6(ContentFilteringDirStateWorkingTree):
1360
 
    """This is the Format 6 working tree.
1361
 
 
1362
 
    This differs from WorkingTree5 by:
1363
 
     - Supporting a current view that may mask the set of files in a tree
1364
 
       impacted by most user operations.
1365
 
 
1366
 
    This is new in bzr 1.14.
1367
 
    """
1368
 
 
1369
 
    def _make_views(self):
1370
 
        return views.PathBasedViews(self)
1371
 
 
1372
 
 
1373
 
class DirStateWorkingTreeFormat(WorkingTreeFormat3):
 
1284
class WorkingTreeFormat4(WorkingTreeFormat3):
 
1285
    """The first consolidated dirstate working tree format.
 
1286
 
 
1287
    This format:
 
1288
        - exists within a metadir controlling .bzr
 
1289
        - includes an explicit version marker for the workingtree control
 
1290
          files, separate from the BzrDir format
 
1291
        - modifies the hash cache format
 
1292
        - is new in bzr 0.15
 
1293
        - uses a LockDir to guard access to it.
 
1294
    """
 
1295
 
 
1296
    upgrade_recommended = False
 
1297
 
 
1298
    def get_format_string(self):
 
1299
        """See WorkingTreeFormat.get_format_string()."""
 
1300
        return "Bazaar Working Tree Format 4 (bzr 0.15)\n"
 
1301
 
 
1302
    def get_format_description(self):
 
1303
        """See WorkingTreeFormat.get_format_description()."""
 
1304
        return "Working tree format 4"
1374
1305
 
1375
1306
    def initialize(self, a_bzrdir, revision_id=None, from_branch=None,
1376
1307
                   accelerator_tree=None, hardlink=False):
1407
1338
        state = dirstate.DirState.initialize(local_path)
1408
1339
        state.unlock()
1409
1340
        del state
1410
 
        wt = self._tree_class(a_bzrdir.root_transport.local_abspath('.'),
 
1341
        wt = WorkingTree4(a_bzrdir.root_transport.local_abspath('.'),
1411
1342
                         branch,
1412
1343
                         _format=self,
1413
1344
                         _bzrdir=a_bzrdir,
1415
1346
        wt._new_tree()
1416
1347
        wt.lock_tree_write()
1417
1348
        try:
1418
 
            self._init_custom_control_files(wt)
1419
 
            if revision_id in (None, _mod_revision.NULL_REVISION):
 
1349
            if revision_id in (None, NULL_REVISION):
1420
1350
                if branch.repository.supports_rich_root():
1421
1351
                    wt._set_root_id(generate_ids.gen_root_id())
1422
1352
                else:
1433
1363
                    pass
1434
1364
            if basis is None:
1435
1365
                basis = branch.repository.revision_tree(revision_id)
1436
 
            if revision_id == _mod_revision.NULL_REVISION:
 
1366
            if revision_id == NULL_REVISION:
1437
1367
                parents_list = []
1438
1368
            else:
1439
1369
                parents_list = [(revision_id, basis)]
1447
1377
                if basis_root_id is not None:
1448
1378
                    wt._set_root_id(basis_root_id)
1449
1379
                    wt.flush()
1450
 
                if wt.supports_content_filtering():
1451
 
                    # The original tree may not have the same content filters
1452
 
                    # applied so we can't safely build the inventory delta from
1453
 
                    # the source tree.
1454
 
                    delta_from_tree = False
1455
 
                else:
1456
 
                    delta_from_tree = True
1457
1380
                # delta_from_tree is safe even for DirStateRevisionTrees,
1458
1381
                # because wt4.apply_inventory_delta does not mutate the input
1459
1382
                # inventory entries.
1460
1383
                transform.build_tree(basis, wt, accelerator_tree,
1461
 
                                     hardlink=hardlink,
1462
 
                                     delta_from_tree=delta_from_tree)
 
1384
                                     hardlink=hardlink, delta_from_tree=True)
1463
1385
            finally:
1464
1386
                basis.unlock()
1465
1387
        finally:
1467
1389
            wt.unlock()
1468
1390
        return wt
1469
1391
 
1470
 
    def _init_custom_control_files(self, wt):
1471
 
        """Subclasses with custom control files should override this method.
1472
 
 
1473
 
        The working tree and control files are locked for writing when this
1474
 
        method is called.
1475
 
 
1476
 
        :param wt: the WorkingTree object
1477
 
        """
1478
 
 
1479
1392
    def _open(self, a_bzrdir, control_files):
1480
1393
        """Open the tree itself.
1481
1394
 
1482
1395
        :param a_bzrdir: the dir for the tree.
1483
1396
        :param control_files: the control files for the tree.
1484
1397
        """
1485
 
        return self._tree_class(a_bzrdir.root_transport.local_abspath('.'),
 
1398
        return WorkingTree4(a_bzrdir.root_transport.local_abspath('.'),
1486
1399
                           branch=a_bzrdir.open_branch(),
1487
1400
                           _format=self,
1488
1401
                           _bzrdir=a_bzrdir,
1489
1402
                           _control_files=control_files)
1490
1403
 
1491
1404
    def __get_matchingbzrdir(self):
1492
 
        return self._get_matchingbzrdir()
1493
 
 
1494
 
    def _get_matchingbzrdir(self):
1495
 
        """Overrideable method to get a bzrdir for testing."""
1496
1405
        # please test against something that will let us do tree references
1497
1406
        return bzrdir.format_registry.make_bzrdir(
1498
1407
            'dirstate-with-subtree')
1500
1409
    _matchingbzrdir = property(__get_matchingbzrdir)
1501
1410
 
1502
1411
 
1503
 
class WorkingTreeFormat4(DirStateWorkingTreeFormat):
1504
 
    """The first consolidated dirstate working tree format.
1505
 
 
1506
 
    This format:
1507
 
        - exists within a metadir controlling .bzr
1508
 
        - includes an explicit version marker for the workingtree control
1509
 
          files, separate from the BzrDir format
1510
 
        - modifies the hash cache format
1511
 
        - is new in bzr 0.15
1512
 
        - uses a LockDir to guard access to it.
1513
 
    """
1514
 
 
1515
 
    upgrade_recommended = False
1516
 
 
1517
 
    _tree_class = WorkingTree4
1518
 
 
1519
 
    def get_format_string(self):
1520
 
        """See WorkingTreeFormat.get_format_string()."""
1521
 
        return "Bazaar Working Tree Format 4 (bzr 0.15)\n"
1522
 
 
1523
 
    def get_format_description(self):
1524
 
        """See WorkingTreeFormat.get_format_description()."""
1525
 
        return "Working tree format 4"
1526
 
 
1527
 
 
1528
 
class WorkingTreeFormat5(DirStateWorkingTreeFormat):
1529
 
    """WorkingTree format supporting content filtering.
1530
 
    """
1531
 
 
1532
 
    upgrade_recommended = False
1533
 
 
1534
 
    _tree_class = WorkingTree5
1535
 
 
1536
 
    def get_format_string(self):
1537
 
        """See WorkingTreeFormat.get_format_string()."""
1538
 
        return "Bazaar Working Tree Format 5 (bzr 1.11)\n"
1539
 
 
1540
 
    def get_format_description(self):
1541
 
        """See WorkingTreeFormat.get_format_description()."""
1542
 
        return "Working tree format 5"
1543
 
 
1544
 
    def supports_content_filtering(self):
1545
 
        return True
1546
 
 
1547
 
 
1548
 
class WorkingTreeFormat6(DirStateWorkingTreeFormat):
1549
 
    """WorkingTree format supporting views.
1550
 
    """
1551
 
 
1552
 
    upgrade_recommended = False
1553
 
 
1554
 
    _tree_class = WorkingTree6
1555
 
 
1556
 
    def get_format_string(self):
1557
 
        """See WorkingTreeFormat.get_format_string()."""
1558
 
        return "Bazaar Working Tree Format 6 (bzr 1.14)\n"
1559
 
 
1560
 
    def get_format_description(self):
1561
 
        """See WorkingTreeFormat.get_format_description()."""
1562
 
        return "Working tree format 6"
1563
 
 
1564
 
    def _init_custom_control_files(self, wt):
1565
 
        """Subclasses with custom control files should override this method."""
1566
 
        wt._transport.put_bytes('views', '', mode=wt.bzrdir._get_file_mode())
1567
 
 
1568
 
    def supports_content_filtering(self):
1569
 
        return True
1570
 
 
1571
 
    def supports_views(self):
1572
 
        return True
1573
 
 
1574
 
 
1575
1412
class DirStateRevisionTree(Tree):
1576
 
    """A revision tree pulling the inventory from a dirstate.
1577
 
    
1578
 
    Note that this is one of the historical (ie revision) trees cached in the
1579
 
    dirstate for easy access, not the workingtree.
1580
 
    """
 
1413
    """A revision tree pulling the inventory from a dirstate."""
1581
1414
 
1582
1415
    def __init__(self, dirstate, revision_id, repository):
1583
1416
        self._dirstate = dirstate
1652
1485
        If either file_id or path is supplied, it is used as the key to lookup.
1653
1486
        If both are supplied, the fastest lookup is used, and an error is
1654
1487
        raised if they do not both point at the same row.
1655
 
 
 
1488
        
1656
1489
        :param file_id: An optional unicode file_id to be looked up.
1657
1490
        :param path: An optional unicode path to be looked up.
1658
1491
        :return: The dirstate row tuple for path/file_id, or (None, None)
1755
1588
            return None
1756
1589
        parent_index = self._get_parent_index()
1757
1590
        last_changed_revision = entry[1][parent_index][4]
1758
 
        try:
1759
 
            rev = self._repository.get_revision(last_changed_revision)
1760
 
        except errors.NoSuchRevision:
1761
 
            raise errors.FileTimestampUnavailable(self.id2path(file_id))
1762
 
        return rev.timestamp
 
1591
        return self._repository.get_revision(last_changed_revision).timestamp
1763
1592
 
1764
1593
    def get_file_sha1(self, file_id, path=None, stat_value=None):
1765
1594
        entry = self._get_entry(file_id=file_id, path=path)
1772
1601
    def get_file(self, file_id, path=None):
1773
1602
        return StringIO(self.get_file_text(file_id))
1774
1603
 
 
1604
    def get_file_lines(self, file_id):
 
1605
        return osutils.split_lines(self.get_file_text(file_id))
 
1606
 
1775
1607
    def get_file_size(self, file_id):
1776
1608
        """See Tree.get_file_size"""
1777
1609
        return self.inventory[file_id].text_size
1778
1610
 
1779
 
    def get_file_text(self, file_id, path=None):
1780
 
        _, content = list(self.iter_files_bytes([(file_id, None)]))[0]
1781
 
        return ''.join(content)
 
1611
    def get_file_text(self, file_id):
 
1612
        return list(self.iter_files_bytes([(file_id, None)]))[0][1]
1782
1613
 
1783
1614
    def get_reference_revision(self, file_id, path=None):
1784
1615
        return self.inventory[file_id].reference_revision
1803
1634
        if entry[1][parent_index][0] != 'l':
1804
1635
            return None
1805
1636
        else:
1806
 
            target = entry[1][parent_index][1]
1807
 
            target = target.decode('utf8')
1808
 
            return target
 
1637
            # At present, none of the tree implementations supports non-ascii
 
1638
            # symlink targets. So we will just assume that the dirstate path is
 
1639
            # correct.
 
1640
            return entry[1][parent_index][1]
1809
1641
 
1810
1642
    def get_revision_id(self):
1811
1643
        """Return the revision id for this tree."""
1832
1664
        entry = self._get_entry(file_id=file_id)[1]
1833
1665
        if entry is None:
1834
1666
            raise errors.NoSuchId(tree=self, file_id=file_id)
1835
 
        parent_index = self._get_parent_index()
1836
 
        return dirstate.DirState._minikind_to_kind[entry[parent_index][0]]
 
1667
        return dirstate.DirState._minikind_to_kind[entry[1][0]]
1837
1668
 
1838
1669
    def stored_kind(self, file_id):
1839
1670
        """See Tree.stored_kind"""
1859
1690
            return None
1860
1691
        return ie.executable
1861
1692
 
1862
 
    def list_files(self, include_root=False, from_dir=None, recursive=True):
 
1693
    def list_files(self, include_root=False):
1863
1694
        # We use a standard implementation, because DirStateRevisionTree is
1864
1695
        # dealing with one of the parents of the current state
1865
1696
        inv = self._get_inventory()
1866
 
        if from_dir is None:
1867
 
            from_dir_id = None
1868
 
        else:
1869
 
            from_dir_id = inv.path2id(from_dir)
1870
 
            if from_dir_id is None:
1871
 
                # Directory not versioned
1872
 
                return
1873
 
        entries = inv.iter_entries(from_dir=from_dir_id, recursive=recursive)
1874
 
        if inv.root is not None and not include_root and from_dir is None:
 
1697
        entries = inv.iter_entries()
 
1698
        if self.inventory.root is not None and not include_root:
1875
1699
            entries.next()
1876
1700
        for path, entry in entries:
1877
1701
            yield path, 'V', entry.kind, entry.file_id, entry
1916
1740
 
1917
1741
    def walkdirs(self, prefix=""):
1918
1742
        # TODO: jam 20070215 This is the lazy way by using the RevisionTree
1919
 
        # implementation based on an inventory.
 
1743
        # implementation based on an inventory.  
1920
1744
        # This should be cleaned up to use the much faster Dirstate code
1921
1745
        # So for now, we just build up the parent inventory, and extract
1922
1746
        # it the same way RevisionTree does.
1951
1775
 
1952
1776
class InterDirStateTree(InterTree):
1953
1777
    """Fast path optimiser for changes_from with dirstate trees.
1954
 
 
1955
 
    This is used only when both trees are in the dirstate working file, and
1956
 
    the source is any parent within the dirstate, and the destination is
 
1778
    
 
1779
    This is used only when both trees are in the dirstate working file, and 
 
1780
    the source is any parent within the dirstate, and the destination is 
1957
1781
    the current working tree of the same dirstate.
1958
1782
    """
1959
1783
    # this could be generalized to allow comparisons between any trees in the
1972
1796
        target.set_parent_ids([revid])
1973
1797
        return target.basis_tree(), target
1974
1798
 
1975
 
    @classmethod
1976
 
    def make_source_parent_tree_python_dirstate(klass, test_case, source, target):
1977
 
        result = klass.make_source_parent_tree(source, target)
1978
 
        result[1]._iter_changes = dirstate.ProcessEntryPython
1979
 
        return result
1980
 
 
1981
 
    @classmethod
1982
 
    def make_source_parent_tree_compiled_dirstate(klass, test_case, source,
1983
 
                                                  target):
1984
 
        from bzrlib.tests.test__dirstate_helpers import \
1985
 
            compiled_dirstate_helpers_feature
1986
 
        test_case.requireFeature(compiled_dirstate_helpers_feature)
1987
 
        from bzrlib._dirstate_helpers_pyx import ProcessEntryC
1988
 
        result = klass.make_source_parent_tree(source, target)
1989
 
        result[1]._iter_changes = ProcessEntryC
1990
 
        return result
1991
 
 
1992
1799
    _matching_from_tree_format = WorkingTreeFormat4()
1993
1800
    _matching_to_tree_format = WorkingTreeFormat4()
1994
 
 
1995
 
    @classmethod
1996
 
    def _test_mutable_trees_to_test_trees(klass, test_case, source, target):
1997
 
        # This method shouldn't be called, because we have python and C
1998
 
        # specific flavours.
1999
 
        raise NotImplementedError
 
1801
    _test_mutable_trees_to_test_trees = make_source_parent_tree
2000
1802
 
2001
1803
    def iter_changes(self, include_unchanged=False,
2002
1804
                      specific_files=None, pb=None, extra_trees=[],
2020
1822
            output. An unversioned file is defined as one with (False, False)
2021
1823
            for the versioned pair.
2022
1824
        """
 
1825
        utf8_decode = cache_utf8._utf8_decode
 
1826
        _minikind_to_kind = dirstate.DirState._minikind_to_kind
 
1827
        cmp_by_dirs = dirstate.cmp_by_dirs
 
1828
        # NB: show_status depends on being able to pass in non-versioned files
 
1829
        # and report them as unknown
2023
1830
        # TODO: handle extra trees in the dirstate.
2024
1831
        if (extra_trees or specific_files == []):
2025
1832
            # we can't fast-path these cases (yet)
2026
 
            return super(InterDirStateTree, self).iter_changes(
 
1833
            for f in super(InterDirStateTree, self).iter_changes(
2027
1834
                include_unchanged, specific_files, pb, extra_trees,
2028
 
                require_versioned, want_unversioned=want_unversioned)
 
1835
                require_versioned, want_unversioned=want_unversioned):
 
1836
                yield f
 
1837
            return
2029
1838
        parent_ids = self.target.get_parent_ids()
2030
1839
        if not (self.source._revision_id in parent_ids
2031
 
                or self.source._revision_id == _mod_revision.NULL_REVISION):
 
1840
                or self.source._revision_id == NULL_REVISION):
2032
1841
            raise AssertionError(
2033
1842
                "revision {%s} is not stored in {%s}, but %s "
2034
1843
                "can only be used for trees stored in the dirstate"
2035
1844
                % (self.source._revision_id, self.target, self.iter_changes))
2036
1845
        target_index = 0
2037
 
        if self.source._revision_id == _mod_revision.NULL_REVISION:
 
1846
        if self.source._revision_id == NULL_REVISION:
2038
1847
            source_index = None
2039
1848
            indices = (target_index,)
2040
1849
        else:
2048
1857
        if specific_files:
2049
1858
            specific_files_utf8 = set()
2050
1859
            for path in specific_files:
2051
 
                # Note, if there are many specific files, using cache_utf8
2052
 
                # would be good here.
2053
1860
                specific_files_utf8.add(path.encode('utf8'))
2054
1861
            specific_files = specific_files_utf8
2055
1862
        else:
2056
1863
            specific_files = set([''])
2057
1864
        # -- specific_files is now a utf8 path set --
2058
 
 
2059
1865
        # -- get the state object and prepare it.
2060
1866
        state = self.target.current_dirstate()
2061
1867
        state._read_dirblocks_if_needed()
 
1868
        def _entries_for_path(path):
 
1869
            """Return a list with all the entries that match path for all ids.
 
1870
            """
 
1871
            dirname, basename = os.path.split(path)
 
1872
            key = (dirname, basename, '')
 
1873
            block_index, present = state._find_block_index_from_key(key)
 
1874
            if not present:
 
1875
                # the block which should contain path is absent.
 
1876
                return []
 
1877
            result = []
 
1878
            block = state._dirblocks[block_index][1]
 
1879
            entry_index, _ = state._find_entry_index(key, block)
 
1880
            # we may need to look at multiple entries at this path: walk while the specific_files match.
 
1881
            while (entry_index < len(block) and
 
1882
                block[entry_index][0][0:2] == key[0:2]):
 
1883
                result.append(block[entry_index])
 
1884
                entry_index += 1
 
1885
            return result
2062
1886
        if require_versioned:
2063
1887
            # -- check all supplied paths are versioned in a search tree. --
2064
 
            not_versioned = []
 
1888
            all_versioned = True
2065
1889
            for path in specific_files:
2066
 
                path_entries = state._entries_for_path(path)
 
1890
                path_entries = _entries_for_path(path)
2067
1891
                if not path_entries:
2068
1892
                    # this specified path is not present at all: error
2069
 
                    not_versioned.append(path)
2070
 
                    continue
 
1893
                    all_versioned = False
 
1894
                    break
2071
1895
                found_versioned = False
2072
1896
                # for each id at this path
2073
1897
                for entry in path_entries:
2080
1904
                if not found_versioned:
2081
1905
                    # none of the indexes was not 'absent' at all ids for this
2082
1906
                    # path.
2083
 
                    not_versioned.append(path)
2084
 
            if len(not_versioned) > 0:
2085
 
                raise errors.PathsNotVersionedError(not_versioned)
 
1907
                    all_versioned = False
 
1908
                    break
 
1909
            if not all_versioned:
 
1910
                raise errors.PathsNotVersionedError(specific_files)
2086
1911
        # -- remove redundancy in supplied specific_files to prevent over-scanning --
2087
 
        search_specific_files = osutils.minimum_path_selection(specific_files)
 
1912
        search_specific_files = set()
 
1913
        for path in specific_files:
 
1914
            other_specific_files = specific_files.difference(set([path]))
 
1915
            if not osutils.is_inside_any(other_specific_files, path):
 
1916
                # this is a top level path, we must check it.
 
1917
                search_specific_files.add(path)
 
1918
        # sketch: 
 
1919
        # compare source_index and target_index at or under each element of search_specific_files.
 
1920
        # follow the following comparison table. Note that we only want to do diff operations when
 
1921
        # the target is fdl because thats when the walkdirs logic will have exposed the pathinfo 
 
1922
        # for the target.
 
1923
        # cases:
 
1924
        # 
 
1925
        # Source | Target | disk | action
 
1926
        #   r    | fdlt   |      | add source to search, add id path move and perform
 
1927
        #        |        |      | diff check on source-target
 
1928
        #   r    | fdlt   |  a   | dangling file that was present in the basis. 
 
1929
        #        |        |      | ???
 
1930
        #   r    |  a     |      | add source to search
 
1931
        #   r    |  a     |  a   | 
 
1932
        #   r    |  r     |      | this path is present in a non-examined tree, skip.
 
1933
        #   r    |  r     |  a   | this path is present in a non-examined tree, skip.
 
1934
        #   a    | fdlt   |      | add new id
 
1935
        #   a    | fdlt   |  a   | dangling locally added file, skip
 
1936
        #   a    |  a     |      | not present in either tree, skip
 
1937
        #   a    |  a     |  a   | not present in any tree, skip
 
1938
        #   a    |  r     |      | not present in either tree at this path, skip as it
 
1939
        #        |        |      | may not be selected by the users list of paths.
 
1940
        #   a    |  r     |  a   | not present in either tree at this path, skip as it
 
1941
        #        |        |      | may not be selected by the users list of paths.
 
1942
        #  fdlt  | fdlt   |      | content in both: diff them
 
1943
        #  fdlt  | fdlt   |  a   | deleted locally, but not unversioned - show as deleted ?
 
1944
        #  fdlt  |  a     |      | unversioned: output deleted id for now
 
1945
        #  fdlt  |  a     |  a   | unversioned and deleted: output deleted id
 
1946
        #  fdlt  |  r     |      | relocated in this tree, so add target to search.
 
1947
        #        |        |      | Dont diff, we will see an r,fd; pair when we reach
 
1948
        #        |        |      | this id at the other path.
 
1949
        #  fdlt  |  r     |  a   | relocated in this tree, so add target to search.
 
1950
        #        |        |      | Dont diff, we will see an r,fd; pair when we reach
 
1951
        #        |        |      | this id at the other path.
 
1952
 
 
1953
        # for all search_indexs in each path at or under each element of
 
1954
        # search_specific_files, if the detail is relocated: add the id, and add the
 
1955
        # relocated path as one to search if its not searched already. If the
 
1956
        # detail is not relocated, add the id.
 
1957
        searched_specific_files = set()
 
1958
        NULL_PARENT_DETAILS = dirstate.DirState.NULL_PARENT_DETAILS
 
1959
        # Using a list so that we can access the values and change them in
 
1960
        # nested scope. Each one is [path, file_id, entry]
 
1961
        last_source_parent = [None, None]
 
1962
        last_target_parent = [None, None]
2088
1963
 
2089
1964
        use_filesystem_for_exec = (sys.platform != 'win32')
2090
 
        iter_changes = self.target._iter_changes(include_unchanged,
2091
 
            use_filesystem_for_exec, search_specific_files, state,
2092
 
            source_index, target_index, want_unversioned, self.target)
2093
 
        return iter_changes.iter_changes()
 
1965
 
 
1966
        # Just a sentry, so that _process_entry can say that this
 
1967
        # record is handled, but isn't interesting to process (unchanged)
 
1968
        uninteresting = object()
 
1969
 
 
1970
 
 
1971
        old_dirname_to_file_id = {}
 
1972
        new_dirname_to_file_id = {}
 
1973
        # TODO: jam 20070516 - Avoid the _get_entry lookup overhead by
 
1974
        #       keeping a cache of directories that we have seen.
 
1975
 
 
1976
        def _process_entry(entry, path_info):
 
1977
            """Compare an entry and real disk to generate delta information.
 
1978
 
 
1979
            :param path_info: top_relpath, basename, kind, lstat, abspath for
 
1980
                the path of entry. If None, then the path is considered absent.
 
1981
                (Perhaps we should pass in a concrete entry for this ?)
 
1982
                Basename is returned as a utf8 string because we expect this
 
1983
                tuple will be ignored, and don't want to take the time to
 
1984
                decode.
 
1985
            :return: None if these don't match
 
1986
                     A tuple of information about the change, or
 
1987
                     the object 'uninteresting' if these match, but are
 
1988
                     basically identical.
 
1989
            """
 
1990
            if source_index is None:
 
1991
                source_details = NULL_PARENT_DETAILS
 
1992
            else:
 
1993
                source_details = entry[1][source_index]
 
1994
            target_details = entry[1][target_index]
 
1995
            target_minikind = target_details[0]
 
1996
            if path_info is not None and target_minikind in 'fdlt':
 
1997
                if not (target_index == 0):
 
1998
                    raise AssertionError()
 
1999
                link_or_sha1 = state.update_entry(entry, abspath=path_info[4],
 
2000
                                                  stat_value=path_info[3])
 
2001
                # The entry may have been modified by update_entry
 
2002
                target_details = entry[1][target_index]
 
2003
                target_minikind = target_details[0]
 
2004
            else:
 
2005
                link_or_sha1 = None
 
2006
            file_id = entry[0][2]
 
2007
            source_minikind = source_details[0]
 
2008
            if source_minikind in 'fdltr' and target_minikind in 'fdlt':
 
2009
                # claimed content in both: diff
 
2010
                #   r    | fdlt   |      | add source to search, add id path move and perform
 
2011
                #        |        |      | diff check on source-target
 
2012
                #   r    | fdlt   |  a   | dangling file that was present in the basis.
 
2013
                #        |        |      | ???
 
2014
                if source_minikind in 'r':
 
2015
                    # add the source to the search path to find any children it
 
2016
                    # has.  TODO ? : only add if it is a container ?
 
2017
                    if not osutils.is_inside_any(searched_specific_files,
 
2018
                                                 source_details[1]):
 
2019
                        search_specific_files.add(source_details[1])
 
2020
                    # generate the old path; this is needed for stating later
 
2021
                    # as well.
 
2022
                    old_path = source_details[1]
 
2023
                    old_dirname, old_basename = os.path.split(old_path)
 
2024
                    path = pathjoin(entry[0][0], entry[0][1])
 
2025
                    old_entry = state._get_entry(source_index,
 
2026
                                                 path_utf8=old_path)
 
2027
                    # update the source details variable to be the real
 
2028
                    # location.
 
2029
                    if old_entry == (None, None):
 
2030
                        raise errors.CorruptDirstate(state._filename,
 
2031
                            "entry '%s/%s' is considered renamed from %r"
 
2032
                            " but source does not exist\n"
 
2033
                            "entry: %s" % (entry[0][0], entry[0][1], old_path, entry))
 
2034
                    source_details = old_entry[1][source_index]
 
2035
                    source_minikind = source_details[0]
 
2036
                else:
 
2037
                    old_dirname = entry[0][0]
 
2038
                    old_basename = entry[0][1]
 
2039
                    old_path = path = None
 
2040
                if path_info is None:
 
2041
                    # the file is missing on disk, show as removed.
 
2042
                    content_change = True
 
2043
                    target_kind = None
 
2044
                    target_exec = False
 
2045
                else:
 
2046
                    # source and target are both versioned and disk file is present.
 
2047
                    target_kind = path_info[2]
 
2048
                    if target_kind == 'directory':
 
2049
                        if path is None:
 
2050
                            old_path = path = pathjoin(old_dirname, old_basename)
 
2051
                        new_dirname_to_file_id[path] = file_id
 
2052
                        if source_minikind != 'd':
 
2053
                            content_change = True
 
2054
                        else:
 
2055
                            # directories have no fingerprint
 
2056
                            content_change = False
 
2057
                        target_exec = False
 
2058
                    elif target_kind == 'file':
 
2059
                        if source_minikind != 'f':
 
2060
                            content_change = True
 
2061
                        else:
 
2062
                            # We could check the size, but we already have the
 
2063
                            # sha1 hash.
 
2064
                            content_change = (link_or_sha1 != source_details[1])
 
2065
                        # Target details is updated at update_entry time
 
2066
                        if use_filesystem_for_exec:
 
2067
                            # We don't need S_ISREG here, because we are sure
 
2068
                            # we are dealing with a file.
 
2069
                            target_exec = bool(stat.S_IEXEC & path_info[3].st_mode)
 
2070
                        else:
 
2071
                            target_exec = target_details[3]
 
2072
                    elif target_kind == 'symlink':
 
2073
                        if source_minikind != 'l':
 
2074
                            content_change = True
 
2075
                        else:
 
2076
                            content_change = (link_or_sha1 != source_details[1])
 
2077
                        target_exec = False
 
2078
                    elif target_kind == 'tree-reference':
 
2079
                        if source_minikind != 't':
 
2080
                            content_change = True
 
2081
                        else:
 
2082
                            content_change = False
 
2083
                        target_exec = False
 
2084
                    else:
 
2085
                        raise Exception, "unknown kind %s" % path_info[2]
 
2086
                if source_minikind == 'd':
 
2087
                    if path is None:
 
2088
                        old_path = path = pathjoin(old_dirname, old_basename)
 
2089
                    old_dirname_to_file_id[old_path] = file_id
 
2090
                # parent id is the entry for the path in the target tree
 
2091
                if old_dirname == last_source_parent[0]:
 
2092
                    source_parent_id = last_source_parent[1]
 
2093
                else:
 
2094
                    try:
 
2095
                        source_parent_id = old_dirname_to_file_id[old_dirname]
 
2096
                    except KeyError:
 
2097
                        source_parent_entry = state._get_entry(source_index,
 
2098
                                                               path_utf8=old_dirname)
 
2099
                        source_parent_id = source_parent_entry[0][2]
 
2100
                    if source_parent_id == entry[0][2]:
 
2101
                        # This is the root, so the parent is None
 
2102
                        source_parent_id = None
 
2103
                    else:
 
2104
                        last_source_parent[0] = old_dirname
 
2105
                        last_source_parent[1] = source_parent_id
 
2106
                new_dirname = entry[0][0]
 
2107
                if new_dirname == last_target_parent[0]:
 
2108
                    target_parent_id = last_target_parent[1]
 
2109
                else:
 
2110
                    try:
 
2111
                        target_parent_id = new_dirname_to_file_id[new_dirname]
 
2112
                    except KeyError:
 
2113
                        # TODO: We don't always need to do the lookup, because the
 
2114
                        #       parent entry will be the same as the source entry.
 
2115
                        target_parent_entry = state._get_entry(target_index,
 
2116
                                                               path_utf8=new_dirname)
 
2117
                        if target_parent_entry == (None, None):
 
2118
                            raise AssertionError(
 
2119
                                "Could not find target parent in wt: %s\nparent of: %s"
 
2120
                                % (new_dirname, entry))
 
2121
                        target_parent_id = target_parent_entry[0][2]
 
2122
                    if target_parent_id == entry[0][2]:
 
2123
                        # This is the root, so the parent is None
 
2124
                        target_parent_id = None
 
2125
                    else:
 
2126
                        last_target_parent[0] = new_dirname
 
2127
                        last_target_parent[1] = target_parent_id
 
2128
 
 
2129
                source_exec = source_details[3]
 
2130
                if (include_unchanged
 
2131
                    or content_change
 
2132
                    or source_parent_id != target_parent_id
 
2133
                    or old_basename != entry[0][1]
 
2134
                    or source_exec != target_exec
 
2135
                    ):
 
2136
                    if old_path is None:
 
2137
                        old_path = path = pathjoin(old_dirname, old_basename)
 
2138
                        old_path_u = utf8_decode(old_path)[0]
 
2139
                        path_u = old_path_u
 
2140
                    else:
 
2141
                        old_path_u = utf8_decode(old_path)[0]
 
2142
                        if old_path == path:
 
2143
                            path_u = old_path_u
 
2144
                        else:
 
2145
                            path_u = utf8_decode(path)[0]
 
2146
                    source_kind = _minikind_to_kind[source_minikind]
 
2147
                    return (entry[0][2],
 
2148
                           (old_path_u, path_u),
 
2149
                           content_change,
 
2150
                           (True, True),
 
2151
                           (source_parent_id, target_parent_id),
 
2152
                           (utf8_decode(old_basename)[0], utf8_decode(entry[0][1])[0]),
 
2153
                           (source_kind, target_kind),
 
2154
                           (source_exec, target_exec))
 
2155
                else:
 
2156
                    return uninteresting
 
2157
            elif source_minikind in 'a' and target_minikind in 'fdlt':
 
2158
                # looks like a new file
 
2159
                if path_info is not None:
 
2160
                    path = pathjoin(entry[0][0], entry[0][1])
 
2161
                    # parent id is the entry for the path in the target tree
 
2162
                    # TODO: these are the same for an entire directory: cache em.
 
2163
                    parent_id = state._get_entry(target_index,
 
2164
                                                 path_utf8=entry[0][0])[0][2]
 
2165
                    if parent_id == entry[0][2]:
 
2166
                        parent_id = None
 
2167
                    if use_filesystem_for_exec:
 
2168
                        # We need S_ISREG here, because we aren't sure if this
 
2169
                        # is a file or not.
 
2170
                        target_exec = bool(
 
2171
                            stat.S_ISREG(path_info[3].st_mode)
 
2172
                            and stat.S_IEXEC & path_info[3].st_mode)
 
2173
                    else:
 
2174
                        target_exec = target_details[3]
 
2175
                    return (entry[0][2],
 
2176
                           (None, utf8_decode(path)[0]),
 
2177
                           True,
 
2178
                           (False, True),
 
2179
                           (None, parent_id),
 
2180
                           (None, utf8_decode(entry[0][1])[0]),
 
2181
                           (None, path_info[2]),
 
2182
                           (None, target_exec))
 
2183
                else:
 
2184
                    # but its not on disk: we deliberately treat this as just
 
2185
                    # never-present. (Why ?! - RBC 20070224)
 
2186
                    pass
 
2187
            elif source_minikind in 'fdlt' and target_minikind in 'a':
 
2188
                # unversioned, possibly, or possibly not deleted: we dont care.
 
2189
                # if its still on disk, *and* theres no other entry at this
 
2190
                # path [we dont know this in this routine at the moment -
 
2191
                # perhaps we should change this - then it would be an unknown.
 
2192
                old_path = pathjoin(entry[0][0], entry[0][1])
 
2193
                # parent id is the entry for the path in the target tree
 
2194
                parent_id = state._get_entry(source_index, path_utf8=entry[0][0])[0][2]
 
2195
                if parent_id == entry[0][2]:
 
2196
                    parent_id = None
 
2197
                return (entry[0][2],
 
2198
                       (utf8_decode(old_path)[0], None),
 
2199
                       True,
 
2200
                       (True, False),
 
2201
                       (parent_id, None),
 
2202
                       (utf8_decode(entry[0][1])[0], None),
 
2203
                       (_minikind_to_kind[source_minikind], None),
 
2204
                       (source_details[3], None))
 
2205
            elif source_minikind in 'fdlt' and target_minikind in 'r':
 
2206
                # a rename; could be a true rename, or a rename inherited from
 
2207
                # a renamed parent. TODO: handle this efficiently. Its not
 
2208
                # common case to rename dirs though, so a correct but slow
 
2209
                # implementation will do.
 
2210
                if not osutils.is_inside_any(searched_specific_files, target_details[1]):
 
2211
                    search_specific_files.add(target_details[1])
 
2212
            elif source_minikind in 'ra' and target_minikind in 'ra':
 
2213
                # neither of the selected trees contain this file,
 
2214
                # so skip over it. This is not currently directly tested, but
 
2215
                # is indirectly via test_too_much.TestCommands.test_conflicts.
 
2216
                pass
 
2217
            else:
 
2218
                raise AssertionError("don't know how to compare "
 
2219
                    "source_minikind=%r, target_minikind=%r"
 
2220
                    % (source_minikind, target_minikind))
 
2221
                ## import pdb;pdb.set_trace()
 
2222
            return None
 
2223
 
 
2224
        while search_specific_files:
 
2225
            # TODO: the pending list should be lexically sorted?  the
 
2226
            # interface doesn't require it.
 
2227
            current_root = search_specific_files.pop()
 
2228
            current_root_unicode = current_root.decode('utf8')
 
2229
            searched_specific_files.add(current_root)
 
2230
            # process the entries for this containing directory: the rest will be
 
2231
            # found by their parents recursively.
 
2232
            root_entries = _entries_for_path(current_root)
 
2233
            root_abspath = self.target.abspath(current_root_unicode)
 
2234
            try:
 
2235
                root_stat = os.lstat(root_abspath)
 
2236
            except OSError, e:
 
2237
                if e.errno == errno.ENOENT:
 
2238
                    # the path does not exist: let _process_entry know that.
 
2239
                    root_dir_info = None
 
2240
                else:
 
2241
                    # some other random error: hand it up.
 
2242
                    raise
 
2243
            else:
 
2244
                root_dir_info = ('', current_root,
 
2245
                    osutils.file_kind_from_stat_mode(root_stat.st_mode), root_stat,
 
2246
                    root_abspath)
 
2247
                if root_dir_info[2] == 'directory':
 
2248
                    if self.target._directory_is_tree_reference(
 
2249
                        current_root.decode('utf8')):
 
2250
                        root_dir_info = root_dir_info[:2] + \
 
2251
                            ('tree-reference',) + root_dir_info[3:]
 
2252
 
 
2253
            if not root_entries and not root_dir_info:
 
2254
                # this specified path is not present at all, skip it.
 
2255
                continue
 
2256
            path_handled = False
 
2257
            for entry in root_entries:
 
2258
                result = _process_entry(entry, root_dir_info)
 
2259
                if result is not None:
 
2260
                    path_handled = True
 
2261
                    if result is not uninteresting:
 
2262
                        yield result
 
2263
            if want_unversioned and not path_handled and root_dir_info:
 
2264
                new_executable = bool(
 
2265
                    stat.S_ISREG(root_dir_info[3].st_mode)
 
2266
                    and stat.S_IEXEC & root_dir_info[3].st_mode)
 
2267
                yield (None,
 
2268
                       (None, current_root_unicode),
 
2269
                       True,
 
2270
                       (False, False),
 
2271
                       (None, None),
 
2272
                       (None, splitpath(current_root_unicode)[-1]),
 
2273
                       (None, root_dir_info[2]),
 
2274
                       (None, new_executable)
 
2275
                      )
 
2276
            initial_key = (current_root, '', '')
 
2277
            block_index, _ = state._find_block_index_from_key(initial_key)
 
2278
            if block_index == 0:
 
2279
                # we have processed the total root already, but because the
 
2280
                # initial key matched it we should skip it here.
 
2281
                block_index +=1
 
2282
            if root_dir_info and root_dir_info[2] == 'tree-reference':
 
2283
                current_dir_info = None
 
2284
            else:
 
2285
                dir_iterator = osutils._walkdirs_utf8(root_abspath, prefix=current_root)
 
2286
                try:
 
2287
                    current_dir_info = dir_iterator.next()
 
2288
                except OSError, e:
 
2289
                    # on win32, python2.4 has e.errno == ERROR_DIRECTORY, but
 
2290
                    # python 2.5 has e.errno == EINVAL,
 
2291
                    #            and e.winerror == ERROR_DIRECTORY
 
2292
                    e_winerror = getattr(e, 'winerror', None)
 
2293
                    win_errors = (ERROR_DIRECTORY, ERROR_PATH_NOT_FOUND)
 
2294
                    # there may be directories in the inventory even though
 
2295
                    # this path is not a file on disk: so mark it as end of
 
2296
                    # iterator
 
2297
                    if e.errno in (errno.ENOENT, errno.ENOTDIR, errno.EINVAL):
 
2298
                        current_dir_info = None
 
2299
                    elif (sys.platform == 'win32'
 
2300
                          and (e.errno in win_errors
 
2301
                               or e_winerror in win_errors)):
 
2302
                        current_dir_info = None
 
2303
                    else:
 
2304
                        raise
 
2305
                else:
 
2306
                    if current_dir_info[0][0] == '':
 
2307
                        # remove .bzr from iteration
 
2308
                        bzr_index = bisect_left(current_dir_info[1], ('.bzr',))
 
2309
                        if current_dir_info[1][bzr_index][0] != '.bzr':
 
2310
                            raise AssertionError()
 
2311
                        del current_dir_info[1][bzr_index]
 
2312
            # walk until both the directory listing and the versioned metadata
 
2313
            # are exhausted. 
 
2314
            if (block_index < len(state._dirblocks) and
 
2315
                osutils.is_inside(current_root, state._dirblocks[block_index][0])):
 
2316
                current_block = state._dirblocks[block_index]
 
2317
            else:
 
2318
                current_block = None
 
2319
            while (current_dir_info is not None or
 
2320
                   current_block is not None):
 
2321
                if (current_dir_info and current_block
 
2322
                    and current_dir_info[0][0] != current_block[0]):
 
2323
                    if cmp_by_dirs(current_dir_info[0][0], current_block[0]) < 0:
 
2324
                        # filesystem data refers to paths not covered by the dirblock.
 
2325
                        # this has two possibilities:
 
2326
                        # A) it is versioned but empty, so there is no block for it
 
2327
                        # B) it is not versioned.
 
2328
 
 
2329
                        # if (A) then we need to recurse into it to check for
 
2330
                        # new unknown files or directories.
 
2331
                        # if (B) then we should ignore it, because we don't
 
2332
                        # recurse into unknown directories.
 
2333
                        path_index = 0
 
2334
                        while path_index < len(current_dir_info[1]):
 
2335
                                current_path_info = current_dir_info[1][path_index]
 
2336
                                if want_unversioned:
 
2337
                                    if current_path_info[2] == 'directory':
 
2338
                                        if self.target._directory_is_tree_reference(
 
2339
                                            current_path_info[0].decode('utf8')):
 
2340
                                            current_path_info = current_path_info[:2] + \
 
2341
                                                ('tree-reference',) + current_path_info[3:]
 
2342
                                    new_executable = bool(
 
2343
                                        stat.S_ISREG(current_path_info[3].st_mode)
 
2344
                                        and stat.S_IEXEC & current_path_info[3].st_mode)
 
2345
                                    yield (None,
 
2346
                                        (None, utf8_decode(current_path_info[0])[0]),
 
2347
                                        True,
 
2348
                                        (False, False),
 
2349
                                        (None, None),
 
2350
                                        (None, utf8_decode(current_path_info[1])[0]),
 
2351
                                        (None, current_path_info[2]),
 
2352
                                        (None, new_executable))
 
2353
                                # dont descend into this unversioned path if it is
 
2354
                                # a dir
 
2355
                                if current_path_info[2] in ('directory',
 
2356
                                                            'tree-reference'):
 
2357
                                    del current_dir_info[1][path_index]
 
2358
                                    path_index -= 1
 
2359
                                path_index += 1
 
2360
 
 
2361
                        # This dir info has been handled, go to the next
 
2362
                        try:
 
2363
                            current_dir_info = dir_iterator.next()
 
2364
                        except StopIteration:
 
2365
                            current_dir_info = None
 
2366
                    else:
 
2367
                        # We have a dirblock entry for this location, but there
 
2368
                        # is no filesystem path for this. This is most likely
 
2369
                        # because a directory was removed from the disk.
 
2370
                        # We don't have to report the missing directory,
 
2371
                        # because that should have already been handled, but we
 
2372
                        # need to handle all of the files that are contained
 
2373
                        # within.
 
2374
                        for current_entry in current_block[1]:
 
2375
                            # entry referring to file not present on disk.
 
2376
                            # advance the entry only, after processing.
 
2377
                            result = _process_entry(current_entry, None)
 
2378
                            if result is not None:
 
2379
                                if result is not uninteresting:
 
2380
                                    yield result
 
2381
                        block_index +=1
 
2382
                        if (block_index < len(state._dirblocks) and
 
2383
                            osutils.is_inside(current_root,
 
2384
                                              state._dirblocks[block_index][0])):
 
2385
                            current_block = state._dirblocks[block_index]
 
2386
                        else:
 
2387
                            current_block = None
 
2388
                    continue
 
2389
                entry_index = 0
 
2390
                if current_block and entry_index < len(current_block[1]):
 
2391
                    current_entry = current_block[1][entry_index]
 
2392
                else:
 
2393
                    current_entry = None
 
2394
                advance_entry = True
 
2395
                path_index = 0
 
2396
                if current_dir_info and path_index < len(current_dir_info[1]):
 
2397
                    current_path_info = current_dir_info[1][path_index]
 
2398
                    if current_path_info[2] == 'directory':
 
2399
                        if self.target._directory_is_tree_reference(
 
2400
                            current_path_info[0].decode('utf8')):
 
2401
                            current_path_info = current_path_info[:2] + \
 
2402
                                ('tree-reference',) + current_path_info[3:]
 
2403
                else:
 
2404
                    current_path_info = None
 
2405
                advance_path = True
 
2406
                path_handled = False
 
2407
                while (current_entry is not None or
 
2408
                    current_path_info is not None):
 
2409
                    if current_entry is None:
 
2410
                        # the check for path_handled when the path is adnvaced
 
2411
                        # will yield this path if needed.
 
2412
                        pass
 
2413
                    elif current_path_info is None:
 
2414
                        # no path is fine: the per entry code will handle it.
 
2415
                        result = _process_entry(current_entry, current_path_info)
 
2416
                        if result is not None:
 
2417
                            if result is not uninteresting:
 
2418
                                yield result
 
2419
                    elif (current_entry[0][1] != current_path_info[1]
 
2420
                          or current_entry[1][target_index][0] in 'ar'):
 
2421
                        # The current path on disk doesn't match the dirblock
 
2422
                        # record. Either the dirblock is marked as absent, or
 
2423
                        # the file on disk is not present at all in the
 
2424
                        # dirblock. Either way, report about the dirblock
 
2425
                        # entry, and let other code handle the filesystem one.
 
2426
 
 
2427
                        # Compare the basename for these files to determine
 
2428
                        # which comes first
 
2429
                        if current_path_info[1] < current_entry[0][1]:
 
2430
                            # extra file on disk: pass for now, but only
 
2431
                            # increment the path, not the entry
 
2432
                            advance_entry = False
 
2433
                        else:
 
2434
                            # entry referring to file not present on disk.
 
2435
                            # advance the entry only, after processing.
 
2436
                            result = _process_entry(current_entry, None)
 
2437
                            if result is not None:
 
2438
                                if result is not uninteresting:
 
2439
                                    yield result
 
2440
                            advance_path = False
 
2441
                    else:
 
2442
                        result = _process_entry(current_entry, current_path_info)
 
2443
                        if result is not None:
 
2444
                            path_handled = True
 
2445
                            if result is not uninteresting:
 
2446
                                yield result
 
2447
                    if advance_entry and current_entry is not None:
 
2448
                        entry_index += 1
 
2449
                        if entry_index < len(current_block[1]):
 
2450
                            current_entry = current_block[1][entry_index]
 
2451
                        else:
 
2452
                            current_entry = None
 
2453
                    else:
 
2454
                        advance_entry = True # reset the advance flaga
 
2455
                    if advance_path and current_path_info is not None:
 
2456
                        if not path_handled:
 
2457
                            # unversioned in all regards
 
2458
                            if want_unversioned:
 
2459
                                new_executable = bool(
 
2460
                                    stat.S_ISREG(current_path_info[3].st_mode)
 
2461
                                    and stat.S_IEXEC & current_path_info[3].st_mode)
 
2462
                                yield (None,
 
2463
                                    (None, utf8_decode(current_path_info[0])[0]),
 
2464
                                    True,
 
2465
                                    (False, False),
 
2466
                                    (None, None),
 
2467
                                    (None, utf8_decode(current_path_info[1])[0]),
 
2468
                                    (None, current_path_info[2]),
 
2469
                                    (None, new_executable))
 
2470
                            # dont descend into this unversioned path if it is
 
2471
                            # a dir
 
2472
                            if current_path_info[2] in ('directory'):
 
2473
                                del current_dir_info[1][path_index]
 
2474
                                path_index -= 1
 
2475
                        # dont descend the disk iterator into any tree 
 
2476
                        # paths.
 
2477
                        if current_path_info[2] == 'tree-reference':
 
2478
                            del current_dir_info[1][path_index]
 
2479
                            path_index -= 1
 
2480
                        path_index += 1
 
2481
                        if path_index < len(current_dir_info[1]):
 
2482
                            current_path_info = current_dir_info[1][path_index]
 
2483
                            if current_path_info[2] == 'directory':
 
2484
                                if self.target._directory_is_tree_reference(
 
2485
                                    current_path_info[0].decode('utf8')):
 
2486
                                    current_path_info = current_path_info[:2] + \
 
2487
                                        ('tree-reference',) + current_path_info[3:]
 
2488
                        else:
 
2489
                            current_path_info = None
 
2490
                        path_handled = False
 
2491
                    else:
 
2492
                        advance_path = True # reset the advance flagg.
 
2493
                if current_block is not None:
 
2494
                    block_index += 1
 
2495
                    if (block_index < len(state._dirblocks) and
 
2496
                        osutils.is_inside(current_root, state._dirblocks[block_index][0])):
 
2497
                        current_block = state._dirblocks[block_index]
 
2498
                    else:
 
2499
                        current_block = None
 
2500
                if current_dir_info is not None:
 
2501
                    try:
 
2502
                        current_dir_info = dir_iterator.next()
 
2503
                    except StopIteration:
 
2504
                        current_dir_info = None
 
2505
 
2094
2506
 
2095
2507
    @staticmethod
2096
2508
    def is_compatible(source, target):
2097
2509
        # the target must be a dirstate working tree
2098
 
        if not isinstance(target, DirStateWorkingTree):
 
2510
        if not isinstance(target, WorkingTree4):
2099
2511
            return False
2100
 
        # the source must be a revtree or dirstate rev tree.
 
2512
        # the source must be a revtreee or dirstate rev tree.
2101
2513
        if not isinstance(source,
2102
2514
            (revisiontree.RevisionTree, DirStateRevisionTree)):
2103
2515
            return False
2104
2516
        # the source revid must be in the target dirstate
2105
 
        if not (source._revision_id == _mod_revision.NULL_REVISION or
 
2517
        if not (source._revision_id == NULL_REVISION or
2106
2518
            source._revision_id in target.get_parent_ids()):
2107
 
            # TODO: what about ghosts? it may well need to
 
2519
            # TODO: what about ghosts? it may well need to 
2108
2520
            # check for them explicitly.
2109
2521
            return False
2110
2522
        return True
2120
2532
 
2121
2533
    def convert(self, tree):
2122
2534
        # lock the control files not the tree, so that we dont get tree
2123
 
        # on-unlock behaviours, and so that noone else diddles with the
 
2535
        # on-unlock behaviours, and so that noone else diddles with the 
2124
2536
        # tree during upgrade.
2125
2537
        tree._control_files.lock_write()
2126
2538
        try:
2155
2567
        tree._transport.put_bytes('format',
2156
2568
            self.target_format.get_format_string(),
2157
2569
            mode=tree.bzrdir._get_file_mode())
2158
 
 
2159
 
 
2160
 
class Converter4to5(object):
2161
 
    """Perform an in-place upgrade of format 4 to format 5 trees."""
2162
 
 
2163
 
    def __init__(self):
2164
 
        self.target_format = WorkingTreeFormat5()
2165
 
 
2166
 
    def convert(self, tree):
2167
 
        # lock the control files not the tree, so that we don't get tree
2168
 
        # on-unlock behaviours, and so that no-one else diddles with the
2169
 
        # tree during upgrade.
2170
 
        tree._control_files.lock_write()
2171
 
        try:
2172
 
            self.update_format(tree)
2173
 
        finally:
2174
 
            tree._control_files.unlock()
2175
 
 
2176
 
    def update_format(self, tree):
2177
 
        """Change the format marker."""
2178
 
        tree._transport.put_bytes('format',
2179
 
            self.target_format.get_format_string(),
2180
 
            mode=tree.bzrdir._get_file_mode())
2181
 
 
2182
 
 
2183
 
class Converter4or5to6(object):
2184
 
    """Perform an in-place upgrade of format 4 or 5 to format 6 trees."""
2185
 
 
2186
 
    def __init__(self):
2187
 
        self.target_format = WorkingTreeFormat6()
2188
 
 
2189
 
    def convert(self, tree):
2190
 
        # lock the control files not the tree, so that we don't get tree
2191
 
        # on-unlock behaviours, and so that no-one else diddles with the
2192
 
        # tree during upgrade.
2193
 
        tree._control_files.lock_write()
2194
 
        try:
2195
 
            self.init_custom_control_files(tree)
2196
 
            self.update_format(tree)
2197
 
        finally:
2198
 
            tree._control_files.unlock()
2199
 
 
2200
 
    def init_custom_control_files(self, tree):
2201
 
        """Initialize custom control files."""
2202
 
        tree._transport.put_bytes('views', '',
2203
 
            mode=tree.bzrdir._get_file_mode())
2204
 
 
2205
 
    def update_format(self, tree):
2206
 
        """Change the format marker."""
2207
 
        tree._transport.put_bytes('format',
2208
 
            self.target_format.get_format_string(),
2209
 
            mode=tree.bzrdir._get_file_mode())