← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/workingtree_4.py

(vila) Make all transport put_bytes() raises TypeError when given unicode
 strings rather than bytes (Vincent Ladeuil)

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) 2007-2012 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
22
22
WorkingTree.open(dir).
23
23
"""
24
24
 
 
25
from __future__ import absolute_import
 
26
 
25
27
from cStringIO import StringIO
26
28
import os
27
29
import sys
31
33
import errno
32
34
import stat
33
35
 
34
 
import bzrlib
35
36
from bzrlib import (
36
37
    bzrdir,
37
38
    cache_utf8,
 
39
    config,
 
40
    conflicts as _mod_conflicts,
 
41
    controldir,
38
42
    debug,
39
43
    dirstate,
40
44
    errors,
 
45
    filters as _mod_filters,
41
46
    generate_ids,
42
47
    osutils,
43
48
    revision as _mod_revision,
46
51
    transform,
47
52
    views,
48
53
    )
49
 
import bzrlib.branch
50
 
import bzrlib.ui
51
54
""")
52
55
 
53
56
from bzrlib.decorators import needs_read_lock, needs_write_lock
54
 
from bzrlib.filters import filtered_input_file, internal_size_sha_file_byname
55
57
from bzrlib.inventory import Inventory, ROOT_ID, entry_factory
56
 
import bzrlib.mutabletree
57
 
from bzrlib.mutabletree import needs_tree_write_lock
 
58
from bzrlib.lock import LogicalLockResult
 
59
from bzrlib.lockable_files import LockableFiles
 
60
from bzrlib.lockdir import LockDir
 
61
from bzrlib.mutabletree import (
 
62
    MutableTree,
 
63
    needs_tree_write_lock,
 
64
    )
58
65
from bzrlib.osutils import (
59
66
    file_kind,
60
67
    isdir,
62
69
    realpath,
63
70
    safe_unicode,
64
71
    )
65
 
from bzrlib.trace import mutter
 
72
from bzrlib.symbol_versioning import (
 
73
    deprecated_in,
 
74
    deprecated_method,
 
75
    )
66
76
from bzrlib.transport.local import LocalTransport
67
 
from bzrlib.tree import InterTree
68
 
from bzrlib.tree import Tree
69
 
from bzrlib.workingtree import WorkingTree, WorkingTree3, WorkingTreeFormat3
70
 
 
71
 
 
72
 
class DirStateWorkingTree(WorkingTree3):
 
77
from bzrlib.tree import (
 
78
    InterTree,
 
79
    InventoryTree,
 
80
    )
 
81
from bzrlib.workingtree import (
 
82
    InventoryWorkingTree,
 
83
    WorkingTree,
 
84
    WorkingTreeFormatMetaDir,
 
85
    )
 
86
 
 
87
 
 
88
class DirStateWorkingTree(InventoryWorkingTree):
 
89
 
