← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/workingtree_4.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2010-07-07 04:03:32 UTC
  • mfrom: (5335.2.3 doc)
  • Revision ID: pqm@pqm.ubuntu.com-20100707040332-we60v2hsd39rumlr
(mbp) developer docs about testing (Martin Pool)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/workingtree_4.py
1
 
# Copyright (C) 2005, 2006, 2007, 2008 Canonical Ltd
 
1
# Copyright (C) 2007-2010 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 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
34
31
import errno
35
 
import itertools
36
 
import operator
37
32
import stat
38
 
from time import time
39
 
import warnings
40
33
 
41
34
import bzrlib
42
35
from bzrlib import (
43
36
    bzrdir,
44
37
    cache_utf8,
45
 
    conflicts as _mod_conflicts,
46
38
    debug,
47
 
    delta,
48
39
    dirstate,
49
40
    errors,
50
41
    generate_ids,
51
 
    globbing,
52
 
    ignores,
53
 
    merge,
54
42
    osutils,
55
43
    revision as _mod_revision,
56
44
    revisiontree,
57
 
    textui,
58
45
    trace,
59
46
    transform,
60
 
    urlutils,
61
 
    xml5,
62
 
    xml6,
 
47
    views,
63
48
    )
64
49
import bzrlib.branch
65
 
from bzrlib.transport import get_transport
66
50
import bzrlib.ui
67
51
""")
68
52
 
69
 
from bzrlib import symbol_versioning
70
53
from bzrlib.decorators import needs_read_lock, needs_write_lock
71
 
from bzrlib.inventory import InventoryEntry, Inventory, ROOT_ID, entry_factory
72
 
import bzrlib.mutabletree
 
54
from bzrlib.filters import filtered_input_file, internal_size_sha_file_byname
 
55
from bzrlib.inventory import Inventory, ROOT_ID, entry_factory
 
56
from bzrlib.lock import LogicalLockResult
73
57
from bzrlib.mutabletree import needs_tree_write_lock
74
58
from bzrlib.osutils import (
75
59
    file_kind,
76
60
    isdir,
77
 
    normpath,
78
61
    pathjoin,
79
 
    rand_chars,
80
62
    realpath,
81
63
    safe_unicode,
82
 
    splitpath,
83
64
    )
84
 
from bzrlib.trace import mutter, note
 
65
from bzrlib.trace import mutter
85
66
from bzrlib.transport.local import LocalTransport
86
67
from bzrlib.tree import InterTree
87
 
from bzrlib.progress import DummyProgress, ProgressPhase
88
 
from bzrlib.revision import NULL_REVISION, CURRENT_REVISION
89
 
from bzrlib.rio import RioReader, rio_file, Stanza
90
 
from bzrlib.symbol_versioning import (deprecated_passed,
91
 
        deprecated_method,
92
 
        deprecated_function,
93
 
        DEPRECATED_PARAMETER,
94
 
        )
95
68
from bzrlib.tree import Tree
96
69
from bzrlib.workingtree import WorkingTree, WorkingTree3, WorkingTreeFormat3
97
70
 
129
102
        self._setup_directory_is_tree_reference()
130
103
        self._detect_case_handling()
131
104
        self._rules_searcher = None
 
105
        self.views = self._make_views()
132
106
        #--- allow tests to select the dirstate iter_changes implementation
133
107
        self._iter_changes = dirstate._process_entry
134
108
 
164
138
    @needs_tree_write_lock
165
139
    def add_reference(self, sub_tree):
166
140
        # use standard implementation, which calls back to self._add
167
 
        # 
 
141
        #
168
142
        # So we don't store the reference_revision in the working dirstate,
169
 
        # it's just recorded at the moment of commit. 
 
143
        # it's just recorded at the moment of commit.
170
144
        self._add_reference(sub_tree)
171
145
 
172
146
    def break_lock(self):
211
185
            WorkingTree3._comparison_data(self, entry, path)
212
186
        # it looks like a plain directory, but it's really a reference -- see
213
187
        # also kind()
214
 
        if (self._repo_supports_tree_reference and
215
 
            kind == 'directory' and
216
 
            self._directory_is_tree_reference(path)):
 
188
        if (self._repo_supports_tree_reference and kind == 'directory'
 
189
            and entry is not None and entry.kind == 'tree-reference'):
217
190
            kind = 'tree-reference'
218
191
        return kind, executable, stat_value
219
192
 
245
218
            return self._dirstate
246
219
        local_path = self.bzrdir.get_workingtree_transport(None
247
220
            ).local_abspath('dirstate')
248
 
        self._dirstate = dirstate.DirState.on_file(local_path)
 
221
        self._dirstate = dirstate.DirState.on_file(local_path,
 
222
            self._sha1_provider())
249
223
        return self._dirstate
250
224
 
 
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
 
251
237
    def filter_unversioned_files(self, paths):
252
238
        """Filter out paths that are versioned.
