← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/bzrdir.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2007-02-01 23:48:08 UTC
  • mfrom: (2225.1.6 revert)
  • Revision ID: pqm@pqm.ubuntu.com-20070201234808-3b1302d73474bd8c
Display changes made by revert

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/bzrdir.py
22
22
 
23
23
# TODO: remove unittest dependency; put that stuff inside the test suite
24
24
 
25
 
from copy import deepcopy
 
25
# TODO: The Format probe_transport seems a bit redundant with just trying to
 
26
# open the bzrdir. -- mbp
 
27
#
 
28
# TODO: Can we move specific formats into separate modules to make this file
 
29
# smaller?
 
30
 
26
31
from cStringIO import StringIO
27
32
import os
 
33
import textwrap
 
34
 
 
35
from bzrlib.lazy_import import lazy_import
 
36
lazy_import(globals(), """
 
37
from copy import deepcopy
28
38
from stat import S_ISDIR
29
 
from unittest import TestSuite
 
39
import unittest
30
40
 
31
41
import bzrlib
32
 
import bzrlib.errors as errors
33
 
from bzrlib.lockable_files import LockableFiles, TransportLock
34
 
from bzrlib.lockdir import LockDir
 
42
from bzrlib import (
 
43
    errors,
 
44
    lockable_files,
 
45
    lockdir,
 
46
    registry,
 
47
    revision as _mod_revision,
 
48
    repository as _mod_repository,
 
49
    symbol_versioning,
 
50
    urlutils,
 
51
    xml4,
 
52
    xml5,
 
53
    )
35
54
from bzrlib.osutils import (
36
 
                            abspath,
37
 
                            pathjoin,
38
 
                            safe_unicode,
39
 
                            sha_strings,
40
 
                            sha_string,
41
 
                            )
 
55
    safe_unicode,
 
56
    sha_strings,
 
57
    sha_string,
 
58
    )
42
59
from bzrlib.store.revision.text import TextRevisionStore
43
60
from bzrlib.store.text import TextStore
44
61
from bzrlib.store.versioned import WeaveStore
45
 
from bzrlib.trace import mutter
46
62
from bzrlib.transactions import WriteTransaction
47
63
from bzrlib.transport import get_transport
 
64
from bzrlib.weave import Weave
 
65
""")
 
66
 
 
67
from bzrlib.trace import mutter
48
68
from bzrlib.transport.local import LocalTransport
49
 
import bzrlib.urlutils as urlutils
50
 
from bzrlib.weave import Weave
51
 
from bzrlib.xml4 import serializer_v4
52
 
import bzrlib.xml5
53
69
 
54
70
 
55
71
class BzrDir(object):
86
102
        """Return true if this bzrdir is one whose format we can convert from."""
87
103
        return True
88
104
 
 
105
    def check_conversion_target(self, target_format):
 
106
        target_repo_format = target_format.repository_format
 
107
        source_repo_format = self._format.repository_format
 
108
        source_repo_format.check_conversion_target(target_repo_format)
 
109
 
89
110
    @staticmethod
90
111
    def _check_supported(format, allow_unsupported):
91
112
        """Check whether format is a supported format.
176
197
    def _make_tail(self, url):
177
198
        head, tail = urlutils.split(url)
178
199
        if tail and tail != '.':
179
 
            t = bzrlib.transport.get_transport(head)
 
200
            t = get_transport(head)
180
201
            try:
181
202
                t.mkdir(tail)
182
203
            except errors.FileExists:
184
205
 
185
206
    # TODO: Should take a Transport
186
207
    @classmethod
187
 
    def create(cls, base):
 
208
    def create(cls, base, format=None):
188
209
        """Create a new BzrDir at the url 'base'.
189
210
        
190
211
        This will call the current default formats initialize with base
191
212
        as the only parameter.
192
213
 
193
 
        If you need a specific format, consider creating an instance
194
 
        of that and calling initialize().
 
214
        :param format: If supplied, the format of branch to create.  If not
 
215
            supplied, the default is used.
195
216
        """
196
217
        if cls is not BzrDir:
197
 
            raise AssertionError("BzrDir.create always creates the default format, "
198
 
                    "not one of %r" % cls)
 
218
            raise AssertionError("BzrDir.create always creates the default"
 
219
                " format, not one of %r" % cls)
199
220
        head, tail = urlutils.split(base)
200
221
        if tail and tail != '.':
201
 
            t = bzrlib.transport.get_transport(head)
 
222
            t = get_transport(head)
202
223
            try:
203
224
                t.mkdir(tail)
204
225
            except errors.FileExists:
205
226
                pass
206
 
        return BzrDirFormat.get_default_format().initialize(safe_unicode(base))
 
227
        if format is None:
 
228
            format = BzrDirFormat.get_default_format()
 
229
        return format.initialize(safe_unicode(base))
207
230
 
208
231
    def create_branch(self):
209
232
        """Create a branch in this BzrDir.
214
237
        raise NotImplementedError(self.create_branch)
215
238
 
216
239
    @staticmethod
217
 
    def create_branch_and_repo(base, force_new_repo=False):
 