73
90
    def __init__(self, basedir,
74
91
                 branch,
75
92
                 _control_files=None,
85
102
        self._format = _format
86
103
        self.bzrdir = _bzrdir
87
104
        basedir = safe_unicode(basedir)
88
 
        mutter("opening working tree %r", basedir)
 
105
        trace.mutter("opening working tree %r", basedir)
89
106
        self._branch = branch
90
107
        self.basedir = realpath(basedir)
91
108
        # if branch is at our basedir and is a format 6 or less
125
142
            state.add(f, file_id, kind, None, '')
126
143
        self._make_dirty(reset_inventory=True)
127
144
 
 
145
    def _get_check_refs(self):
 
146
        """Return the references needed to perform a check of this tree."""
 
147
        return [('trees', self.last_revision())]
 
148
 
128
149
    def _make_dirty(self, reset_inventory):
129
150
        """Make the tree state dirty.
130
151
 
182
203
 
183
204
    def _comparison_data(self, entry, path):
184
205
        kind, executable, stat_value = \
185
 
            WorkingTree3._comparison_data(self, entry, path)
 
206
            WorkingTree._comparison_data(self, entry, path)
186
207
        # it looks like a plain directory, but it's really a reference -- see
187
208
        # also kind()
188
209
        if (self._repo_supports_tree_reference and kind == 'directory'
194
215
    def commit(self, message=None, revprops=None, *args, **kwargs):
195
216
        # mark the tree as dirty post commit - commit
196
217
        # can change the current versioned list by doing deletes.
197
 
        result = WorkingTree3.commit(self, message, revprops, *args, **kwargs)
 
218
        result = WorkingTree.commit(self, message, revprops, *args, **kwargs)
198
219
        self._make_dirty(reset_inventory=True)
199
220
        return result
200
221
 
219
240
        local_path = self.bzrdir.get_workingtree_transport(None
220
241
            ).local_abspath('dirstate')
221
242
        self._dirstate = dirstate.DirState.on_file(local_path,
222
 
            self._sha1_provider())
 
243
            self._sha1_provider(), self._worth_saving_limit())
223
244
        return self._dirstate
224
245
 
225
246
    def _sha1_provider(self):
234
255
        else:
235
256
            return None
236
257
 
 
258
    def _worth_saving_limit(self):
 
259
        """How many hash changes are ok before we must save the dirstate.
 
260
 
 
261
        :return: an integer. -1 means never save.
 
262
        """
 
263
        conf = self.get_config_stack()
 
264
        return conf.get('bzr.workingtree.worth_saving_limit')
 
265
 
237
266
    def filter_unversioned_files(self, paths):
238
267
        """Filter out paths that are versioned.
239
268
 
369
398
        state = self.current_dirstate()
370
399
        if stat_value is None:
371
400
            try:
372
 
                stat_value = os.lstat(file_abspath)
 
401
                stat_value = osutils.lstat(file_abspath)
373
402
            except OSError, e:
374
403
                if e.errno == errno.ENOENT:
375
404
                    return None
390
419
                return link_or_sha1
391
420
        return None
392
421
 
393
 
    def _get_inventory(self):
 
422
    def _get_root_inventory(self):
394
423
        """Get the inventory for the tree. This is only valid within a lock."""
395
424
        if 'evil' in debug.debug_flags:
396
425
            trace.mutter_callsite(2,
401
430
        self._generate_inventory()
402
431
        return self._inventory
403
432
 
 
433
    @deprecated_method(deprecated_in((2, 5, 0)))
 
434
    def _get_inventory(self):
 
435
        return self.root_inventory
 
436
 
404
437
    inventory = property(_get_inventory,
405
438
                         doc="Inventory of this Tree")
406
439
 
 
440
    root_inventory = property(_get_root_inventory,
 
441
        "Root inventory of this tree")
 
442
 
407
443
    @needs_read_lock
408
444
    def get_parent_ids(self):
409
445
        """See Tree.get_parent_ids.
456
492
            return False # Missing entries are not executable
457
493
        return entry[1][0][3] # Executable?
458
494
 
459
 
    if not osutils.supports_executable():
460
 
        def is_executable(self, file_id, path=None):
461
 
            """Test if a file is executable or not.
 
495
    def is_executable(self, file_id, path=None):
 
496
        """Test if a file is executable or not.
462
497
 
463
 
            Note: The caller is expected to take a read-lock before calling this.
464
 
            """
 
498
        Note: The caller is expected to take a read-lock before calling this.
 
499
        """
 
500
        if not self._supports_executable():
465
501
            entry = self._get_entry(file_id=file_id, path=path)
466
502
            if entry == (None, None):
467
503
                return False
468
504
            return entry[1][0][3]
469
 
 
470
 
        _is_executable_from_path_and_stat = \
471
 
            _is_executable_from_path_and_stat_from_basis
472
 
    else:
473
 
        def is_executable(self, file_id, path=None):
474
 
            """Test if a file is executable or not.
475
 
 
476
 
            Note: The caller is expected to take a read-lock before calling this.
477
 
            """
 
505
        else:
478
506
            self._must_be_locked()
479
507
            if not path:
480
508
                path = self.id2path(file_id)
481
 
            mode = os.lstat(self.abspath(path)).st_mode
 
509
            mode = osutils.lstat(self.abspath(path)).st_mode
482
510
            return bool(stat.S_ISREG(mode) and stat.S_IEXEC & mode)
483
511
 
484
512
    def all_file_ids(self):
568
596
            return _mod_revision.NULL_REVISION
569
597
 
570
598
    def lock_read(self):
571
 
        """See Branch.lock_read, and WorkingTree.unlock."""
 
599
        """See Branch.lock_read, and WorkingTree.unlock.
 
600
 
 
601
        :return: A bzrlib.lock.LogicalLockResult.
 
602
        """
572
603
        self.branch.lock_read()
573
604
        try:
574
605
            self._control_files.lock_read()
587
618
        except:
588
619
            self.branch.unlock()
589
620
            raise
 
621
        return LogicalLockResult(self.unlock)
590
622
 
591
623
    def _lock_self_write(self):
592
624
        """This should be called after the branch is locked."""
607
639
        except:
608
640
            self.branch.unlock()
609
641
            raise
 
642
        return LogicalLockResult(self.unlock)
610
643
 
611
644
    def lock_tree_write(self):
612
 
        """See MutableTree.lock_tree_write, and WorkingTree.unlock."""
 
645
        """See MutableTree.lock_tree_write, and WorkingTree.unlock.
 
646
 
 
647
        :return: A bzrlib.lock.LogicalLockResult.
 
648
        """
613
649
        self.branch.lock_read()
614
 
        self._lock_self_write()
 
650
        return self._lock_self_write()
615
651
 
616
652
    def lock_write(self):
617
 
        """See MutableTree.lock_write, and WorkingTree.unlock."""
 
653
        """See MutableTree.lock_write, and WorkingTree.unlock.
 
654
 
 
655
        :return: A bzrlib.lock.LogicalLockResult.
 
656
        """
618
657
        self.branch.lock_write()
619
 
        self._lock_self_write()
 
658
        return self._lock_self_write()
620
659
 
621
660
    @needs_tree_write_lock
622
661
    def move(self, from_paths, to_dir, after=False):
653
692
 
654
693
        if self._inventory is not None:
655
694
            update_inventory = True
656
 
            inv = self.inventory
 
695
            inv = self.root_inventory
657
696
            to_dir_id = to_entry[0][2]
658
697
            to_dir_ie = inv[to_dir_id]
659
698
        else:
839
878
                rollback_rename()
840
879
                raise
841
880
            result.append((from_rel, to_rel))
842
 
            state._dirblock_state = dirstate.DirState.IN_MEMORY_MODIFIED
 
881
            state._mark_modified()
843
882
            self._make_dirty(reset_inventory=False)
844
883
 
845
884
        return result
855
894
    @needs_read_lock
856
895
    def path2id(self, path):
857
896
        """Return the id for path in this tree."""
 
897
        if isinstance(path, list):
 
898
            if path == []:
 
899
                path = [""]
 
900
            path = osutils.pathjoin(*path)
858
901
        path = path.strip('/')
859
902
        entry = self._get_entry(path=path)
860
903
        if entry == (None, None):
938
981
                    all_versioned = False
939
982
                    break
940
983
            if not all_versioned:
941
 
                raise errors.PathsNotVersionedError(paths)
 
984
                raise errors.PathsNotVersionedError(
 
985
                    [p.decode('utf-8') for p in paths])
942
986
        # -- remove redundancy in supplied paths to prevent over-scanning --
943
987
        search_paths = osutils.minimum_path_selection(paths)
944
988
        # sketch:
993
1037
            found_dir_names = set(dir_name_id[:2] for dir_name_id in found)
994
1038
            for dir_name in split_paths:
995
1039
                if dir_name not in found_dir_names:
996
 
                    raise errors.PathsNotVersionedError(paths)
 
1040
                    raise errors.PathsNotVersionedError(
 
1041
                        [p.decode('utf-8') for p in paths])
997
1042
 
998
1043
        for dir_name_id, trees_info in found.iteritems():
999
1044
            for index in search_indexes:
1006
1051
 
1007
1052
        This is a meaningless operation for dirstate, but we obey it anyhow.
1008
1053
        """
1009
 
        return self.inventory
 
1054
        return self.root_inventory
1010
1055
 
1011
1056
    @needs_read_lock
1012
1057
    def revision_tree(self, revision_id):
1102
1147
                        _mod_revision.NULL_REVISION)))