253
239
 
285
271
 
286
272
    def _generate_inventory(self):
287
273
        """Create and set self.inventory from the dirstate object.
288
 
        
 
274
 
289
275
        This is relatively expensive: we have to walk the entire dirstate.
290
276
        Ideally we would not, and can deprecate this function.
291
277
        """
336
322
                    parent_ies[(dirname + '/' + name).strip('/')] = inv_entry
337
323
                elif kind == 'tree-reference':
338
324
                    if not self._repo_supports_tree_reference:
339
 
                        raise AssertionError(
340
 
                            "repository of %r "
341
 
                            "doesn't support tree references "
342
 
                            "required by entry %r"
343
 
                            % (self, name))
 
325
                        raise errors.UnsupportedOperation(
 
326
                            self._generate_inventory,
 
327
                            self.branch.repository)
344
328
                    inv_entry.reference_revision = link_or_sha1 or None
345
329
                elif kind != 'symlink':
346
330
                    raise AssertionError("unknown kind %r" % kind)
361
345
        If either file_id or path is supplied, it is used as the key to lookup.
362
346
        If both are supplied, the fastest lookup is used, and an error is
363
347
        raised if they do not both point at the same row.
364
 
        
 
348
 
365
349
        :param file_id: An optional unicode file_id to be looked up.
366
350
        :param path: An optional unicode path to be looked up.
367
351
        :return: The dirstate row tuple for path/file_id, or (None, None)
423
407
    @needs_read_lock
424
408
    def get_parent_ids(self):
425
409
        """See Tree.get_parent_ids.
426
 
        
 
410
 
427
411
        This implementation requests the ids list from the dirstate file.
428
412
        """
429
413
        return self.current_dirstate().get_parent_ids()
451
435
        return osutils.lexists(pathjoin(
452
436
                    self.basedir, row[0].decode('utf8'), row[1].decode('utf8')))
453
437
 
 
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
 
454
443
    @needs_read_lock
455
444
    def id2path(self, file_id):
456
445
        "Convert a file-id to a path."
562
551
    def _kind(self, relpath):
563
552
        abspath = self.abspath(relpath)
564
553
        kind = file_kind(abspath)
565
 
        if (self._repo_supports_tree_reference and
566
 
            kind == 'directory' and
567
 
            self._directory_is_tree_reference(relpath)):
568
 
            kind = 'tree-reference'
 
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'
569
559
        return kind
570
560
 
571
561
    @needs_read_lock
578
568
            return _mod_revision.NULL_REVISION
579
569
 
580
570
    def lock_read(self):
581
 
        """See Branch.lock_read, and WorkingTree.unlock."""
 
571
        """See Branch.lock_read, and WorkingTree.unlock.
 
572
 
 
573
        :return: A bzrlib.lock.LogicalLockResult.
 
574
        """
582
575
        self.branch.lock_read()
583
576
        try:
584
577
            self._control_files.lock_read()
597
590
        except:
598
591
            self.branch.unlock()
599
592
            raise
 
593
        return LogicalLockResult(self.unlock)
600
594
 
601
595
    def _lock_self_write(self):
602
596
        """This should be called after the branch is locked."""
617
611
        except:
618
612
            self.branch.unlock()
619
613
            raise
 
614
        return LogicalLockResult(self.unlock)
620
615
 
621
616
    def lock_tree_write(self):
622
 
        """See MutableTree.lock_tree_write, and WorkingTree.unlock."""
 
617
        """See MutableTree.lock_tree_write, and WorkingTree.unlock.
 
618
 
 
619
        :return: A bzrlib.lock.LogicalLockResult.
 
620
        """
623
621
        self.branch.lock_read()
624
 
        self._lock_self_write()
 
622
        return self._lock_self_write()
625
623
 
626
624
    def lock_write(self):
627
 
        """See MutableTree.lock_write, and WorkingTree.unlock."""
 