240
    def create_branch_and_repo(base, force_new_repo=False, format=None):
218
241
        """Create a new BzrDir, Branch and Repository at the url 'base'.
219
242
 
220
243
        This will use the current default BzrDirFormat, and use whatever 
227
250
        :param base: The URL to create the branch at.
228
251
        :param force_new_repo: If True a new repository is always created.
229
252
        """
230
 
        bzrdir = BzrDir.create(base)
 
253
        bzrdir = BzrDir.create(base, format)
231
254
        bzrdir._find_or_create_repository(force_new_repo)
232
255
        return bzrdir.create_branch()
233
256
 
271
294
            t = get_transport(safe_unicode(base))
272
295
            if not isinstance(t, LocalTransport):
273
296
                raise errors.NotLocalUrl(base)
274
 
        if format is None:
275
 
            bzrdir = BzrDir.create(base)
276
 
        else:
277
 
            bzrdir = format.initialize(base)
 
297
        bzrdir = BzrDir.create(base, format)
278
298
        repo = bzrdir._find_or_create_repository(force_new_repo)
279
299
        result = bzrdir.create_branch()
280
300
        if force_new_tree or (repo.make_working_trees() and 
286
306
        return result
287
307
        
288
308
    @staticmethod
289
 
    def create_repository(base, shared=False):
 
309
    def create_repository(base, shared=False, format=None):
290
310
        """Create a new BzrDir and Repository at the url 'base'.
291
311
 
292
 
        This will use the current default BzrDirFormat, and use whatever 
293
 
        repository format that that uses for bzrdirformat.create_repository.
 
312
        If no format is supplied, this will default to the current default
 
313
        BzrDirFormat by default, and use whatever repository format that that
 
314
        uses for bzrdirformat.create_repository.
294
315
 
295
 
        ;param shared: Create a shared repository rather than a standalone
 
316
        :param shared: Create a shared repository rather than a standalone
296
317
                       repository.
297
318
        The Repository object is returned.
298
319
 
300
321
        it should take no parameters and construct whatever repository format
301
322
        that child class desires.
302
323
        """
303
 
        bzrdir = BzrDir.create(base)
 
324
        bzrdir = BzrDir.create(base, format)
304
325
        return bzrdir.create_repository(shared)
305
326
 
306
327
    @staticmethod
307
 
    def create_standalone_workingtree(base):
 
328
    def create_standalone_workingtree(base, format=None):
308
329
        """Create a new BzrDir, WorkingTree, Branch and Repository at 'base'.
309
330
 
310
331
        'base' must be a local path or a file:// url.
313
334
        repository format that that uses for bzrdirformat.create_workingtree,
314
335
        create_branch and create_repository.
315
336
 
316
 
        The WorkingTree object is returned.
 
337
        :return: The WorkingTree object.
317
338
        """
318
339
        t = get_transport(safe_unicode(base))
319
340
        if not isinstance(t, LocalTransport):
320
341
            raise errors.NotLocalUrl(base)
321
342
        bzrdir = BzrDir.create_branch_and_repo(safe_unicode(base),
322
 
                                               force_new_repo=True).bzrdir
 
343
                                               force_new_repo=True,
 
344
                                               format=format).bzrdir
323
345
        return bzrdir.create_workingtree()
324
346
 
325
347
    def create_workingtree(self, revision_id=None):
329
351
        """
330
352
        raise NotImplementedError(self.create_workingtree)
331
353
 
 
354
    def destroy_workingtree(self):
 
355
        """Destroy the working tree at this BzrDir.
 
356
 
 
357
        Formats that do not support this may raise UnsupportedOperation.
 
358
        """
 
359
        raise NotImplementedError(self.destroy_workingtree)
 
360
 
 
361
    def destroy_workingtree_metadata(self):
 
362
        """Destroy the control files for the working tree at this BzrDir.
 
363
 
 
364
        The contents of working tree files are not affected.
 
365
        Formats that do not support this may raise UnsupportedOperation.
 
366
        """
 
367
        raise NotImplementedError(self.destroy_workingtree_metadata)
 
368
 
332
369
    def find_repository(self):
333
370
        """Find the repository that should be used for a_bzrdir.
334
371
 
460
497
        _unsupported is a private parameter to the BzrDir class.
461
498
        """
462
499
        t = get_transport(base)
463
 
        mutter("trying to open %r with transport %r", base, t)
464
 
        format = BzrDirFormat.find_format(t)
 
500
        return BzrDir.open_from_transport(t, _unsupported=_unsupported)
 
501
 
 
502
    @staticmethod
 
503
    def open_from_transport(transport, _unsupported=False):
 
504
        """Open a bzrdir within a particular directory.
 
505
 
 
506
        :param transport: Transport containing the bzrdir.
 
507
        :param _unsupported: private.
 
508
        """
 
509
        format = BzrDirFormat.find_format(transport)
465
510
        BzrDir._check_supported(format, _unsupported)
466
 
        return format.open(t, _found=True)
 
511
        return format.open(transport, _found=True)
467
512
 
468
513
    def open_branch(self, unsupported=False):
469
514
        """Open the branch object at this BzrDir if one is present.
