/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-10-14 21:35:27 UTC
  • mto: This revision was merged to the branch mainline in revision 3805.
  • Revision ID: john@arbash-meinel.com-20081014213527-4j9uc93aq1qmn43b
Add in a shortcut when we haven't cached much yet.

Document the current algorithm more completely, including the proper
justification for the various steps.

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
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
 
72
113
    def __init__(self, basedir,
73
114
                 branch,
74
115
                 _control_files=None,
101
142
        self._setup_directory_is_tree_reference()
102
143
        self._detect_case_handling()
103
144
        self._rules_searcher = None
104
 
        self.views = self._make_views()
105
145
        #--- allow tests to select the dirstate iter_changes implementation
106
146
        self._iter_changes = dirstate._process_entry
107
147
 
137
177
    @needs_tree_write_lock
138
178
    def add_reference(self, sub_tree):
139
179
        # use standard implementation, which calls back to self._add
140
 
        #
 
180
        # 
141
181
        # So we don't store the reference_revision in the working dirstate,
142
 
        # it's just recorded at the moment of commit.
 
182
        # it's just recorded at the moment of commit. 
143
183
        self._add_reference(sub_tree)
144
184
 
145
185
    def break_lock(self):
184
224
            WorkingTree3._comparison_data(self, entry, path)
185
225
        # it looks like a plain directory, but it's really a reference -- see
186
226
        # also kind()
187
 
        if (self._repo_supports_tree_reference and kind == 'directory'
188
 
            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)):
189
230
            kind = 'tree-reference'
190
231
        return kind, executable, stat_value
191
232
 
217
258
            return self._dirstate
218
259
        local_path = self.bzrdir.get_workingtree_transport(None
219
260
            ).local_abspath('dirstate')
220
 
        self._dirstate = dirstate.DirState.on_file(local_path,
221
 
            self._sha1_provider())
 
261
        self._dirstate = dirstate.DirState.on_file(local_path)
222
262
        return self._dirstate
223
263
 
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
264
    def filter_unversioned_files(self, paths):
237
265
        """Filter out paths that are versioned.
238
266
 
270
298
 
271
299
    def _generate_inventory(self):
272
300
        """Create and set self.inventory from the dirstate object.
273
 
 
 
301
        
274
302
        This is relatively expensive: we have to walk the entire dirstate.
275
303
        Ideally we would not, and can deprecate this function.
276
304
        """
321
349
                    parent_ies[(dirname + '/' + name).strip('/')] = inv_entry
322
350
                elif kind == 'tree-reference':
323
351
                    if not self._repo_supports_tree_reference:
324
 
                        raise errors.UnsupportedOperation(
325
 
                            self._generate_inventory,
326
 
                            self.branch.repository)
 
352
                        raise AssertionError(
 
353
                            "repository of %r "
 
354
                            "doesn't support tree references "
 
355
                            "required by entry %r"
 
356
                            % (self, name))
327
357
                    inv_entry.reference_revision = link_or_sha1 or None
328
358
                elif kind != 'symlink':
329
359
                    raise AssertionError("unknown kind %r" % kind)
344
374
        If either file_id or path is supplied, it is used as the key to lookup.
345
375
        If both are supplied, the fastest lookup is used, and an error is
346
376
        raised if they do not both point at the same row.
347
 
 
 
377
        
348
378
        :param file_id: An optional unicode file_id to be looked up.
349
379
        :param path: An optional unicode path to be looked up.
350
380
        :return: The dirstate row tuple for path/file_id, or (None, None)
406
436
    @needs_read_lock
407
437
    def get_parent_ids(self):
408
438
        """See Tree.get_parent_ids.
409
 
 
 
439
        
410
440
        This implementation requests the ids list from the dirstate file.
411
441
        """
412
442
        return self.current_dirstate().get_parent_ids()
434
464
        return osutils.lexists(pathjoin(
435
465
                    self.basedir, row[0].decode('utf8'), row[1].decode('utf8')))
436
466
 
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
467
    @needs_read_lock
443
468
    def id2path(self, file_id):
444
469
        "Convert a file-id to a path."
550
575
    def _kind(self, relpath):
551
576
        abspath = self.abspath(relpath)
552
577
        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'
 
578
        if (self._repo_supports_tree_reference and
 
579
            kind == 'directory' and
 
580
            self._directory_is_tree_reference(relpath)):
 
581
            kind = 'tree-reference'
558
582
        return kind
559
583
 
560
584
    @needs_read_lock
567
591
            return _mod_revision.NULL_REVISION
568
592
 
569
593
    def lock_read(self):
570
 
        """See Branch.lock_read, and WorkingTree.unlock.