625
        """See MutableTree.lock_write, and WorkingTree.unlock.
 
626
 
 
627
        :return: A bzrlib.lock.LogicalLockResult.
 
628
        """
628
629
        self.branch.lock_write()
629
 
        self._lock_self_write()
 
630
        return self._lock_self_write()
630
631
 
631
632
    @needs_tree_write_lock
632
633
    def move(self, from_paths, to_dir, after=False):
702
703
            from_entry = self._get_entry(path=from_rel)
703
704
            if from_entry == (None, None):
704
705
                raise errors.BzrMoveFailedError(from_rel,to_dir,
705
 
                    errors.NotVersionedError(path=str(from_rel)))
 
706
                    errors.NotVersionedError(path=from_rel))
706
707
 
707
708
            from_id = from_entry[0][2]
708
709
            to_rel = pathjoin(to_dir, from_tail)
951
952
                raise errors.PathsNotVersionedError(paths)
952
953
        # -- remove redundancy in supplied paths to prevent over-scanning --
953
954
        search_paths = osutils.minimum_path_selection(paths)
954
 
        # sketch: 
 
955
        # sketch:
955
956
        # for all search_indexs in each path at or under each element of
956
957
        # search_paths, if the detail is relocated: add the id, and add the
957
958
        # relocated path as one to search if its not searched already. If the
1013
1014
 
1014
1015
    def read_working_inventory(self):
1015
1016
        """Read the working inventory.
1016
 
        
 
1017
 
1017
1018
        This is a meaningless operation for dirstate, but we obey it anyhow.
1018
1019
        """
1019
1020
        return self.inventory
1037
1038
    def set_last_revision(self, new_revision):
1038
1039
        """Change the last revision in the working tree."""
1039
1040
        parents = self.get_parent_ids()
1040
 
        if new_revision in (NULL_REVISION, None):
 
1041
        if new_revision in (_mod_revision.NULL_REVISION, None):
1041
1042
            if len(parents) >= 2:
1042
1043
                raise AssertionError(
1043
1044
                    "setting the last parent to none with a pending merge is "
1050
1051
    @needs_tree_write_lock
1051
1052
    def set_parent_ids(self, revision_ids, allow_leftmost_as_ghost=False):
1052
1053
        """Set the parent ids to revision_ids.
1053
 
        
 
1054
 
1054
1055
        See also set_parent_trees. This api will try to retrieve the tree data
1055
1056
        for each element of revision_ids from the trees repository. If you have
1056
1057
        tree data already available, it is more efficient to use
1210
1211
                # just forget the whole block.
1211
1212
                entry_index = 0
1212
1213
                while entry_index < len(block[1]):
1213
 
                    # Mark this file id as having been removed
1214
1214
                    entry = block[1][entry_index]
1215
 
                    ids_to_unversion.discard(entry[0][2])
1216
 
                    if (entry[1][0][0] in 'ar' # don't remove absent or renamed
1217
 
                                               # entries
1218
 
                        or not state._make_absent(entry)):
 
1215
                    if entry[1][0][0] in 'ar':
 
1216
                        # don't remove absent or renamed entries
1219
1217
                        entry_index += 1
 
1218
                    else:
 
1219
                        # Mark this file id as having been removed
 
1220
                        ids_to_unversion.discard(entry[0][2])
 
1221
                        if not state._make_absent(entry):
 
1222
                            # The block has not shrunk.
 
1223
                            entry_index += 1
1220
1224
                # go to the next block. (At the moment we dont delete empty
1221
1225
                # dirblocks)
1222
1226
                block_index += 1
1274
1278
        if self._dirty:
1275
1279
            raise AssertionError("attempting to write an inventory when the "
1276
1280
                "dirstate is dirty will lose pending changes")
1277
 
        self.current_dirstate().set_state_from_inventory(inv)
1278
 
        self._make_dirty(reset_inventory=False)
1279
 
        if self._inventory is not None:
 
1281
        had_inventory = self._inventory is not None
 
1282
        # Setting self._inventory = None forces the dirstate to regenerate the
 
1283
        # working inventory. We do this because self.inventory may be inv, or
 
1284
        # may have been modified, and either case would prevent a clean delta
 
1285
        # being created.
 
1286
        self._inventory = None
 
1287
        # generate a delta,
 
1288
        delta = inv._make_delta(self.inventory)
 
1289
        # and apply it.
 
1290
        self.apply_inventory_delta(delta)
 
1291
        if had_inventory:
1280
1292
            self._inventory = inv
1281
1293
        self.flush()
1282
1294
 
1283
1295
 
 
1296
class ContentFilterAwareSHA1Provider(dirstate.SHA1Provider):
 
1297
 
 
1298
    def __init__(self, tree):
 
1299
        self.tree = tree
 
1300
 
 
1301
    def sha1(self, abspath):
 
1302
        """See dirstate.SHA1Provider.sha1()."""
 
1303
        filters = self.tree._content_filter_stack(
 
1304
            self.tree.relpath(osutils.safe_unicode(abspath)))
 
1305
        return internal_size_sha_file_byname(abspath, filters)[1]
 
1306
 
 
1307
    def stat_and_sha1(self, abspath):
 
1308
        """See dirstate.SHA1Provider.stat_and_sha1()."""
 
1309
        filters = self.tree._content_filter_stack(
 
1310
            self.tree.relpath(osutils.safe_unicode(abspath)))
 
1311
        file_obj = file(abspath, 'rb', 65000)
 
1312
        try:
 
1313
            statvalue = os.fstat(file_obj.fileno())
 
1314
            if filters:
 
1315
                file_obj = filtered_input_file(file_obj, filters)
 
1316
            sha1 = osutils.size_sha_file(file_obj)[1]
 
1317
        finally:
 
1318
            file_obj.close()
 
1319
        return statvalue, sha1
 
1320
 
 
1321
 
 
1322
class ContentFilteringDirStateWorkingTree(DirStateWorkingTree):
 
1323
    """Dirstate working tree that supports content filtering.
 
1324
 
 
1325
    The dirstate holds the hash and size of the canonical form of the file, 
 
1326
    and most methods must return that.
 
1327
    """
 
1328
 
 
1329
    def _file_content_summary(self, path, stat_result):
 
1330
        # This is to support the somewhat obsolete path_content_summary method
 
1331
        # with content filtering: see
 
1332
        # <https://bugs.launchpad.net/bzr/+bug/415508>.
 
1333
        #
 
1334
        # If the dirstate cache is up to date and knows the hash and size,
 
1335
        # return that.
 
1336
        # Otherwise if there are no content filters, return the on-disk size
 
1337
        # and leave the hash blank.
 
1338
        # Otherwise, read and filter the on-disk file and use its size and
 
1339
        # hash.
 
1340
        #
 
1341
        # The dirstate doesn't store the size of the canonical form so we
 
1342
        # can't trust it for content-filtered trees.  We just return None.
 
1343
        dirstate_sha1 = self._dirstate.sha1_from_stat(path, stat_result)
 
1344
        executable = self._is_executable_from_path_and_stat(path, stat_result)
 
1345
        return ('file', None, executable, dirstate_sha1)
 
1346
 
 
1347
 
1284
1348
class WorkingTree4(DirStateWorkingTree):
1285
1349
    """This is the Format 4 working tree.
1286
1350
 
1287
1351
    This differs from WorkingTree3 by:
1288
1352
     - Having a consolidated internal dirstate, stored in a
1289
1353
       randomly-accessible sorted file on disk.
1290
 
     - Not having a regular inventory attribute.  One can be synthesized 
 
1354
     - Not having a regular inventory attribute.  One can be synthesized
1291
1355
       on demand but this is expensive and should be avoided.
1292
1356
 
1293
1357
    This is new in bzr 0.15.
1294
1358
    """
1295
1359
 
1296
1360
 
1297
 
class WorkingTree5(DirStateWorkingTree):
 
1361
class WorkingTree5(ContentFilteringDirStateWorkingTree):
1298
1362
    """This is the Format 5 working tree.
1299
1363
 
1300
1364
    This differs from WorkingTree4 by:
1301
1365
     - Supporting content filtering.
 
1366
 
 
1367
    This is new in bzr 1.11.
 
1368
    """
 
1369
 
 
1370
 
 
1371
class WorkingTree6(ContentFilteringDirStateWorkingTree):
 
1372
    """This is the Format 6 working tree.
 
1373
 
 
1374
    This differs from WorkingTree5 by:
1302
1375
     - Supporting a current view that may mask the set of files in a tree
1303
1376
       impacted by most user operations.
1304
1377
 
1305
 
    This is new in bzr 1.11.
 
1378
    This is new in bzr 1.14.
1306
1379
    """
1307
1380
 
 
1381
    def _make_views(self):
 
1382
        return views.PathBasedViews(self)
 
1383
 
1308
1384
 
1309
1385
class DirStateWorkingTreeFormat(WorkingTreeFormat3):
 
1386
 
1310
1387
    def initialize(self, a_bzrdir, revision_id=None, from_branch=None,
1311
1388
                   accelerator_tree=None, hardlink=False):
1312
1389
        """See WorkingTreeFormat.initialize().
1351
1428
        wt.lock_tree_write()
1352
1429
        try:
1353
1430
            self._init_custom_control_files(wt)
1354
 
            if revision_id in (None, NULL_REVISION):
 
1431
            if revision_id in (None, _mod_revision.NULL_REVISION):
1355
1432
                if branch.repository.supports_rich_root():
1356
1433
                    wt._set_root_id(generate_ids.gen_root_id())
1357
1434
                else:
1368
1445
                    pass
1369
1446
            if basis is None:
1370
1447
                basis = branch.repository.revision_tree(revision_id)
1371
 
            if revision_id == NULL_REVISION:
 
1448
            if revision_id == _mod_revision.NULL_REVISION:
1372
1449
                parents_list = []
1373
1450
            else:
1374
1451
                parents_list = [(revision_id, basis)]
1382
1459
                if basis_root_id is not None:
1383
1460
                    wt._set_root_id(basis_root_id)
1384
1461
                    wt.flush()
 
1462
                if wt.supports_content_filtering():
 
1463
                    # The original tree may not have the same content filters
 
1464
                    # applied so we can't safely build the inventory delta from
 
1465
                    # the source tree.
 
1466
                    delta_from_tree = False
 
1467
                else:
 
1468
                    delta_from_tree = True
1385
1469
                # delta_from_tree is safe even for DirStateRevisionTrees,
1386
1470
                # because wt4.apply_inventory_delta does not mutate the input
1387
1471
                # inventory entries.
1388
1472
                transform.build_tree(basis, wt, accelerator_tree,
1389
 
                                     hardlink=hardlink, delta_from_tree=True)
 
1473
                                     hardlink=hardlink,
 
1474
                                     delta_from_tree=delta_from_tree)