503
548
        url = a_transport.base
504
549
        while True:
505
550
            try:
506
 
                format = BzrDirFormat.find_format(a_transport)
507
 
                BzrDir._check_supported(format, False)
508
 
                return format.open(a_transport), urlutils.unescape(a_transport.relpath(url))
 
551
                result = BzrDir.open_from_transport(a_transport)
 
552
                return result, urlutils.unescape(a_transport.relpath(url))
509
553
            except errors.NotBranchError, e:
510
 
                ## mutter('not a branch in: %r %s', a_transport.base, e)
511
554
                pass
512
555
            new_t = a_transport.clone('..')
513
556
            if new_t.base == a_transport.base:
515
558
                raise errors.NotBranchError(path=url)
516
559
            a_transport = new_t
517
560
 
 
561
    @classmethod
 
562
    def open_containing_tree_or_branch(klass, location):
 
563
        """Return the branch and working tree contained by a location.
 
564
 
 
565
        Returns (tree, branch, relpath).
 
566
        If there is no tree at containing the location, tree will be None.
 
567
        If there is no branch containing the location, an exception will be
 
568
        raised
 
569
        relpath is the portion of the path that is contained by the branch.
 
570
        """
 
571
        bzrdir, relpath = klass.open_containing(location)
 
572
        try:
 
573
            tree = bzrdir.open_workingtree()
 
574
        except (errors.NoWorkingTree, errors.NotLocalUrl):
 
575
            tree = None
 
576
            branch = bzrdir.open_branch()
 
577
        else:
 
578
            branch = tree.branch
 
579
        return tree, branch, relpath
 
580
 
518
581
    def open_repository(self, _unsupported=False):
519
582
        """Open the repository object at this BzrDir if one is present.
520
583
 
563
626
        except errors.NoWorkingTree:
564
627
            return False
565
628
 
 
629
    def cloning_metadir(self, basis=None):
 
630
        """Produce a metadir suitable for cloning with"""
 
631
        def related_repository(bzrdir):
 
632
            try:
 
633
                branch = bzrdir.open_branch()
 
634
                return branch.repository
 
635
            except errors.NotBranchError:
 
636
                source_branch = None
 
637
                return bzrdir.open_repository()
 
638
        result_format = self._format.__class__()
 
639
        try:
 
640
            try:
 
641
                source_repository = related_repository(self)
 
642
            except errors.NoRepositoryPresent:
 
643
                if basis is None:
 
644
                    raise
 
645
                source_repository = related_repository(self)
 
646
            result_format.repository_format = source_repository._format
 
647
        except errors.NoRepositoryPresent:
 
648
            pass
 
649
        return result_format
 
650
 
566
651
    def sprout(self, url, revision_id=None, basis=None, force_new_repo=False):
567
652
        """Create a copy of this bzrdir prepared for use as a new line of
568
653
        development.
578
663
            itself to download less data.
