/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: Canonical.com Patch Queue Manager
  • Date: 2008-09-26 05:14:51 UTC
  • mfrom: (3737.1.3 trivial_python_compat)
  • Revision ID: pqm@pqm.ubuntu.com-20080926051451-dvc1qg5inn7msjvr
(jam) Some win32 tweaks for the faster iter_changes code.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/workingtree_4.py
1
 
# Copyright (C) 2007-2010 Canonical Ltd
 
1
# Copyright (C) 2005, 2006, 2007, 2008 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
12
12
#
13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
 
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
16
 
17
17
"""WorkingTree4 format and implementation.
18
18
 
28
28
 
29
29
from bzrlib.lazy_import import lazy_import
30
30
lazy_import(globals(), """
 
31
from bisect import bisect_left
 
32
import collections
 
33
from copy import deepcopy
31
34
import errno
 
35
import itertools
 
36
import operator
32
37
import stat
 
38
from time import time
 
39
import warnings
33
40
 
34
41
import bzrlib
35
42
from bzrlib import (
36
43
    bzrdir,
37
44
    cache_utf8,
 
45
    conflicts as _mod_conflicts,
38
46
    debug,
 
47
    delta,
39
48
    dirstate,
40
49
    errors,
41
50
    generate_ids,
 
51
    globbing,
 
52
    ignores,
 
53
    merge,
42
54
    osutils,
43
55
    revision as _mod_revision,
44
56
    revisiontree,
 
57
    textui,
45
58
    trace,
46
59
    transform,
47
 
    views,
 
60
    urlutils,
 
61
    xml5,
 
62
    xml6,
48
63
    )
49
64
import bzrlib.branch
 
65
from bzrlib.transport import get_transport
50
66
import bzrlib.ui
51
67
""")
52
68
 
 
69
from bzrlib import symbol_versioning
53
70
from bzrlib.decorators import needs_read_lock, needs_write_lock
54
 
from bzrlib.filters import filtered_input_file, internal_size_sha_file_byname
55
 
from bzrlib.inventory import Inventory, ROOT_ID, entry_factory
 
71
from bzrlib.inventory import InventoryEntry, Inventory, ROOT_ID, entry_factory
 
72
from bzrlib.lockable_files import LockableFiles, TransportLock
 
73
from bzrlib.lockdir import LockDir
 
74
import bzrlib.mutabletree
56
75
from bzrlib.mutabletree import needs_tree_write_lock
57
76
from bzrlib.osutils import (
58
77
    file_kind,
59
78
    isdir,
 
79
    normpath,
60
80
    pathjoin,
 
81
    rand_chars,
61
82
    realpath,
62
83
    safe_unicode,
 
84
    splitpath,
63
85
    )
64
 
from bzrlib.trace import mutter
 
86
from bzrlib.trace import mutter, note
65
87
from bzrlib.transport.local import LocalTransport
66
88
from bzrlib.tree import InterTree
 
89
from bzrlib.progress import DummyProgress, ProgressPhase
 
90
from bzrlib.revision import NULL_REVISION, CURRENT_REVISION
 
91
from bzrlib.rio import RioReader, rio_file, Stanza
 
92
from bzrlib.symbol_versioning import (deprecated_passed,
 
93
        deprecated_method,
 
94
        deprecated_function,
 
95
        DEPRECATED_PARAMETER,
 
96
        )
67
97
from bzrlib.tree import Tree
68
98
from bzrlib.workingtree import WorkingTree, WorkingTree3, WorkingTreeFormat3
69
99
 
70
100
 
71
 
class DirStateWorkingTree(WorkingTree3):
 
101
class WorkingTree4(WorkingTree3):
 
102
    """This is the Format 4 working tree.
 
103
 
 
104
    This differs from WorkingTree3 by:
 
105
     - Having a consolidated internal dirstate, stored in a
 
106
       randomly-accessible sorted file on disk.
 
107
     - Not having a regular inventory attribute.  One can be synthesized 
 
108
       on demand but this is expensive and should be avoided.
 
109
 
 
110
    This is new in bzr 0.15.
 
111
    """
 
112
 
72
113
    def __init__(self, basedir,
73
114
                 branch,
74
115
                 _control_files=None,
101
142
        self._setup_directory_is_tree_reference()
102
143
        self._detect_case_handling()
103
144
        self._rules_searcher = None
104
 
        self.views = self._make_views()
105
145
        #--- allow tests to select the dirstate iter_changes implementation
106
146
        self._iter_changes = dirstate._process_entry
107
147
 
137
177
    @needs_tree_write_lock
138
178
    def add_reference(self, sub_tree):
139
179
        # use standard implementation, which calls back to self._add
140
 
        #
 
180
        # 
141
181
        # So we don't store the reference_revision in the working dirstate,
142
 
        # it's just recorded at the moment of commit.
 
182
        # it's just recorded at the moment of commit. 
143
183
        self._add_reference(sub_tree)
144
184
 
145
185
    def break_lock(self):
184
224
            WorkingTree3._comparison_data(self, entry, path)
185
225
        # it looks like a plain directory, but it's really a reference -- see
186
226
        # also kind()
187
 
        if (self._repo_supports_tree_reference and kind == 'directory'
188
 
            and entry is not None and entry.kind == 'tree-reference'):
 
227
        if (self._repo_supports_tree_reference and
 
228
            kind == 'directory' and
 
229
            self._directory_is_tree_reference(path)):
189
230
            kind = 'tree-reference'
190
231
        return kind, executable, stat_value
191
232
 
217
258
            return self._dirstate
218
259
        local_path = self.bzrdir.get_workingtree_transport(None
219
260
            ).local_abspath('dirstate')
220
 
        self._dirstate = dirstate.DirState.on_file(local_path,
221
 
            self._sha1_provider())
 
261
        self._dirstate = dirstate.DirState.on_file(local_path)
222
262
        return self._dirstate
223
263
 
224
 
    def _sha1_provider(self):
225
 
        """A function that returns a SHA1Provider suitable for this tree.