571
 
 
572
 
        :return: An object with an unlock method which will release the lock
573
 
            obtained.
574
 
        """
 
594
        """See Branch.lock_read, and WorkingTree.unlock."""
575
595
        self.branch.lock_read()
576
596
        try:
577
597
            self._control_files.lock_read()
590
610
        except:
591
611
            self.branch.unlock()
592
612
            raise
593
 
        return self
594
613
 
595
614
    def _lock_self_write(self):
596
615
        """This should be called after the branch is locked."""
611
630
        except:
612
631
            self.branch.unlock()
613
632
            raise
614
 
        return self
615
633
 
616
634
    def lock_tree_write(self):
617
 
        """See MutableTree.lock_tree_write, and WorkingTree.unlock.
618
 
 
619
 
        :return: An object with an unlock method which will release the lock
620
 
            obtained.
621
 
        """
 
635
        """See MutableTree.lock_tree_write, and WorkingTree.unlock."""
622
636
        self.branch.lock_read()
623
 
        return self._lock_self_write()
 
637
        self._lock_self_write()
624
638
 
625
639
    def lock_write(self):
626
 
        """See MutableTree.lock_write, and WorkingTree.unlock.
627
 
 
628
 
        :return: An object with an unlock method which will release the lock
629
 
            obtained.
630
 
        """
 
640
        """See MutableTree.lock_write, and WorkingTree.unlock."""
631
641
        self.branch.lock_write()
632
 
        return self._lock_self_write()
 
642
        self._lock_self_write()
633
643
 
634
644
    @needs_tree_write_lock
635
645
    def move(self, from_paths, to_dir, after=False):
705
715
            from_entry = self._get_entry(path=from_rel)
706
716
            if from_entry == (None, None):
707
717
                raise errors.BzrMoveFailedError(from_rel,to_dir,
708
 
                    errors.NotVersionedError(path=from_rel))
 
718
                    errors.NotVersionedError(path=str(from_rel)))
709
719
 
710
720
            from_id = from_entry[0][2]
711
721
            to_rel = pathjoin(to_dir, from_tail)
886
896
        for tree in trees:
887
897
            if not (isinstance(tree, DirStateRevisionTree) and tree._revision_id in
888
898
                parents):
889
 
                return super(DirStateWorkingTree, self).paths2ids(paths,
890
 
                    trees, require_versioned)
 
899
                return super(WorkingTree4, self).paths2ids(paths, trees, require_versioned)
891
900
        search_indexes = [0] + [1 + parents.index(tree._revision_id) for tree in trees]
892
901
        # -- make all paths utf8 --
893
902
        paths_utf8 = set()
954
963
                raise errors.PathsNotVersionedError(paths)
955
964
        # -- remove redundancy in supplied paths to prevent over-scanning --
956
965
        search_paths = osutils.minimum_path_selection(paths)
957
 
        # sketch:
 
966
        # sketch: 
958
967
        # for all search_indexs in each path at or under each element of
959
968
        # search_paths, if the detail is relocated: add the id, and add the
960
969
        # relocated path as one to search if its not searched already. If the
1016
1025
 
1017
1026
    def read_working_inventory(self):
1018
1027
        """Read the working inventory.
1019
 
 
 
1028
        
1020
1029
        This is a meaningless operation for dirstate, but we obey it anyhow.
1021
1030
        """
1022
1031
        return self.inventory
1040
1049
    def set_last_revision(self, new_revision):
1041
1050
        """Change the last revision in the working tree."""
1042
1051
        parents = self.get_parent_ids()
1043
 
        if new_revision in (_mod_revision.NULL_REVISION, None):
 
1052
        if new_revision in (NULL_REVISION, None):
1044
1053
            if len(parents) >= 2:
1045
1054
                raise AssertionError(
1046
1055
                    "setting the last parent to none with a pending merge is "
1053
1062
    @needs_tree_write_lock
1054
1063
    def set_parent_ids(self, revision_ids, allow_leftmost_as_ghost=False):
1055
1064
        """Set the parent ids to revision_ids.
1056
 
 
 
1065
        
1057
1066
        See also set_parent_trees. This api will try to retrieve the tree data
