← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/workingtree.py

  • Committer: Andrew Bennetts
  • Date: 2011-07-11 02:06:18 UTC
  • mfrom: (6018 +trunk)
  • mto: This revision was merged to the branch mainline in revision 6020.
  • Revision ID: andrew.bennetts@canonical.com-20110711020618-gcjgoeb5azwjrnu6
Merge lp:bzr/2.4.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/workingtree.py
29
29
WorkingTree.open(dir).
30
30
"""
31
31
 
32
 
from __future__ import absolute_import
33
32
 
34
33
from cStringIO import StringIO
35
34
import os
47
46
 
48
47
from bzrlib import (
49
48
    branch,
 
49
    bzrdir,
50
50
    conflicts as _mod_conflicts,
51
51
    controldir,
52
52
    errors,
54
54
    generate_ids,
55
55
    globbing,
56
56
    graph as _mod_graph,
 
57
    hashcache,
57
58
    ignores,
58
59
    inventory,
59
60
    merge,
60
61
    revision as _mod_revision,
61
62
    revisiontree,
62
63
    rio as _mod_rio,
63
 
    shelf,
64
64
    transform,
65
65
    transport,
66
66
    ui,
70
70
    )
71
71
""")
72
72
 
73
 
# Explicitly import bzrlib.bzrdir so that the BzrProber
74
 
# is guaranteed to be registered.
75
 
from bzrlib import (
76
 
    bzrdir,
77
 
    symbol_versioning,
78
 
    )
79
 
 
 
73
from bzrlib import symbol_versioning
80
74
from bzrlib.decorators import needs_read_lock, needs_write_lock
81
 
from bzrlib.i18n import gettext
82
75
from bzrlib.lock import LogicalLockResult
83
76
import bzrlib.mutabletree
84
77
from bzrlib.mutabletree import needs_tree_write_lock
91
84
    realpath,
92
85
    safe_unicode,
93
86
    splitpath,
 
87
    supports_executable,
94
88
    )
95
89
from bzrlib.trace import mutter, note
96
90
from bzrlib.revision import CURRENT_REVISION
178
172
 
179
173
    def __init__(self, basedir='.',
180
174
                 branch=DEPRECATED_PARAMETER,
 
175
                 _control_files=None,
181
176
                 _internal=False,
182
 
                 _transport=None,
183
177
                 _format=None,
184
178
                 _bzrdir=None):
185
179
        """Construct a WorkingTree instance. This is not a public API.
198
192
        else:
199
193
            self._branch = self.bzrdir.open_branch()
200
194
        self.basedir = realpath(basedir)
201
 
        self._transport = _transport
 
195
        self._control_files = _control_files
 
196
        self._transport = self._control_files._transport
 
197
        # update the whole cache up front and write to disk if anything changed;
 
198
        # in the future we might want to do this more selectively
 
199
        # two possible ways offer themselves : in self._unlock, write the cache
 
200
        # if needed, or, when the cache sees a change, append it to the hash
 
201
        # cache file, and have the parser take the most recent entry for a
 
202
        # given path only.
 
203
        wt_trans = self.bzrdir.get_workingtree_transport(None)
 
204
        cache_filename = wt_trans.local_abspath('stat-cache')
 
205
        self._hashcache = hashcache.HashCache(basedir, cache_filename,
 
206
            self.bzrdir._get_file_mode(),
 
207
            self._content_filter_stack_provider())
 
208
        hc = self._hashcache
 
209
        hc.read()
 
210
        # is this scan needed ? it makes things kinda slow.
 
211
        #hc.scan()
 
212
 
 
213
        if hc.needs_write:
 
214
            mutter("write hc")
 
215
            hc.write()
 
216
 
 
217
        self._detect_case_handling()
202
218
        self._rules_searcher = None
203
219
        self.views = self._make_views()
204
220
 
222
238
        """
223
239
        return self.bzrdir.is_control_filename(filename)
224
240
 
 
241
    def _detect_case_handling(self):
 
242
        wt_trans = self.bzrdir.get_workingtree_transport(None)
 
243
        try:
 
244
            wt_trans.stat(self._format.case_sensitive_filename)
 
245
        except errors.NoSuchFile:
 
246
            self.case_sensitive = True
 
247
        else:
 
248
            self.case_sensitive = False
 
249
 
 
250
        self._setup_directory_is_tree_reference()
 
251
 
225
252
    branch = property(
226
253
        fget=lambda self: self._branch,
227
254
        doc="""The branch this WorkingTree is connected to.
230
257
            the working tree has been constructed from.
231
258
            """)
232
259
 
233
 
    def has_versioned_directories(self):
234
 
        """See `Tree.has_versioned_directories`."""
235
 
        return self._format.supports_versioned_directories
236
 
 
237
 
    def _supports_executable(self):
238
 
        if sys.platform == 'win32':
239
 
            return False
240
 
        # FIXME: Ideally this should check the file system
241
 
        return True
242
 
 
243
260
    def break_lock(self):
244
261
        """Break a lock if one is present from another instance.
245
262
 
248
265
 
249
266
        This will probe the repository for its lock as well.
250
267
        """
251
 
        raise NotImplementedError(self.break_lock)
 
268
        self._control_files.break_lock()
 
269
        self.branch.break_lock()
252
270
 
253
271
    def requires_rich_root(self):
254
272
        return self._format.requires_rich_root
262
280
    def supports_views(self):
263
281
        return self.views.supports_views()
264
282
 
265
 
    def get_config_stack(self):
266
 
        """Retrieve the config stack for this tree.
267
 
 
268
 
        :return: A ``bzrlib.config.Stack``
269
 
        """
270
 
        # For the moment, just provide the branch config stack.
271
 
        return self.branch.get_config_stack()
272
 
 
273
283
    @staticmethod
274
284
    def open(path=None, _unsupported=False):
275
285
        """Open an existing working tree at path.
277
287
        """
278
288
        if path is None:
279
289
            path = osutils.getcwd()
280
 
        control = controldir.ControlDir.open(path, _unsupported=_unsupported)
281
 
        return control.open_workingtree(unsupported=_unsupported)
 
290
        control = bzrdir.BzrDir.open(path, _unsupported)
 
291
        return control.open_workingtree(_unsupported)
282
292
 
283
293
    @staticmethod
284
294
    def open_containing(path=None):