226
 
 
227
 
        :return: None if content filtering is not supported by this tree.
228
 
          Otherwise, a SHA1Provider is returned that sha's the canonical
229
 
          form of files, i.e. after read filters are applied.
230
 
        """
231
 
        if self.supports_content_filtering():
232
 
            return ContentFilterAwareSHA1Provider(self)
233
 
        else:
234
 
            return None
235
 
 
236
264
    def filter_unversioned_files(self, paths):
237
265
        """Filter out paths that are versioned.
238
266
 
270
298
 
271
299
    def _generate_inventory(self):
272
300
        """Create and set self.inventory from the dirstate object.
273
 
 
 
301
        
274
302
        This is relatively expensive: we have to walk the entire dirstate.
275
303
        Ideally we would not, and can deprecate this function.
276
304
        """
321
349
                    parent_ies[(dirname + '/' + name).strip('/')] = inv_entry
322
350
                elif kind == 'tree-reference':
323
351
                    if not self._repo_supports_tree_reference:
324
 
                        raise errors.UnsupportedOperation(
325
 
                            self._generate_inventory,
326
 
                            self.branch.repository)
 
352
                        raise AssertionError(
 
353
                            "repository of %r "
 
354
                            "doesn't support tree references "
 
355
                            "required by entry %r"
 
356
                            % (self, name))
327
357
                    inv_entry.reference_revision = link_or_sha1 or None
328
358
                elif kind != 'symlink':
329
359
                    raise AssertionError("unknown kind %r" % kind)
344
374
        If either file_id or path is supplied, it is used as the key to lookup.
345
375
        If both are supplied, the fastest lookup is used, and an error is
346
376
        raised if they do not both point at the same row.
347
 
 
 
377
        
348
378
        :param file_id: An optional unicode file_id to be looked up.
349
379
        :param path: An optional unicode path to be looked up.
350
380
        :return: The dirstate row tuple for path/file_id, or (None, None)
377
407
        link_or_sha1 = dirstate.update_entry(state, entry, file_abspath,
378
408
            stat_value=stat_value)
379
409
        if entry[1][0][0] == 'f':
380
 
            if link_or_sha1 is None:
381
 
                file_obj, statvalue = self.get_file_with_stat(file_id, path)
382
 
                try:
383
 
                    sha1 = osutils.sha_file(file_obj)
384
 
                finally:
385
 
                    file_obj.close()
386
 
                self._observed_sha1(file_id, path, (sha1, statvalue))
387
 
                return sha1
388
 
            else:
389
 
                return link_or_sha1
 
410
            return link_or_sha1
390
411
        return None
391
412
 
392
413
    def _get_inventory(self):
406
427
    @needs_read_lock
407
428
    def get_parent_ids(self):
408
429
        """See Tree.get_parent_ids.
409
 
 
 
430
        
410
431
        This implementation requests the ids list from the dirstate file.
411
432
        """
412
433
        return self.current_dirstate().get_parent_ids()
434
455
        return osutils.lexists(pathjoin(
435
456
                    self.basedir, row[0].decode('utf8'), row[1].decode('utf8')))
436
457
 
437
 
    def has_or_had_id(self, file_id):
438
 
        state = self.current_dirstate()
439
 
        row, parents = self._get_entry(file_id=file_id)
440
 
        return row is not None
441
 
 
442
458
    @needs_read_lock
443
459
    def id2path(self, file_id):
444
460
        "Convert a file-id to a path."
527
543
                # path is missing on disk.
528
544
                continue
529
545
 
530
 
    def _observed_sha1(self, file_id, path, (sha1, statvalue)):
531
 
        """See MutableTree._observed_sha1."""
532
 
        state = self.current_dirstate()
533
 
        entry = self._get_entry(file_id=file_id, path=path)
534
 
        state._observed_sha1(entry, sha1, statvalue)
535
 
 
536
546
    def kind(self, file_id):