1058
1067
        for each element of revision_ids from the trees repository. If you have
1059
1068
        tree data already available, it is more efficient to use
1213
1222
                # just forget the whole block.
1214
1223
                entry_index = 0
1215
1224
                while entry_index < len(block[1]):
 
1225
                    # Mark this file id as having been removed
1216
1226
                    entry = block[1][entry_index]
1217
 
                    if entry[1][0][0] in 'ar':
1218
 
                        # 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)):
1219
1231
                        entry_index += 1
1220
 
                    else:
1221
 
                        # Mark this file id as having been removed
1222
 
                        ids_to_unversion.discard(entry[0][2])
1223
 
                        if not state._make_absent(entry):
1224
 
                            # The block has not shrunk.
1225
 
                            entry_index += 1
1226
1232
                # go to the next block. (At the moment we dont delete empty
1227
1233
                # dirblocks)
1228
1234
                block_index += 1
1280
1286
        if self._dirty:
1281
1287
            raise AssertionError("attempting to write an inventory when the "
1282
1288
                "dirstate is dirty will lose pending changes")
1283
 
        had_inventory = self._inventory is not None
1284
 
        # Setting self._inventory = None forces the dirstate to regenerate the
1285
 
        # working inventory. We do this because self.inventory may be inv, or
1286
 
        # may have been modified, and either case would prevent a clean delta
1287
 
        # being created.
1288
 
        self._inventory = None
1289
 
        # generate a delta,
1290
 
        delta = inv._make_delta(self.inventory)
1291
 
        # and apply it.
1292
 
        self.apply_inventory_delta(delta)
1293
 
        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:
1294
1292
            self._inventory = inv
1295
1293
        self.flush()
1296
1294
 
1297
1295
 
1298
 
class ContentFilterAwareSHA1Provider(dirstate.SHA1Provider):
1299
 
 
1300
 
    def __init__(self, tree):
1301
 
        self.tree = tree
1302
 
 
1303
 
    def sha1(self, abspath):
1304
 
        """See dirstate.SHA1Provider.sha1()."""
1305
 
        filters = self.tree._content_filter_stack(
1306
 
            self.tree.relpath(osutils.safe_unicode(abspath)))
1307
 
        return internal_size_sha_file_byname(abspath, filters)[1]
1308
 
 
1309
 
    def stat_and_sha1(self, abspath):
1310
 
        """See dirstate.SHA1Provider.stat_and_sha1()."""
1311
 
        filters = self.tree._content_filter_stack(
1312
 
            self.tree.relpath(osutils.safe_unicode(abspath)))
1313
 
        file_obj = file(abspath, 'rb', 65000)
1314
 
        try:
1315
 
            statvalue = os.fstat(file_obj.fileno())
1316
 
            if filters:
1317
 
                file_obj = filtered_input_file(file_obj, filters)
1318
 
            sha1 = osutils.size_sha_file(file_obj)[1]
1319
 
        finally:
1320
 
            file_obj.close()
1321
 
        return statvalue, sha1
1322
 
 
1323
 
 
1324
 
class ContentFilteringDirStateWorkingTree(DirStateWorkingTree):
1325
 
    """Dirstate working tree that supports content filtering.
1326
 
 
1327
 
    The dirstate holds the hash and size of the canonical form of the file, 
1328
 
    and most methods must return that.
1329
 
    """
1330
 
 
1331
 
    def _file_content_summary(self, path, stat_result):
1332
 
        # This is to support the somewhat obsolete path_content_summary method
1333
 
        # with content filtering: see
1334
 
        # <https://bugs.edge.launchpad.net/bzr/+bug/415508>.
1335
 
        #
1336
 
        # If the dirstate cache is up to date and knows the hash and size,
1337
 
        # return that.
1338
 
        # Otherwise if there are no content filters, return the on-disk size
1339
 
        # and leave the hash blank.
1340
 
        # Otherwise, read and filter the on-disk file and use its size and
1341
 
        # hash.
1342
 
        #
1343
 
        # The dirstate doesn't store the size of the canonical form so we
1344
 
        # can't trust it for content-filtered trees.  We just return None.
1345
 
        dirstate_sha1 = self._dirstate.sha1_from_stat(path, stat_result)
1346
 
        executable = self._is_executable_from_path_and_stat(path, stat_result)
1347
 
        return ('file', None, executable, dirstate_sha1)
1348
 
 
1349
 
 
1350
 