295
305
        """
296
306
        if path is None:
297
307
            path = osutils.getcwd()
298
 
        control, relpath = controldir.ControlDir.open_containing(path)
 
308
        control, relpath = bzrdir.BzrDir.open_containing(path)
299
309
        return control.open_workingtree(), relpath
300
310
 
301
311
    @staticmethod
321
331
                if view_files:
322
332
                    file_list = view_files
323
333
                    view_str = views.view_display_str(view_files)
324
 
                    note(gettext("Ignoring files outside view. View is %s") % view_str)
 
334
                    note("Ignoring files outside view. View is %s" % view_str)
325
335
            return tree, file_list
326
336
        if default_directory == u'.':
327
337
            seed = file_list[0]
384
394
            else:
385
395
                return True, tree
386
396
        t = transport.get_transport(location)
387
 
        iterator = controldir.ControlDir.find_bzrdirs(t, evaluate=evaluate,
 
397
        iterator = bzrdir.BzrDir.find_bzrdirs(t, evaluate=evaluate,
388
398
                                              list_current=list_current)
389
399
        return [tr for tr in iterator if tr is not None]
390
400
 
 
401
    def all_file_ids(self):
 
402
        """See Tree.iter_all_file_ids"""
 
403
        raise NotImplementedError(self.all_file_ids)
 
404
 
391
405
    def __repr__(self):
392
406
        return "<%s of %s>" % (self.__class__.__name__,
393
407
                               getattr(self, 'basedir', None))
508
522
        raise NotImplementedError(self.get_root_id)
509
523
 
510
524
    @needs_read_lock
511
 
    def clone(self, to_controldir, revision_id=None):
 
525
    def clone(self, to_bzrdir, revision_id=None):
512
526
        """Duplicate this working tree into to_bzr, including all state.
513
527
 
514
528
        Specifically modified files are kept as modified, but
515
529
        ignored and unknown files are discarded.
516
530
 
517
 
        If you want to make a new line of development, see ControlDir.sprout()
 
531
        If you want to make a new line of development, see bzrdir.sprout()
518
532
 
519
533
        revision
520
534
            If not None, the cloned tree will have its last revision set to
522
536
            and this one merged in.
523
537
        """
524
538
        # assumes the target bzr dir format is compatible.
525
 
        result = to_controldir.create_workingtree()
 
539
        result = to_bzrdir.create_workingtree()
526
540
        self.copy_content_into(result, revision_id)
527
541
        return result
528
542
 
535
549
        else:
536
550
            # TODO now merge from tree.last_revision to revision (to preserve
537
551
            # user local changes)
538
 
            try:
539
 
                other_tree = self.revision_tree(revision_id)
540
 
            except errors.NoSuchRevision:
541
 
                other_tree = self.branch.repository.revision_tree(revision_id)
542
 
 
543
 
            merge.transform_tree(tree, other_tree)
544
 
            if revision_id == _mod_revision.NULL_REVISION:
545
 
                new_parents = []
546
 
            else:
547
 
                new_parents = [revision_id]
548
 
            tree.set_parent_ids(new_parents)
 
552
            merge.transform_tree(tree, self)
 
553
            tree.set_parent_ids([revision_id])
549
554
 
550
555
    def id2abspath(self, file_id):
551
556
        return self.abspath(self.id2path(file_id))
590
595
            else:
591
596
                return None
592
597
 
 
598
    def get_file_sha1(self, file_id, path=None, stat_value=None):
 
599
        # FIXME: Shouldn't this be in Tree?
 
600
        raise NotImplementedError(self.get_file_sha1)
 
601
 
593
602
    @needs_tree_write_lock
594
603
    def _gather_kinds(self, files, kinds):
595
604
        """See MutableTree._gather_kinds."""
760
769
 
761
770
    @needs_tree_write_lock
762
771
    def set_merge_modified(self, modified_hashes):
763
 
        """Set the merge modified hashes."""
764
 
        raise NotImplementedError(self.set_merge_modified)
 
772
        def iter_stanzas():
 
773
            for file_id, hash in modified_hashes.iteritems():
 
774
                yield _mod_rio.Stanza(file_id=file_id.decode('utf8'),
 
775
                    hash=hash)
 
776
        self._put_rio('merge-hashes', iter_stanzas(), MERGE_MODIFIED_HEADER_1)
765
777
 
766
778
    def _sha_from_stat(self, path, stat_result):
767
779
        """Get a sha digest from the tree's stat cache.
773
785
        """
774
786
        return None
775
787
 
 
788
    def _put_rio(self, filename, stanzas, header):
 
789
        self._must_be_locked()
 
790
        my_file = _mod_rio.rio_file(stanzas, header)
 
791
        self._transport.put_file(filename, my_file,
 
792
            mode=self.bzrdir._get_file_mode())
 
793
 
776
794
    @needs_write_lock # because merge pulls data into the branch.
777
795
    def merge_from_branch(self, branch, to_revision=None, from_revision=None,
778
796
                          merge_type=None, force=False):
1018
1036
                                show_base=show_base)
1019
1037
                    basis_root_id = basis_tree.get_root_id()
1020
1038
                    new_root_id = new_basis_tree.get_root_id()
1021
 
                    if new_root_id is not None and basis_root_id != new_root_id:
 
1039
                    if basis_root_id != new_root_id:
1022
1040
                        self.set_root_id(new_root_id)
1023
1041
                finally:
1024
1042
                    basis_tree.unlock()
1025
1043
                # TODO - dedup parents list with things merged by pull ?
1026
1044
                # reuse the revisiontree we merged against to set the new
1027
1045
                # tree data.
1028
 
                parent_trees = []
1029
 
                if self.branch.last_revision() != _mod_revision.NULL_REVISION:
1030
 
                    parent_trees.append(
1031
 
                        (self.branch.last_revision(), new_basis_tree))
 
1046
                parent_trees = [(self.branch.last_revision(), new_basis_tree)]
1032
1047
                # we have to pull the merge trees out again, because
1033
1048
                # merge_inner has set the ids. - this corner is not yet
1034
1049
                # layered well enough to prevent double handling.
1051
1066
            stream.write(bytes)
1052
1067
        finally:
1053
1068
            stream.close()
 
1069
        # TODO: update the hashcache here ?
1054
1070
 
1055
1071
    def extras(self):
1056
1072
        """Yield all unversioned files in this WorkingTree.
1133
1149
        else:
1134
1150
            mode = stat_value.st_mode
1135
1151
            kind = osutils.file_kind_from_stat_mode(mode)
1136
 
            if not self._supports_executable():
 
1152
            if not supports_executable():
1137
1153
                executable = entry is not None and entry.executable
1138
1154
            else:
1139
1155
                executable = bool(stat.S_ISREG(mode) and stat.S_IEXEC & mode)
1158
1174
        return _mod_revision.ensure_null(self.branch.last_revision())
1159
1175
 
1160
1176
    def is_locked(self):
1161
 
        """Check if this tree is locked."""