537
547
        """Return the kind of a file.
538
548
 
550
560
    def _kind(self, relpath):
551
561
        abspath = self.abspath(relpath)
552
562
        kind = file_kind(abspath)
553
 
        if (self._repo_supports_tree_reference and kind == 'directory'):
554
 
            entry = self._get_entry(path=relpath)
555
 
            if entry[1] is not None:
556
 
                if entry[1][0][0] == 't':
557
 
                    kind = 'tree-reference'
 
563
        if (self._repo_supports_tree_reference and
 
564
            kind == 'directory' and
 
565
            self._directory_is_tree_reference(relpath)):
 
566
            kind = 'tree-reference'
558
567
        return kind
559
568
 
560
569
    @needs_read_lock
691
700
            from_entry = self._get_entry(path=from_rel)
692
701
            if from_entry == (None, None):
693
702
                raise errors.BzrMoveFailedError(from_rel,to_dir,
694
 
                    errors.NotVersionedError(path=from_rel))
 
703
                    errors.NotVersionedError(path=str(from_rel)))
695
704
 
696
705
            from_id = from_entry[0][2]
697
706
            to_rel = pathjoin(to_dir, from_tail)
872
881
        for tree in trees:
873
882
            if not (isinstance(tree, DirStateRevisionTree) and tree._revision_id in
874
883
                parents):
875
 
                return super(DirStateWorkingTree, self).paths2ids(paths,
876
 
                    trees, require_versioned)
 
884
                return super(WorkingTree4, self).paths2ids(paths, trees, require_versioned)
877
885
        search_indexes = [0] + [1 + parents.index(tree._revision_id) for tree in trees]
878
886
        # -- make all paths utf8 --
879
887
        paths_utf8 = set()
940
948
                raise errors.PathsNotVersionedError(paths)
941
949
        # -- remove redundancy in supplied paths to prevent over-scanning --
942
950
        search_paths = osutils.minimum_path_selection(paths)
943
 
        # sketch:
 
951
        # sketch: 
944
952
        # for all search_indexs in each path at or under each element of
945
953
        # search_paths, if the detail is relocated: add the id, and add the
946
954
        # relocated path as one to search if its not searched already. If the
1002
1010
 
1003
1011
    def read_working_inventory(self):
1004
1012
        """Read the working inventory.
1005
 
 
 
1013
        
1006
1014
        This is a meaningless operation for dirstate, but we obey it anyhow.
1007
1015
        """
1008
1016
        return self.inventory
1026
1034
    def set_last_revision(self, new_revision):
1027
1035
        """Change the last revision in the working tree."""
1028
1036
        parents = self.get_parent_ids()
1029
 
        if new_revision in (_mod_revision.NULL_REVISION, None):
 
1037
        if new_revision in (NULL_REVISION, None):
1030
1038
            if len(parents) >= 2:
1031
1039
                raise AssertionError(
1032
1040
                    "setting the last parent to none with a pending merge is "
1039
1047
    @needs_tree_write_lock
1040
1048
    def set_parent_ids(self, revision_ids, allow_leftmost_as_ghost=False):
1041
1049
        """Set the parent ids to revision_ids.
1042
 
 
 
1050
        
1043
1051
        See also set_parent_trees. This api will try to retrieve the tree data
1044
1052
        for each element of revision_ids from the trees repository. If you have
1045
1053
        tree data already available, it is more efficient to use
1199
1207
                # just forget the whole block.
1200
1208
                entry_index = 0
1201
1209
                while entry_index < len(block[1]):
 
1210
                    # Mark this file id as having been removed
1202
1211
                    entry = block[1][entry_index]
1203
 
                    if entry[1][0][0] in 'ar':
1204
 
                        # don't remove absent or renamed entries
 
1212
                    ids_to_unversion.discard(entry[0][2])
 
1213
                    if (entry[1][0][0] in 'ar' # don't remove absent or renamed
 
1214
                                               # entries
 
1215
                        or not state._make_absent(entry)):
1205
1216
                        entry_index += 1
1206
 
                    else:
1207
 
                        # Mark this file id as having been removed
1208
 
                        ids_to_unversion.discard(entry[0][2])
1209
 
                        if not state._make_absent(entry):
1210
 
                            # The block has not shrunk.
1211
 
                            entry_index += 1
1212
1217
                # go to the next block. (At the moment we dont delete empty
1213
1218
                # dirblocks)
1214
1219
                block_index += 1
1266
1271
        if self._dirty:
1267
1272
            raise AssertionError("attempting to write an inventory when the "
1268
1273
                "dirstate is dirty will lose pending changes")
1269
 
        had_inventory = self._inventory is not None
1270
 
        # Setting self._inventory = None forces the dirstate to regenerate the
1271
 
        # working inventory. We do this because self.inventory may be inv, or
1272
 
        # may have been modified, and either case would prevent a clean delta
1273
 
        # being created.
1274
 
        self._inventory = None
1275
 
        # generate a delta,
1276
 
        delta = inv._make_delta(self.inventory)
1277
 
        # and apply it.
1278
 
        self.apply_inventory_delta(delta)
1279
 
        if had_inventory:
 
1274
        self.current_dirstate().set_state_from_inventory(inv)
 
1275
        self._make_dirty(reset_inventory=False)
 
1276
        if self._inventory is not None:
1280
1277
            self._inventory = inv