579
664
        """
580
665
        self._make_tail(url)
581
 
        result = self._format.initialize(url)
 
666
        cloning_format = self.cloning_metadir(basis)
 
667
        result = cloning_format.initialize(url)
582
668
        basis_repo, basis_branch, basis_tree = self._get_basis_components(basis)
583
669
        try:
584
670
            source_branch = self.open_branch()
615
701
                # XXX FIXME RBC 20060214 need tests for this when the basis
616
702
                # is incomplete
617
703
                result_repo.fetch(basis_repo, revision_id=revision_id)
618
 
            result_repo.fetch(source_repository, revision_id=revision_id)
 
704
            if source_repository is not None:
 
705
                result_repo.fetch(source_repository, revision_id=revision_id)
619
706
        if source_branch is not None:
620
707
            source_branch.sprout(result, revision_id=revision_id)
621
708
        else:
623
710
        # TODO: jam 20060426 we probably need a test in here in the
624
711
        #       case that the newly sprouted branch is a remote one
625
712
        if result_repo is None or result_repo.make_working_trees():
626
 
            result.create_workingtree()
 
713
            wt = result.create_workingtree()
 
714
            if wt.inventory.root is None:
 
715
                try:
 
716
                    wt.set_root_id(self.open_workingtree.get_root_id())
 
717
                except errors.NoWorkingTree:
 
718
                    pass
627
719
        return result
628
720
 
629
721
 
633
725
    def __init__(self, _transport, _format):
634
726
        """See BzrDir.__init__."""
635
727
        super(BzrDirPreSplitOut, self).__init__(_transport, _format)
636
 
        assert self._format._lock_class == TransportLock
 
728
        assert self._format._lock_class == lockable_files.TransportLock
637
729
        assert self._format._lock_file_name == 'branch-lock'
638
 
        self._control_files = LockableFiles(self.get_branch_transport(None),
 
730
        self._control_files = lockable_files.LockableFiles(
 
731
                                            self.get_branch_transport(None),
639
732
                                            self._format._lock_file_name,
640
733
                                            self._format._lock_class)
641
734
 
685
778
        # done on this format anyway. So - acceptable wart.
686
779
        result = self.open_workingtree()
687
780
        if revision_id is not None:
688
 
            result.set_last_revision(revision_id)
 
781
            if revision_id == _mod_revision.NULL_REVISION:
 
782
                result.set_parent_ids([])
 
783
            else:
 
784
                result.set_parent_ids([revision_id])
689
785
        return result
690
786
 
 
787
    def destroy_workingtree(self):
 
788
        """See BzrDir.destroy_workingtree."""
 
789
        raise errors.UnsupportedOperation(self.destroy_workingtree, self)
 
790
 
 
791
    def destroy_workingtree_metadata(self):
 
792
        """See BzrDir.destroy_workingtree_metadata."""
 
793
        raise errors.UnsupportedOperation(self.destroy_workingtree_metadata, 
 
794
                                          self)
 
795
 
691
796
    def get_branch_transport(self, branch_format):
692
797
        """See BzrDir.get_branch_transport()."""
693
798
        if branch_format is None:
733
838
        self._check_supported(format, unsupported)
734
839
        return format.open(self, _found=True)
735
840
 
736
 
    def sprout(self, url, revision_id=None, basis=None):
 
841
    def sprout(self, url, revision_id=None, basis=None, force_new_repo=False):
737
842
        """See BzrDir.sprout()."""
738
843
        from bzrlib.workingtree import WorkingTreeFormat2
739
844
        self._make_tail(url)
833
938
        from bzrlib.workingtree import WorkingTreeFormat
834
939
        return WorkingTreeFormat.get_default_format().initialize(self, revision_id)
835
940
 
 
941
    def destroy_workingtree(self):
 
942
        """See BzrDir.destroy_workingtree."""
 
943
        wt = self.open_workingtree()
 
944
        repository = wt.branch.repository
 
945
        empty = repository.revision_tree(_mod_revision.NULL_REVISION)
 
946
        wt.revert([], old_tree=empty)
 
947
        self.destroy_workingtree_metadata()
 
948
 
 
949
    def destroy_workingtree_metadata(self):
 
950
        self.transport.delete_tree('checkout')
 
951
 
836
952
    def _get_mkdir_mode(self):
837
953
        """Figure out the mode to use when creating a bzrdir subdir."""
838
 
        temp_control = LockableFiles(self.transport, '', TransportLock)
 
954
        temp_control = lockable_files.LockableFiles(self.transport, '',
 
955
                                     lockable_files.TransportLock)
839
956
        return temp_control._dir_mode
840
957
 
841
958
    def get_branch_transport(self, branch_format):
1017
1134
        """Initialize a new bzrdir in the base directory of a Transport."""
1018
1135
        # Since we don't have a .bzr directory, inherit the
1019
1136
        # mode from the root directory
1020
 
        temp_control = LockableFiles(transport, '', TransportLock)
 
1137
        temp_control = lockable_files.LockableFiles(transport,
 
1138
                            '', lockable_files.TransportLock)
1021
1139
        temp_control._transport.mkdir('.bzr',
1022
1140
                                      # FIXME: RBC 20060121 don't peek under
1023
1141
                                      # the covers
1032
1150
                      ('branch-format', self.get_format_string()),
1033
1151
                      ]
1034
1152
        # NB: no need to escape relative paths that are url safe.
1035
 
        control_files = LockableFiles(control, self._lock_file_name, 
1036
 
                                      self._lock_class)
 
1153
        control_files = lockable_files.LockableFiles(control,
 
1154
                            self._lock_file_name, self._lock_class)
1037
1155
        control_files.create_lock()
1038
1156
        control_files.lock_write()
1039
1157
        try:
1052
1170
        """
1053
1171
        return True
1054
1172
 
 
1173
    def same_model(self, target_format):
 
1174
        return (self.repository_format.rich_root_data == 
 
1175
            target_format.rich_root_data)
 
1176
 
1055
1177
    @classmethod
1056
1178
    def known_formats(klass):
1057
1179
        """Return all the known formats.
1077
1199
        _found is a private parameter, do not use it.
1078
1200
        """
1079
1201
        if not _found:
1080
 
            assert isinstance(BzrDirFormat.find_format(transport),
1081
 
                              self.__class__)
 
1202
            found_format = BzrDirFormat.find_format(transport)
 
1203
            if not isinstance(found_format, self.__class__):
 
1204
                raise AssertionError("%s was asked to open %s, but it seems to need "
 
1205
                        "format %s" 
 
1206
                        % (self, transport, found_format))
1082
1207
        return self._open(transport)
1083
1208
 
1084
1209
    def _open(self, transport):
1105
1230
        klass._control_formats.append(format)
1106
1231
 
1107
1232
    @classmethod
 
1233
    @symbol_versioning.deprecated_method(symbol_versioning.zero_fourteen)
1108
1234
    def set_default_format(klass, format):
 
1235
        klass._set_default_format(format)
 
1236
 
 
1237
    @classmethod
 
1238
    def _set_default_format(klass, format):
 
1239
        """Set default format (for testing behavior of defaults only)"""
1109
1240
        klass._default_format = format
1110
1241
 
1111
1242
    def __str__(self):
1138
1269
    removed in format 5; write support for this format has been removed.