1162
 
        raise NotImplementedError(self.is_locked)
 
1177
        return self._control_files.is_locked()
 
1178
 
 
1179
    def _must_be_locked(self):
 
1180
        if not self.is_locked():
 
1181
            raise errors.ObjectNotLocked(self)
1163
1182
 
1164
1183
    def lock_read(self):
1165
1184
        """Lock the tree for reading.
1168
1187
 
1169
1188
        :return: A bzrlib.lock.LogicalLockResult.
1170
1189
        """
1171
 
        raise NotImplementedError(self.lock_read)
 
1190
        if not self.is_locked():
 
1191
            self._reset_data()
 
1192
        self.branch.lock_read()
 
1193
        try:
 
1194
            self._control_files.lock_read()
 
1195
            return LogicalLockResult(self.unlock)
 
1196
        except:
 
1197
            self.branch.unlock()
 
1198
            raise
1172
1199
 
1173
1200
    def lock_tree_write(self):
1174
1201
        """See MutableTree.lock_tree_write, and WorkingTree.unlock.
1175
1202
 
1176
1203
        :return: A bzrlib.lock.LogicalLockResult.
1177
1204
        """
1178
 
        raise NotImplementedError(self.lock_tree_write)
 
1205
        if not self.is_locked():
 
1206
            self._reset_data()
 
1207
        self.branch.lock_read()
 
1208
        try:
 
1209
            self._control_files.lock_write()
 
1210
            return LogicalLockResult(self.unlock)
 
1211
        except:
 
1212
            self.branch.unlock()
 
1213
            raise
1179
1214
 
1180
1215
    def lock_write(self):
1181
1216
        """See MutableTree.lock_write, and WorkingTree.unlock.
1182
1217
 
1183
1218
        :return: A bzrlib.lock.LogicalLockResult.
1184
1219
        """
1185
 
        raise NotImplementedError(self.lock_write)
 
1220
        if not self.is_locked():
 
1221
            self._reset_data()
 
1222
        self.branch.lock_write()
 
1223
        try:
 
1224
            self._control_files.lock_write()
 
1225
            return LogicalLockResult(self.unlock)
 
1226
        except:
 
1227
            self.branch.unlock()
 
1228
            raise
1186
1229
 
1187
1230
    def get_physical_lock_status(self):
1188
 
        raise NotImplementedError(self.get_physical_lock_status)
 
1231
        return self._control_files.get_physical_lock_status()
 
1232
 
 
1233
    def _reset_data(self):
 
1234
        """Reset transient data that cannot be revalidated."""
 
1235
        raise NotImplementedError(self._reset_data)
1189
1236
 
1190
1237
    def set_last_revision(self, new_revision):
1191
1238
        """Change the last revision in the working tree."""
1357
1404
                basis_tree.unlock()
1358
1405
        return conflicts
1359
1406
 
1360
 
    @needs_write_lock
1361
 
    def store_uncommitted(self):
1362
 
        """Store uncommitted changes from the tree in the branch."""
1363
 
        target_tree = self.basis_tree()
1364
 
        shelf_creator = shelf.ShelfCreator(self, target_tree)
1365
 
        try:
1366
 
            if not shelf_creator.shelve_all():
1367
 
                return
1368
 
            self.branch.store_uncommitted(shelf_creator)
1369
 
            shelf_creator.transform()
1370
 
        finally:
1371
 
            shelf_creator.finalize()
1372
 
        note('Uncommitted changes stored in branch "%s".', self.branch.nick)
1373
 
 
1374
 
    @needs_write_lock
1375
 
    def restore_uncommitted(self):
1376
 
        """Restore uncommitted changes from the branch into the tree."""
1377
 
        unshelver = self.branch.get_unshelver(self)
1378
 
        if unshelver is None:
1379
 
            return
1380
 
        try:
1381
 
            merger = unshelver.make_merger()
1382
 
            merger.ignore_zero = True
1383
 
            merger.do_merge()
1384
 
            self.branch.store_uncommitted(None)
1385
 
        finally:
1386
 
            unshelver.finalize()
1387
 
 
1388
1407
    def revision_tree(self, revision_id):
1389
1408
        """See Tree.revision_tree.
1390
1409
 
1513
1532
                                             show_base=show_base)
1514
1533
            if nb_conflicts:
1515
1534
                self.add_parent_tree((old_tip, other_tree))
1516
 
                note(gettext('Rerun update after fixing the conflicts.'))
 
1535
                note('Rerun update after fixing the conflicts.')
1517
1536
                return nb_conflicts
1518
1537
 
1519
1538
        if last_rev != _mod_revision.ensure_null(revision):
1561
1580
            last_rev = parent_trees[0][0]
1562
1581
        return nb_conflicts
1563
1582
 
 
1583
    def _write_hashcache_if_dirty(self):
 
1584
        """Write out the hashcache if it is dirty."""
 
1585
        if self._hashcache.needs_write:
 
1586
            try:
 
1587
                self._hashcache.write()
 
1588
            except OSError, e:
 
1589
                if e.errno not in (errno.EPERM, errno.EACCES):
 
1590
                    raise
 
1591
                # TODO: jam 20061219 Should this be a warning? A single line
 
1592
                #       warning might be sufficient to let the user know what
 
1593
                #       is going on.
 
1594
                mutter('Could not write hashcache for %s\nError: %s',
 
1595
                              self._hashcache.cache_file_name(), e)
 
1596
 
1564
1597
    def set_conflicts(self, arg):
1565
1598
        raise errors.UnsupportedOperation(self.set_conflicts, self)
1566
1599
 
1795
1828
        :param branch: A branch to override probing for the branch.
1796
1829
        """
1797
1830
        super(InventoryWorkingTree, self).__init__(basedir=basedir,
1798
 
            branch=branch, _transport=_control_files._transport,
1799
 
            _internal=_internal, _format=_format, _bzrdir=_bzrdir)
1800
 
 
1801
 
        self._control_files = _control_files
1802
 
        self._detect_case_handling()
 
1831
            branch=branch, _control_files=_control_files, _internal=_internal,
 
1832
            _format=_format, _bzrdir=_bzrdir)
1803
1833
 
1804
1834
        if _inventory is None:
1805
1835
            # This will be acquired on lock_read() or lock_write()
1825
1855
        self._inventory = inv
1826
1856
        self._inventory_is_modified = dirty
1827
1857
 
1828
 
    def _detect_case_handling(self):
1829
 
        wt_trans = self.bzrdir.get_workingtree_transport(None)
1830
 
        try:
1831
 
            wt_trans.stat(self._format.case_sensitive_filename)
1832
 
        except errors.NoSuchFile:
1833
 
            self.case_sensitive = True