class WorkingTree4(DirStateWorkingTree):
1351
 
    """This is the Format 4 working tree.
1352
 
 
1353
 
    This differs from WorkingTree3 by:
1354
 
     - Having a consolidated internal dirstate, stored in a
1355
 
       randomly-accessible sorted file on disk.
1356
 
     - Not having a regular inventory attribute.  One can be synthesized
1357
 
       on demand but this is expensive and should be avoided.
1358
 
 
1359
 
    This is new in bzr 0.15.
1360
 
    """
1361
 
 
1362
 
 
1363
 
class WorkingTree5(ContentFilteringDirStateWorkingTree):
1364
 
    """This is the Format 5 working tree.
1365
 
 
1366
 
    This differs from WorkingTree4 by:
1367
 
     - Supporting content filtering.
1368
 
 
1369
 
    This is new in bzr 1.11.
1370
 
    """
1371
 
 
1372
 
 
1373
 
class WorkingTree6(ContentFilteringDirStateWorkingTree):
1374
 
    """This is the Format 6 working tree.
1375
 
 
1376
 
    This differs from WorkingTree5 by:
1377
 
     - Supporting a current view that may mask the set of files in a tree
1378
 
       impacted by most user operations.
1379
 
 
1380
 
    This is new in bzr 1.14.
1381
 
    """
1382
 
 
1383
 
    def _make_views(self):
1384
 
        return views.PathBasedViews(self)
1385
 
 
1386
 
 
1387
 
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"
1388
1319
 
1389
1320
    def initialize(self, a_bzrdir, revision_id=None, from_branch=None,
1390
1321
                   accelerator_tree=None, hardlink=False):
1430
1361
        wt.lock_tree_write()
1431
1362
        try:
1432
1363
            self._init_custom_control_files(wt)
1433
 
            if revision_id in (None, _mod_revision.NULL_REVISION):
 
1364
            if revision_id in (None, NULL_REVISION):
1434
1365
                if branch.repository.supports_rich_root():
1435
1366
                    wt._set_root_id(generate_ids.gen_root_id())
1436
1367
                else:
1447
1378
                    pass
1448
1379
            if basis is None:
1449
1380
                basis = branch.repository.revision_tree(revision_id)
1450
 
            if revision_id == _mod_revision.NULL_REVISION:
 
1381
            if revision_id == NULL_REVISION:
1451
1382
                parents_list = []
1452
1383
            else:
1453
1384
                parents_list = [(revision_id, basis)]
1461
1392
                if basis_root_id is not None:
1462
1393
                    wt._set_root_id(basis_root_id)
1463
1394
                    wt.flush()
1464
 
                if wt.supports_content_filtering():
1465
 
                    # The original tree may not have the same content filters
1466
 
                    # applied so we can't safely build the inventory delta from
1467
 
                    # the source tree.
1468
 
                    delta_from_tree = False
1469
 
                else:
1470
 
                    delta_from_tree = True
1471
1395
                # delta_from_tree is safe even for DirStateRevisionTrees,
1472
1396
                # because wt4.apply_inventory_delta does not mutate the input
1473
1397
                # inventory entries.
1474
1398
                transform.build_tree(basis, wt, accelerator_tree,
1475
 
                                     hardlink=hardlink,
1476
 
                                     delta_from_tree=delta_from_tree)
 
1399
                                     hardlink=hardlink, delta_from_tree=True)
1477
1400
            finally:
1478
1401
                basis.unlock()
1479
1402
        finally:
1483
1406
 
1484
1407
    def _init_custom_control_files(self, wt):
1485
1408
        """Subclasses with custom control files should override this method.
1486
 
 
 
1409
        
1487
1410
        The working tree and control files are locked for writing when this
1488
1411
        method is called.
1489
 
 
 
1412
        
1490
1413
        :param wt: the WorkingTree object
1491
1414
        """
1492
1415
 
1503
1426
                           _control_files=control_files)
1504
1427
 
1505
1428
    def __get_matchingbzrdir(self):
1506
 
        return self._get_matchingbzrdir()
1507
 
 
1508
 
    def _get_matchingbzrdir(self):
1509
 
        """Overrideable method to get a bzrdir for testing."""
1510
1429
        # please test against something that will let us do tree references
1511
1430
        return bzrdir.format_registry.make_bzrdir(
1512
1431
            'dirstate-with-subtree')
1514
1433
    _matchingbzrdir = property(__get_matchingbzrdir)
1515
1434
 