1103
1148
                ghosts.append(rev_id)
1104
1149
            accepted_revisions.add(rev_id)
1105
 
        dirstate.set_parent_trees(real_trees, ghosts=ghosts)
 
1150
        updated = False
 
1151
        if (len(real_trees) == 1
 
1152
            and not ghosts
 
1153
            and self.branch.repository._format.fast_deltas
 
1154
            and isinstance(real_trees[0][1],
 
1155
                revisiontree.InventoryRevisionTree)
 
1156
            and self.get_parent_ids()):
 
1157
            rev_id, rev_tree = real_trees[0]
 
1158
            basis_id = self.get_parent_ids()[0]
 
1159
            # There are times when basis_tree won't be in
 
1160
            # self.branch.repository, (switch, for example)
 
1161
            try:
 
1162
                basis_tree = self.branch.repository.revision_tree(basis_id)
 
1163
            except errors.NoSuchRevision:
 
1164
                # Fall back to the set_parent_trees(), since we can't use
 
1165
                # _make_delta if we can't get the RevisionTree
 
1166
                pass
 
1167
            else:
 
1168
                delta = rev_tree.root_inventory._make_delta(
 
1169
                    basis_tree.root_inventory)
 
1170
                dirstate.update_basis_by_delta(delta, rev_id)
 