1281
1278
        self.flush()
1282
1279
 
1283
1280
 
1284
 
class ContentFilterAwareSHA1Provider(dirstate.SHA1Provider):
1285
 
 
1286
 
    def __init__(self, tree):
1287
 
        self.tree = tree
1288
 
 
1289
 
    def sha1(self, abspath):
1290
 
        """See dirstate.SHA1Provider.sha1()."""
1291
 
        filters = self.tree._content_filter_stack(
1292
 
            self.tree.relpath(osutils.safe_unicode(abspath)))
1293
 
        return internal_size_sha_file_byname(abspath, filters)[1]
1294
 
 
1295
 
    def stat_and_sha1(self, abspath):
1296
 
        """See dirstate.SHA1Provider.stat_and_sha1()."""
1297
 
        filters = self.tree._content_filter_stack(
1298
 
            self.tree.relpath(osutils.safe_unicode(abspath)))
1299
 
        file_obj = file(abspath, 'rb', 65000)
1300
 
        try:
1301
 
            statvalue = os.fstat(file_obj.fileno())
1302
 
            if filters:
1303
 
                file_obj = filtered_input_file(file_obj, filters)
1304
 
            sha1 = osutils.size_sha_file(file_obj)[1]
1305
 
        finally:
1306
 
            file_obj.close()
1307
 
        return statvalue, sha1
1308
 
 
1309
 
 
1310
 
class ContentFilteringDirStateWorkingTree(DirStateWorkingTree):
1311
 
    """Dirstate working tree that supports content filtering.
1312
 
 
1313
 
    The dirstate holds the hash and size of the canonical form of the file, 
1314
 
    and most methods must return that.
1315
 
    """
1316
 
 
1317
 
    def _file_content_summary(self, path, stat_result):
1318
 
        # This is to support the somewhat obsolete path_content_summary method
1319
 
        # with content filtering: see
1320
 
        # <https://bugs.edge.launchpad.net/bzr/+bug/415508>.
1321
 
        #
1322
 
        # If the dirstate cache is up to date and knows the hash and size,
1323
 
        # return that.
1324
 
        # Otherwise if there are no content filters, return the on-disk size
1325
 
        # and leave the hash blank.
1326
 
        # Otherwise, read and filter the on-disk file and use its size and
1327
 
        # hash.
1328
 
        #
1329
 
        # The dirstate doesn't store the size of the canonical form so we
1330
 
        # can't trust it for content-filtered trees.  We just return None.
1331
 
        dirstate_sha1 = self._dirstate.sha1_from_stat(path, stat_result)
1332
 
        executable = self._is_executable_from_path_and_stat(path, stat_result)
1333
 
        return ('file', None, executable, dirstate_sha1)
1334
 
 
1335
 
 
1336
 
class WorkingTree4(DirStateWorkingTree):
1337
 
    """This is the Format 4 working tree.
1338
 
 
1339
 
    This differs from WorkingTree3 by:
1340
 
     - Having a consolidated internal dirstate, stored in a
1341
 
       randomly-accessible sorted file on disk.
1342
 
     - Not having a regular inventory attribute.  One can be synthesized
1343
 
       on demand but this is expensive and should be avoided.
1344
 
 
1345
 
    This is new in bzr 0.15.
1346
 
    """
1347
 
 
1348
 
 
1349
 
class WorkingTree5(ContentFilteringDirStateWorkingTree):
1350
 
    """This is the Format 5 working tree.
1351
 
 
1352
 
    This differs from WorkingTree4 by:
1353
 
     - Supporting content filtering.
1354
 
 
1355
 
    This is new in bzr 1.11.
1356
 
    """
1357
 
 
1358
 
 
1359
 
class WorkingTree6(ContentFilteringDirStateWorkingTree):
1360
 
    """This is the Format 6 working tree.
1361
 
 
1362
 
    This differs from WorkingTree5 by:
1363
 
     - Supporting a current view that may mask the set of files in a tree
1364
 
       impacted by most user operations.
1365
 
 
1366
 
    This is new in bzr 1.14.
1367
 
    """
1368
 
 
1369
 
    def _make_views(self):
1370
 
        return views.PathBasedViews(self)
1371
 
 
1372
 
 
1373
 
class DirStateWorkingTreeFormat(WorkingTreeFormat3):
 
1281
class WorkingTreeFormat4(WorkingTreeFormat3):
 
1282
    """The first consolidated dirstate working tree format.
 
1283
 
 
1284
    This format:
 
1285
        - exists within a metadir controlling .bzr
 
1286
        - includes an explicit version marker for the workingtree control
 
1287
          files, separate from the BzrDir format
 
1288
        - modifies the hash cache format
 
1289
        - is new in bzr 0.15
 
1290
        - uses a LockDir to guard access to it.
 
1291
    """
 
1292
 
 
1293
    upgrade_recommended = False
 
1294
 
 
1295
    _tree_class = WorkingTree4
 
1296
 
 
1297
    def get_format_string(self):
 
1298
        """See WorkingTreeFormat.get_format_string()."""
 
1299
        return "Bazaar Working Tree Format 4 (bzr 0.15)\n"
 