1139
1270
    """
1140
1271
 
1141
 
    _lock_class = TransportLock
 
1272
    _lock_class = lockable_files.TransportLock
1142
1273
 
1143
1274
    def get_format_string(self):
1144
1275
        """See BzrDirFormat.get_format_string()."""
1173
1304
    def __return_repository_format(self):
1174
1305
        """Circular import protection."""
1175
1306
        from bzrlib.repository import RepositoryFormat4
1176
 
        return RepositoryFormat4(self)
 
1307
        return RepositoryFormat4()
1177
1308
    repository_format = property(__return_repository_format)
1178
1309
 
1179
1310
 
1188
1319
       Unhashed stores in the repository.
1189
1320
    """
1190
1321
 
1191
 
    _lock_class = TransportLock
 
1322
    _lock_class = lockable_files.TransportLock
1192
1323
 
1193
1324
    def get_format_string(self):
1194
1325
        """See BzrDirFormat.get_format_string()."""
1217
1348
        result = (super(BzrDirFormat5, self).initialize_on_transport(transport))
1218
1349
        RepositoryFormat5().initialize(result, _internal=True)
1219
1350
        if not _cloning:
1220
 
            BzrBranchFormat4().initialize(result)
1221
 
            WorkingTreeFormat2().initialize(result)
 
1351
            branch = BzrBranchFormat4().initialize(result)
 
1352
            try:
 
1353
                WorkingTreeFormat2().initialize(result)
 
1354
            except errors.NotLocalUrl:
 
1355
                # Even though we can't access the working tree, we need to
 
1356
                # create its control files.
 
1357
                WorkingTreeFormat2().stub_initialize_remote(branch.control_files)
1222
1358
        return result
1223
1359
 
1224
1360
    def _open(self, transport):
1228
1364
    def __return_repository_format(self):
1229
1365
        """Circular import protection."""
1230
1366
        from bzrlib.repository import RepositoryFormat5
1231
 
        return RepositoryFormat5(self)
 
1367
        return RepositoryFormat5()
1232
1368
    repository_format = property(__return_repository_format)
1233
1369
 
1234
1370
 
1242
1378
     - Format 6 repositories [always]
1243
1379
    """
1244
1380
 
1245
 
    _lock_class = TransportLock
 
1381
    _lock_class = lockable_files.TransportLock
1246
1382
 
1247
1383
    def get_format_string(self):
1248
1384
        """See BzrDirFormat.get_format_string()."""
1271
1407
        result = super(BzrDirFormat6, self).initialize_on_transport(transport)
1272
1408
        RepositoryFormat6().initialize(result, _internal=True)
1273
1409
        if not _cloning:
1274
 
            BzrBranchFormat4().initialize(result)
 
1410
            branch = BzrBranchFormat4().initialize(result)
1275
1411
            try:
1276
1412
                WorkingTreeFormat2().initialize(result)
1277
1413
            except errors.NotLocalUrl:
1278
 
                # emulate pre-check behaviour for working tree and silently 
1279
 
                # fail.
1280
 
                pass
 
1414
                # Even though we can't access the working tree, we need to
 
1415
                # create its control files.
 
1416
                WorkingTreeFormat2().stub_initialize_remote(branch.control_files)
1281
1417
        return result
1282
1418
 
1283
1419
    def _open(self, transport):
1287
1423
    def __return_repository_format(self):
1288
1424
        """Circular import protection."""
1289
1425
        from bzrlib.repository import RepositoryFormat6
1290
 
        return RepositoryFormat6(self)
 
1426
        return RepositoryFormat6()
1291
1427
    repository_format = property(__return_repository_format)
1292
1428
 
1293
1429
 
1302
1438
     - Format 7 repositories [optional]
1303
1439
    """
1304
1440
 
1305
 
    _lock_class = LockDir
 
1441
    _lock_class = lockdir.LockDir
1306
1442
 
1307
1443
    def get_converter(self, format=None):
1308
1444
        """See BzrDirFormat.get_converter()."""
1344
1480
BzrDirFormat.register_format(BzrDirFormat6())
1345
1481
__default_format = BzrDirMetaFormat1()
1346
1482
BzrDirFormat.register_format(__default_format)
1347
 
BzrDirFormat.set_default_format(__default_format)
 
1483
BzrDirFormat._default_format = __default_format
1348
1484
 
1349
1485
 
1350
1486
class BzrDirTestProviderAdapter(object):
1362
1498
        self._formats = formats
1363
1499
    
1364
1500
    def adapt(self, test):
1365
 
        result = TestSuite()
 
1501
        result = unittest.TestSuite()
1366
1502
        for format in self._formats:
1367
1503
            new_test = deepcopy(test)
1368
1504
            new_test.transport_server = self._transport_server
1466
1602
        self.bzrdir.transport.delete_tree('text-store')
1467
1603
 
1468
1604
    def _convert_working_inv(self):
1469
 
        inv = serializer_v4.read_inventory(self.branch.control_files.get('inventory'))
1470
 
        new_inv_xml = bzrlib.xml5.serializer_v5.write_inventory_to_string(inv)
 
1605
        inv = xml4.serializer_v4.read_inventory(
 
1606
                    self.branch.control_files.get('inventory'))
 