1834
 
        else:
1835
 
            self.case_sensitive = False
1836
 
 
1837
 
        self._setup_directory_is_tree_reference()
1838
 
 
1839
1858
    def _serialize(self, inventory, out_file):
1840
1859
        xml5.serializer_v5.write_inventory(self._inventory, out_file,
1841
1860
            working=True)
1843
1862
    def _deserialize(selt, in_file):
1844
1863
        return xml5.serializer_v5.read_inventory(in_file)
1845
1864
 
1846
 
    def break_lock(self):
1847
 
        """Break a lock if one is present from another instance.
1848
 
 
1849
 
        Uses the ui factory to ask for confirmation if the lock may be from
1850
 
        an active process.
1851
 
 
1852
 
        This will probe the repository for its lock as well.
1853
 
        """
1854
 
        self._control_files.break_lock()
1855
 
        self.branch.break_lock()
1856
 
 
1857
 
    def is_locked(self):
1858
 
        return self._control_files.is_locked()
1859
 
 
1860
 
    def _must_be_locked(self):
1861
 
        if not self.is_locked():
1862
 
            raise errors.ObjectNotLocked(self)
1863
 
 
1864
 
    def lock_read(self):
1865
 
        """Lock the tree for reading.
1866
 
 
1867
 
        This also locks the branch, and can be unlocked via self.unlock().
1868
 
 
1869
 
        :return: A bzrlib.lock.LogicalLockResult.
1870
 
        """
1871
 
        if not self.is_locked():
1872
 
            self._reset_data()
1873
 
        self.branch.lock_read()
1874
 
        try:
1875
 
            self._control_files.lock_read()
1876
 
            return LogicalLockResult(self.unlock)
1877
 
        except:
1878
 
            self.branch.unlock()
1879
 
            raise
1880
 
 
1881
 
    def lock_tree_write(self):
1882
 
        """See MutableTree.lock_tree_write, and WorkingTree.unlock.
1883
 
 
1884
 
        :return: A bzrlib.lock.LogicalLockResult.
1885
 
        """
1886
 
        if not self.is_locked():
1887
 
            self._reset_data()
1888
 
        self.branch.lock_read()
1889
 
        try:
1890
 
            self._control_files.lock_write()
1891
 
            return LogicalLockResult(self.unlock)
1892
 
        except:
1893
 
            self.branch.unlock()
1894
 
            raise
1895
 
 
1896
 
    def lock_write(self):
1897
 
        """See MutableTree.lock_write, and WorkingTree.unlock.
1898
 
 
1899
 
        :return: A bzrlib.lock.LogicalLockResult.
1900
 
        """
1901
 
        if not self.is_locked():
1902
 
            self._reset_data()
1903
 
        self.branch.lock_write()
1904
 
        try:
1905
 
            self._control_files.lock_write()
1906
 
            return LogicalLockResult(self.unlock)
1907
 
        except:
1908
 
            self.branch.unlock()
1909
 
            raise
1910
 
 
1911
 
    def get_physical_lock_status(self):
1912
 
        return self._control_files.get_physical_lock_status()
1913
 
 
1914
1865
    @needs_tree_write_lock
1915
1866
    def _write_inventory(self, inv):
1916
1867
        """Write inventory as the current inventory."""
1984
1935
            if entry.parent_id == orig_root_id:
1985
1936
                entry.parent_id = inv.root.file_id
1986
1937
 
 
1938
    def all_file_ids(self):
 
1939
        """See Tree.iter_all_file_ids"""
 
1940
        return set(self.inventory)
 
1941
 
1987
1942
    @needs_tree_write_lock
1988
1943
    def set_parent_trees(self, parents_list, allow_leftmost_as_ghost=False):
1989
1944
        """See MutableTree.set_parent_trees."""
2008
1963
                # parent tree from the repository.
2009
1964
                self._cache_basis_inventory(leftmost_parent_id)
2010
1965
            else:
2011
 
                inv = leftmost_parent_tree.root_inventory
 
1966
                inv = leftmost_parent_tree.inventory
2012
1967
                xml = self._create_basis_xml_from_inventory(
2013
1968
                                        leftmost_parent_id, inv)
2014
1969
                self._write_basis_inventory(xml)
2111
2066
 
2112
2067
    def has_id(self, file_id):
2113
2068
        # files that have been deleted are excluded
2114
 
        inv, inv_file_id = self._unpack_file_id(file_id)
2115
 
        if not inv.has_id(inv_file_id):
 
2069
        inv = self.inventory
 
2070
        if not inv.has_id(file_id):
2116
2071
            return False
2117
 
        path = inv.id2path(inv_file_id)
 
2072
        path = inv.id2path(file_id)
2118
2073
        return osutils.lexists(self.abspath(path))
2119
2074
 
2120
2075
    def has_or_had_id(self, file_id):
2121
 
        if file_id == self.get_root_id():
 
2076
        if file_id == self.inventory.root.file_id:
2122
2077
            return True
2123
 
        inv, inv_file_id = self._unpack_file_id(file_id)
2124
 
        return inv.has_id(inv_file_id)
 
2078
        return self.inventory.has_id(file_id)
2125
2079
 
2126
 
    def all_file_ids(self):
 
2080
    @symbol_versioning.deprecated_method(symbol_versioning.deprecated_in((2, 4, 0)))
 
2081
    def __iter__(self):
2127
2082
        """Iterate through file_ids for this tree.
2128
2083
 
2129
2084
        file_ids are in a WorkingTree if they are in the working inventory
2130
2085
        and the working file exists.
2131
2086
        """
2132
 
        ret = set()
2133
 
        for path, ie in self.iter_entries_by_dir():
2134
 
            ret.add(ie.file_id)
2135
 
        return ret
 
2087
        inv = self._inventory
 
2088
        for path, ie in inv.iter_entries():
 
2089
            if osutils.lexists(self.abspath(path)):
 
2090
                yield ie.file_id
2136
2091
 
2137
2092
    @needs_tree_write_lock
2138
2093
    def set_last_revision(self, new_revision):
2194
2149
                _mod_revision.NULL_REVISION)
2195
2150
        else:
2196
2151
            rt = self.branch.repository.revision_tree(revision_ids[0])
2197
 
        self._write_inventory(rt.root_inventory)
 
2152
        self._write_inventory(rt.inventory)
2198
2153
        self.set_parent_ids(revision_ids)
2199
2154
 
2200
2155
    def flush(self):
2209
2164
            mode=self.bzrdir._get_file_mode())
2210
2165
        self._inventory_is_modified = False
2211
2166
 
 
2167
    @needs_read_lock
 