1300
 
 
1301
    def get_format_description(self):
 
1302
        """See WorkingTreeFormat.get_format_description()."""
 
1303
        return "Working tree format 4"
1374
1304
 
1375
1305
    def initialize(self, a_bzrdir, revision_id=None, from_branch=None,
1376
1306
                   accelerator_tree=None, hardlink=False):
1416
1346
        wt.lock_tree_write()
1417
1347
        try:
1418
1348
            self._init_custom_control_files(wt)
1419
 
            if revision_id in (None, _mod_revision.NULL_REVISION):
 
1349
            if revision_id in (None, NULL_REVISION):
1420
1350
                if branch.repository.supports_rich_root():
1421
1351
                    wt._set_root_id(generate_ids.gen_root_id())
1422
1352
                else:
1433
1363
                    pass
1434
1364
            if basis is None:
1435
1365
                basis = branch.repository.revision_tree(revision_id)
1436
 
            if revision_id == _mod_revision.NULL_REVISION:
 
1366
            if revision_id == NULL_REVISION:
1437
1367
                parents_list = []
1438
1368
            else:
1439
1369
                parents_list = [(revision_id, basis)]
1447
1377
                if basis_root_id is not None:
1448
1378
                    wt._set_root_id(basis_root_id)
1449
1379
                    wt.flush()
1450
 
                if wt.supports_content_filtering():
1451
 
                    # The original tree may not have the same content filters
1452
 
                    # applied so we can't safely build the inventory delta from
1453
 
                    # the source tree.
1454
 
                    delta_from_tree = False
1455
 
                else:
1456
 
                    delta_from_tree = True
1457
1380
                # delta_from_tree is safe even for DirStateRevisionTrees,
1458
1381
                # because wt4.apply_inventory_delta does not mutate the input
1459
1382
                # inventory entries.
1460
1383
                transform.build_tree(basis, wt, accelerator_tree,
1461
 
                                     hardlink=hardlink,
1462
 
                                     delta_from_tree=delta_from_tree)
 
1384
                                     hardlink=hardlink, delta_from_tree=True)
1463
1385
            finally:
1464
1386
                basis.unlock()
1465
1387
        finally:
1469
1391
 
1470
1392
    def _init_custom_control_files(self, wt):
1471
1393
        """Subclasses with custom control files should override this method.
1472
 
 
 
1394
        
1473
1395
        The working tree and control files are locked for writing when this
1474
1396
        method is called.
1475
 
 
 
1397
        
1476
1398
        :param wt: the WorkingTree object
1477
1399
        """
1478
1400
 
1489
1411
                           _control_files=control_files)
1490
1412
 
1491
1413
    def __get_matchingbzrdir(self):
1492
 
        return self._get_matchingbzrdir()
1493
 
 
1494
 
    def _get_matchingbzrdir(self):
1495
 
        """Overrideable method to get a bzrdir for testing."""
1496
1414
        # please test against something that will let us do tree references
1497
1415
        return bzrdir.format_registry.make_bzrdir(
1498
1416
            'dirstate-with-subtree')
1500
1418
    _matchingbzrdir = property(__get_matchingbzrdir)
1501
1419
 
1502
1420
 
1503
 
class WorkingTreeFormat4(DirStateWorkingTreeFormat):
1504
 
    """The first consolidated dirstate working tree format.
1505
 
 
1506
 
    This format:
1507
 
        - exists within a metadir controlling .bzr
1508
 
        - includes an explicit version marker for the workingtree control
1509
 
          files, separate from the BzrDir format
1510
 
        - modifies the hash cache format
1511
 
        - is new in bzr 0.15
1512
 
        - uses a LockDir to guard access to it.
1513
 
    """
1514
 
 
1515
 
    upgrade_recommended = False
1516
 
 
1517
 
    _tree_class = WorkingTree4
1518
 
 
1519
 
    def get_format_string(self):
1520
 
        """See WorkingTreeFormat.get_format_string()."""
1521
 
        return "Bazaar Working Tree Format 4 (bzr 0.15)\n"
1522
 
 
1523
 
    def get_format_description(self):
1524
 
        """See WorkingTreeFormat.get_format_description()."""
1525
 
        return "Working tree format 4"
1526
 
 
1527
 
 
1528
 
class WorkingTreeFormat5(DirStateWorkingTreeFormat):
1529
 
    """WorkingTree format supporting content filtering.
1530
 
    """
1531
 
 
1532
 
    upgrade_recommended = False
1533
 
 
1534
 
    _tree_class = WorkingTree5
1535
 
 
1536
 
    def get_format_string(self):
1537
 
        """See WorkingTreeFormat.get_format_string()."""
1538
 
        return "Bazaar Working Tree Format 5 (bzr 1.11)\n"
1539
 
 
1540
 
    def get_format_description(self):
1541
 
        """See WorkingTreeFormat.get_format_description()."""
1542
 
        return "Working tree format 5"
1543
 
 
1544
 
    def supports_content_filtering(self):
1545
 
        return True
1546
 
 
1547
 
 
1548
 