1607
        new_inv_xml = xml5.serializer_v5.write_inventory_to_string(inv)
1471
1608
        # FIXME inventory is a working tree change.
1472
 
        self.branch.control_files.put('inventory', new_inv_xml)
 
1609
        self.branch.control_files.put('inventory', StringIO(new_inv_xml))
1473
1610
 
1474
1611
    def _write_all_weaves(self):
1475
1612
        controlweaves = WeaveStore(self.bzrdir.transport, prefixed=False)
1499
1636
                                                      prefixed=False,
1500
1637
                                                      compressed=True))
1501
1638
        try:
1502
 
            transaction = bzrlib.transactions.WriteTransaction()
 
1639
            transaction = WriteTransaction()
1503
1640
            for i, rev_id in enumerate(self.converted_revs):
1504
1641
                self.pb.update('write revision', i, len(self.converted_revs))
1505
1642
                _revision_store.add_revision(self.revisions[rev_id], transaction)
1531
1668
    def _load_old_inventory(self, rev_id):
1532
1669
        assert rev_id not in self.converted_revs
1533
1670
        old_inv_xml = self.branch.repository.inventory_store.get(rev_id).read()
1534
 
        inv = serializer_v4.read_inventory_from_string(old_inv_xml)
 
1671
        inv = xml4.serializer_v4.read_inventory_from_string(old_inv_xml)
 
1672
        inv.revision_id = rev_id
1535
1673
        rev = self.revisions[rev_id]
1536
1674
        if rev.inventory_sha1:
1537
1675
            assert rev.inventory_sha1 == sha_string(old_inv_xml), \
1541
1679
    def _load_updated_inventory(self, rev_id):
1542
1680
        assert rev_id in self.converted_revs
1543
1681
        inv_xml = self.inv_weave.get_text(rev_id)
1544
 
        inv = bzrlib.xml5.serializer_v5.read_inventory_from_string(inv_xml)
 
1682
        inv = xml5.serializer_v5.read_inventory_from_string(inv_xml)
1545
1683
        return inv
1546
1684
 
1547
1685
    def _convert_one_rev(self, rev_id):
1557
1695
    def _store_new_weave(self, rev, inv, present_parents):
1558
1696
        # the XML is now updated with text versions
1559
1697
        if __debug__:
1560
 
            for file_id in inv:
1561
 
                ie = inv[file_id]
1562
 
                if ie.kind == 'root_directory':
1563
 
                    continue
1564
 
                assert hasattr(ie, 'revision'), \
 
1698
            entries = inv.iter_entries()
 
1699
            entries.next()
 
1700
            for path, ie in entries:
 
1701
                assert getattr(ie, 'revision', None) is not None, \
1565
1702
                    'no revision on {%s} in {%s}' % \
1566
1703
                    (file_id, rev.revision_id)
1567
 
        new_inv_xml = bzrlib.xml5.serializer_v5.write_inventory_to_string(inv)
 
1704
        new_inv_xml = xml5.serializer_v5.write_inventory_to_string(inv)
1568
1705
        new_inv_sha1 = sha_string(new_inv_xml)