1390
1475
            finally:
1391
1476
                basis.unlock()
1392
1477
        finally:
1396
1481
 
1397
1482
    def _init_custom_control_files(self, wt):
1398
1483
        """Subclasses with custom control files should override this method.
1399
 
        
 
1484
 
1400
1485
        The working tree and control files are locked for writing when this
1401
1486
        method is called.
1402
 
        
 
1487
 
1403
1488
        :param wt: the WorkingTree object
1404
1489
        """
1405
1490
 
1416
1501
                           _control_files=control_files)
1417
1502
 
1418
1503
    def __get_matchingbzrdir(self):
 
1504
        return self._get_matchingbzrdir()
 
1505
 
 
1506
    def _get_matchingbzrdir(self):
 
1507
        """Overrideable method to get a bzrdir for testing."""
1419
1508
        # please test against something that will let us do tree references
1420
1509
        return bzrdir.format_registry.make_bzrdir(
1421
1510
            'dirstate-with-subtree')
1449
1538
 
1450
1539
 
1451
1540
class WorkingTreeFormat5(DirStateWorkingTreeFormat):
1452
 
    """WorkingTree format supporting views.
 
1541
    """WorkingTree format supporting content filtering.
1453
1542
    """
1454
1543
 
1455
1544
    upgrade_recommended = False
1464
1553
        """See WorkingTreeFormat.get_format_description()."""
1465
1554
        return "Working tree format 5"
1466
1555
 
 
1556
    def supports_content_filtering(self):
 
1557
        return True
 
1558
 
 
1559
 
 
1560
class WorkingTreeFormat6(DirStateWorkingTreeFormat):
 
1561
    """WorkingTree format supporting views.
 
1562
    """
 
1563
 
 
1564
    upgrade_recommended = False
 
1565
 
 
1566
    _tree_class = WorkingTree6
 
1567
 
 
1568
    def get_format_string(self):
 
1569
        """See WorkingTreeFormat.get_format_string()."""
 
1570
        return "Bazaar Working Tree Format 6 (bzr 1.14)\n"
 
1571
 
 
1572
    def get_format_description(self):
 
1573
        """See WorkingTreeFormat.get_format_description()."""
 
1574
        return "Working tree format 6"
 
1575
 
1467
1576
    def _init_custom_control_files(self, wt):
1468
1577
        """Subclasses with custom control files should override this method."""
1469
1578
        wt._transport.put_bytes('views', '', mode=wt.bzrdir._get_file_mode())
1476
1585
 
1477
1586
 
1478
1587
class DirStateRevisionTree(Tree):
1479
 
    """A revision tree pulling the inventory from a dirstate."""
 
1588
    """A revision tree pulling the inventory from a dirstate.
 