1171
                updated = True
 
1172
        if not updated:
 
1173
            dirstate.set_parent_trees(real_trees, ghosts=ghosts)
1106
1174
        self._make_dirty(reset_inventory=False)
1107
1175
 
1108
1176
    def _set_root_id(self, file_id):
1128
1196
 
1129
1197
    def unlock(self):
1130
1198
        """Unlock in format 4 trees needs to write the entire dirstate."""
1131
 
        # do non-implementation specific cleanup
1132
 
        self._cleanup()
1133
 
 
1134
1199
        if self._control_files._lock_count == 1:
 
1200
            # do non-implementation specific cleanup
 
1201
            self._cleanup()
 
1202
 
1135
1203
            # eventually we should do signature checking during read locks for
1136
1204
            # dirstate updates.
1137
1205
            if self._control_files._lock_mode == 'w':
1236
1304
        # have to change the legacy inventory too.
1237
1305
        if self._inventory is not None:
1238
1306
            for file_id in file_ids:
1239
 
                self._inventory.remove_recursive_id(file_id)
 
1307
                if self._inventory.has_id(file_id):
 
1308
                    self._inventory.remove_recursive_id(file_id)
1240
1309
 
1241
1310
    @needs_tree_write_lock
1242
1311
    def rename_one(self, from_rel, to_rel, after=False):
1243
1312
        """See WorkingTree.rename_one"""
1244
1313
        self.flush()
1245
 
        WorkingTree.rename_one(self, from_rel, to_rel, after)
 
1314
        super(DirStateWorkingTree, self).rename_one(from_rel, to_rel, after)
1246
1315
 
1247
1316
    @needs_tree_write_lock
1248
1317
    def apply_inventory_delta(self, changes):
1274
1343
        # being created.
1275
1344
        self._inventory = None
1276
1345
        # generate a delta,
1277
 
        delta = inv._make_delta(self.inventory)
 
1346
        delta = inv._make_delta(self.root_inventory)
1278
1347
        # and apply it.
1279
1348
        self.apply_inventory_delta(delta)
1280
1349
        if had_inventory:
1281
1350
            self._inventory = inv
1282
1351
        self.flush()
1283
1352
 
 
1353
    @needs_tree_write_lock
 
1354
    def reset_state(self, revision_ids=None):
 
1355
        """Reset the state of the working tree.
 
1356
 
 
1357
        This does a hard-reset to a last-known-good state. This is a way to
 
1358
        fix if something got corrupted (like the .bzr/checkout/dirstate file)
 
1359
        """
 
1360
        if revision_ids is None:
 
1361
            revision_ids = self.get_parent_ids()
 
1362
        if not revision_ids:
 
1363
            base_tree = self.branch.repository.revision_tree(
 
1364
                _mod_revision.NULL_REVISION)
 
1365
            trees = []
 
1366
        else:
 
1367
            trees = zip(revision_ids,
 
1368
                        self.branch.repository.revision_trees(revision_ids))
 
1369
            base_tree = trees[0][1]
 
1370
        state = self.current_dirstate()
 
1371
        # We don't support ghosts yet
 
1372
        state.set_state_from_scratch(base_tree.root_inventory, trees, [])
 
1373
 
1284
1374
 
1285
1375
class ContentFilterAwareSHA1Provider(dirstate.SHA1Provider):
1286
1376
 
1291
1381
        """See dirstate.SHA1Provider.sha1()."""
1292
1382
        filters = self.tree._content_filter_stack(
1293
1383
            self.tree.relpath(osutils.safe_unicode(abspath)))
1294
 
        return internal_size_sha_file_byname(abspath, filters)[1]
 
1384
        return _mod_filters.internal_size_sha_file_byname(abspath, filters)[1]
1295
1385
 
1296
1386
    def stat_and_sha1(self, abspath):
1297
1387
        """See dirstate.SHA1Provider.stat_and_sha1()."""
1301
1391
        try:
1302
1392
            statvalue = os.fstat(file_obj.fileno())
1303
1393
            if filters:
1304
 
                file_obj = filtered_input_file(file_obj, filters)
 
1394
                file_obj = _mod_filters.filtered_input_file(file_obj, filters)
1305
1395
            sha1 = osutils.size_sha_file(file_obj)[1]
1306
1396
        finally:
1307
1397
            file_obj.close()
1318
1408
    def _file_content_summary(self, path, stat_result):
1319
1409
        # This is to support the somewhat obsolete path_content_summary method