2168
    def get_file_sha1(self, file_id, path=None, stat_value=None):
 
2169
        if not path:
 
2170
            path = self._inventory.id2path(file_id)
 
2171
        return self._hashcache.get_sha1(path, stat_value)
 
2172
 
2212
2173
    def get_file_mtime(self, file_id, path=None):
2213
2174
        """See Tree.get_file_mtime."""
2214
2175
        if not path:
2215
 
            path = self.id2path(file_id)
2216
 
        try:
2217
 
            return os.lstat(self.abspath(path)).st_mtime
2218
 
        except OSError, e:
2219
 
            if e.errno == errno.ENOENT:
2220
 
                raise errors.FileTimestampUnavailable(path)
2221
 
            raise
 
2176
            path = self.inventory.id2path(file_id)
 
2177
        return os.lstat(self.abspath(path)).st_mtime
2222
2178
 
2223
2179
    def _is_executable_from_path_and_stat_from_basis(self, path, stat_result):
2224
 
        inv, file_id = self._path2inv_file_id(path)
 
2180
        file_id = self.path2id(path)
2225
2181
        if file_id is None:
2226
2182
            # For unversioned files on win32, we just assume they are not
2227
2183
            # executable
2228
2184
            return False
2229
 
        return inv[file_id].executable
 
2185
        return self._inventory[file_id].executable
2230
2186
 
2231
2187
    def _is_executable_from_path_and_stat_from_stat(self, path, stat_result):
2232
2188
        mode = stat_result.st_mode
2233
2189
        return bool(stat.S_ISREG(mode) and stat.S_IEXEC & mode)
2234
2190
 
2235
 
    def is_executable(self, file_id, path=None):
2236
 
        if not self._supports_executable():
2237
 
            inv, inv_file_id = self._unpack_file_id(file_id)
2238
 
            return inv[inv_file_id].executable
2239
 
        else:
 
2191
    if not supports_executable():
 
2192
        def is_executable(self, file_id, path=None):
 
2193
            return self._inventory[file_id].executable
 
2194
 
 
2195
        _is_executable_from_path_and_stat = \
 
2196
            _is_executable_from_path_and_stat_from_basis
 
2197
    else:
 
2198
        def is_executable(self, file_id, path=None):
2240
2199
            if not path:
2241
2200
                path = self.id2path(file_id)
2242
2201
            mode = os.lstat(self.abspath(path)).st_mode
2243
2202
            return bool(stat.S_ISREG(mode) and stat.S_IEXEC & mode)
2244
2203
 
2245
 
    def _is_executable_from_path_and_stat(self, path, stat_result):
2246
 
        if not self._supports_executable():
2247
 
            return self._is_executable_from_path_and_stat_from_basis(path, stat_result)
2248
 
        else:
2249
 
            return self._is_executable_from_path_and_stat_from_stat(path, stat_result)
 
2204
        _is_executable_from_path_and_stat = \
 
2205
            _is_executable_from_path_and_stat_from_stat
2250
2206
 
2251
2207
    @needs_tree_write_lock
2252
2208
    def _add(self, files, ids, kinds):
2255
2211
        # should probably put it back with the previous ID.
2256
2212
        # the read and write working inventory should not occur in this
2257
2213
        # function - they should be part of lock_write and unlock.
2258
 
        # FIXME: nested trees
2259
 
        inv = self.root_inventory
 
2214
        inv = self.inventory
2260
2215
        for f, file_id, kind in zip(files, ids, kinds):
2261
2216
            if file_id is None:
2262
2217
                inv.add_path(f, kind=kind)
2303
2258
                parent_tree = self.branch.repository.revision_tree(parent_id)
2304
2259
            parent_tree.lock_read()
2305
2260
            try:
2306
 
                try:
2307
 
                    kind = parent_tree.kind(file_id)
2308
 
                except errors.NoSuchId:
 
2261
                if not parent_tree.has_id(file_id):
2309
2262
                    continue
2310
 
                if kind != 'file':
 
2263
                ie = parent_tree.inventory[file_id]
 
2264
                if ie.kind != 'file':
2311
2265
                    # Note: this is slightly unnecessary, because symlinks and
2312
2266
                    # directories have a "text" which is the empty text, and we
2313
2267
                    # know that won't mess up annotations. But it seems cleaner
2314
2268
                    continue
2315
 
                parent_text_key = (
2316
 
                    file_id, parent_tree.get_file_revision(file_id))
 
2269
                parent_text_key = (file_id, ie.revision)
2317
2270
                if parent_text_key not in maybe_file_parent_keys:
2318
2271
                    maybe_file_parent_keys.append(parent_text_key)
2319
2272
            finally:
2334
2287
                       for key, line in annotator.annotate_flat(this_key)]
2335
2288
        return annotations
2336
2289
 
2337
 
    def _put_rio(self, filename, stanzas, header):
2338
 
        self._must_be_locked()
2339
 
        my_file = _mod_rio.rio_file(stanzas, header)
2340
 
        self._transport.put_file(filename, my_file,
2341
 
            mode=self.bzrdir._get_file_mode())
2342
 
 
2343
 
    @needs_tree_write_lock
2344
 
    def set_merge_modified(self, modified_hashes):
2345
 
        def iter_stanzas():
2346
 
            for file_id, hash in modified_hashes.iteritems():
2347
 
                yield _mod_rio.Stanza(file_id=file_id.decode('utf8'),
2348
 
                    hash=hash)
2349
 
        self._put_rio('merge-hashes', iter_stanzas(), MERGE_MODIFIED_HEADER_1)
2350
 
 
2351
2290
    @needs_read_lock
2352
2291
    def merge_modified(self):