1589
    
 
1590
    Note that this is one of the historical (ie revision) trees cached in the
 
1591
    dirstate for easy access, not the workingtree.
 
1592
    """
1480
1593
 
1481
1594
    def __init__(self, dirstate, revision_id, repository):
1482
1595
        self._dirstate = dirstate
1551
1664
        If either file_id or path is supplied, it is used as the key to lookup.
1552
1665
        If both are supplied, the fastest lookup is used, and an error is
1553
1666
        raised if they do not both point at the same row.
1554
 
        
 
1667
 
1555
1668
        :param file_id: An optional unicode file_id to be looked up.
1556
1669
        :param path: An optional unicode path to be looked up.
1557
1670
        :return: The dirstate row tuple for path/file_id, or (None, None)
1654
1767
            return None
1655
1768
        parent_index = self._get_parent_index()
1656
1769
        last_changed_revision = entry[1][parent_index][4]
1657
 
        return self._repository.get_revision(last_changed_revision).timestamp
 
1770
        try:
 
1771
            rev = self._repository.get_revision(last_changed_revision)
 
1772
        except errors.NoSuchRevision:
 
1773
            raise errors.FileTimestampUnavailable(self.id2path(file_id))
 
1774
        return rev.timestamp
1658
1775
 
1659
1776
    def get_file_sha1(self, file_id, path=None, stat_value=None):
1660
1777
        entry = self._get_entry(file_id=file_id, path=path)
1672
1789
        return self.inventory[file_id].text_size
1673
1790
 
1674
1791
    def get_file_text(self, file_id, path=None):
1675
 
        return list(self.iter_files_bytes([(file_id, None)]))[0][1]
 
1792
        _, content = list(self.iter_files_bytes([(file_id, None)]))[0]
 
1793
        return ''.join(content)
1676
1794
 
1677
1795
    def get_reference_revision(self, file_id, path=None):
1678
1796
        return self.inventory[file_id].reference_revision
1697
1815
        if entry[1][parent_index][0] != 'l':
1698
1816
            return None
1699
1817
        else:
1700
 
            # At present, none of the tree implementations supports non-ascii
1701
 
            # symlink targets. So we will just assume that the dirstate path is
1702
 
            # correct.
1703
 
            return entry[1][parent_index][1]
 
1818
            target = entry[1][parent_index][1]
 
1819
            target = target.decode('utf8')
 
1820
            return target
1704
1821
 
1705
1822
    def get_revision_id(self):
1706
1823
        """Return the revision id for this tree."""
1727
1844
        entry = self._get_entry(file_id=file_id)[1]
1728
1845
        if entry is None:
1729
1846
            raise errors.NoSuchId(tree=self, file_id=file_id)
1730
 
        return dirstate.DirState._minikind_to_kind[entry[1][0]]
 
1847
        parent_index = self._get_parent_index()
 
1848
        return dirstate.DirState._minikind_to_kind[entry[parent_index][0]]
1731
1849
 
1732
1850
    def stored_kind(self, file_id):
1733
1851
        """See Tree.stored_kind"""
1753
1871
            return None
1754
1872
        return ie.executable
1755
1873
 
1756
 
    def list_files(self, include_root=False):
 
1874
    def is_locked(self):
 
1875
        return self._locked
 
1876
 
 
1877
    def list_files(self, include_root=False, from_dir=None, recursive=True):
1757
1878
        # We use a standard implementation, because DirStateRevisionTree is
1758
1879
        # dealing with one of the parents of the current state
1759
1880
        inv = self._get_inventory()
1760
 
        entries = inv.iter_entries()
1761
 
        if self.inventory.root is not None and not include_root:
 
1881
        if from_dir is None:
 
1882
            from_dir_id = None
 
1883
        else:
 
1884
            from_dir_id = inv.path2id(from_dir)
 
1885
            if from_dir_id is None:
 
1886
                # Directory not versioned
 
1887
                return
 
1888
        entries = inv.iter_entries(from_dir=from_dir_id, recursive=recursive)
 
1889
        if inv.root is not None and not include_root and from_dir is None:
1762
1890
            entries.next()
1763
1891
        for path, entry in entries:
1764
1892
            yield path, 'V', entry.kind, entry.file_id, entry
1765
1893
 
1766
1894
    def lock_read(self):
1767
 
        """Lock the tree for a set of operations."""
 
1895
        """Lock the tree for a set of operations.
 