1320
1410
        # with content filtering: see
1321
 
        # <https://bugs.edge.launchpad.net/bzr/+bug/415508>.
 
1411
        # <https://bugs.launchpad.net/bzr/+bug/415508>.
1322
1412
        #
1323
1413
        # If the dirstate cache is up to date and knows the hash and size,
1324
1414
        # return that.
1337
1427
class WorkingTree4(DirStateWorkingTree):
1338
1428
    """This is the Format 4 working tree.
1339
1429
 
1340
 
    This differs from WorkingTree3 by:
 
1430
    This differs from WorkingTree by:
1341
1431
     - Having a consolidated internal dirstate, stored in a
1342
1432
       randomly-accessible sorted file on disk.
1343
1433
     - Not having a regular inventory attribute.  One can be synthesized
1371
1461
        return views.PathBasedViews(self)
1372
1462
 
1373
1463
 
1374
 
class DirStateWorkingTreeFormat(WorkingTreeFormat3):
 
1464
class DirStateWorkingTreeFormat(WorkingTreeFormatMetaDir):
 
1465
 
 
1466
    missing_parent_conflicts = True
 
1467
 
 
1468
    supports_versioned_directories = True
 
1469
 
 
1470
    _lock_class = LockDir
 
1471
    _lock_file_name = 'lock'
 
1472
 
 
1473
    def _open_control_files(self, a_bzrdir):
 
1474
        transport = a_bzrdir.get_workingtree_transport(None)
 
1475
        return LockableFiles(transport, self._lock_file_name,
 
1476
                             self._lock_class)
1375
1477
 
1376
1478
    def initialize(self, a_bzrdir, revision_id=None, from_branch=None,
1377
1479
                   accelerator_tree=None, hardlink=False):
1378
1480
        """See WorkingTreeFormat.initialize().
1379
1481
 
1380
1482
        :param revision_id: allows creating a working tree at a different
1381
 
        revision than the branch is at.
 
1483
            revision than the branch is at.
1382
1484
        :param accelerator_tree: A tree which can be used for retrieving file
1383
1485
            contents more quickly than the revision tree, i.e. a workingtree.
1384
1486
            The revision tree will be used for cases where accelerator_tree's
1395
1497
        control_files = self._open_control_files(a_bzrdir)
1396
1498
        control_files.create_lock()
1397
1499
        control_files.lock_write()