1569
1706
        self.inv_weave.add_lines(rev.revision_id, 
1570
1707
                                 present_parents,
1579
1716
        mutter('converting texts of revision {%s}',
1580
1717
               rev_id)
1581
1718
        parent_invs = map(self._load_updated_inventory, present_parents)
1582
 
        for file_id in inv:
1583
 
            ie = inv[file_id]
 
1719
        entries = inv.iter_entries()
 
1720
        entries.next()
 
1721
        for path, ie in entries:
1584
1722
            self._convert_file_version(rev, ie, parent_invs)
1585
1723
 
1586
1724
    def _convert_file_version(self, rev, ie, parent_invs):
1589
1727
        The file needs to be added into the weave if it is a merge
1590
1728
        of >=2 parents or if it's changed from its parent.
1591
1729
        """
1592
 
        if ie.kind == 'root_directory':
1593
 
            return
1594
1730
        file_id = ie.file_id
1595
1731
        rev_id = rev.revision_id
1596
1732
        w = self.text_weaves.get(file_id)
1604
1740
                                                  entry_vf=w)
1605
1741
        for old_revision in previous_entries:
1606
1742
                # if this fails, its a ghost ?
1607
 
                assert old_revision in self.converted_revs 
 
1743
                assert old_revision in self.converted_revs, \
 
1744
                    "Revision {%s} not in converted_revs" % old_revision
1608
1745
        self.snapshot_ie(previous_entries, ie, w, rev_id)
1609
1746
        del ie.text_id
1610
1747
        assert getattr(ie, 'revision', None) is not None
1697
1834
 
1698
1835
    def convert(self, to_convert, pb):
1699
1836
        """See Converter.convert()."""
 
1837
        from bzrlib.branch import BzrBranchFormat5
1700
1838
        self.bzrdir = to_convert
1701
1839
        self.pb = pb
1702
1840
        self.count = 0
1731
1869
        # we hard code the formats here because we are converting into
1732
1870
        # the meta format. The meta format upgrader can take this to a 
1733
1871
        # future format within each component.
1734
 
        self.put_format('repository', bzrlib.repository.RepositoryFormat7())
 
1872
        self.put_format('repository', _mod_repository.RepositoryFormat7())
1735
1873
        for entry in repository_names:
1736
1874
            self.move_entry('repository', entry)
1737
1875
 
1738
1876
        self.step('Upgrading branch      ')
1739
1877
        self.bzrdir.transport.mkdir('branch', mode=self.dir_mode)
1740
1878
        self.make_lock('branch')
1741
 
        self.put_format('branch', bzrlib.branch.BzrBranchFormat5())
 
1879
        self.put_format('branch', BzrBranchFormat5())
1742
1880
        branch_files = [('revision-history', True),
1743
1881
                        ('branch-name', True),
1744
1882
                        ('parent', False)]
1745
1883
        for entry in branch_files:
1746
1884
            self.move_entry('branch', entry)
1747
1885
 
1748
 
        self.step('Upgrading working tree')
1749
 
        self.bzrdir.transport.mkdir('checkout', mode=self.dir_mode)
1750
 
        self.make_lock('checkout')
1751
 
        self.put_format('checkout', bzrlib.workingtree.WorkingTreeFormat3())
1752
 
        self.bzrdir.transport.delete_multi(self.garbage_inventories, self.pb)
1753
1886
        checkout_files = [('pending-merges', True),
1754
1887
                          ('inventory', True),
1755
1888
                          ('stat-cache', False)]
1756
 
        for entry in checkout_files:
1757
 
            self.move_entry('checkout', entry)
1758
 
        if last_revision is not None:
1759
 
            self.bzrdir._control_files.put_utf8('checkout/last-revision',
1760
 
                                                last_revision)
1761
 
        self.bzrdir._control_files.put_utf8('branch-format', BzrDirMetaFormat1().get_format_string())
 
1889
        # If a mandatory checkout file is not present, the branch does not have
 
1890
        # a functional checkout. Do not create a checkout in the converted
 
1891
        # branch.
 
1892
        for name, mandatory in checkout_files:
 
1893
            if mandatory and name not in bzrcontents:
 
1894
                has_checkout = False
 
1895
                break
 
1896
        else:
 
1897
            has_checkout = True
 
1898
        if not has_checkout:
 
1899
            self.pb.note('No working tree.')
 
1900
            # If some checkout files are there, we may as well get rid of them.
 
1901
            for name, mandatory in checkout_files:
 
1902
                if name in bzrcontents:
 
1903
                    self.bzrdir.transport.delete(name)
 
1904
        else:
 
1905
            from bzrlib.workingtree import WorkingTreeFormat3
 
1906
            self.step('Upgrading working tree')
 
1907
            self.bzrdir.transport.mkdir('checkout', mode=self.dir_mode)
 
1908
            self.make_lock('checkout')
 
1909
            self.put_format(
 
1910
                'checkout', WorkingTreeFormat3())
 
1911
            self.bzrdir.transport.delete_multi(
 
1912
                self.garbage_inventories, self.pb)
 
1913
            for entry in checkout_files:
 
1914
                self.move_entry('checkout', entry)
 
1915
            if last_revision is not None:
 
1916
                self.bzrdir._control_files.put_utf8(
 
1917
                    'checkout/last-revision', last_revision)
 
1918
        self.bzrdir._control_files.put_utf8(
 
1919
            'branch-format', BzrDirMetaFormat1().get_format_string())
1762
1920
        return BzrDir.open(self.bzrdir.root_transport.base)
1763
1921
 
1764
1922
    def make_lock(self, name):
1765
1923
        """Make a lock for the new control dir name."""
1766
1924
        self.step('Make %s lock' % name)
1767
 
        ld = LockDir(self.bzrdir.transport, 
1768
 
                     '%s/lock' % name,
1769
 
                     file_modebits=self.file_mode,
1770
 
                     dir_modebits=self.dir_mode)
 
1925
        ld = lockdir.LockDir(self.bzrdir.transport,
 
1926
                             '%s/lock' % name,
 
1927
                             file_modebits=self.file_mode,
 
1928
                             dir_modebits=self.dir_mode)
1771
1929
        ld.create()
1772
1930
 
1773
1931
    def move_entry(self, new_dir, entry):
1813
1971
                converter = CopyConverter(self.target_format.repository_format)
1814
1972
                converter.convert(repo, pb)
1815
1973
        return to_convert
 
1974
 
 
1975
 
 
1976
class BzrDirFormatInfo(object):
 
1977
 
 
1978
    def __init__(self, native, deprecated):
 
1979
        self.deprecated = deprecated
 
1980
        self.native = native
 
1981
 
 
1982
 
 
1983
class BzrDirFormatRegistry(registry.Registry):
 
1984
    """Registry of user-selectable BzrDir subformats.
 
1985
    
 
1986
    Differs from BzrDirFormat._control_formats in that it provides sub-formats,
 
1987
    e.g. BzrDirMeta1 with weave repository.  Also, it's more user-oriented.
 
1988
    """
 
1989
 
 
1990
    def register_metadir(self, key, repo, help, native=True, deprecated=False):
 
1991
        """Register a metadir subformat.
 
1992
        
 
1993
        repo is the repository format name as a string.
 
1994
        """
 
1995
        # This should be expanded to support setting WorkingTree and Branch
 
1996
        # formats, once BzrDirMetaFormat1 supports that.
 
1997
        def helper():
 
1998
            import bzrlib.repository
 
1999
            repo_format = getattr(bzrlib.repository, repo)
 
2000
            bd = BzrDirMetaFormat1()
 
2001
            bd.repository_format = repo_format()
 
2002
            return bd
 
2003
        self.register(key, helper, help, native, deprecated)
 
2004
 
 
2005
    def register(self, key, factory, help, native=True, deprecated=False):
 
2006
        """Register a BzrDirFormat factory.
 
2007
        
 
2008
        The factory must be a callable that takes one parameter: the key.
 
2009
        It must produce an instance of the BzrDirFormat when called.
 
2010
 
 
2011
        This function mainly exists to prevent the info object from being
 
2012
        supplied directly.
 
2013
        """
 
2014
        registry.Registry.register(self, key, factory, help, 
 
2015
            BzrDirFormatInfo(native, deprecated))
 
2016
 
 
2017
    def register_lazy(self, key, module_name, member_name, help, native=True,
 
2018
                      deprecated=False):
 
2019
        registry.Registry.register_lazy(self, key, module_name, member_name, 
 
2020
            help, BzrDirFormatInfo(native, deprecated))
 
2021
 
 
2022
    def set_default(self, key):
 
2023
        """Set the 'default' key to be a clone of the supplied key.
 
2024
        
 
2025
        This method must be called once and only once.
 
2026
        """
 
2027
        registry.Registry.register(self, 'default', self.get(key), 
 
2028
            self.get_help(key), info=self.get_info(key))
 
2029
 
 
2030
    def set_default_repository(self, key):
 
2031
        """Set the FormatRegistry default and Repository default.
 
2032
        
 
2033
        This is a transitional method while Repository.set_default_format
 
2034
        is deprecated.
 
2035
        """
 
2036
        if 'default' in self:
 
2037
            self.remove('default')
 
2038
        self.set_default(key)
 
2039
        format = self.get('default')()
 
2040
        assert isinstance(format, BzrDirMetaFormat1)
 
2041
        from bzrlib import repository
 
2042
        repository.RepositoryFormat._set_default_format(
 
2043
            format.repository_format)
 
2044
 
 
2045
    def make_bzrdir(self, key):
 
2046
        return self.get(key)()
 
2047
 
 
2048
    def help_topic(self, topic):
 
2049
        output = textwrap.dedent("""\
 
2050
            Bazaar directory formats
 
2051
            ------------------------
 
2052
 
 
2053
            These formats can be used for creating branches, working trees, and
 
2054
            repositories.
 
2055
 
 
2056
            """)
 
2057
        default_help = self.get_help('default')
 
2058
        help_pairs = []
 
2059
        for key in self.keys():
 
2060
            if key == 'default':
 
2061
                continue
 
2062
            help = self.get_help(key)
 
2063
            if help == default_help:
 
2064
                default_realkey = key
 
2065
            else:
 
2066
                help_pairs.append((key, help))
 
2067
 
 
2068
        def wrapped(key, help, info):
 
2069
            if info.native:
 
2070
                help = '(native) ' + help
 
2071
            return '  %s:\n%s\n\n' % (key, 
 
2072
                    textwrap.fill(help, initial_indent='    ', 
 
2073
                    subsequent_indent='    '))
 
2074
        output += wrapped('%s/default' % default_realkey, default_help,
 
2075
                          self.get_info('default'))
 
2076
        deprecated_pairs = []
 
2077
        for key, help in help_pairs:
 
2078
            info = self.get_info(key)
 
2079
            if info.deprecated:
 
2080
                deprecated_pairs.append((key, help))
 
2081
            else:
 
2082
                output += wrapped(key, help, info)
 
2083
        if len(deprecated_pairs) > 0:
 
2084
            output += "Deprecated formats\n------------------\n\n"
 
2085
            for key, help in deprecated_pairs:
 
2086
                info = self.get_info(key)
 
2087
                output += wrapped(key, help, info)
 
2088
 
 
2089
        return output
 
2090
 
 
2091
 
 
2092
format_registry = BzrDirFormatRegistry()
 
2093
format_registry.register('weave', BzrDirFormat6,
 
2094
    'Pre-0.8 format.  Slower than knit and does not'
 
2095
    ' support checkouts or shared repositories.', deprecated=True)
 
2096
format_registry.register_metadir('knit', 'RepositoryFormatKnit1',
 
2097
    'Format using knits.  Recommended.')
 
2098
format_registry.set_default('knit')
 
2099
format_registry.register_metadir('metaweave', 'RepositoryFormat7',
 
2100
    'Transitional format in 0.8.  Slower than knit.',
 
2101
    deprecated=True)
 
2102
format_registry.register_metadir('experimental-knit2', 'RepositoryFormatKnit2',
 
2103
    'Experimental successor to knit.  Use at your own risk.')