1516
1435
 
1517
 
class WorkingTreeFormat4(DirStateWorkingTreeFormat):
1518
 
    """The first consolidated dirstate working tree format.
1519
 
 
1520
 
    This format:
1521
 
        - exists within a metadir controlling .bzr
1522
 
        - includes an explicit version marker for the workingtree control
1523
 
          files, separate from the BzrDir format
1524
 
        - modifies the hash cache format
1525
 
        - is new in bzr 0.15
1526
 
        - uses a LockDir to guard access to it.
1527
 
    """
1528
 
 
1529
 
    upgrade_recommended = False
1530
 
 
1531
 
    _tree_class = WorkingTree4
1532
 
 
1533
 
    def get_format_string(self):
1534
 
        """See WorkingTreeFormat.get_format_string()."""
1535
 
        return "Bazaar Working Tree Format 4 (bzr 0.15)\n"
1536
 
 
1537
 
    def get_format_description(self):
1538
 
        """See WorkingTreeFormat.get_format_description()."""
1539
 
        return "Working tree format 4"
1540
 
 
1541
 
 
1542
 
class WorkingTreeFormat5(DirStateWorkingTreeFormat):
1543
 
    """WorkingTree format supporting content filtering.
1544
 
    """
1545
 
 
1546
 
    upgrade_recommended = False
1547
 
 
1548
 
    _tree_class = WorkingTree5
1549
 
 
1550
 
    def get_format_string(self):
1551
 
        """See WorkingTreeFormat.get_format_string()."""
1552
 
        return "Bazaar Working Tree Format 5 (bzr 1.11)\n"
1553
 
 
1554
 
    def get_format_description(self):
1555
 
        """See WorkingTreeFormat.get_format_description()."""
1556
 
        return "Working tree format 5"
1557
 
 
1558
 
    def supports_content_filtering(self):
1559
 
        return True
1560
 
 
1561
 
 
1562
 
class WorkingTreeFormat6(DirStateWorkingTreeFormat):
1563
 
    """WorkingTree format supporting views.
1564
 
    """
1565
 
 
1566
 
    upgrade_recommended = False
1567
 
 
1568
 
    _tree_class = WorkingTree6
1569
 
 
1570
 
    def get_format_string(self):
1571
 
        """See WorkingTreeFormat.get_format_string()."""
1572
 
        return "Bazaar Working Tree Format 6 (bzr 1.14)\n"
1573
 
 
1574
 
    def get_format_description(self):
1575
 
        """See WorkingTreeFormat.get_format_description()."""
1576
 
        return "Working tree format 6"
1577
 
 
1578
 
    def _init_custom_control_files(self, wt):
1579
 
        """Subclasses with custom control files should override this method."""
1580
 
        wt._transport.put_bytes('views', '', mode=wt.bzrdir._get_file_mode())
1581
 
 
1582
 
    def supports_content_filtering(self):
1583
 
        return True
1584
 
 
1585
 
    def supports_views(self):
1586
 
        return True
1587
 
 
1588
 
 
1589
1436
class DirStateRevisionTree(Tree):
1590
 
    """A revision tree pulling the inventory from a dirstate.
1591
 
    
1592
 
    Note that this is one of the historical (ie revision) trees cached in the
1593
 
    dirstate for easy access, not the workingtree.
1594
 
    """
 
1437
    """A revision tree pulling the inventory from a dirstate."""
1595
1438
 
1596
1439
    def __init__(self, dirstate, revision_id, repository):
1597
1440
        self._dirstate = dirstate
1666
1509
        If either file_id or path is supplied, it is used as the key to lookup.
1667
1510
        If both are supplied, the fastest lookup is used, and an error is
1668
1511
        raised if they do not both point at the same row.
1669
 
 
 
1512
        
1670
1513
        :param file_id: An optional unicode file_id to be looked up.
1671
1514
        :param path: An optional unicode path to be looked up.
1672
1515
        :return: The dirstate row tuple for path/file_id, or (None, None)
1769
1612
            return None
1770
1613
        parent_index = self._get_parent_index()
1771
1614
        last_changed_revision = entry[1][parent_index][4]
1772
 
        try:
1773
 
            rev = self._repository.get_revision(last_changed_revision)
1774
 
        except errors.NoSuchRevision:
1775
 
            raise errors.FileTimestampUnavailable(self.id2path(file_id))
1776
 
        return rev.timestamp
 