class WorkingTreeFormat6(DirStateWorkingTreeFormat):
1549
 
    """WorkingTree format supporting views.
1550
 
    """
1551
 
 
1552
 
    upgrade_recommended = False
1553
 
 
1554
 
    _tree_class = WorkingTree6
1555
 
 
1556
 
    def get_format_string(self):
1557
 
        """See WorkingTreeFormat.get_format_string()."""
1558
 
        return "Bazaar Working Tree Format 6 (bzr 1.14)\n"
1559
 
 
1560
 
    def get_format_description(self):
1561
 
        """See WorkingTreeFormat.get_format_description()."""
1562
 
        return "Working tree format 6"
1563
 
 
1564
 
    def _init_custom_control_files(self, wt):
1565
 
        """Subclasses with custom control files should override this method."""
1566
 
        wt._transport.put_bytes('views', '', mode=wt.bzrdir._get_file_mode())
1567
 
 
1568
 
    def supports_content_filtering(self):
1569
 
        return True
1570
 
 
1571
 
    def supports_views(self):
1572
 
        return True
1573
 
 
1574
 
 
1575
1421
class DirStateRevisionTree(Tree):
1576
 
    """A revision tree pulling the inventory from a dirstate.
1577
 
    
1578
 
    Note that this is one of the historical (ie revision) trees cached in the
1579
 
    dirstate for easy access, not the workingtree.
1580
 
    """
 
1422
    """A revision tree pulling the inventory from a dirstate."""
1581
1423
 
1582
1424
    def __init__(self, dirstate, revision_id, repository):
1583
1425
        self._dirstate = dirstate
1652
1494
        If either file_id or path is supplied, it is used as the key to lookup.
1653
1495
        If both are supplied, the fastest lookup is used, and an error is
1654
1496
        raised if they do not both point at the same row.
1655
 
 
 
1497
        
1656
1498
        :param file_id: An optional unicode file_id to be looked up.
1657
1499
        :param path: An optional unicode path to be looked up.
1658
1500
        :return: The dirstate row tuple for path/file_id, or (None, None)
1755
1597
            return None
1756
1598
        parent_index = self._get_parent_index()
1757
1599
        last_changed_revision = entry[1][parent_index][4]
1758
 
        try:
1759
 
            rev = self._repository.get_revision(last_changed_revision)
1760
 
        except errors.NoSuchRevision:
1761
 
            raise errors.FileTimestampUnavailable(self.id2path(file_id))
1762
 
        return rev.timestamp
 
1600
        return self._repository.get_revision(last_changed_revision).timestamp
1763
1601
 
1764
1602
    def get_file_sha1(self, file_id, path=None, stat_value=None):
1765
1603
        entry = self._get_entry(file_id=file_id, path=path)
1772
1610
    def get_file(self, file_id, path=None):
1773
1611
        return StringIO(self.get_file_text(file_id))
1774
1612
 
 
1613
    def get_file_lines(self, file_id):
 
1614
        return osutils.split_lines(self.get_file_text(file_id))
 
1615
 
1775
1616
    def get_file_size(self, file_id):
1776
1617
        """See Tree.get_file_size"""
1777
1618
        return self.inventory[file_id].text_size
1778
1619
 
1779
 
    def get_file_text(self, file_id, path=None):
1780
 
        _, content = list(self.iter_files_bytes([(file_id, None)]))[0]
1781
 
        return ''.join(content)
 
1620
    def get_file_text(self, file_id):
 
1621
        return list(self.iter_files_bytes([(file_id, None)]))[0][1]
1782
1622
 
1783
1623
    def get_reference_revision(self, file_id, path=None):
1784
1624
        return self.inventory[file_id].reference_revision
1803
1643
        if entry[1][parent_index][0] != 'l':
1804
1644
            return None
1805
1645
        else:
1806
 
            target = entry[1][parent_index][1]
1807
 
            target = target.decode('utf8')
1808
 
            return target
 
1646
            # At present, none of the tree implementations supports non-ascii
 
1647
            # symlink targets. So we will just assume that the dirstate path is
 
1648
            # correct.
 
1649
            return entry[1][parent_index][1]
1809
1650
 
1810
1651
    def get_revision_id(self):
1811
1652
        """Return the revision id for this tree."""
1832
1673
        entry = self._get_entry(file_id=file_id)[1]
1833
1674
        if entry is None:
1834
1675
            raise errors.NoSuchId(tree=self, file_id=file_id)
1835
 
        parent_index = self._get_parent_index()
1836
 
        return dirstate.DirState._minikind_to_kind[entry[parent_index][0]]
 
1676
        return dirstate.DirState._minikind_to_kind[entry[1][0]]
1837
1677
 
1838
1678
    def stored_kind(self, file_id):
1839
1679
        """See Tree.stored_kind"""
1859
1699
            return None
1860
1700
        return ie.executable
1861
1701
 
1862
 
    def list_files(self, include_root=False, from_dir=None, recursive=True):
 
1702
    def list_files(self, include_root=False):
1863
1703
        # We use a standard implementation, because DirStateRevisionTree is