1398
 
        transport.put_bytes('format', self.get_format_string(),
 
1500
        transport.put_bytes('format', self.as_string(),
1399
1501
            mode=a_bzrdir._get_file_mode())
1400
1502
        if from_branch is not None:
1401
1503
            branch = from_branch
1461
1563
                transform.build_tree(basis, wt, accelerator_tree,
1462
1564
                                     hardlink=hardlink,
1463
1565
                                     delta_from_tree=delta_from_tree)
 
1566
                for hook in MutableTree.hooks['post_build_tree']:
 
1567
                    hook(wt)
1464
1568
            finally:
1465
1569
                basis.unlock()
1466
1570
        finally:
1477
1581
        :param wt: the WorkingTree object
1478
1582
        """
1479
1583
 
 
1584
    def open(self, a_bzrdir, _found=False):
 
1585
        """Return the WorkingTree object for a_bzrdir
 
1586
 
 
1587
        _found is a private parameter, do not use it. It is used to indicate
 
1588
               if format probing has already been done.
 
1589
        """
 
1590
        if not _found:
 
1591
            # we are being called directly and must probe.
 
1592
            raise NotImplementedError
 
1593
        if not isinstance(a_bzrdir.transport, LocalTransport):
 
1594
            raise errors.NotLocalUrl(a_bzrdir.transport.base)
 
1595
        wt = self._open(a_bzrdir, self._open_control_files(a_bzrdir))
 
1596
        return wt
 
1597
 
1480
1598
    def _open(self, a_bzrdir, control_files):
1481
1599
        """Open the tree itself.
1482
1600
 
1495
1613
    def _get_matchingbzrdir(self):
1496
1614
        """Overrideable method to get a bzrdir for testing."""
1497
1615
        # please test against something that will let us do tree references
1498
 
        return bzrdir.format_registry.make_bzrdir(
1499
 
            'dirstate-with-subtree')
 
1616
        return controldir.format_registry.make_bzrdir(
 
1617
            'development-subtree')
1500
1618
 
1501
1619
    _matchingbzrdir = property(__get_matchingbzrdir)
1502
1620
 
1507
1625
    This format:
1508
1626
        - exists within a metadir controlling .bzr
1509
1627
        - includes an explicit version marker for the workingtree control
1510
 
          files, separate from the BzrDir format
 
1628
          files, separate from the ControlDir format
1511
1629
        - modifies the hash cache format
1512
1630
        - is new in bzr 0.15
1513
1631
        - uses a LockDir to guard access to it.
1517
1635
 
1518
1636
    _tree_class = WorkingTree4
1519
1637
 
1520
 
    def get_format_string(self):
 
1638
    @classmethod
 
1639
    def get_format_string(cls):
1521
1640
        """See WorkingTreeFormat.get_format_string()."""
1522
1641
        return "Bazaar Working Tree Format 4 (bzr 0.15)\n"
1523
1642
 
1534
1653
 
1535
1654
    _tree_class = WorkingTree5
1536
1655
 
1537
 
    def get_format_string(self):
 
1656
    @classmethod
 
1657
    def get_format_string(cls):
1538
1658
        """See WorkingTreeFormat.get_format_string()."""
1539
1659
        return "Bazaar Working Tree Format 5 (bzr 1.11)\n"
1540
1660
 
1554
1674
 
1555
1675
    _tree_class = WorkingTree6
1556
1676
 
1557
 
    def get_format_string(self):
 
1677
    @classmethod
 
1678
    def get_format_string(cls):
1558
1679
        """See WorkingTreeFormat.get_format_string()."""
1559
1680
        return "Bazaar Working Tree Format 6 (bzr 1.14)\n"
1560
1681
 
1572
1693
    def supports_views(self):
1573
1694
        return True
1574
1695
 
1575
 
 
1576
 
class DirStateRevisionTree(Tree):
 
1696
    def _get_matchingbzrdir(self):
 
1697
        """Overrideable method to get a bzrdir for testing."""
 
1698
        # We use 'development-subtree' instead of '2a', because we have a
 
1699
        # few tests that want to test tree references
 
1700
        return bzrdir.format_registry.make_bzrdir('development-subtree')
 
1701
 
 
1702
 
 
1703
class DirStateRevisionTree(InventoryTree):
1577
1704
    """A revision tree pulling the inventory from a dirstate.
1578
1705
    
1579
1706
    Note that this is one of the historical (ie revision) trees cached in the
1598
1725
    def annotate_iter(self, file_id,
1599
1726
                      default_revision=_mod_revision.CURRENT_REVISION):
1600
1727
        """See Tree.annotate_iter"""
1601
 
        text_key = (file_id, self.inventory[file_id].revision)
 
1728
        text_key = (file_id, self.get_file_revision(file_id))
1602
1729
        annotations = self._repository.texts.annotate(text_key)
1603
1730
        return [(key[-1], line) for (key, line) in annotations]
1604
1731
 
1605
 
    def _get_ancestors(self, default_revision):
1606
 
        return set(self._repository.get_ancestry(self._revision_id,
1607
 
                                                 topo_sorted=False))
1608
1732
    def _comparison_data(self, entry, path):
1609
1733
        """See Tree._comparison_data."""
1610
1734
        if entry is None:
1663
1787
        if path is not None:
1664
1788
            path = path.encode('utf8')
1665
1789
        parent_index = self._get_parent_index()
1666
 
        return self._dirstate._get_entry(parent_index, fileid_utf8=file_id, path_utf8=path)
 
1790
        return self._dirstate._get_entry(parent_index, fileid_utf8=file_id,
 
1791
            path_utf8=path)
1667
1792
 
1668
1793
    def _generate_inventory(self):
1669
1794
        """Create and set self.inventory from the dirstate object.
1726
1851
                elif kind == 'directory':
1727
1852
                    parent_ies[(dirname + '/' + name).strip('/')] = inv_entry
1728
1853
                elif kind == 'symlink':
1729
 
                    inv_entry.executable = False
1730
 
                    inv_entry.text_size = None
1731
1854
                    inv_entry.symlink_target = utf8_decode(fingerprint)[0]
1732
1855
                elif kind == 'tree-reference':
1733
1856
                    inv_entry.reference_revision = fingerprint or None
1753
1876
        # Make sure the file exists
1754
1877
        entry = self._get_entry(file_id, path=path)
1755
1878
        if entry == (None, None): # do we raise?
1756
 
            return None
 
1879
            raise errors.NoSuchId(self, file_id)
1757
1880
        parent_index = self._get_parent_index()
1758
1881
        last_changed_revision = entry[1][parent_index][4]
1759
1882
        try:
1770
1893
            return parent_details[1]
1771
1894
        return None
1772
1895
 
 
1896
    @needs_read_lock
 
1897
    def get_file_revision(self, file_id):
 
1898
        inv, inv_file_id = self._unpack_file_id(file_id)
 
1899
        return inv[inv_file_id].revision
 
1900
 
1773
1901
    def get_file(self, file_id, path=None):
1774
1902
        return StringIO(self.get_file_text(file_id))
1775
1903
 
1776
1904
    def get_file_size(self, file_id):
1777
1905
        """See Tree.get_file_size"""
1778
 
        return self.inventory[file_id].text_size
 
1906
        inv, inv_file_id = self._unpack_file_id(file_id)
 
1907
        return inv[inv_file_id].text_size
1779
1908
 
1780
1909
    def get_file_text(self, file_id, path=None):
1781
 
        _, content = list(self.iter_files_bytes([(file_id, None)]))[0]
1782
 
        return ''.join(content)
 
1910
        content = None
 
1911
        for _, content_iter in self.iter_files_bytes([(file_id, None)]):
 
1912
            if content is not None:
 
1913
                raise AssertionError('iter_files_bytes returned'
 
1914
                    ' too many entries')
 
1915
            # For each entry returned by iter_files_bytes, we must consume the
 
1916
            # content_iter before we step the files iterator.
 
1917
            content = ''.join(content_iter)
 
1918
        if content is None:
 
1919
            raise AssertionError('iter_files_bytes did not return'
 
1920
                ' the requested data')
 
1921
        return content
1783
1922
 
1784
1923
    def get_reference_revision(self, file_id, path=None):
1785
 
        return self.inventory[file_id].reference_revision
 
1924
        inv, inv_file_id = self._unpack_file_id(file_id)
 
1925
        return inv[inv_file_id].reference_revision
1786
1926
 
1787
1927
    def iter_files_bytes(self, desired_files):
1788
1928
        """See Tree.iter_files_bytes.
1798
1938
                                       identifier))
1799
1939
        return self._repository.iter_files_bytes(repo_desired_files)
1800
1940
 
1801
 
    def get_symlink_target(self, file_id):
 
1941
    def get_symlink_target(self, file_id, path=None):
1802
1942
        entry = self._get_entry(file_id=file_id)
1803
1943
        parent_index = self._get_parent_index()
1804
1944
        if entry[1][parent_index][0] != 'l':
1812
1952
        """Return the revision id for this tree."""
1813
1953
        return self._revision_id
1814
1954
 
1815
 
    def _get_inventory(self):
 
1955
    def _get_root_inventory(self):
1816
1956
        if self._inventory is not None:
1817
1957
            return self._inventory
1818
1958
        self._must_be_locked()
1819
1959
        self._generate_inventory()
1820
1960
        return self._inventory
1821
1961
 
 
1962
    root_inventory = property(_get_root_inventory,
 
1963
                         doc="Inventory of this Tree")
 
1964
 
 
1965
    @deprecated_method(deprecated_in((2, 5, 0)))
 
1966
    def _get_inventory(self):
 
1967
        return self.root_inventory
 
1968
 
1822
1969
    inventory = property(_get_inventory,
1823
1970
                         doc="Inventory of this Tree")
1824
1971
 
1842
1989
 
1843
1990
    def path_content_summary(self, path):
1844
1991
        """See Tree.path_content_summary."""
1845
 
        id = self.inventory.path2id(path)
1846
 
        if id is None:
 
1992
        inv, inv_file_id = self._path2inv_file_id(path)
 
1993
        if inv_file_id is None:
1847
1994
            return ('missing', None, None, None)
1848
 
        entry = self._inventory[id]
 
1995
        entry = inv[inv_file_id]
1849
1996
        kind = entry.kind
1850
1997
        if kind == 'file':
1851
1998
            return (kind, entry.text_size, entry.executable, entry.text_sha1)
1855
2002
            return (kind, None, None, None)
1856
2003
 
1857
2004
    def is_executable(self, file_id, path=None):
1858
 
        ie = self.inventory[file_id]
 
2005
        inv, inv_file_id = self._unpack_file_id(file_id)
 
2006
        ie = inv[inv_file_id]
1859
2007
        if ie.kind != "file":
1860
 
            return None
 
2008
            return False
1861
2009
        return ie.executable
1862
2010
 
 
2011
    def is_locked(self):
 
2012
        return self._locked
 
2013
 
1863
2014
    def list_files(self, include_root=False, from_dir=None, recursive=True):
1864
2015
        # We use a standard implementation, because DirStateRevisionTree is
1865
2016
        # dealing with one of the parents of the current state
1866
 
        inv = self._get_inventory()
1867
2017
        if from_dir is None:
 
2018
            inv = self.root_inventory
1868
2019
            from_dir_id = None
1869
2020
        else:
1870
 
            from_dir_id = inv.path2id(from_dir)
 
2021
            inv, from_dir_id = self._path2inv_file_id(from_dir)
1871
2022
            if from_dir_id is None:
1872
2023
                # Directory not versioned
1873
2024
                return
 
2025
        # FIXME: Support nested trees
1874
2026
        entries = inv.iter_entries(from_dir=from_dir_id, recursive=recursive)
1875
2027
        if inv.root is not None and not include_root and from_dir is None:
1876
2028
            entries.next()
1878
2030
            yield path, 'V', entry.kind, entry.file_id, entry
1879
2031
 
1880
2032
    def lock_read(self):
1881
 
        """Lock the tree for a set of operations."""
 
2033
        """Lock the tree for a set of operations.
 
2034
 
 
2035
        :return: A bzrlib.lock.LogicalLockResult.
 
2036
        """
1882
2037
        if not self._locked:
1883
2038
            self._repository.lock_read()
1884
2039
            if self._dirstate._lock_token is None:
1885
2040
                self._dirstate.lock_read()
1886
2041
                self._dirstate_locked = True
1887
2042
        self._locked += 1
 
2043
        return LogicalLockResult(self.unlock)
1888
2044
 
1889
2045
    def _must_be_locked(self):
1890
2046
        if not self._locked:
1894
2050
    def path2id(self, path):
1895
2051
        """Return the id for path in this tree."""
1896
2052
        # lookup by path: faster than splitting and walking the ivnentory.
 
2053
        if isinstance(path, list):
 
2054
            if path == []:
 
2055
                path = [""]
 
2056
            path = osutils.pathjoin(*path)
1897
2057
        entry = self._get_entry(path=path)
1898
2058
        if entry == (None, None):
1899
2059
            return None
1922
2082
        # So for now, we just build up the parent inventory, and extract
1923
2083
        # it the same way RevisionTree does.
1924
2084
        _directory = 'directory'
1925
 
        inv = self._get_inventory()
 
2085
        inv = self._get_root_inventory()
1926
2086
        top_id = inv.path2id(prefix)
1927
2087
        if top_id is None:
1928
2088
            pending = []
1969
2129
    def make_source_parent_tree(source, target):
1970
2130
        """Change the source tree into a parent of the target."""
1971
2131
        revid = source.commit('record tree')
1972
 
        target.branch.repository.fetch(source.branch.repository, revid)
 
2132
        target.branch.fetch(source.branch, revid)
1973
2133
        target.set_parent_ids([revid])
1974
2134
        return target.basis_tree(), target
1975
2135
 
2067
2227
                path_entries = state._entries_for_path(path)
2068
2228
                if not path_entries:
2069
2229
                    # this specified path is not present at all: error
2070
 
                    not_versioned.append(path)
 
2230
                    not_versioned.append(path.decode('utf-8'))
2071
2231
                    continue
2072
2232
                found_versioned = False
2073
2233
                # for each id at this path
2081
2241
                if not found_versioned:
2082
2242
                    # none of the indexes was not 'absent' at all ids for this
2083
2243
                    # path.
2084
 
                    not_versioned.append(path)
 
2244
                    not_versioned.append(path.decode('utf-8'))
2085
2245
            if len(not_versioned) > 0:
2086
2246
                raise errors.PathsNotVersionedError(not_versioned)
2087
2247
        # -- remove redundancy in supplied specific_files to prevent over-scanning --
2154
2314
    def update_format(self, tree):
2155
2315
        """Change the format marker."""
2156
2316
        tree._transport.put_bytes('format',
2157
 
            self.target_format.get_format_string(),
 
2317
            self.target_format.as_string(),
2158
2318
            mode=tree.bzrdir._get_file_mode())
2159
2319
 
2160
2320
 
2177
2337
    def update_format(self, tree):
2178
2338
        """Change the format marker."""
2179
2339
        tree._transport.put_bytes('format',
2180
 
            self.target_format.get_format_string(),
 
2340
            self.target_format.as_string(),
2181
2341
            mode=tree.bzrdir._get_file_mode())
2182
2342
 
2183
2343
 
2206
2366
    def update_format(self, tree):
2207
2367
        """Change the format marker."""
2208
2368
        tree._transport.put_bytes('format',
2209
 
            self.target_format.get_format_string(),
 
2369
            self.target_format.as_string(),
2210
2370
            mode=tree.bzrdir._get_file_mode())