1615
        return self._repository.get_revision(last_changed_revision).timestamp
1777
1616
 
1778
1617
    def get_file_sha1(self, file_id, path=None, stat_value=None):
1779
1618
        entry = self._get_entry(file_id=file_id, path=path)
1786
1625
    def get_file(self, file_id, path=None):
1787
1626
        return StringIO(self.get_file_text(file_id))
1788
1627
 
 
1628
    def get_file_lines(self, file_id):
 
1629
        return osutils.split_lines(self.get_file_text(file_id))
 
1630
 
1789
1631
    def get_file_size(self, file_id):
1790
1632
        """See Tree.get_file_size"""
1791
1633
        return self.inventory[file_id].text_size
1792
1634
 
1793
 
    def get_file_text(self, file_id, path=None):
1794
 
        _, content = list(self.iter_files_bytes([(file_id, None)]))[0]
1795
 
        return ''.join(content)
 
1635
    def get_file_text(self, file_id):
 
1636
        return list(self.iter_files_bytes([(file_id, None)]))[0][1]
1796
1637
 
1797
1638
    def get_reference_revision(self, file_id, path=None):
1798
1639
        return self.inventory[file_id].reference_revision
1817
1658
        if entry[1][parent_index][0] != 'l':
1818
1659
            return None
1819
1660
        else:
1820
 
            target = entry[1][parent_index][1]
1821
 
            target = target.decode('utf8')
1822
 
            return target
 
1661
            # At present, none of the tree implementations supports non-ascii
 
1662
            # symlink targets. So we will just assume that the dirstate path is
 
1663
            # correct.
 
1664
            return entry[1][parent_index][1]
1823
1665
 
1824
1666
    def get_revision_id(self):
1825
1667
        """Return the revision id for this tree."""
1846
1688
        entry = self._get_entry(file_id=file_id)[1]
1847
1689
        if entry is None:
1848
1690
            raise errors.NoSuchId(tree=self, file_id=file_id)
1849
 
        parent_index = self._get_parent_index()
1850
 
        return dirstate.DirState._minikind_to_kind[entry[parent_index][0]]
 
1691
        return dirstate.DirState._minikind_to_kind[entry[1][0]]
1851
1692
 
1852
1693
    def stored_kind(self, file_id):
1853
1694
        """See Tree.stored_kind"""
1873
1714
            return None
1874
1715
        return ie.executable
1875
1716
 
1876
 
    def is_locked(self):
1877
 
        return self._locked
1878
 
 
1879
 
    def list_files(self, include_root=False, from_dir=None, recursive=True):
 
1717
    def list_files(self, include_root=False):
1880
1718
        # We use a standard implementation, because DirStateRevisionTree is
1881
1719
        # dealing with one of the parents of the current state
1882
1720
        inv = self._get_inventory()
1883
 
        if from_dir is None:
1884
 
            from_dir_id = None
1885
 
        else:
1886
 
            from_dir_id = inv.path2id(from_dir)
1887
 
            if from_dir_id is None:
1888
 
                # Directory not versioned
1889
 
                return
1890
 
        entries = inv.iter_entries(from_dir=from_dir_id, recursive=recursive)
1891
 
        if inv.root is not None and not include_root and from_dir is None:
 
1721
        entries = inv.iter_entries()
 
1722
        if self.inventory.root is not None and not include_root:
1892
1723
            entries.next()
1893
1724
        for path, entry in entries:
1894
1725
            yield path, 'V', entry.kind, entry.file_id, entry
1895
1726
 
1896
1727
    def lock_read(self):
1897
 
        """Lock the tree for a set of operations.
1898
 
 
1899
 
        :return: An object with an unlock method which will release the lock
1900
 
            obtained.
1901
 
        """
 
1728
        """Lock the tree for a set of operations."""
1902
1729
        if not self._locked:
1903
1730
            self._repository.lock_read()
1904
1731
            if self._dirstate._lock_token is None:
1905
1732
                self._dirstate.lock_read()
1906
1733
                self._dirstate_locked = True
1907
1734
        self._locked += 1
1908
 
        return self
1909
1735
 
1910
1736
    def _must_be_locked(self):
1911
1737
        if not self._locked:
1938
1764
 
1939
1765
    def walkdirs(self, prefix=""):
1940
1766
        # TODO: jam 20070215 This is the lazy way by using the RevisionTree
1941
 
        # implementation based on an inventory.
 
1767
        # implementation based on an inventory.  