1864
1704
        # dealing with one of the parents of the current state
1865
1705
        inv = self._get_inventory()
1866
 
        if from_dir is None:
1867
 
            from_dir_id = None
1868
 
        else:
1869
 
            from_dir_id = inv.path2id(from_dir)
1870
 
            if from_dir_id is None:
1871
 
                # Directory not versioned
1872
 
                return
1873
 
        entries = inv.iter_entries(from_dir=from_dir_id, recursive=recursive)
1874
 
        if inv.root is not None and not include_root and from_dir is None:
 
1706
        entries = inv.iter_entries()
 
1707
        if self.inventory.root is not None and not include_root:
1875
1708
            entries.next()
1876
1709
        for path, entry in entries:
1877
1710
            yield path, 'V', entry.kind, entry.file_id, entry
1916
1749
 
1917
1750
    def walkdirs(self, prefix=""):
1918
1751
        # TODO: jam 20070215 This is the lazy way by using the RevisionTree
1919
 
        # implementation based on an inventory.
 
1752
        # implementation based on an inventory.  
1920
1753
        # This should be cleaned up to use the much faster Dirstate code
1921
1754
        # So for now, we just build up the parent inventory, and extract
1922
1755
        # it the same way RevisionTree does.
1951
1784
 
1952
1785
class InterDirStateTree(InterTree):
1953
1786
    """Fast path optimiser for changes_from with dirstate trees.
1954
 
 
1955
 
    This is used only when both trees are in the dirstate working file, and
1956
 
    the source is any parent within the dirstate, and the destination is
 
1787
    
 
1788
    This is used only when both trees are in the dirstate working file, and 
 
1789
    the source is any parent within the dirstate, and the destination is 
1957
1790
    the current working tree of the same dirstate.
1958
1791
    """
1959
1792
    # this could be generalized to allow comparisons between any trees in the
1979
1812
        return result
1980
1813
 
1981
1814
    @classmethod
1982
 
    def make_source_parent_tree_compiled_dirstate(klass, test_case, source,
1983
 
                                                  target):
 
1815
    def make_source_parent_tree_compiled_dirstate(klass, test_case, source, target):
1984
1816
        from bzrlib.tests.test__dirstate_helpers import \
1985
 
            compiled_dirstate_helpers_feature
1986
 
        test_case.requireFeature(compiled_dirstate_helpers_feature)
1987
 
        from bzrlib._dirstate_helpers_pyx import ProcessEntryC
 
1817
            CompiledDirstateHelpersFeature
 
1818
        if not CompiledDirstateHelpersFeature.available():
 
1819
            from bzrlib.tests import UnavailableFeature
 
1820
            raise UnavailableFeature(CompiledDirstateHelpersFeature)
 
1821
        from bzrlib._dirstate_helpers_c import ProcessEntryC
1988
1822
        result = klass.make_source_parent_tree(source, target)
1989
1823
        result[1]._iter_changes = ProcessEntryC
1990
1824
        return result
2020
1854
            output. An unversioned file is defined as one with (False, False)
2021
1855
            for the versioned pair.
