/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: Colin D Bennett
  • Date: 2009-02-12 17:11:41 UTC
  • mto: This revision was merged to the branch mainline in revision 4008.
  • Revision ID: colin@gibibit.com-20090212171141-bq8gllubhwyfgr52
Ignore all generated PDFs, not just the A4 size document.

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