2353
2292
        """Return a dictionary of files modified by a merge.
2373
2312
            for s in _mod_rio.RioReader(hashfile):
2374
2313
                # RioReader reads in Unicode, so convert file_ids back to utf8
2375
2314
                file_id = osutils.safe_file_id(s.get("file_id"), warn=False)
2376
 
                if not self.has_id(file_id):
 
2315
                if not self.inventory.has_id(file_id):
2377
2316
                    continue
2378
2317
                text_hash = s.get("hash")
2379
2318
                if text_hash == self.get_file_sha1(file_id):
2409
2348
        other_tree.lock_tree_write()
2410
2349
        try:
2411
2350
            new_parents = other_tree.get_parent_ids()
2412
 
            other_root = other_tree.root_inventory.root
 
2351
            other_root = other_tree.inventory.root
2413
2352
            other_root.parent_id = new_root_parent
2414
2353
            other_root.name = osutils.basename(other_tree_path)
2415
 
            self.root_inventory.add(other_root)
2416
 
            add_children(self.root_inventory, other_root)
2417
 
            self._write_inventory(self.root_inventory)
 
2354
            self.inventory.add(other_root)
 
2355
            add_children(self.inventory, other_root)
 
2356
            self._write_inventory(self.inventory)
2418
2357
            # normally we don't want to fetch whole repositories, but i think
2419
2358
            # here we really do want to consolidate the whole thing.
2420
2359
            for parent_id in other_tree.get_parent_ids():
2458
2397
        tree_transport = self.bzrdir.root_transport.clone(sub_path)
2459
2398
        if tree_transport.base != branch_transport.base:
2460
2399
            tree_bzrdir = format.initialize_on_transport(tree_transport)
2461
 
            tree_bzrdir.set_branch_reference(new_branch)
 
2400
            branch.BranchReferenceFormat().initialize(tree_bzrdir,
 
2401
                target_branch=new_branch)
2462
2402
        else:
2463
2403
            tree_bzrdir = branch_bzrdir
2464
2404
        wt = tree_bzrdir.create_workingtree(_mod_revision.NULL_REVISION)
2465
2405
        wt.set_parent_ids(self.get_parent_ids())
2466
 
        # FIXME: Support nested trees
2467
 
        my_inv = self.root_inventory
 
2406
        my_inv = self.inventory
2468
2407
        child_inv = inventory.Inventory(root_id=None)
2469
2408
        new_root = my_inv[file_id]
2470
2409
        my_inv.remove_recursive_id(file_id)
2490
2429
        if not self.is_locked():
2491
2430
            raise errors.ObjectNotLocked(self)
2492
2431
 
 
2432
        inv = self.inventory
2493
2433
        if from_dir is None and include_root is True:
2494
 
            yield ('', 'V', 'directory', self.get_root_id(), self.root_inventory.root)
 
2434
            yield ('', 'V', 'directory', inv.root.file_id, inv.root)
2495
2435
        # Convert these into local objects to save lookup times
2496
2436
        pathjoin = osutils.pathjoin
2497
2437
        file_kind = self._kind
2504
2444
 
2505
2445
        # directory file_id, relative path, absolute path, reverse sorted children
2506
2446
        if from_dir is not None:
2507
 
            inv, from_dir_id = self._path2inv_file_id(from_dir)
 
2447
            from_dir_id = inv.path2id(from_dir)
2508
2448
            if from_dir_id is None:
2509
2449
                # Directory not versioned
2510
2450
                return
2511
2451
            from_dir_abspath = pathjoin(self.basedir, from_dir)
2512
2452
        else:
2513
 
            inv = self.root_inventory
2514
2453
            from_dir_id = inv.root.file_id
2515
2454
            from_dir_abspath = self.basedir
2516
2455
        children = os.listdir(from_dir_abspath)
2639
2578
        rename_entries = []
2640
2579
        rename_tuples = []
2641
2580
 
2642
 
        invs_to_write = set()
2643
 
 
2644
2581
        # check for deprecated use of signature
2645
2582
        if to_dir is None:
2646
2583
            raise TypeError('You must supply a target directory')
2647
2584
        # check destination directory
2648
2585
        if isinstance(from_paths, basestring):
2649
2586
            raise ValueError()
 
2587
        inv = self.inventory
2650
2588
        to_abs = self.abspath(to_dir)
2651
2589
        if not isdir(to_abs):
2652
2590
            raise errors.BzrMoveFailedError('',to_dir,
2654
2592
        if not self.has_filename(to_dir):
2655
2593
            raise errors.BzrMoveFailedError('',to_dir,
2656
2594
                errors.NotInWorkingDirectory(to_dir))
2657
 
        to_inv, to_dir_id = self._path2inv_file_id(to_dir)
 
2595
        to_dir_id = inv.path2id(to_dir)
2658
2596
        if to_dir_id is None:
2659
2597
            raise errors.BzrMoveFailedError('',to_dir,
2660
2598
                errors.NotVersionedError(path=to_dir))
2661
2599
 
2662
 
        to_dir_ie = to_inv[to_dir_id]
 
2600
        to_dir_ie = inv[to_dir_id]
2663
2601
        if to_dir_ie.kind != 'directory':
2664
2602
            raise errors.BzrMoveFailedError('',to_dir,
2665
2603
                errors.NotADirectory(to_abs))
2667
2605
        # create rename entries and tuples
2668
2606
        for from_rel in from_paths:
2669
2607
            from_tail = splitpath(from_rel)[-1]
2670
 
            from_inv, from_id = self._path2inv_file_id(from_rel)
 
2608
            from_id = inv.path2id(from_rel)
2671
2609
            if from_id is None:
2672
2610
                raise errors.BzrMoveFailedError(from_rel,to_dir,
2673
2611
                    errors.NotVersionedError(path=from_rel))
2674
2612
 
2675
 
            from_entry = from_inv[from_id]
 
2613
            from_entry = inv[from_id]
2676
2614
            from_parent_id = from_entry.parent_id
2677
2615
            to_rel = pathjoin(to_dir, from_tail)
2678
2616
            rename_entry = InventoryWorkingTree._RenameEntry(
2697
2635
            # restore the inventory on error
2698
2636
            self._inventory_is_modified = original_modified
2699
2637
            raise
2700
 
        #FIXME: Should potentially also write the from_invs
2701
 
        self._write_inventory(to_inv)
 
2638
        self._write_inventory(inv)
2702
2639
        return rename_tuples
2703
2640
 
2704
2641
    @needs_tree_write_lock
2724
2661
 
2725
2662
        Everything else results in an error.
2726
2663
        """
 
2664
        inv = self.inventory
2727
2665
        rename_entries = []
2728
2666
 
2729
2667
        # create rename entries and tuples
2730
2668
        from_tail = splitpath(from_rel)[-1]
2731
 
        from_inv, from_id = self._path2inv_file_id(from_rel)
 
2669
        from_id = inv.path2id(from_rel)
2732
2670
        if from_id is None:
2733
2671
            # if file is missing in the inventory maybe it's in the basis_tree
2734
2672
            basis_tree = self.branch.basis_tree()
2737
2675
                raise errors.BzrRenameFailedError(from_rel,to_rel,
2738
2676
                    errors.NotVersionedError(path=from_rel))
2739
2677
            # put entry back in the inventory so we can rename it
2740
 
            from_entry = basis_tree.root_inventory[from_id].copy()
2741
 
            from_inv.add(from_entry)
 
2678
            from_entry = basis_tree.inventory[from_id].copy()
 
2679
            inv.add(from_entry)
2742
2680
        else:
2743
 
            from_inv, from_inv_id = self._unpack_file_id(from_id)
2744
 
            from_entry = from_inv[from_inv_id]
 