2022
1856
        """
 
1857
        # NB: show_status depends on being able to pass in non-versioned files
 
1858
        # and report them as unknown
2023
1859
        # TODO: handle extra trees in the dirstate.
2024
1860
        if (extra_trees or specific_files == []):
2025
1861
            # we can't fast-path these cases (yet)
2028
1864
                require_versioned, want_unversioned=want_unversioned)
2029
1865
        parent_ids = self.target.get_parent_ids()
2030
1866
        if not (self.source._revision_id in parent_ids
2031
 
                or self.source._revision_id == _mod_revision.NULL_REVISION):
 
1867
                or self.source._revision_id == NULL_REVISION):
2032
1868
            raise AssertionError(
2033
1869
                "revision {%s} is not stored in {%s}, but %s "
2034
1870
                "can only be used for trees stored in the dirstate"
2035
1871
                % (self.source._revision_id, self.target, self.iter_changes))
2036
1872
        target_index = 0
2037
 
        if self.source._revision_id == _mod_revision.NULL_REVISION:
 
1873
        if self.source._revision_id == NULL_REVISION:
2038
1874
            source_index = None
2039
1875
            indices = (target_index,)
2040
1876
        else:
2055
1891
        else:
2056
1892
            specific_files = set([''])
2057
1893
        # -- specific_files is now a utf8 path set --
2058
 
 
 
1894
        search_specific_files = set()
2059
1895
        # -- get the state object and prepare it.
2060
1896
        state = self.target.current_dirstate()
2061
1897
        state._read_dirblocks_if_needed()
2062
1898
        if require_versioned:
2063
1899
            # -- check all supplied paths are versioned in a search tree. --
2064
 
            not_versioned = []
 
1900
            all_versioned = True
2065
1901
            for path in specific_files:
2066
1902
                path_entries = state._entries_for_path(path)
2067
1903
                if not path_entries:
2068
1904
                    # this specified path is not present at all: error
2069
 
                    not_versioned.append(path)
2070
 
                    continue
 
1905
                    all_versioned = False
 
1906
                    break
2071
1907
                found_versioned = False
2072
1908
                # for each id at this path
2073
1909
                for entry in path_entries:
2080
1916
                if not found_versioned:
2081
1917
                    # none of the indexes was not 'absent' at all ids for this
2082
1918
                    # path.
2083
 
                    not_versioned.append(path)
2084
 
            if len(not_versioned) > 0:
2085
 
                raise errors.PathsNotVersionedError(not_versioned)
 
1919
                    all_versioned = False
 
1920
                    break
 
1921
            if not all_versioned:
 
1922
                raise errors.PathsNotVersionedError(specific_files)
2086
1923
        # -- remove redundancy in supplied specific_files to prevent over-scanning --
2087
 
        search_specific_files = osutils.minimum_path_selection(specific_files)
 
1924
        for path in specific_files:
 
1925
            other_specific_files = specific_files.difference(set([path]))
 
1926
            if not osutils.is_inside_any(other_specific_files, path):
 
1927
                # this is a top level path, we must check it.
 
1928
                search_specific_files.add(path)
2088
1929
 
2089
1930
        use_filesystem_for_exec = (sys.platform != 'win32')
2090
1931
        iter_changes = self.target._iter_changes(include_unchanged,
2095
1936
    @staticmethod
2096
1937
    def is_compatible(source, target):
2097
1938
        # the target must be a dirstate working tree
2098
 
        if not isinstance(target, DirStateWorkingTree):
 
1939
        if not isinstance(target, WorkingTree4):
2099
1940
            return False
2100
 
        # the source must be a revtree or dirstate rev tree.
 
1941
        # the source must be a revtreee or dirstate rev tree.
2101
1942
        if not isinstance(source,
2102
1943
            (revisiontree.RevisionTree, DirStateRevisionTree)):
2103
1944
            return False
2104
1945
        # the source revid must be in the target dirstate
2105
 
        if not (source._revision_id == _mod_revision.NULL_REVISION or
 
1946
        if not (source._revision_id == NULL_REVISION or
2106
1947
            source._revision_id in target.get_parent_ids()):
2107
 
            # TODO: what about ghosts? it may well need to
 
1948
            # TODO: what about ghosts? it may well need to 
2108
1949
            # check for them explicitly.
2109
1950
            return False
2110
1951
        return True
2120
1961
 
2121
1962
    def convert(self, tree):
2122
1963
        # lock the control files not the tree, so that we dont get tree
2123
 
        # on-unlock behaviours, and so that noone else diddles with the
 
1964
        # on-unlock behaviours, and so that noone else diddles with the 
2124
1965
        # tree during upgrade.
2125
1966
        tree._control_files.lock_write()
2126
1967
        try:
2155
1996
        tree._transport.put_bytes('format',
2156
1997
            self.target_format.get_format_string(),
2157
1998
            mode=tree.bzrdir._get_file_mode())
2158
 
 
2159
 
 
2160
 
class Converter4to5(object):
2161
 
    """Perform an in-place upgrade of format 4 to format 5 trees."""
2162
 
 
2163
 
    def __init__(self):
2164
 
        self.target_format = WorkingTreeFormat5()
2165
 
 
2166
 
    def convert(self, tree):
2167
 
        # lock the control files not the tree, so that we don't get tree
2168
 
        # on-unlock behaviours, and so that no-one else diddles with the
2169
 
        # tree during upgrade.
2170
 
        tree._control_files.lock_write()
2171
 
        try:
2172
 
            self.update_format(tree)
2173
 
        finally:
2174
 
            tree._control_files.unlock()
2175
 
 
2176
 
    def update_format(self, tree):
2177
 
        """Change the format marker."""
2178
 
        tree._transport.put_bytes('format',
2179
 
            self.target_format.get_format_string(),
2180
 
            mode=tree.bzrdir._get_file_mode())
2181
 
 
2182
 
 
2183
 
class Converter4or5to6(object):
2184
 
    """Perform an in-place upgrade of format 4 or 5 to format 6 trees."""
2185
 
 
2186
 
    def __init__(self):
2187
 
        self.target_format = WorkingTreeFormat6()
2188
 
 
2189
 
    def convert(self, tree):
2190
 
        # lock the control files not the tree, so that we don't get tree
2191
 
        # on-unlock behaviours, and so that no-one else diddles with the
2192
 
        # tree during upgrade.
2193
 
        tree._control_files.lock_write()
2194
 
        try:
2195
 
            self.init_custom_control_files(tree)
2196
 
            self.update_format(tree)
2197
 
        finally:
2198
 
            tree._control_files.unlock()
2199
 
 
2200
 
    def init_custom_control_files(self, tree):
2201
 
        """Initialize custom control files."""
2202
 
        tree._transport.put_bytes('views', '',
2203
 
            mode=tree.bzrdir._get_file_mode())
2204
 
 
2205
 
    def update_format(self, tree):
2206
 
        """Change the format marker."""
2207
 
        tree._transport.put_bytes('format',
2208
 
            self.target_format.get_format_string(),
2209
 
            mode=tree.bzrdir._get_file_mode())