1896
 
 
1897
        :return: A bzrlib.lock.LogicalLockResult.
 
1898
        """
1768
1899
        if not self._locked:
1769
1900
            self._repository.lock_read()
1770
1901
            if self._dirstate._lock_token is None:
1771
1902
                self._dirstate.lock_read()
1772
1903
                self._dirstate_locked = True
1773
1904
        self._locked += 1
 
1905
        return LogicalLockResult(self.unlock)
1774
1906
 
1775
1907
    def _must_be_locked(self):
1776
1908
        if not self._locked:
1803
1935
 
1804
1936
    def walkdirs(self, prefix=""):
1805
1937
        # TODO: jam 20070215 This is the lazy way by using the RevisionTree
1806
 
        # implementation based on an inventory.  
 
1938
        # implementation based on an inventory.
1807
1939
        # This should be cleaned up to use the much faster Dirstate code
1808
1940
        # So for now, we just build up the parent inventory, and extract
1809
1941
        # it the same way RevisionTree does.
1838
1970
 
1839
1971
class InterDirStateTree(InterTree):
1840
1972
    """Fast path optimiser for changes_from with dirstate trees.
1841
 
    
1842
 
    This is used only when both trees are in the dirstate working file, and 
1843
 
    the source is any parent within the dirstate, and the destination is 
 
1973
 
 
1974
    This is used only when both trees are in the dirstate working file, and
 
1975
    the source is any parent within the dirstate, and the destination is
1844
1976
    the current working tree of the same dirstate.
1845
1977
    """
1846
1978
    # this could be generalized to allow comparisons between any trees in the
1866
1998
        return result
1867
1999
 
1868
2000
    @classmethod
1869
 
    def make_source_parent_tree_compiled_dirstate(klass, test_case, source, target):
 
2001
    def make_source_parent_tree_compiled_dirstate(klass, test_case, source,
 
2002
                                                  target):
1870
2003
        from bzrlib.tests.test__dirstate_helpers import \
1871
 
            CompiledDirstateHelpersFeature
1872
 
        if not CompiledDirstateHelpersFeature.available():
1873
 
            from bzrlib.tests import UnavailableFeature
1874
 
            raise UnavailableFeature(CompiledDirstateHelpersFeature)
1875
 
        from bzrlib._dirstate_helpers_c import ProcessEntryC
 
2004
            compiled_dirstate_helpers_feature
 
2005
        test_case.requireFeature(compiled_dirstate_helpers_feature)
 
2006
        from bzrlib._dirstate_helpers_pyx import ProcessEntryC
1876
2007
        result = klass.make_source_parent_tree(source, target)
1877
2008
        result[1]._iter_changes = ProcessEntryC
1878
2009
        return result
1908
2039
            output. An unversioned file is defined as one with (False, False)
1909
2040
            for the versioned pair.
1910
2041
        """
1911
 
        # NB: show_status depends on being able to pass in non-versioned files
1912
 
        # and report them as unknown
1913
2042
        # TODO: handle extra trees in the dirstate.
1914
2043
        if (extra_trees or specific_files == []):
1915
2044
            # we can't fast-path these cases (yet)
1918
2047
                require_versioned, want_unversioned=want_unversioned)
1919
2048
        parent_ids = self.target.get_parent_ids()
1920
2049
        if not (self.source._revision_id in parent_ids
1921
 
                or self.source._revision_id == NULL_REVISION):
 
2050
                or self.source._revision_id == _mod_revision.NULL_REVISION):
1922
2051
            raise AssertionError(
1923
2052
                "revision {%s} is not stored in {%s}, but %s "
1924
2053
                "can only be used for trees stored in the dirstate"
1925
2054
                % (self.source._revision_id, self.target, self.iter_changes))
1926
2055
        target_index = 0
1927
 
        if self.source._revision_id == NULL_REVISION:
 
2056
        if self.source._revision_id == _mod_revision.NULL_REVISION:
1928
2057
            source_index = None
1929
2058
            indices = (target_index,)
1930
2059
        else:
1945
2074
        else:
1946
2075
            specific_files = set([''])
1947
2076
        # -- specific_files is now a utf8 path set --
1948
 
        search_specific_files = set()
 
2077
 
1949
2078
        # -- get the state object and prepare it.
1950
2079
        state = self.target.current_dirstate()
1951
2080
        state._read_dirblocks_if_needed()
1952
2081
        if require_versioned:
1953
2082
            # -- check all supplied paths are versioned in a search tree. --
1954
 
            all_versioned = True
 
2083
            not_versioned = []
1955
2084
            for path in specific_files:
1956
2085
                path_entries = state._entries_for_path(path)
1957
2086
                if not path_entries:
1958
2087
                    # this specified path is not present at all: error
1959
 
                    all_versioned = False
1960
 
                    break
 
2088
                    not_versioned.append(path)
 
2089
                    continue
1961
2090
                found_versioned = False
1962
2091
                # for each id at this path
1963
2092
                for entry in path_entries:
1970
2099
                if not found_versioned:
1971
2100
                    # none of the indexes was not 'absent' at all ids for this
1972
2101
                    # path.
1973
 
                    all_versioned = False
1974
 
                    break
1975
 
            if not all_versioned:
1976
 
                raise errors.PathsNotVersionedError(specific_files)
 
2102
                    not_versioned.append(path)
 
2103
            if len(not_versioned) > 0:
 
2104
                raise errors.PathsNotVersionedError(not_versioned)
1977
2105
        # -- remove redundancy in supplied specific_files to prevent over-scanning --
1978
 
        for path in specific_files:
1979
 
            other_specific_files = specific_files.difference(set([path]))
1980
 
            if not osutils.is_inside_any(other_specific_files, path):
1981
 
                # this is a top level path, we must check it.
1982
 
                search_specific_files.add(path)
 
2106
        search_specific_files = osutils.minimum_path_selection(specific_files)
1983
2107
 
1984
2108
        use_filesystem_for_exec = (sys.platform != 'win32')
1985
2109
        iter_changes = self.target._iter_changes(include_unchanged,
1997
2121
            (revisiontree.RevisionTree, DirStateRevisionTree)):
1998
2122
            return False
1999
2123
        # the source revid must be in the target dirstate
2000
 
        if not (source._revision_id == NULL_REVISION or
 
2124
        if not (source._revision_id == _mod_revision.NULL_REVISION or
2001
2125
            source._revision_id in target.get_parent_ids()):
2002
 
            # TODO: what about ghosts? it may well need to 
 
2126
            # TODO: what about ghosts? it may well need to
2003
2127
            # check for them explicitly.
2004
2128
            return False
2005
2129
        return True
2015
2139
 
2016
2140
    def convert(self, tree):
2017
2141
        # lock the control files not the tree, so that we dont get tree
2018
 
        # on-unlock behaviours, and so that noone else diddles with the 
 
2142
        # on-unlock behaviours, and so that noone else diddles with the
2019
2143
        # tree during upgrade.
2020
2144
        tree._control_files.lock_write()
2021
2145
        try:
2060
2184
 
2061
2185
    def convert(self, tree):
2062
2186
        # lock the control files not the tree, so that we don't get tree
2063
 
        # on-unlock behaviours, and so that no-one else diddles with the 
 
2187
        # on-unlock behaviours, and so that no-one else diddles with the
 
2188
        # tree during upgrade.
 
2189
        tree._control_files.lock_write()
 
2190
        try:
 
2191
            self.update_format(tree)
 
2192
        finally:
 
2193
            tree._control_files.unlock()
 
2194
 
 
2195
    def update_format(self, tree):
 
2196
        """Change the format marker."""
 
2197
        tree._transport.put_bytes('format',
 
2198
            self.target_format.get_format_string(),
 
2199
            mode=tree.bzrdir._get_file_mode())
 
2200
 
 
2201
 
 
2202
class Converter4or5to6(object):
 
2203
    """Perform an in-place upgrade of format 4 or 5 to format 6 trees."""
 
2204
 
 
2205
    def __init__(self):
 
2206
        self.target_format = WorkingTreeFormat6()
 
2207
 
 
2208
    def convert(self, tree):
 
2209
        # lock the control files not the tree, so that we don't get tree
 
2210
        # on-unlock behaviours, and so that no-one else diddles with the
2064
2211
        # tree during upgrade.
2065
2212
        tree._control_files.lock_write()
2066
2213
        try: