← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/workingtree_4.py

  • Committer: John Arbash Meinel
  • Date: 2008-11-25 17:15:26 UTC
  • mto: This revision was merged to the branch mainline in revision 3851.
  • Revision ID: john@arbash-meinel.com-20081125171526-pi2g4m1w70pkie1f
Add a bit of help text when supplying --help.

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
56
74
import bzrlib.mutabletree
57
75
from bzrlib.mutabletree import needs_tree_write_lock
58
76
from bzrlib.osutils import (
59
77
    file_kind,
60
78
    isdir,
 
79
    normpath,
61
80
    pathjoin,
 
81
    rand_chars,
62
82
    realpath,
63
83
    safe_unicode,
 
84
    splitpath,
64
85
    )
65
 
from bzrlib.trace import mutter
 
86
from bzrlib.trace import mutter, note
66
87
from bzrlib.transport.local import LocalTransport
67
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
        )
68
97
from bzrlib.tree import Tree
69
98
from bzrlib.workingtree import WorkingTree, WorkingTree3, WorkingTreeFormat3
70
99
 
71
100
 
72
 
class DirStateWorkingTree(WorkingTree3):
 
101
class WorkingTree4(WorkingTree3):
 
102
    """This is the Format 4 working tree.
 
103
 
 
104
    This differs from WorkingTree3 by:
 
105
     - Having a consolidated internal dirstate, stored in a
 
106
       randomly-accessible sorted file on disk.
 
107
     - Not having a regular inventory attribute.  One can be synthesized 
 
108
       on demand but this is expensive and should be avoided.
 
109
 
 
110
    This is new in bzr 0.15.
 
111
    """
 
112
 
73
113
    def __init__(self, basedir,
74
114
                 branch,
75
115
                 _control_files=None,
102
142
        self._setup_directory_is_tree_reference()
103
143
        self._detect_case_handling()
104
144
        self._rules_searcher = None
105
 
        self.views = self._make_views()
106
145
        #--- allow tests to select the dirstate iter_changes implementation
107
146
        self._iter_changes = dirstate._process_entry
108
147
 
138
177
    @needs_tree_write_lock
139
178
    def add_reference(self, sub_tree):
140
179
        # use standard implementation, which calls back to self._add
141
 
        #
 
180
        # 
142
181
        # So we don't store the reference_revision in the working dirstate,
143
 
        # it's just recorded at the moment of commit.
 
182
        # it's just recorded at the moment of commit. 
144
183
        self._add_reference(sub_tree)
145
184
 
146
185
    def break_lock(self):
185
224
            WorkingTree3._comparison_data(self, entry, path)
186
225
        # it looks like a plain directory, but it's really a reference -- see
187
226
        # also kind()
188
 
        if (self._repo_supports_tree_reference and kind == 'directory'
189
 
            and entry is not None and entry.kind == 'tree-reference'):
 
227
        if (self._repo_supports_tree_reference and
 
228
            kind == 'directory' and
 
229
            self._directory_is_tree_reference(path)):
190
230
            kind = 'tree-reference'
191
231
        return kind, executable, stat_value
192
232
 
218
258
            return self._dirstate
219
259
        local_path = self.bzrdir.get_workingtree_transport(None
220
260
            ).local_abspath('dirstate')
221
 
        self._dirstate = dirstate.DirState.on_file(local_path,
222
 
            self._sha1_provider())
 
261
        self._dirstate = dirstate.DirState.on_file(local_path)
223
262
        return self._dirstate
224
263
 
225
 
    def _sha1_provider(self):
226
 
        """A function that returns a SHA1Provider suitable for this tree.
227
 
 
228
 
        :return: None if content filtering is not supported by this tree.
229
 
          Otherwise, a SHA1Provider is returned that sha's the canonical
230
 
          form of files, i.e. after read filters are applied.
231
 
        """
232
 
        if self.supports_content_filtering():
233
 
            return ContentFilterAwareSHA1Provider(self)
234
 
        else:
235
 
            return None
236
 
 
237
264
    def filter_unversioned_files(self, paths):
238
265
        """Filter out paths that are versioned.
239
266
 
271
298
 
272
299
    def _generate_inventory(self):
273
300
        """Create and set self.inventory from the dirstate object.
274
 
 
 
301
        
275
302
        This is relatively expensive: we have to walk the entire dirstate.
276
303
        Ideally we would not, and can deprecate this function.
277
304
        """
322
349
                    parent_ies[(dirname + '/' + name).strip('/')] = inv_entry
323
350
                elif kind == 'tree-reference':
324
351
                    if not self._repo_supports_tree_reference:
325
 
                        raise errors.UnsupportedOperation(
326
 
                            self._generate_inventory,
327
 
                            self.branch.repository)
 
352
                        raise AssertionError(
 
353
                            "repository of %r "
 
354
                            "doesn't support tree references "
 
355
                            "required by entry %r"
 
356
                            % (self, name))
328
357
                    inv_entry.reference_revision = link_or_sha1 or None
329
358
                elif kind != 'symlink':
330
359
                    raise AssertionError("unknown kind %r" % kind)
345
374
        If either file_id or path is supplied, it is used as the key to lookup.
346
375
        If both are supplied, the fastest lookup is used, and an error is
347
376
        raised if they do not both point at the same row.
348
 
 
 
377
        
349
378
        :param file_id: An optional unicode file_id to be looked up.
350
379
        :param path: An optional unicode path to be looked up.
351
380
        :return: The dirstate row tuple for path/file_id, or (None, None)
407
436
    @needs_read_lock
408
437
    def get_parent_ids(self):
409
438
        """See Tree.get_parent_ids.
410
 
 
 
439
        
411
440
        This implementation requests the ids list from the dirstate file.
412
441
        """
413
442
        return self.current_dirstate().get_parent_ids()
435
464
        return osutils.lexists(pathjoin(
436
465
                    self.basedir, row[0].decode('utf8'), row[1].decode('utf8')))
437
466
 
438
 
    def has_or_had_id(self, file_id):
439
 
        state = self.current_dirstate()
440
 
        row, parents = self._get_entry(file_id=file_id)
441
 
        return row is not None
442
 
 
443
467
    @needs_read_lock
444
468
    def id2path(self, file_id):
445
469
        "Convert a file-id to a path."
551
575
    def _kind(self, relpath):
552
576
        abspath = self.abspath(relpath)
553
577
        kind = file_kind(abspath)
554
 
        if (self._repo_supports_tree_reference and kind == 'directory'):
555
 
            entry = self._get_entry(path=relpath)
556
 
            if entry[1] is not None:
557
 
                if entry[1][0][0] == 't':
558
 
                    kind = 'tree-reference'
 
578
        if (self._repo_supports_tree_reference and
 
579
            kind == 'directory' and
 
580
            self._directory_is_tree_reference(relpath)):
 
581
            kind = 'tree-reference'
559
582
        return kind
560
583
 
561
584
    @needs_read_lock
692
715
            from_entry = self._get_entry(path=from_rel)
693
716
            if from_entry == (None, None):
694
717
                raise errors.BzrMoveFailedError(from_rel,to_dir,
695
 
                    errors.NotVersionedError(path=from_rel))
 
718
                    errors.NotVersionedError(path=str(from_rel)))
696
719
 
697
720
            from_id = from_entry[0][2]
698
721
            to_rel = pathjoin(to_dir, from_tail)
873
896
        for tree in trees:
874
897
            if not (isinstance(tree, DirStateRevisionTree) and tree._revision_id in
875
898
                parents):
876
 
                return super(DirStateWorkingTree, self).paths2ids(paths,
877
 
                    trees, require_versioned)
 
899
                return super(WorkingTree4, self).paths2ids(paths, trees, require_versioned)
878
900
        search_indexes = [0] + [1 + parents.index(tree._revision_id) for tree in trees]
879
901
        # -- make all paths utf8 --
880
902
        paths_utf8 = set()
941
963
                raise errors.PathsNotVersionedError(paths)
942
964
        # -- remove redundancy in supplied paths to prevent over-scanning --
943
965
        search_paths = osutils.minimum_path_selection(paths)
944
 
        # sketch:
 
966
        # sketch: 
945
967
        # for all search_indexs in each path at or under each element of
946
968
        # search_paths, if the detail is relocated: add the id, and add the
947
969
        # relocated path as one to search if its not searched already. If the
1003
1025
 
1004
1026
    def read_working_inventory(self):
1005
1027
        """Read the working inventory.
1006
 
 
 
1028
        
1007
1029
        This is a meaningless operation for dirstate, but we obey it anyhow.
1008
1030
        """
1009
1031
        return self.inventory
1027
1049
    def set_last_revision(self, new_revision):
1028
1050
        """Change the last revision in the working tree."""
1029
1051
        parents = self.get_parent_ids()
1030
 
        if new_revision in (_mod_revision.NULL_REVISION, None):
 
1052
        if new_revision in (NULL_REVISION, None):
1031
1053
            if len(parents) >= 2:
1032
1054
                raise AssertionError(
1033
1055
                    "setting the last parent to none with a pending merge is "
1040
1062
    @needs_tree_write_lock
1041
1063
    def set_parent_ids(self, revision_ids, allow_leftmost_as_ghost=False):
1042
1064
        """Set the parent ids to revision_ids.
1043
 
 
 
1065
        
1044
1066
        See also set_parent_trees. This api will try to retrieve the tree data
1045
1067
        for each element of revision_ids from the trees repository. If you have
1046
1068
        tree data already available, it is more efficient to use
1200
1222
                # just forget the whole block.
1201
1223
                entry_index = 0
1202
1224
                while entry_index < len(block[1]):
 
1225
                    # Mark this file id as having been removed
1203
1226
                    entry = block[1][entry_index]
1204
 
                    if entry[1][0][0] in 'ar':
1205
 
                        # don't remove absent or renamed entries
 
1227
                    ids_to_unversion.discard(entry[0][2])
 
1228
                    if (entry[1][0][0] in 'ar' # don't remove absent or renamed
 
1229
                                               # entries
 
1230
                        or not state._make_absent(entry)):
1206
1231
                        entry_index += 1
1207
 
                    else:
1208
 
                        # Mark this file id as having been removed
1209
 
                        ids_to_unversion.discard(entry[0][2])
1210
 
                        if not state._make_absent(entry):
1211
 
                            # The block has not shrunk.
1212
 
                            entry_index += 1
1213
1232
                # go to the next block. (At the moment we dont delete empty
1214
1233
                # dirblocks)
1215
1234
                block_index += 1
1267
1286
        if self._dirty:
1268
1287
            raise AssertionError("attempting to write an inventory when the "
1269
1288
                "dirstate is dirty will lose pending changes")
1270
 
        had_inventory = self._inventory is not None
1271
 
        # Setting self._inventory = None forces the dirstate to regenerate the
1272
 
        # working inventory. We do this because self.inventory may be inv, or
1273
 
        # may have been modified, and either case would prevent a clean delta
1274
 
        # being created.
1275
 
        self._inventory = None
1276
 
        # generate a delta,
1277
 
        delta = inv._make_delta(self.inventory)
1278
 
        # and apply it.
1279
 
        self.apply_inventory_delta(delta)
1280
 
        if had_inventory:
 
1289
        self.current_dirstate().set_state_from_inventory(inv)
 
1290
        self._make_dirty(reset_inventory=False)
 
1291
        if self._inventory is not None:
1281
1292
            self._inventory = inv
1282
1293
        self.flush()
1283
1294
 
1284
1295
 
1285
 
class ContentFilterAwareSHA1Provider(dirstate.SHA1Provider):
1286
 
 
1287
 
    def __init__(self, tree):
1288
 
        self.tree = tree
1289
 
 
1290
 
    def sha1(self, abspath):
1291
 
        """See dirstate.SHA1Provider.sha1()."""
1292
 
        filters = self.tree._content_filter_stack(
1293
 
            self.tree.relpath(osutils.safe_unicode(abspath)))
1294
 
        return internal_size_sha_file_byname(abspath, filters)[1]
1295
 
 
1296
 
    def stat_and_sha1(self, abspath):
1297
 
        """See dirstate.SHA1Provider.stat_and_sha1()."""
1298
 
        filters = self.tree._content_filter_stack(
1299
 
            self.tree.relpath(osutils.safe_unicode(abspath)))
1300
 
        file_obj = file(abspath, 'rb', 65000)
1301
 
        try:
1302
 
            statvalue = os.fstat(file_obj.fileno())
1303
 
            if filters:
1304
 
                file_obj = filtered_input_file(file_obj, filters)
1305
 
            sha1 = osutils.size_sha_file(file_obj)[1]
1306
 
        finally:
1307
 
            file_obj.close()
1308
 
        return statvalue, sha1
1309
 
 
1310
 
 
1311
 
class ContentFilteringDirStateWorkingTree(DirStateWorkingTree):
1312
 
    """Dirstate working tree that supports content filtering.
1313
 
 
1314
 
    The dirstate holds the hash and size of the canonical form of the file, 
1315
 
    and most methods must return that.
1316
 
    """
1317
 
 
1318
 
    def _file_content_summary(self, path, stat_result):
1319
 
        # This is to support the somewhat obsolete path_content_summary method
1320
 
        # with content filtering: see
1321
 
        # <https://bugs.edge.launchpad.net/bzr/+bug/415508>.
1322
 
        #
1323
 
        # If the dirstate cache is up to date and knows the hash and size,
1324
 
        # return that.
1325
 
        # Otherwise if there are no content filters, return the on-disk size
1326
 
        # and leave the hash blank.
1327
 
        # Otherwise, read and filter the on-disk file and use its size and
1328
 
        # hash.
1329
 
        #
1330
 
        # The dirstate doesn't store the size of the canonical form so we
1331
 
        # can't trust it for content-filtered trees.  We just return None.
1332
 
        dirstate_sha1 = self._dirstate.sha1_from_stat(path, stat_result)
1333
 
        executable = self._is_executable_from_path_and_stat(path, stat_result)
1334
 
        return ('file', None, executable, dirstate_sha1)
1335
 
 
1336
 
 
1337
 
class WorkingTree4(DirStateWorkingTree):
1338
 
    """This is the Format 4 working tree.
1339
 
 
1340
 
    This differs from WorkingTree3 by:
1341
 
     - Having a consolidated internal dirstate, stored in a
1342
 
       randomly-accessible sorted file on disk.
1343
 
     - Not having a regular inventory attribute.  One can be synthesized
1344
 
       on demand but this is expensive and should be avoided.
1345
 
 
1346
 
    This is new in bzr 0.15.
1347
 
    """
1348
 
 
1349
 
 
1350
 
class WorkingTree5(ContentFilteringDirStateWorkingTree):
1351
 
    """This is the Format 5 working tree.
1352
 
 
1353
 
    This differs from WorkingTree4 by:
1354
 
     - Supporting content filtering.
1355
 
 
1356
 
    This is new in bzr 1.11.
1357
 
    """
1358
 
 
1359
 
 
1360
 
class WorkingTree6(ContentFilteringDirStateWorkingTree):
1361
 
    """This is the Format 6 working tree.
1362
 
 
1363
 
    This differs from WorkingTree5 by:
1364
 
     - Supporting a current view that may mask the set of files in a tree
1365
 
       impacted by most user operations.
1366
 
 
1367
 
    This is new in bzr 1.14.
1368
 
    """
1369
 
 
1370
 
    def _make_views(self):
1371
 
        return views.PathBasedViews(self)
1372
 
 
1373
 
 
1374
 
class DirStateWorkingTreeFormat(WorkingTreeFormat3):
 
1296
class WorkingTreeFormat4(WorkingTreeFormat3):
 
1297
    """The first consolidated dirstate working tree format.
 
1298
 
 
1299
    This format:
 
1300
        - exists within a metadir controlling .bzr
 
1301
        - includes an explicit version marker for the workingtree control
 
1302
          files, separate from the BzrDir format
 
1303
        - modifies the hash cache format
 
1304
        - is new in bzr 0.15
 
1305
        - uses a LockDir to guard access to it.
 
1306
    """
 
1307
 
 
1308
    upgrade_recommended = False
 
1309
 
 
1310
    _tree_class = WorkingTree4
 
1311
 
 
1312
    def get_format_string(self):
 
1313
        """See WorkingTreeFormat.get_format_string()."""
 
1314
        return "Bazaar Working Tree Format 4 (bzr 0.15)\n"
 
1315
 
 
1316
    def get_format_description(self):
 
1317
        """See WorkingTreeFormat.get_format_description()."""
 
1318
        return "Working tree format 4"
 
1319
 
1375
1320
    def initialize(self, a_bzrdir, revision_id=None, from_branch=None,
1376
1321
                   accelerator_tree=None, hardlink=False):
1377
1322
        """See WorkingTreeFormat.initialize().
1416
1361
        wt.lock_tree_write()
1417
1362
        try:
1418
1363
            self._init_custom_control_files(wt)
1419
 
            if revision_id in (None, _mod_revision.NULL_REVISION):
 
1364
            if revision_id in (None, NULL_REVISION):
1420
1365
                if branch.repository.supports_rich_root():
1421
1366
                    wt._set_root_id(generate_ids.gen_root_id())
1422
1367
                else:
1433
1378
                    pass
1434
1379
            if basis is None:
1435
1380
                basis = branch.repository.revision_tree(revision_id)
1436
 
            if revision_id == _mod_revision.NULL_REVISION:
 
1381
            if revision_id == NULL_REVISION:
1437
1382
                parents_list = []
1438
1383
            else:
1439
1384
                parents_list = [(revision_id, basis)]
1447
1392
                if basis_root_id is not None:
1448
1393
                    wt._set_root_id(basis_root_id)
1449
1394
                    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
1395
                # delta_from_tree is safe even for DirStateRevisionTrees,
1458
1396
                # because wt4.apply_inventory_delta does not mutate the input
1459
1397
                # inventory entries.
1460
1398
                transform.build_tree(basis, wt, accelerator_tree,
1461
 
                                     hardlink=hardlink,
1462
 
                                     delta_from_tree=delta_from_tree)
 
1399
                                     hardlink=hardlink, delta_from_tree=True)
1463
1400
            finally:
1464
1401
                basis.unlock()
1465
1402
        finally:
1469
1406
 
1470
1407
    def _init_custom_control_files(self, wt):
1471
1408
        """Subclasses with custom control files should override this method.
1472
 
 
 
1409
        
1473
1410
        The working tree and control files are locked for writing when this
1474
1411
        method is called.
1475
 
 
 
1412
        
1476
1413
        :param wt: the WorkingTree object
1477
1414
        """
1478
1415
 
1489
1426
                           _control_files=control_files)
1490
1427
 
1491
1428
    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
1429
        # please test against something that will let us do tree references
1497
1430
        return bzrdir.format_registry.make_bzrdir(
1498
1431
            'dirstate-with-subtree')
1500
1433
    _matchingbzrdir = property(__get_matchingbzrdir)
1501
1434
 
1502
1435
 
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
1436
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
 
    """
 
1437
    """A revision tree pulling the inventory from a dirstate."""
1581
1438
 
1582
1439
    def __init__(self, dirstate, revision_id, repository):
1583
1440
        self._dirstate = dirstate
1652
1509
        If either file_id or path is supplied, it is used as the key to lookup.
1653
1510
        If both are supplied, the fastest lookup is used, and an error is
1654
1511
        raised if they do not both point at the same row.
1655
 
 
 
1512
        
1656
1513
        :param file_id: An optional unicode file_id to be looked up.
1657
1514
        :param path: An optional unicode path to be looked up.
1658
1515
        :return: The dirstate row tuple for path/file_id, or (None, None)
1755
1612
            return None
1756
1613
        parent_index = self._get_parent_index()
1757
1614
        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
 
1615
        return self._repository.get_revision(last_changed_revision).timestamp
1763
1616
 
1764
1617
    def get_file_sha1(self, file_id, path=None, stat_value=None):
1765
1618
        entry = self._get_entry(file_id=file_id, path=path)
1777
1630
        return self.inventory[file_id].text_size
1778
1631
 
1779
1632
    def get_file_text(self, file_id, path=None):
1780
 
        _, content = list(self.iter_files_bytes([(file_id, None)]))[0]
1781
 
        return ''.join(content)
 
1633
        return list(self.iter_files_bytes([(file_id, None)]))[0][1]
1782
1634
 
1783
1635
    def get_reference_revision(self, file_id, path=None):
1784
1636
        return self.inventory[file_id].reference_revision
1803
1655
        if entry[1][parent_index][0] != 'l':
1804
1656
            return None
1805
1657
        else:
1806
 
            target = entry[1][parent_index][1]
1807
 
            target = target.decode('utf8')
1808
 
            return target
 
1658
            # At present, none of the tree implementations supports non-ascii
 
1659
            # symlink targets. So we will just assume that the dirstate path is
 
1660
            # correct.
 
1661
            return entry[1][parent_index][1]
1809
1662
 
1810
1663
    def get_revision_id(self):
1811
1664
        """Return the revision id for this tree."""
1858
1711
            return None
1859
1712
        return ie.executable
1860
1713
 
1861
 
    def list_files(self, include_root=False, from_dir=None, recursive=True):
 
1714
    def list_files(self, include_root=False):
1862
1715
        # We use a standard implementation, because DirStateRevisionTree is
1863
1716
        # dealing with one of the parents of the current state
1864
1717
        inv = self._get_inventory()
1865
 
        if from_dir is None:
1866
 
            from_dir_id = None
1867
 
        else:
1868
 
            from_dir_id = inv.path2id(from_dir)
1869
 
            if from_dir_id is None:
1870
 
                # Directory not versioned
1871
 
                return
1872
 
        entries = inv.iter_entries(from_dir=from_dir_id, recursive=recursive)
1873
 
        if inv.root is not None and not include_root and from_dir is None:
 
1718
        entries = inv.iter_entries()
 
1719
        if self.inventory.root is not None and not include_root:
1874
1720
            entries.next()
1875
1721
        for path, entry in entries:
1876
1722
            yield path, 'V', entry.kind, entry.file_id, entry
1915
1761
 
1916
1762
    def walkdirs(self, prefix=""):
1917
1763
        # TODO: jam 20070215 This is the lazy way by using the RevisionTree
1918
 
        # implementation based on an inventory.
 
1764
        # implementation based on an inventory.  
1919
1765
        # This should be cleaned up to use the much faster Dirstate code
1920
1766
        # So for now, we just build up the parent inventory, and extract
1921
1767
        # it the same way RevisionTree does.
1950
1796
 
1951
1797
class InterDirStateTree(InterTree):
1952
1798
    """Fast path optimiser for changes_from with dirstate trees.
1953
 
 
1954
 
    This is used only when both trees are in the dirstate working file, and
1955
 
    the source is any parent within the dirstate, and the destination is
 
1799
    
 
1800
    This is used only when both trees are in the dirstate working file, and 
 
1801
    the source is any parent within the dirstate, and the destination is 
1956
1802
    the current working tree of the same dirstate.
1957
1803
    """
1958
1804
    # this could be generalized to allow comparisons between any trees in the
1978
1824
        return result
1979
1825
 
1980
1826
    @classmethod
1981
 
    def make_source_parent_tree_compiled_dirstate(klass, test_case, source,
1982
 
                                                  target):
 
1827
    def make_source_parent_tree_compiled_dirstate(klass, test_case, source, target):
1983
1828
        from bzrlib.tests.test__dirstate_helpers import \
1984
 
            compiled_dirstate_helpers_feature
1985
 
        test_case.requireFeature(compiled_dirstate_helpers_feature)
1986
 
        from bzrlib._dirstate_helpers_pyx import ProcessEntryC
 
1829
            CompiledDirstateHelpersFeature
 
1830
        if not CompiledDirstateHelpersFeature.available():
 
1831
            from bzrlib.tests import UnavailableFeature
 
1832
            raise UnavailableFeature(CompiledDirstateHelpersFeature)
 
1833
        from bzrlib._dirstate_helpers_c import ProcessEntryC
1987
1834
        result = klass.make_source_parent_tree(source, target)
1988
1835
        result[1]._iter_changes = ProcessEntryC
1989
1836
        return result
2019
1866
            output. An unversioned file is defined as one with (False, False)
2020
1867
            for the versioned pair.
2021
1868
        """
 
1869
        # NB: show_status depends on being able to pass in non-versioned files
 
1870
        # and report them as unknown
2022
1871
        # TODO: handle extra trees in the dirstate.
2023
1872
        if (extra_trees or specific_files == []):
2024
1873
            # we can't fast-path these cases (yet)
2027
1876
                require_versioned, want_unversioned=want_unversioned)
2028
1877
        parent_ids = self.target.get_parent_ids()
2029
1878
        if not (self.source._revision_id in parent_ids
2030
 
                or self.source._revision_id == _mod_revision.NULL_REVISION):
 
1879
                or self.source._revision_id == NULL_REVISION):
2031
1880
            raise AssertionError(
2032
1881
                "revision {%s} is not stored in {%s}, but %s "
2033
1882
                "can only be used for trees stored in the dirstate"
2034
1883
                % (self.source._revision_id, self.target, self.iter_changes))
2035
1884
        target_index = 0
2036
 
        if self.source._revision_id == _mod_revision.NULL_REVISION:
 
1885
        if self.source._revision_id == NULL_REVISION:
2037
1886
            source_index = None
2038
1887
            indices = (target_index,)
2039
1888
        else:
2054
1903
        else:
2055
1904
            specific_files = set([''])
2056
1905
        # -- specific_files is now a utf8 path set --
2057
 
 
 
1906
        search_specific_files = set()
2058
1907
        # -- get the state object and prepare it.
2059
1908
        state = self.target.current_dirstate()
2060
1909
        state._read_dirblocks_if_needed()
2061
1910
        if require_versioned:
2062
1911
            # -- check all supplied paths are versioned in a search tree. --
2063
 
            not_versioned = []
 
1912
            all_versioned = True
2064
1913
            for path in specific_files:
2065
1914
                path_entries = state._entries_for_path(path)
2066
1915
                if not path_entries:
2067
1916
                    # this specified path is not present at all: error
2068
 
                    not_versioned.append(path)
2069
 
                    continue
 
1917
                    all_versioned = False
 
1918
                    break
2070
1919
                found_versioned = False
2071
1920
                # for each id at this path
2072
1921
                for entry in path_entries:
2079
1928
                if not found_versioned:
2080
1929
                    # none of the indexes was not 'absent' at all ids for this
2081
1930
                    # path.
2082
 
                    not_versioned.append(path)
2083
 
            if len(not_versioned) > 0:
2084
 
                raise errors.PathsNotVersionedError(not_versioned)
 
1931
                    all_versioned = False
 
1932
                    break
 
1933
            if not all_versioned:
 
1934
                raise errors.PathsNotVersionedError(specific_files)
2085
1935
        # -- remove redundancy in supplied specific_files to prevent over-scanning --
2086
 
        search_specific_files = osutils.minimum_path_selection(specific_files)
 
1936
        for path in specific_files:
 
1937
            other_specific_files = specific_files.difference(set([path]))
 
1938
            if not osutils.is_inside_any(other_specific_files, path):
 
1939
                # this is a top level path, we must check it.
 
1940
                search_specific_files.add(path)
2087
1941
 
2088
1942
        use_filesystem_for_exec = (sys.platform != 'win32')
2089
1943
        iter_changes = self.target._iter_changes(include_unchanged,
2094
1948
    @staticmethod
2095
1949
    def is_compatible(source, target):
2096
1950
        # the target must be a dirstate working tree
2097
 
        if not isinstance(target, DirStateWorkingTree):
 
1951
        if not isinstance(target, WorkingTree4):
2098
1952
            return False
2099
 
        # the source must be a revtree or dirstate rev tree.
 
1953
        # the source must be a revtreee or dirstate rev tree.
2100
1954
        if not isinstance(source,
2101
1955
            (revisiontree.RevisionTree, DirStateRevisionTree)):
2102
1956
            return False
2103
1957
        # the source revid must be in the target dirstate
2104
 
        if not (source._revision_id == _mod_revision.NULL_REVISION or
 
1958
        if not (source._revision_id == NULL_REVISION or
2105
1959
            source._revision_id in target.get_parent_ids()):
2106
 
            # TODO: what about ghosts? it may well need to
 
1960
            # TODO: what about ghosts? it may well need to 
2107
1961
            # check for them explicitly.
2108
1962
            return False
2109
1963
        return True
2119
1973
 
2120
1974
    def convert(self, tree):
2121
1975
        # lock the control files not the tree, so that we dont get tree
2122
 
        # on-unlock behaviours, and so that noone else diddles with the
 
1976
        # on-unlock behaviours, and so that noone else diddles with the 
2123
1977
        # tree during upgrade.
2124
1978
        tree._control_files.lock_write()
2125
1979
        try:
2154
2008
        tree._transport.put_bytes('format',
2155
2009
            self.target_format.get_format_string(),
2156
2010
            mode=tree.bzrdir._get_file_mode())
2157
 
 
2158
 
 
2159
 
class Converter4to5(object):
2160
 
    """Perform an in-place upgrade of format 4 to format 5 trees."""
2161
 
 
2162
 
    def __init__(self):
2163
 
        self.target_format = WorkingTreeFormat5()
2164
 
 
2165
 
    def convert(self, tree):
2166
 
        # lock the control files not the tree, so that we don't get tree
2167
 
        # on-unlock behaviours, and so that no-one else diddles with the
2168
 
        # tree during upgrade.
2169
 
        tree._control_files.lock_write()
2170
 
        try:
2171
 
            self.update_format(tree)
2172
 
        finally:
2173
 
            tree._control_files.unlock()
2174
 
 
2175
 
    def update_format(self, tree):
2176
 
        """Change the format marker."""
2177
 
        tree._transport.put_bytes('format',
2178
 
            self.target_format.get_format_string(),
2179
 
            mode=tree.bzrdir._get_file_mode())
2180
 
 
2181
 
 
2182
 
class Converter4or5to6(object):
2183
 
    """Perform an in-place upgrade of format 4 or 5 to format 6 trees."""
2184
 
 
2185
 
    def __init__(self):
2186
 
        self.target_format = WorkingTreeFormat6()
2187
 
 
2188
 
    def convert(self, tree):
2189
 
        # lock the control files not the tree, so that we don't get tree
2190
 
        # on-unlock behaviours, and so that no-one else diddles with the
2191
 
        # tree during upgrade.
2192
 
        tree._control_files.lock_write()
2193
 
        try:
2194
 
            self.init_custom_control_files(tree)
2195
 
            self.update_format(tree)
2196
 
        finally:
2197
 
            tree._control_files.unlock()
2198
 
 
2199
 
    def init_custom_control_files(self, tree):
2200
 
        """Initialize custom control files."""
2201
 
        tree._transport.put_bytes('views', '',
2202
 
            mode=tree.bzrdir._get_file_mode())
2203
 
 
2204
 
    def update_format(self, tree):
2205
 
        """Change the format marker."""
2206
 
        tree._transport.put_bytes('format',
2207
 
            self.target_format.get_format_string(),
2208
 
            mode=tree.bzrdir._get_file_mode())