2681
            from_entry = inv[from_id]
2745
2682
        from_parent_id = from_entry.parent_id
2746
2683
        to_dir, to_tail = os.path.split(to_rel)
2747
 
        to_inv, to_dir_id = self._path2inv_file_id(to_dir)
 
2684
        to_dir_id = inv.path2id(to_dir)
2748
2685
        rename_entry = InventoryWorkingTree._RenameEntry(from_rel=from_rel,
2749
2686
                                     from_id=from_id,
2750
2687
                                     from_tail=from_tail,
2772
2709
               from_id, from_rel, to_rel, to_dir, to_dir_id)
2773
2710
 
2774
2711
        self._move(rename_entries)
2775
 
        self._write_inventory(to_inv)
 
2712
        self._write_inventory(inv)
2776
2713
 
2777
2714
    class _RenameEntry(object):
2778
2715
        def __init__(self, from_rel, from_id, from_tail, from_parent_id,
2794
2731
 
2795
2732
        Also does basic plausability tests.
2796
2733
        """
2797
 
        # FIXME: Handling of nested trees
2798
 
        inv = self.root_inventory
 
2734
        inv = self.inventory
2799
2735
 
2800
2736
        for rename_entry in rename_entries:
2801
2737
            # store to local variables for easier reference
2846
2782
                # something is wrong, so lets determine what exactly
2847
2783
                if not self.has_filename(from_rel) and \
2848
2784
                   not self.has_filename(to_rel):
2849
 
                    raise errors.BzrRenameFailedError(from_rel, to_rel,
2850
 
                        errors.PathsDoNotExist(paths=(from_rel, to_rel)))
 
2785
                    raise errors.BzrRenameFailedError(from_rel,to_rel,
 
2786
                        errors.PathsDoNotExist(paths=(str(from_rel),
 
2787
                        str(to_rel))))
2851
2788
                else:
2852
2789
                    raise errors.RenameFailedFilesExist(from_rel, to_rel)
2853
2790
            rename_entry.only_change_inv = only_change_inv
2859
2796
        Depending on the value of the flag 'only_change_inv', the
2860
2797
        file will be moved on the file system or not.
2861
2798
        """
 
2799
        inv = self.inventory
2862
2800
        moved = []
2863
2801
 
2864
2802
        for entry in rename_entries:
2871
2809
 
2872
2810
    def _rollback_move(self, moved):
2873
2811
        """Try to rollback a previous move in case of an filesystem error."""
 
2812
        inv = self.inventory
2874
2813
        for entry in moved:
2875
2814
            try:
2876
2815
                self._move_entry(WorkingTree._RenameEntry(
2885
2824
                        " Error message is: %s" % e)
2886
2825
 
2887
2826
    def _move_entry(self, entry):
2888
 
        inv = self.root_inventory
 
2827
        inv = self.inventory
2889
2828
        from_rel_abs = self.abspath(entry.from_rel)
2890
2829
        to_rel_abs = self.abspath(entry.to_rel)
2891
2830
        if from_rel_abs == to_rel_abs:
2932
2871
 
2933
2872
    def stored_kind(self, file_id):
2934
2873
        """See Tree.stored_kind"""
2935
 
        inv, inv_file_id = self._unpack_file_id(file_id)
2936
 
        return inv[inv_file_id].kind
 
2874
        return self.inventory[file_id].kind
2937
2875
 
2938
2876
    def extras(self):
2939
2877
        """Yield all unversioned files in this WorkingTree.
2946
2884
        This is the same order used by 'osutils.walkdirs'.
2947
2885
        """
2948
2886
        ## TODO: Work from given directory downwards
2949
 
        for path, dir_entry in self.iter_entries_by_dir():
2950
 
            if dir_entry.kind != 'directory':
2951
 
                continue
 
2887
        for path, dir_entry in self.inventory.directories():
2952
2888
            # mutter("search for unknowns in %r", path)
2953
2889
            dirabs = self.abspath(path)
2954
2890
            if not isdir(dirabs):
2991
2927
        """
2992
2928
        _directory = 'directory'
2993
2929
        # get the root in the inventory
2994
 
        inv, top_id = self._path2inv_file_id(prefix)
 
2930
        inv = self.inventory
 
2931
        top_id = inv.path2id(prefix)
2995
2932
        if top_id is None:
2996
2933
            pending = []
2997
2934
        else:
3018
2955
                if dir[2] == _directory:
3019
2956
                    pending.append(dir)
3020
2957
 
3021
 
    @needs_write_lock
3022
 
    def update_feature_flags(self, updated_flags):
3023
 
        """Update the feature flags for this branch.
3024
 
 
3025
 
        :param updated_flags: Dictionary mapping feature names to necessities
3026
 
            A necessity can be None to indicate the feature should be removed
3027
 
        """
3028
 
        self._format._update_feature_flags(updated_flags)
3029
 
        self.control_transport.put_bytes('format', self._format.as_string())
3030
 
 
3031
2958
 
3032
2959
class WorkingTreeFormatRegistry(controldir.ControlComponentFormatRegistry):
3033
2960
    """Registry for working tree formats."""
3089
3016
 
3090
3017
    supports_versioned_directories = None
3091
3018
 
3092
 
    def initialize(self, controldir, revision_id=None, from_branch=None,
 
3019
    @classmethod
 
3020
    def find_format_string(klass, a_bzrdir):
 
3021
        """Return format name for the working tree object in a_bzrdir."""
 
3022
        try:
 
3023
            transport = a_bzrdir.get_workingtree_transport(None)
 
3024
            return transport.get_bytes("format")
 
3025
        except errors.NoSuchFile:
 
3026
            raise errors.NoWorkingTree(base=transport.base)
 
3027
 
 
3028
    @classmethod
 
3029
    def find_format(klass, a_bzrdir):
 
3030
        """Return the format for the working tree object in a_bzrdir."""
 
3031
        try:
 
3032
            format_string = klass.find_format_string(a_bzrdir)
 
3033
            return format_registry.get(format_string)
 
3034
        except KeyError:
 
3035
            raise errors.UnknownFormatError(format=format_string,
 
3036
                                            kind="working tree")
 
3037
 
 
3038
    def initialize(self, a_bzrdir, revision_id=None, from_branch=None,
3093
3039
                   accelerator_tree=None, hardlink=False):
3094
 
        """Initialize a new working tree in controldir.
 
3040
        """Initialize a new working tree in a_bzrdir.
3095
3041
 
3096
 
        :param controldir: ControlDir to initialize the working tree in.
 
3042
        :param a_bzrdir: BzrDir to initialize the working tree in.
3097
3043
        :param revision_id: allows creating a working tree at a different
3098
3044
            revision than the branch is at.
3099
3045
        :param from_branch: Branch to checkout
3112
3058
    def __ne__(self, other):
3113
3059
        return not (self == other)
3114
3060
 
 
3061
    @classmethod
 
3062
    @symbol_versioning.deprecated_method(
 
3063
        symbol_versioning.deprecated_in((2, 4, 0)))
 
3064
    def get_default_format(klass):
 
3065
        """Return the current default format."""
 
3066
        return format_registry.get_default()
 
3067
 
 
3068
    def get_format_string(self):
 
3069
        """Return the ASCII format string that identifies this format."""
 
3070
        raise NotImplementedError(self.get_format_string)
 
3071
 
3115
3072
    def get_format_description(self):
3116
3073
        """Return the short description for this format."""
3117
3074
        raise NotImplementedError(self.get_format_description)
3133
3090
        """True if this format supports stored views."""
3134
3091
        return False
3135
3092
 
3136
 
    def get_controldir_for_branch(self):
3137
 
        """Get the control directory format for creating branches.
3138
 
 
3139
 
        This is to support testing of working tree formats that can not exist
3140
 
        in the same control directory as a branch.
3141
 
        """
3142
 
        return self._matchingbzrdir
3143
 
 
3144
 
 
3145
 
class WorkingTreeFormatMetaDir(bzrdir.BzrFormat, WorkingTreeFormat):
3146
 
    """Base class for working trees that live in bzr meta directories."""
3147
 
 
3148
 
    def __init__(self):
3149
 
        WorkingTreeFormat.__init__(self)
3150
 
        bzrdir.BzrFormat.__init__(self)
3151
 
 
3152
 
    @classmethod
3153
 
    def find_format_string(klass, controldir):
3154
 
        """Return format name for the working tree object in controldir."""
3155
 
        try:
3156
 
            transport = controldir.get_workingtree_transport(None)
3157
 
            return transport.get_bytes("format")
3158
 
        except errors.NoSuchFile:
3159
 
            raise errors.NoWorkingTree(base=transport.base)
3160
 
 
3161
 
    @classmethod
3162
 
    def find_format(klass, controldir):
3163
 
        """Return the format for the working tree object in controldir."""
3164
 
        format_string = klass.find_format_string(controldir)
3165
 
        return klass._find_format(format_registry, 'working tree',
3166
 
                format_string)
3167
 
 
3168
 
    def check_support_status(self, allow_unsupported, recommend_upgrade=True,
3169
 
            basedir=None):
3170
 
        WorkingTreeFormat.check_support_status(self,
3171
 
            allow_unsupported=allow_unsupported, recommend_upgrade=recommend_upgrade,
3172
 
            basedir=basedir)
3173
 
        bzrdir.BzrFormat.check_support_status(self, allow_unsupported=allow_unsupported,
3174
 
            recommend_upgrade=recommend_upgrade, basedir=basedir)
3175
 
 
3176
 
    def get_controldir_for_branch(self):
3177
 
        """Get the control directory format for creating branches.
3178
 
 
3179
 
        This is to support testing of working tree formats that can not exist
3180
 
        in the same control directory as a branch.
3181
 
        """
3182
 
        return self._matchingbzrdir
3183
 
 
3184
 
 
3185
 
class WorkingTreeFormatMetaDir(bzrdir.BzrFormat, WorkingTreeFormat):
3186
 
    """Base class for working trees that live in bzr meta directories."""
3187
 
 
3188
 
    def __init__(self):
3189
 
        WorkingTreeFormat.__init__(self)
3190
 
        bzrdir.BzrFormat.__init__(self)
3191
 
 
3192
 
    @classmethod
3193
 
    def find_format_string(klass, controldir):
3194
 
        """Return format name for the working tree object in controldir."""
3195
 
        try:
3196
 
            transport = controldir.get_workingtree_transport(None)
3197
 
            return transport.get_bytes("format")
3198
 
        except errors.NoSuchFile:
3199
 
            raise errors.NoWorkingTree(base=transport.base)
3200
 
 
3201
 
    @classmethod
3202
 
    def find_format(klass, controldir):
3203
 
        """Return the format for the working tree object in controldir."""
3204
 
        format_string = klass.find_format_string(controldir)
3205
 
        return klass._find_format(format_registry, 'working tree',
3206
 
                format_string)
3207
 
 
3208
 
    def check_support_status(self, allow_unsupported, recommend_upgrade=True,
3209
 
            basedir=None):
3210
 
        WorkingTreeFormat.check_support_status(self,
3211
 
            allow_unsupported=allow_unsupported, recommend_upgrade=recommend_upgrade,
3212
 
            basedir=basedir)
3213
 
        bzrdir.BzrFormat.check_support_status(self, allow_unsupported=allow_unsupported,
3214
 
            recommend_upgrade=recommend_upgrade, basedir=basedir)
 
3093
    @classmethod
 
3094
    @symbol_versioning.deprecated_method(
 
3095
        symbol_versioning.deprecated_in((2, 4, 0)))
 
3096
    def register_format(klass, format):
 
3097
        format_registry.register(format)
 
3098
 
 
3099
    @classmethod
 
3100
    @symbol_versioning.deprecated_method(
 
3101
        symbol_versioning.deprecated_in((2, 4, 0)))
 
3102
    def register_extra_format(klass, format):
 
3103
        format_registry.register_extra(format)
 
3104
 
 
3105
    @classmethod
 
3106
    @symbol_versioning.deprecated_method(
 
3107
        symbol_versioning.deprecated_in((2, 4, 0)))
 
3108
    def unregister_extra_format(klass, format):
 
3109
        format_registry.unregister_extra(format)
 
3110
 
 
3111
    @classmethod
 
3112
    @symbol_versioning.deprecated_method(
 
3113
        symbol_versioning.deprecated_in((2, 4, 0)))
 
3114
    def get_formats(klass):
 
3115
        return format_registry._get_all()
 
3116
 
 
3117
    @classmethod
 
3118
    @symbol_versioning.deprecated_method(
 
3119
        symbol_versioning.deprecated_in((2, 4, 0)))
 
3120
    def set_default_format(klass, format):
 
3121
        format_registry.set_default(format)
 
3122
 
 
3123
    @classmethod
 
3124
    @symbol_versioning.deprecated_method(
 
3125
        symbol_versioning.deprecated_in((2, 4, 0)))
 
3126
    def unregister_format(klass, format):
 
3127
        format_registry.remove(format)
3215
3128
 
3216
3129
 
3217
3130
format_registry.register_lazy("Bazaar Working Tree Format 4 (bzr 0.15)\n",