1942
1768
        # This should be cleaned up to use the much faster Dirstate code
1943
1769
        # So for now, we just build up the parent inventory, and extract
1944
1770
        # it the same way RevisionTree does.
1973
1799
 
1974
1800
class InterDirStateTree(InterTree):
1975
1801
    """Fast path optimiser for changes_from with dirstate trees.
1976
 
 
1977
 
    This is used only when both trees are in the dirstate working file, and
1978
 
    the source is any parent within the dirstate, and the destination is
 
1802
    
 
1803
    This is used only when both trees are in the dirstate working file, and 
 
1804
    the source is any parent within the dirstate, and the destination is 
1979
1805
    the current working tree of the same dirstate.
1980
1806
    """
1981
1807
    # this could be generalized to allow comparisons between any trees in the
2001
1827
        return result
2002
1828
 
2003
1829
    @classmethod
2004
 
    def make_source_parent_tree_compiled_dirstate(klass, test_case, source,
2005
 
                                                  target):
 
1830
    def make_source_parent_tree_compiled_dirstate(klass, test_case, source, target):
2006
1831
        from bzrlib.tests.test__dirstate_helpers import \
2007
 
            compiled_dirstate_helpers_feature
2008
 
        test_case.requireFeature(compiled_dirstate_helpers_feature)
2009
 
        from bzrlib._dirstate_helpers_pyx import ProcessEntryC
 
1832
            CompiledDirstateHelpersFeature
 
1833
        if not CompiledDirstateHelpersFeature.available():
 
1834
            from bzrlib.tests import UnavailableFeature
 
1835
            raise UnavailableFeature(CompiledDirstateHelpersFeature)
 
1836
        from bzrlib._dirstate_helpers_c import ProcessEntryC
2010
1837
        result = klass.make_source_parent_tree(source, target)
2011
1838
        result[1]._iter_changes = ProcessEntryC
2012
1839
        return result
2042
1869
            output. An unversioned file is defined as one with (False, False)
2043
1870
            for the versioned pair.
2044
1871
        """
 
1872
        # NB: show_status depends on being able to pass in non-versioned files
 
1873
        # and report them as unknown
2045
1874
        # TODO: handle extra trees in the dirstate.
2046
1875
        if (extra_trees or specific_files == []):
2047
1876
            # we can't fast-path these cases (yet)
2050
1879
                require_versioned, want_unversioned=want_unversioned)
2051
1880
        parent_ids = self.target.get_parent_ids()
2052
1881
        if not (self.source._revision_id in parent_ids
2053
 
                or self.source._revision_id == _mod_revision.NULL_REVISION):
 
1882
                or self.source._revision_id == NULL_REVISION):
2054
1883
            raise AssertionError(
2055
1884
                "revision {%s} is not stored in {%s}, but %s "
2056
1885
                "can only be used for trees stored in the dirstate"
2057
1886
                % (self.source._revision_id, self.target, self.iter_changes))
2058
1887
        target_index = 0
2059
 
        if self.source._revision_id == _mod_revision.NULL_REVISION:
 
1888
        if self.source._revision_id == NULL_REVISION:
2060
1889
            source_index = None
2061
1890
            indices = (target_index,)
2062
1891
        else:
2077
1906
        else:
2078
1907
            specific_files = set([''])
2079
1908
        # -- specific_files is now a utf8 path set --
2080
 
 
 
1909
        search_specific_files = set()
2081
1910
        # -- get the state object and prepare it.
2082
1911
        state = self.target.current_dirstate()
2083
1912
        state._read_dirblocks_if_needed()
2084
1913
        if require_versioned:
2085
1914
            # -- check all supplied paths are versioned in a search tree. --
2086
 
            not_versioned = []
 
1915
            all_versioned = True
2087
1916
            for path in specific_files:
2088
1917
                path_entries = state._entries_for_path(path)
2089
1918
                if not path_entries:
2090
1919
                    # this specified path is not present at all: error
2091
 
                    not_versioned.append(path)
2092
 
                    continue
 
1920
                    all_versioned = False
 
1921
                    break
2093
1922
                found_versioned = False
2094
1923
                # for each id at this path
2095
1924
                for entry in path_entries:
2102
1931
                if not found_versioned:
2103
1932
                    # none of the indexes was not 'absent' at all ids for this
2104
1933
                    # path.
2105
 
                    not_versioned.append(path)
2106
 
            if len(not_versioned) > 0:
2107
 
                raise errors.PathsNotVersionedError(not_versioned)
 
1934
                    all_versioned = False
 
1935
                    break
 
1936
            if not all_versioned:
 
1937
                raise errors.PathsNotVersionedError(specific_files)
2108
1938
        # -- remove redundancy in supplied specific_files to prevent over-scanning --
2109
 
        search_specific_files = osutils.minimum_path_selection(specific_files)
 
1939
        for path in specific_files:
 
1940
            other_specific_files = specific_files.difference(set([path]))
 
1941
            if not osutils.is_inside_any(other_specific_files, path):
 
1942
                # this is a top level path, we must check it.
 
1943
                search_specific_files.add(path)
2110
1944
 
2111
1945
        use_filesystem_for_exec = (sys.platform != 'win32')
2112
1946
        iter_changes = self.target._iter_changes(include_unchanged,
2117
1951
    @staticmethod
2118
1952
    def is_compatible(source, target):
2119
1953
        # the target must be a dirstate working tree
2120
 
        if not isinstance(target, DirStateWorkingTree):
 
1954
        if not isinstance(target, WorkingTree4):
2121
1955
            return False
2122
 
        # the source must be a revtree or dirstate rev tree.
 
1956
        # the source must be a revtreee or dirstate rev tree.
2123
1957
        if not isinstance(source,
2124
1958
            (revisiontree.RevisionTree, DirStateRevisionTree)):
2125
1959
            return False
2126
1960
        # the source revid must be in the target dirstate
2127
 
        if not (source._revision_id == _mod_revision.NULL_REVISION or
 
1961
        if not (source._revision_id == NULL_REVISION or
2128
1962
            source._revision_id in target.get_parent_ids()):
2129
 
            # TODO: what about ghosts? it may well need to
 
1963
            # TODO: what about ghosts? it may well need to 
2130
1964
            # check for them explicitly.
2131
1965
            return False
2132
1966
        return True
2142
1976
 
2143
1977
    def convert(self, tree):
2144
1978
        # lock the control files not the tree, so that we dont get tree
2145
 
        # on-unlock behaviours, and so that noone else diddles with the
 
1979
        # on-unlock behaviours, and so that noone else diddles with the 
2146
1980
        # tree during upgrade.
2147
1981
        tree._control_files.lock_write()
2148
1982
        try:
2177
2011
        tree._transport.put_bytes('format',
2178
2012
            self.target_format.get_format_string(),
2179
2013
            mode=tree.bzrdir._get_file_mode())
2180
 
 
2181
 
 
2182
 
class Converter4to5(object):
2183
 
    """Perform an in-place upgrade of format 4 to format 5 trees."""
2184
 
 
2185
 
    def __init__(self):
2186
 
        self.target_format = WorkingTreeFormat5()
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.update_format(tree)
2195
 
        finally:
2196
 
            tree._control_files.unlock()
2197
 
 
2198
 
    def update_format(self, tree):
2199
 
        """Change the format marker."""
2200
 
        tree._transport.put_bytes('format',
2201
 
            self.target_format.get_format_string(),
2202
 
            mode=tree.bzrdir._get_file_mode())
2203
 
 
2204
 
 
2205
 
class Converter4or5to6(object):
2206
 
    """Perform an in-place upgrade of format 4 or 5 to format 6 trees."""
2207
 
 
2208
 
    def __init__(self):
2209
 
        self.target_format = WorkingTreeFormat6()
2210
 
 
2211
 
    def convert(self, tree):
2212
 
        # lock the control files not the tree, so that we don't get tree
2213
 
        # on-unlock behaviours, and so that no-one else diddles with the
2214
 
        # tree during upgrade.
2215
 
        tree._control_files.lock_write()
2216
 
        try:
2217
 
            self.init_custom_control_files(tree)
2218
 
            self.update_format(tree)
2219
 
        finally:
2220
 
            tree._control_files.unlock()
2221
 
 
2222
 
    def init_custom_control_files(self, tree):
2223
 
        """Initialize custom control files."""
2224
 
        tree._transport.put_bytes('views', '',
2225
 
            mode=tree.bzrdir._get_file_mode())
2226
 
 
2227
 
    def update_format(self, tree):
2228
 
        """Change the format marker."""
2229
 
        tree._transport.put_bytes('format',
2230
 
            self.target_format.get_format_string(),
2231
 
            mode=tree.bzrdir._get_file_mode())