← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/bzrdir.py

  • Committer: Vincent Ladeuil
  • Date: 2007-07-15 11:24:18 UTC
  • mfrom: (2617 +trunk)
  • mto: This revision was merged to the branch mainline in revision 2646.
  • Revision ID: v.ladeuil+lp@free.fr-20070715112418-9nn4n6esxv60ny4b
merge bzr.dev@1617

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/bzrdir.py
1
 
# Copyright (C) 2005, 2006 Canonical Ltd
2
 
 
 
1
# Copyright (C) 2005, 2006, 2007 Canonical Ltd
 
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
5
5
# the Free Software Foundation; either version 2 of the License, or
6
6
# (at your option) any later version.
7
 
 
 
7
#
8
8
# This program is distributed in the hope that it will be useful,
9
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
11
11
# GNU General Public License for more details.
12
 
 
 
12
#
13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
20
20
directories.
21
21
"""
22
22
 
23
 
# TODO: remove unittest dependency; put that stuff inside the test suite
 
23
# TODO: Can we move specific formats into separate modules to make this file
 
24
# smaller?
24
25
 
25
 
from copy import deepcopy
26
26
from cStringIO import StringIO
27
27
import os
 
28
import textwrap
 
29
 
 
30
from bzrlib.lazy_import import lazy_import
 
31
lazy_import(globals(), """
28
32
from stat import S_ISDIR
29
 
from unittest import TestSuite
30
33
 
31
34
import bzrlib
32
 
import bzrlib.errors as errors
33
 
from bzrlib.lockable_files import LockableFiles, TransportLock
34
 
from bzrlib.lockdir import LockDir
 
35
from bzrlib import (
 
36
    errors,
 
37
    lockable_files,
 
38
    lockdir,
 
39
    registry,
 
40
    remote,
 
41
    revision as _mod_revision,
 
42
    symbol_versioning,
 
43
    ui,
 
44
    urlutils,
 
45
    xml4,
 
46
    xml5,
 
47
    workingtree,
 
48
    workingtree_4,
 
49
    )
35
50
from bzrlib.osutils import (
36
 
                            abspath,
37
 
                            pathjoin,
38
 
                            safe_unicode,
39
 
                            sha_strings,
40
 
                            sha_string,
41
 
                            )
 
51
    sha_strings,
 
52
    sha_string,
 
53
    )
 
54
from bzrlib.smart.client import _SmartClient
 
55
from bzrlib.smart import protocol
42
56
from bzrlib.store.revision.text import TextRevisionStore
43
57
from bzrlib.store.text import TextStore
44
58
from bzrlib.store.versioned import WeaveStore
45
 
from bzrlib.trace import mutter
46
59
from bzrlib.transactions import WriteTransaction
47
 
from bzrlib.transport import get_transport
 
60
from bzrlib.transport import (
 
61
    do_catching_redirections,
 
62
    get_transport,
 
63
    )
 
64
from bzrlib.weave import Weave
 
65
""")
 
66
 
 
67
from bzrlib.trace import (
 
68
    mutter,
 
69
    note,
 
70
    )
48
71
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
72
 
54
73
 
55
74
class BzrDir(object):
70
89
        If there is a tree, the tree is opened and break_lock() called.
71
90
        Otherwise, branch is tried, and finally repository.
72
91
        """
 
92
        # XXX: This seems more like a UI function than something that really
 
93
        # belongs in this class.
73
94
        try:
74
95
            thing_to_unlock = self.open_workingtree()
75
96
        except (errors.NotLocalUrl, errors.NoWorkingTree):
86
107
        """Return true if this bzrdir is one whose format we can convert from."""
87
108
        return True
88
109
 
 
110
    def check_conversion_target(self, target_format):
 
111
        target_repo_format = target_format.repository_format
 
112
        source_repo_format = self._format.repository_format
 
113
        source_repo_format.check_conversion_target(target_repo_format)
 
114
 
89
115
    @staticmethod
90
 
    def _check_supported(format, allow_unsupported):
91
 
        """Check whether format is a supported format.
92
 
 
93
 
        If allow_unsupported is True, this is a no-op.
 
116
    def _check_supported(format, allow_unsupported,
 
117
        recommend_upgrade=True,
 
118
        basedir=None):
 
119
        """Give an error or warning on old formats.
 
120
 
 
121
        :param format: may be any kind of format - workingtree, branch, 
 
122
        or repository.
 
123
 
 
124
        :param allow_unsupported: If true, allow opening 
 
125
        formats that are strongly deprecated, and which may 
 
126
        have limited functionality.
 
127
 
 
128
        :param recommend_upgrade: If true (default), warn
 
129
        the user through the ui object that they may wish
 
130
        to upgrade the object.
94
131
        """
 
132
        # TODO: perhaps move this into a base Format class; it's not BzrDir
 
133
        # specific. mbp 20070323
95
134
        if not allow_unsupported and not format.is_supported():
96
135
            # see open_downlevel to open legacy branches.
97
136
            raise errors.UnsupportedFormatError(format=format)
 
137
        if recommend_upgrade \
 
138
            and getattr(format, 'upgrade_recommended', False):
 
139
            ui.ui_factory.recommend_upgrade(
 
140
                format.get_format_description(),
 
141
                basedir)
98
142
 
99
 
    def clone(self, url, revision_id=None, basis=None, force_new_repo=False):
 
143
    def clone(self, url, revision_id=None, force_new_repo=False):
100
144
        """Clone this bzrdir and its contents to url verbatim.
101
145
 
102
146
        If urls last component does not exist, it will be created.
106
150
        :param force_new_repo: Do not use a shared repository for the target 
107
151
                               even if one is available.
108
152
        """
109
 
        self._make_tail(url)
110
 
        basis_repo, basis_branch, basis_tree = self._get_basis_components(basis)
111
 
        result = self._format.initialize(url)
 
153
        return self.clone_on_transport(get_transport(url),
 
154
                                       revision_id=revision_id,
 
155
                                       force_new_repo=force_new_repo)
 
156
 
 
157
    def clone_on_transport(self, transport, revision_id=None,
 
158
                           force_new_repo=False):
 
159
        """Clone this bzrdir and its contents to transport verbatim.
 
160
 
 
161
        If the target directory does not exist, it will be created.
 
162
 
 
163
        if revision_id is not None, then the clone operation may tune
 
164
            itself to download less data.
 
165
        :param force_new_repo: Do not use a shared repository for the target 
 
166
                               even if one is available.
 
167
        """
 
168
        transport.ensure_base()
 
169
        result = self._format.initialize_on_transport(transport)
112
170
        try:
113
171
            local_repo = self.find_repository()
114
172
        except errors.NoRepositoryPresent:
118
176
            if force_new_repo:
119
177
                result_repo = local_repo.clone(
120
178
                    result,
121
 
                    revision_id=revision_id,
122
 
                    basis=basis_repo)
 
179
                    revision_id=revision_id)
123
180
                result_repo.set_make_working_trees(local_repo.make_working_trees())
124
181
            else:
125
182
                try:
126
183
                    result_repo = result.find_repository()
127
184
                    # fetch content this dir needs.
128
 
                    if basis_repo:
129
 
                        # XXX FIXME RBC 20060214 need tests for this when the basis
130
 
                        # is incomplete
131
 
                        result_repo.fetch(basis_repo, revision_id=revision_id)
132
185
                    result_repo.fetch(local_repo, revision_id=revision_id)
133
186
                except errors.NoRepositoryPresent:
134
187
                    # needed to make one anyway.
135
188
                    result_repo = local_repo.clone(
136
189
                        result,
137
 
                        revision_id=revision_id,
138
 
                        basis=basis_repo)
 
190
                        revision_id=revision_id)
139
191
                    result_repo.set_make_working_trees(local_repo.make_working_trees())
140
192
        # 1 if there is a branch present
141
193
        #   make sure its content is available in the target repository
145
197
        except errors.NotBranchError:
146
198
            pass
147
199
        try:
148
 
            self.open_workingtree().clone(result, basis=basis_tree)
 
200
            self.open_workingtree().clone(result)
149
201
        except (errors.NoWorkingTree, errors.NotLocalUrl):
150
202
            pass
151
203
        return result
152
204
 
153
 
    def _get_basis_components(self, basis):
154
 
        """Retrieve the basis components that are available at basis."""
155
 
        if basis is None:
156
 
            return None, None, None
157
 
        try:
158
 
            basis_tree = basis.open_workingtree()
159
 
            basis_branch = basis_tree.branch
160
 
            basis_repo = basis_branch.repository
161
 
        except (errors.NoWorkingTree, errors.NotLocalUrl):
162
 
            basis_tree = None
163
 
            try:
164
 
                basis_branch = basis.open_branch()
165
 
                basis_repo = basis_branch.repository
166
 
            except errors.NotBranchError:
167
 
                basis_branch = None
168
 
                try:
169
 
                    basis_repo = basis.open_repository()
170
 
                except errors.NoRepositoryPresent:
171
 
                    basis_repo = None
172
 
        return basis_repo, basis_branch, basis_tree
173
 
 
174
205
    # TODO: This should be given a Transport, and should chdir up; otherwise
175
206
    # this will open a new connection.
176
207
    def _make_tail(self, url):
177
 
        head, tail = urlutils.split(url)
178
 
        if tail and tail != '.':
179
 
            t = bzrlib.transport.get_transport(head)
180
 
            try:
181
 
                t.mkdir(tail)
182
 
            except errors.FileExists:
183
 
                pass
 
208
        t = get_transport(url)
 
209
        t.ensure_base()
184
210
 
185
 
    # TODO: Should take a Transport
186
211
    @classmethod
187
 
    def create(cls, base):
 
212
    def create(cls, base, format=None, possible_transports=None):
188
213
        """Create a new BzrDir at the url 'base'.
189
214
        
190
215
        This will call the current default formats initialize with base
191
216
        as the only parameter.
192
217
 
193
 
        If you need a specific format, consider creating an instance
194
 
        of that and calling initialize().
 
218
        :param format: If supplied, the format of branch to create.  If not
 
219
            supplied, the default is used.
 
220
        :param possible_transports: If supplied, a list of transports that 
 
221
            can be reused to share a remote connection.
195
222
        """
196
223
        if cls is not BzrDir:
197
 
            raise AssertionError("BzrDir.create always creates the default format, "
198
 
                    "not one of %r" % cls)
199
 
        head, tail = urlutils.split(base)
200
 
        if tail and tail != '.':
201
 
            t = bzrlib.transport.get_transport(head)
202
 
            try:
203
 
                t.mkdir(tail)
204
 
            except errors.FileExists:
205
 
                pass
206
 
        return BzrDirFormat.get_default_format().initialize(safe_unicode(base))
 
224
            raise AssertionError("BzrDir.create always creates the default"
 
225
                " format, not one of %r" % cls)
 
226
        t = get_transport(base, possible_transports)
 
227
        t.ensure_base()
 
228
        if format is None:
 
229
            format = BzrDirFormat.get_default_format()
 
230
        return format.initialize(base, possible_transports)
207
231
 
208
232
    def create_branch(self):
209
233
        """Create a branch in this BzrDir.
214
238
        raise NotImplementedError(self.create_branch)
215
239
 
216
240
    @staticmethod
217
 
    def create_branch_and_repo(base, force_new_repo=False):
 
241
    def create_branch_and_repo(base, force_new_repo=False, format=None):
218
242
        """Create a new BzrDir, Branch and Repository at the url 'base'.
219
243
 
220
244
        This will use the current default BzrDirFormat, and use whatever 
227
251
        :param base: The URL to create the branch at.
228
252
        :param force_new_repo: If True a new repository is always created.
229
253
        """
230
 
        bzrdir = BzrDir.create(base)
 
254
        bzrdir = BzrDir.create(base, format)
231
255
        bzrdir._find_or_create_repository(force_new_repo)
232
256
        return bzrdir.create_branch()
233
257
 
242
266
        
243
267
    @staticmethod
244
268
    def create_branch_convenience(base, force_new_repo=False,
245
 
                                  force_new_tree=None, format=None):
 
269
                                  force_new_tree=None, format=None,
 
270
                                  possible_transports=None):
246
271
        """Create a new BzrDir, Branch and Repository at the url 'base'.
247
272
 
248
273
        This is a convenience function - it will use an existing repository
264
289
        :param force_new_repo: If True a new repository is always created.
265
290
        :param force_new_tree: If True or False force creation of a tree or 
266
291
                               prevent such creation respectively.
267
 
        :param format: Override for the for the bzrdir format to create
 
292
        :param format: Override for the for the bzrdir format to create.
 
293
        :param possible_transports: An optional reusable transports list.
268
294
        """
269
295
        if force_new_tree:
270
296
            # check for non local urls
271
 
            t = get_transport(safe_unicode(base))
 
297
            t = get_transport(base, possible_transports)
272
298
            if not isinstance(t, LocalTransport):
273
299
                raise errors.NotLocalUrl(base)
274
 
        if format is None:
275
 
            bzrdir = BzrDir.create(base)
276
 
        else:
277
 
            bzrdir = format.initialize(base)
 
300
        bzrdir = BzrDir.create(base, format, possible_transports)
278
301
        repo = bzrdir._find_or_create_repository(force_new_repo)
279
302
        result = bzrdir.create_branch()
280
 
        if force_new_tree or (repo.make_working_trees() and 
 
303
        if force_new_tree or (repo.make_working_trees() and
281
304
                              force_new_tree is None):
282
305
            try:
283
306
                bzrdir.create_workingtree()
284
307
            except errors.NotLocalUrl:
285
308
                pass
286
309
        return result
287
 
        
 
310
 
288
311
    @staticmethod
289
 
    def create_repository(base, shared=False):
 
312
    def create_repository(base, shared=False, format=None):
290
313
        """Create a new BzrDir and Repository at the url 'base'.
291
314
 
292
 
        This will use the current default BzrDirFormat, and use whatever 
293
 
        repository format that that uses for bzrdirformat.create_repository.
 
315
        If no format is supplied, this will default to the current default
 
316
        BzrDirFormat by default, and use whatever repository format that that
 
317
        uses for bzrdirformat.create_repository.
294
318
 
295
 
        ;param shared: Create a shared repository rather than a standalone
 
319
        :param shared: Create a shared repository rather than a standalone
296
320
                       repository.
297
321
        The Repository object is returned.
298
322
 
300
324
        it should take no parameters and construct whatever repository format
301
325
        that child class desires.
302
326
        """
303
 
        bzrdir = BzrDir.create(base)
 
327
        bzrdir = BzrDir.create(base, format)
304
328
        return bzrdir.create_repository(shared)
305
329
 
306
330
    @staticmethod
307
 
    def create_standalone_workingtree(base):
 
331
    def create_standalone_workingtree(base, format=None):
308
332
        """Create a new BzrDir, WorkingTree, Branch and Repository at 'base'.
309
333
 
310
334
        'base' must be a local path or a file:// url.
313
337
        repository format that that uses for bzrdirformat.create_workingtree,
314
338
        create_branch and create_repository.
315
339
 
316
 
        The WorkingTree object is returned.
 
340
        :return: The WorkingTree object.
317
341
        """
318
 
        t = get_transport(safe_unicode(base))
 
342
        t = get_transport(base)
319
343
        if not isinstance(t, LocalTransport):
320
344
            raise errors.NotLocalUrl(base)
321
 
        bzrdir = BzrDir.create_branch_and_repo(safe_unicode(base),
322
 
                                               force_new_repo=True).bzrdir
 
345
        bzrdir = BzrDir.create_branch_and_repo(base,
 
346
                                               force_new_repo=True,
 
347
                                               format=format).bzrdir
323
348
        return bzrdir.create_workingtree()
324
349
 
325
350
    def create_workingtree(self, revision_id=None):
329
354
        """
330
355
        raise NotImplementedError(self.create_workingtree)
331
356
 
 
357
    def retire_bzrdir(self):
 
358
        """Permanently disable the bzrdir.
 
359
 
 
360
        This is done by renaming it to give the user some ability to recover
 
361
        if there was a problem.
 
362
 
 
363
        This will have horrible consequences if anyone has anything locked or
 
364
        in use.
 
365
        """
 
366
        for i in xrange(10000):
 
367
            try:
 
368
                to_path = '.bzr.retired.%d' % i
 
369
                self.root_transport.rename('.bzr', to_path)
 
370
                note("renamed %s to %s"
 
371
                    % (self.root_transport.abspath('.bzr'), to_path))
 
372
                break
 
373
            except (errors.TransportError, IOError, errors.PathError):
 
374
                pass
 
375
 
 
376
    def destroy_workingtree(self):
 
377
        """Destroy the working tree at this BzrDir.
 
378
 
 
379
        Formats that do not support this may raise UnsupportedOperation.
 
380
        """
 
381
        raise NotImplementedError(self.destroy_workingtree)
 
382
 
 
383
    def destroy_workingtree_metadata(self):
 
384
        """Destroy the control files for the working tree at this BzrDir.
 
385
 
 
386
        The contents of working tree files are not affected.
 
387
        Formats that do not support this may raise UnsupportedOperation.
 
388
        """
 
389
        raise NotImplementedError(self.destroy_workingtree_metadata)
 
390
 
332
391
    def find_repository(self):
333
392
        """Find the repository that should be used for a_bzrdir.
334
393
 
359
418
                    break
360
419
                else:
361
420
                    continue
362
 
            if ((found_bzrdir.root_transport.base == 
 
421
            if ((found_bzrdir.root_transport.base ==
363
422
                 self.root_transport.base) or repository.is_shared()):
364
423
                return repository
365
424
            else:
366
425
                raise errors.NoRepositoryPresent(self)
367
426
        raise errors.NoRepositoryPresent(self)
368
427
 
 
428
    def get_branch_reference(self):
 
429
        """Return the referenced URL for the branch in this bzrdir.
 
430
 
 
431
        :raises NotBranchError: If there is no Branch.
 
432
        :return: The URL the branch in this bzrdir references if it is a
 
433
            reference branch, or None for regular branches.
 
434
        """
 
435
        return None
 
436
 
369
437
    def get_branch_transport(self, branch_format):
370
438
        """Get the transport for use by branch format in this BzrDir.
371
439
 
396
464
        """Get the transport for use by workingtree format in this BzrDir.
397
465
 
398
466
        Note that bzr dirs that do not support format strings will raise
399
 
        IncompatibleFormat if the workingtree format they are given has
400
 
        a format string, and vice versa.
 
467
        IncompatibleFormat if the workingtree format they are given has a
 
468
        format string, and vice versa.
401
469
 
402
470
        If workingtree_format is None, the transport is returned with no 
403
471
        checking. if it is not None, then the returned transport is
460
528
        _unsupported is a private parameter to the BzrDir class.
461
529
        """
462
530
        t = get_transport(base)
463
 
        mutter("trying to open %r with transport %r", base, t)
464
 
        format = BzrDirFormat.find_format(t)
 
531
        return BzrDir.open_from_transport(t, _unsupported=_unsupported)
 
532
 
 
533
    @staticmethod
 
534
    def open_from_transport(transport, _unsupported=False,
 
535
                            _server_formats=True):
 
536
        """Open a bzrdir within a particular directory.
 
537
 
 
538
        :param transport: Transport containing the bzrdir.
 
539
        :param _unsupported: private.
 
540
        """
 
541
        base = transport.base
 
542
 
 
543
        def find_format(transport):
 
544
            return transport, BzrDirFormat.find_format(
 
545
                transport, _server_formats=_server_formats)
 
546
 
 
547
        def redirected(transport, e, redirection_notice):
 
548
            qualified_source = e.get_source_url()
 
549
            relpath = transport.relpath(qualified_source)
 
550
            if not e.target.endswith(relpath):
 
551
                # Not redirected to a branch-format, not a branch
 
552
                raise errors.NotBranchError(path=e.target)
 
553
            target = e.target[:-len(relpath)]
 
554
            note('%s is%s redirected to %s',
 
555
                 transport.base, e.permanently, target)
 
556
            # Let's try with a new transport
 
557
            qualified_target = e.get_target_url()[:-len(relpath)]
 
558
            # FIXME: If 'transport' has a qualifier, this should
 
559
            # be applied again to the new transport *iff* the
 
560
            # schemes used are the same. It's a bit tricky to
 
561
            # verify, so I'll punt for now
 
562
            # -- vila20070212
 
563
            return get_transport(target)
 
564
 
 
565
        try:
 
566
            transport, format = do_catching_redirections(find_format,
 
567
                                                         transport,
 
568
                                                         redirected)
 
569
        except errors.TooManyRedirections:
 
570
            raise errors.NotBranchError(base)
 
571
 
465
572
        BzrDir._check_supported(format, _unsupported)
466
 
        return format.open(t, _found=True)
 
573
        return format.open(transport, _found=True)
467
574
 
468
575
    def open_branch(self, unsupported=False):
469
576
        """Open the branch object at this BzrDir if one is present.
476
583
        raise NotImplementedError(self.open_branch)
477
584
 
478
585
    @staticmethod
479
 
    def open_containing(url):
 
586
    def open_containing(url, possible_transports=None):
480
587
        """Open an existing branch which contains url.
481
588
        
482
589
        :param url: url to search from.
483
590
        See open_containing_from_transport for more detail.
484
591
        """
485
 
        return BzrDir.open_containing_from_transport(get_transport(url))
 
592
        transport = get_transport(url, possible_transports)
 
593
        return BzrDir.open_containing_from_transport(transport)
486
594
    
487
595
    @staticmethod
488
596
    def open_containing_from_transport(a_transport):
503
611
        url = a_transport.base
504
612
        while True:
505
613
            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))
 
614
                result = BzrDir.open_from_transport(a_transport)
 
615
                return result, urlutils.unescape(a_transport.relpath(url))
509
616
            except errors.NotBranchError, e:
510
 
                ## mutter('not a branch in: %r %s', a_transport.base, e)
511
617
                pass
512
 
            new_t = a_transport.clone('..')
 
618
            try:
 
619
                new_t = a_transport.clone('..')
 
620
            except errors.InvalidURLJoin:
 
621
                # reached the root, whatever that may be
 
622
                raise errors.NotBranchError(path=url)
513
623
            if new_t.base == a_transport.base:
514
624
                # reached the root, whatever that may be
515
625
                raise errors.NotBranchError(path=url)
516
626
            a_transport = new_t
517
627
 
 
628
    @classmethod
 
629
    def open_containing_tree_or_branch(klass, location):
 
630
        """Return the branch and working tree contained by a location.
 
631
 
 
632
        Returns (tree, branch, relpath).
 
633
        If there is no tree at containing the location, tree will be None.
 
634
        If there is no branch containing the location, an exception will be
 
635
        raised
 
636
        relpath is the portion of the path that is contained by the branch.
 
637
        """
 
638
        bzrdir, relpath = klass.open_containing(location)
 
639
        try:
 
640
            tree = bzrdir.open_workingtree()
 
641
        except (errors.NoWorkingTree, errors.NotLocalUrl):
 
642
            tree = None
 
643
            branch = bzrdir.open_branch()
 
644
        else:
 
645
            branch = tree.branch
 
646
        return tree, branch, relpath
 
647
 
518
648
    def open_repository(self, _unsupported=False):
519
649
        """Open the repository object at this BzrDir if one is present.
520
650
 
527
657
        """
528
658
        raise NotImplementedError(self.open_repository)
529
659
 
530
 
    def open_workingtree(self, _unsupported=False):
 
660
    def open_workingtree(self, _unsupported=False,
 
661
            recommend_upgrade=True):
531
662
        """Open the workingtree object at this BzrDir if one is present.
532
 
        
533
 
        TODO: static convenience version of this?
 
663
 
 
664
        :param recommend_upgrade: Optional keyword parameter, when True (the
 
665
            default), emit through the ui module a recommendation that the user
 
666
            upgrade the working tree when the workingtree being opened is old
 
667
            (but still fully supported).
534
668
        """
535
669
        raise NotImplementedError(self.open_workingtree)
536
670
 
558
692
        workingtree and discards it, and that's somewhat expensive.) 
559
693
        """
560
694
        try:
561
 
            self.open_workingtree()
 
695
            self.open_workingtree(recommend_upgrade=False)
562
696
            return True
563
697
        except errors.NoWorkingTree:
564
698
            return False
565
699
 
566
 
    def sprout(self, url, revision_id=None, basis=None, force_new_repo=False):
 
700
    def _cloning_metadir(self):
 
701
        """Produce a metadir suitable for cloning with"""
 
702
        result_format = self._format.__class__()
 
703
        try:
 
704
            try:
 
705
                branch = self.open_branch()
 
706
                source_repository = branch.repository
 
707
            except errors.NotBranchError:
 
708
                source_branch = None
 
709
                source_repository = self.open_repository()
 
710
        except errors.NoRepositoryPresent:
 
711
            source_repository = None
 
712
        else:
 
713
            # XXX TODO: This isinstance is here because we have not implemented
 
714
            # the fix recommended in bug # 103195 - to delegate this choice the
 
715
            # repository itself.
 
716
            repo_format = source_repository._format
 
717
            if not isinstance(repo_format, remote.RemoteRepositoryFormat):
 
718
                result_format.repository_format = repo_format
 
719
        try:
 
720
            # TODO: Couldn't we just probe for the format in these cases,
 
721
            # rather than opening the whole tree?  It would be a little
 
722
            # faster. mbp 20070401
 
723
            tree = self.open_workingtree(recommend_upgrade=False)
 
724
        except (errors.NoWorkingTree, errors.NotLocalUrl):
 
725
            result_format.workingtree_format = None
 
726
        else:
 
727
            result_format.workingtree_format = tree._format.__class__()
 
728
        return result_format, source_repository
 
729
 
 
730
    def cloning_metadir(self):
 
731
        """Produce a metadir suitable for cloning or sprouting with.
 
732
 
 
733
        These operations may produce workingtrees (yes, even though they're
 
734
        "cloning" something that doesn't have a tree, so a viable workingtree
 
735
        format must be selected.
 
736
        """
 
737
        format, repository = self._cloning_metadir()
 
738
        if format._workingtree_format is None:
 
739
            if repository is None:
 
740
                return format
 
741
            tree_format = repository._format._matchingbzrdir.workingtree_format
 
742
            format.workingtree_format = tree_format.__class__()
 
743
        return format
 
744
 
 
745
    def checkout_metadir(self):
 
746
        return self.cloning_metadir()
 
747
 
 
748
    def sprout(self, url, revision_id=None, force_new_repo=False,
 
749
               recurse='down', possible_transports=None):
567
750
        """Create a copy of this bzrdir prepared for use as a new line of
568
751
        development.
569
752
 
577
760
        if revision_id is not None, then the clone operation may tune
578
761
            itself to download less data.
579
762
        """
580
 
        self._make_tail(url)
581
 
        result = self._format.initialize(url)
582
 
        basis_repo, basis_branch, basis_tree = self._get_basis_components(basis)
 
763
        target_transport = get_transport(url, possible_transports)
 
764
        target_transport.ensure_base()
 
765
        cloning_format = self.cloning_metadir()
 
766
        result = cloning_format.initialize_on_transport(target_transport)
583
767
        try:
584
768
            source_branch = self.open_branch()
585
769
            source_repository = source_branch.repository
588
772
            try:
589
773
                source_repository = self.open_repository()
590
774
            except errors.NoRepositoryPresent:
591
 
                # copy the entire basis one if there is one
592
 
                # but there is no repository.
593
 
                source_repository = basis_repo
 
775
                source_repository = None
594
776
        if force_new_repo:
595
777
            result_repo = None
596
778
        else:
605
787
            result.create_repository()
606
788
        elif source_repository is not None and result_repo is None:
607
789
            # have source, and want to make a new target repo
608
 
            # we don't clone the repo because that preserves attributes
609
 
            # like is_shared(), and we have not yet implemented a 
610
 
            # repository sprout().
611
 
            result_repo = result.create_repository()
612
 
        if result_repo is not None:
 
790
            result_repo = source_repository.sprout(result,
 
791
                                                   revision_id=revision_id)
 
792
        else:
613
793
            # fetch needed content into target.
614
 
            if basis_repo:
615
 
                # XXX FIXME RBC 20060214 need tests for this when the basis
616
 
                # is incomplete
617
 
                result_repo.fetch(basis_repo, revision_id=revision_id)
618
 
            result_repo.fetch(source_repository, revision_id=revision_id)
 
794
            if source_repository is not None:
 
795
                # would rather do 
 
796
                # source_repository.copy_content_into(result_repo,
 
797
                #                                     revision_id=revision_id)
 
798
                # so we can override the copy method
 
799
                result_repo.fetch(source_repository, revision_id=revision_id)
619
800
        if source_branch is not None:
620
801
            source_branch.sprout(result, revision_id=revision_id)
621
802
        else:
622
803
            result.create_branch()
623
 
        # TODO: jam 20060426 we probably need a test in here in the
624
 
        #       case that the newly sprouted branch is a remote one
625
 
        if result_repo is None or result_repo.make_working_trees():
626
 
            result.create_workingtree()
 
804
        if isinstance(target_transport, LocalTransport) and (
 
805
            result_repo is None or result_repo.make_working_trees()):
 
806
            wt = result.create_workingtree()
 
807
            wt.lock_write()
 
808
            try:
 
809
                if wt.path2id('') is None:
 
810
                    try:
 
811
                        wt.set_root_id(self.open_workingtree.get_root_id())
 
812
                    except errors.NoWorkingTree:
 
813
                        pass
 
814
            finally:
 
815
                wt.unlock()
 
816
        else:
 
817
            wt = None
 
818
        if recurse == 'down':
 
819
            if wt is not None:
 
820
                basis = wt.basis_tree()
 
821
                basis.lock_read()
 
822
                subtrees = basis.iter_references()
 
823
                recurse_branch = wt.branch
 
824
            elif source_branch is not None:
 
825
                basis = source_branch.basis_tree()
 
826
                basis.lock_read()
 
827
                subtrees = basis.iter_references()
 
828
                recurse_branch = source_branch
 
829
            else:
 
830
                subtrees = []
 
831
                basis = None
 
832
            try:
 
833
                for path, file_id in subtrees:
 
834
                    target = urlutils.join(url, urlutils.escape(path))
 
835
                    sublocation = source_branch.reference_parent(file_id, path)
 
836
                    sublocation.bzrdir.sprout(target,
 
837
                        basis.get_reference_revision(file_id, path),
 
838
                        force_new_repo=force_new_repo, recurse=recurse)
 
839
            finally:
 
840
                if basis is not None:
 
841
                    basis.unlock()
627
842
        return result
628
843
 
629
844
 
633
848
    def __init__(self, _transport, _format):
634
849
        """See BzrDir.__init__."""
635
850
        super(BzrDirPreSplitOut, self).__init__(_transport, _format)
636
 
        assert self._format._lock_class == TransportLock
 
851
        assert self._format._lock_class == lockable_files.TransportLock
637
852
        assert self._format._lock_file_name == 'branch-lock'
638
 
        self._control_files = LockableFiles(self.get_branch_transport(None),
 
853
        self._control_files = lockable_files.LockableFiles(
 
854
                                            self.get_branch_transport(None),
639
855
                                            self._format._lock_file_name,
640
856
                                            self._format._lock_class)
641
857
 
643
859
        """Pre-splitout bzrdirs do not suffer from stale locks."""
644
860
        raise NotImplementedError(self.break_lock)
645
861
 
646
 
    def clone(self, url, revision_id=None, basis=None, force_new_repo=False):
 
862
    def clone(self, url, revision_id=None, force_new_repo=False):
647
863
        """See BzrDir.clone()."""
648
864
        from bzrlib.workingtree import WorkingTreeFormat2
649
865
        self._make_tail(url)
650
866
        result = self._format._initialize_for_clone(url)
651
 
        basis_repo, basis_branch, basis_tree = self._get_basis_components(basis)
652
 
        self.open_repository().clone(result, revision_id=revision_id, basis=basis_repo)
 
867
        self.open_repository().clone(result, revision_id=revision_id)
653
868
        from_branch = self.open_branch()
654
869
        from_branch.clone(result, revision_id=revision_id)
655
870
        try:
656
 
            self.open_workingtree().clone(result, basis=basis_tree)
 
871
            self.open_workingtree().clone(result)
657
872
        except errors.NotLocalUrl:
658
873
            # make a new one, this format always has to have one.
659
874
            try:
677
892
    def create_workingtree(self, revision_id=None):
678
893
        """See BzrDir.create_workingtree."""
679
894
        # this looks buggy but is not -really-
 
895
        # because this format creates the workingtree when the bzrdir is
 
896
        # created
680
897
        # clone and sprout will have set the revision_id
681
898
        # and that will have set it for us, its only
682
899
        # specific uses of create_workingtree in isolation
683
900
        # that can do wonky stuff here, and that only
684
901
        # happens for creating checkouts, which cannot be 
685
902
        # done on this format anyway. So - acceptable wart.
686
 
        result = self.open_workingtree()
 
903
        result = self.open_workingtree(recommend_upgrade=False)
687
904
        if revision_id is not None:
688
 
            result.set_last_revision(revision_id)
 
905
            if revision_id == _mod_revision.NULL_REVISION:
 
906
                result.set_parent_ids([])
 
907
            else:
 
908
                result.set_parent_ids([revision_id])
689
909
        return result
690
910
 
 
911
    def destroy_workingtree(self):
 
912
        """See BzrDir.destroy_workingtree."""
 
913
        raise errors.UnsupportedOperation(self.destroy_workingtree, self)
 
914
 
 
915
    def destroy_workingtree_metadata(self):
 
916
        """See BzrDir.destroy_workingtree_metadata."""
 
917
        raise errors.UnsupportedOperation(self.destroy_workingtree_metadata, 
 
918
                                          self)
 
919
 
691
920
    def get_branch_transport(self, branch_format):
692
921
        """See BzrDir.get_branch_transport()."""
693
922
        if branch_format is None:
733
962
        self._check_supported(format, unsupported)
734
963
        return format.open(self, _found=True)
735
964
 
736
 
    def sprout(self, url, revision_id=None, basis=None):
 
965
    def sprout(self, url, revision_id=None, force_new_repo=False,
 
966
               possible_transports=None):
737
967
        """See BzrDir.sprout()."""
738
968
        from bzrlib.workingtree import WorkingTreeFormat2
739
969
        self._make_tail(url)
740
970
        result = self._format._initialize_for_clone(url)
741
 
        basis_repo, basis_branch, basis_tree = self._get_basis_components(basis)
742
971
        try:
743
 
            self.open_repository().clone(result, revision_id=revision_id, basis=basis_repo)
 
972
            self.open_repository().clone(result, revision_id=revision_id)
744
973
        except errors.NoRepositoryPresent:
745
974
            pass
746
975
        try:
768
997
 
769
998
    def open_repository(self):
770
999
        """See BzrDir.open_repository."""
771
 
        from bzrlib.repository import RepositoryFormat4
 
1000
        from bzrlib.repofmt.weaverepo import RepositoryFormat4
772
1001
        return RepositoryFormat4().open(self, _found=True)
773
1002
 
774
1003
 
780
1009
 
781
1010
    def open_repository(self):
782
1011
        """See BzrDir.open_repository."""
783
 
        from bzrlib.repository import RepositoryFormat5
 
1012
        from bzrlib.repofmt.weaverepo import RepositoryFormat5
784
1013
        return RepositoryFormat5().open(self, _found=True)
785
1014
 
786
 
    def open_workingtree(self, _unsupported=False):
 
1015
    def open_workingtree(self, _unsupported=False,
 
1016
            recommend_upgrade=True):
787
1017
        """See BzrDir.create_workingtree."""
788
1018
        from bzrlib.workingtree import WorkingTreeFormat2
789
 
        return WorkingTreeFormat2().open(self, _found=True)
 
1019
        wt_format = WorkingTreeFormat2()
 
1020
        # we don't warn here about upgrades; that ought to be handled for the
 
1021
        # bzrdir as a whole
 
1022
        return wt_format.open(self, _found=True)
790
1023
 
791
1024
 
792
1025
class BzrDir6(BzrDirPreSplitOut):
797
1030
 
798
1031
    def open_repository(self):
799
1032
        """See BzrDir.open_repository."""
800
 
        from bzrlib.repository import RepositoryFormat6
 
1033
        from bzrlib.repofmt.weaverepo import RepositoryFormat6
801
1034
        return RepositoryFormat6().open(self, _found=True)
802
1035
 
803
 
    def open_workingtree(self, _unsupported=False):
 
1036
    def open_workingtree(self, _unsupported=False,
 
1037
        recommend_upgrade=True):
804
1038
        """See BzrDir.create_workingtree."""
 
1039
        # we don't warn here about upgrades; that ought to be handled for the
 
1040
        # bzrdir as a whole
805
1041
        from bzrlib.workingtree import WorkingTreeFormat2
806
1042
        return WorkingTreeFormat2().open(self, _found=True)
807
1043
 
821
1057
 
822
1058
    def create_branch(self):
823
1059
        """See BzrDir.create_branch."""
824
 
        from bzrlib.branch import BranchFormat
825
 
        return BranchFormat.get_default_format().initialize(self)
 
1060
        return self._format.get_branch_format().initialize(self)
826
1061
 
827
1062
    def create_repository(self, shared=False):
828
1063
        """See BzrDir.create_repository."""
831
1066
    def create_workingtree(self, revision_id=None):
832
1067
        """See BzrDir.create_workingtree."""
833
1068
        from bzrlib.workingtree import WorkingTreeFormat
834
 
        return WorkingTreeFormat.get_default_format().initialize(self, revision_id)
 
1069
        return self._format.workingtree_format.initialize(self, revision_id)
 
1070
 
 
1071
    def destroy_workingtree(self):
 
1072
        """See BzrDir.destroy_workingtree."""
 
1073
        wt = self.open_workingtree(recommend_upgrade=False)
 
1074
        repository = wt.branch.repository
 
1075
        empty = repository.revision_tree(_mod_revision.NULL_REVISION)
 
1076
        wt.revert([], old_tree=empty)
 
1077
        self.destroy_workingtree_metadata()
 
1078
 
 
1079
    def destroy_workingtree_metadata(self):
 
1080
        self.transport.delete_tree('checkout')
 
1081
 
 
1082
    def find_branch_format(self):
 
1083
        """Find the branch 'format' for this bzrdir.
 
1084
 
 
1085
        This might be a synthetic object for e.g. RemoteBranch and SVN.
 
1086
        """
 
1087
        from bzrlib.branch import BranchFormat
 
1088
        return BranchFormat.find_format(self)
835
1089
 
836
1090
    def _get_mkdir_mode(self):
837
1091
        """Figure out the mode to use when creating a bzrdir subdir."""
838
 
        temp_control = LockableFiles(self.transport, '', TransportLock)
 
1092
        temp_control = lockable_files.LockableFiles(self.transport, '',
 
1093
                                     lockable_files.TransportLock)
839
1094
        return temp_control._dir_mode
840
1095
 
 
1096
    def get_branch_reference(self):
 
1097
        """See BzrDir.get_branch_reference()."""
 
1098
        from bzrlib.branch import BranchFormat
 
1099
        format = BranchFormat.find_format(self)
 
1100
        return format.get_reference(self)
 
1101
 
841
1102
    def get_branch_transport(self, branch_format):
842
1103
        """See BzrDir.get_branch_transport()."""
843
1104
        if branch_format is None:
895
1156
                return True
896
1157
        except errors.NoRepositoryPresent:
897
1158
            pass
898
 
        # currently there are no other possible conversions for meta1 formats.
 
1159
        try:
 
1160
            if not isinstance(self.open_branch()._format,
 
1161
                              format.get_branch_format().__class__):
 
1162
                # the branch needs an upgrade.
 
1163
                return True
 
1164
        except errors.NotBranchError:
 
1165
            pass
 
1166
        try:
 
1167
            my_wt = self.open_workingtree(recommend_upgrade=False)
 
1168
            if not isinstance(my_wt._format,
 
1169
                              format.workingtree_format.__class__):
 
1170
                # the workingtree needs an upgrade.
 
1171
                return True
 
1172
        except (errors.NoWorkingTree, errors.NotLocalUrl):
 
1173
            pass
899
1174
        return False
900
1175
 
901
1176
    def open_branch(self, unsupported=False):
902
1177
        """See BzrDir.open_branch."""
903
 
        from bzrlib.branch import BranchFormat
904
 
        format = BranchFormat.find_format(self)
 
1178
        format = self.find_branch_format()
905
1179
        self._check_supported(format, unsupported)
906
1180
        return format.open(self, _found=True)
907
1181
 
912
1186
        self._check_supported(format, unsupported)
913
1187
        return format.open(self, _found=True)
914
1188
 
915
 
    def open_workingtree(self, unsupported=False):
 
1189
    def open_workingtree(self, unsupported=False,
 
1190
            recommend_upgrade=True):
916
1191
        """See BzrDir.open_workingtree."""
917
1192
        from bzrlib.workingtree import WorkingTreeFormat
918
1193
        format = WorkingTreeFormat.find_format(self)
919
 
        self._check_supported(format, unsupported)
 
1194
        self._check_supported(format, unsupported,
 
1195
            recommend_upgrade,
 
1196
            basedir=self.root_transport.base)
920
1197
        return format.open(self, _found=True)
921
1198
 
922
1199
 
949
1226
    This is a list of BzrDirFormat objects.
950
1227
    """
951
1228
 
 
1229
    _control_server_formats = []
 
1230
    """The registered control server formats, e.g. RemoteBzrDirs.
 
1231
 
 
1232
    This is a list of BzrDirFormat objects.
 
1233
    """
 
1234
 
952
1235
    _lock_file_name = 'branch-lock'
953
1236
 
954
1237
    # _lock_class must be set in subclasses to the lock type, typ.
955
1238
    # TransportLock or LockDir
956
1239
 
957
1240
    @classmethod
958
 
    def find_format(klass, transport):
 
1241
    def find_format(klass, transport, _server_formats=True):
959
1242
        """Return the format present at transport."""
960
 
        for format in klass._control_formats:
 
1243
        if _server_formats:
 
1244
            formats = klass._control_server_formats + klass._control_formats
 
1245
        else:
 
1246
            formats = klass._control_formats
 
1247
        for format in formats:
961
1248
            try:
962
1249
                return format.probe_transport(transport)
963
1250
            except errors.NotBranchError:
967
1254
 
968
1255
    @classmethod
969
1256
    def probe_transport(klass, transport):
970
 
        """Return the .bzrdir style transport present at URL."""
 
1257
        """Return the .bzrdir style format present in a directory."""
971
1258
        try:
972
1259
            format_string = transport.get(".bzr/branch-format").read()
973
1260
        except errors.NoSuchFile:
1005
1292
        """
1006
1293
        raise NotImplementedError(self.get_converter)
1007
1294
 
1008
 
    def initialize(self, url):
 
1295
    def initialize(self, url, possible_transports=None):
1009
1296
        """Create a bzr control dir at this url and return an opened copy.
1010
1297
        
1011
1298
        Subclasses should typically override initialize_on_transport
1012
1299
        instead of this method.
1013
1300
        """
1014
 
        return self.initialize_on_transport(get_transport(url))
 
1301
        return self.initialize_on_transport(get_transport(url,
 
1302
                                                          possible_transports))
1015
1303
 
1016
1304
    def initialize_on_transport(self, transport):
1017
1305
        """Initialize a new bzrdir in the base directory of a Transport."""
1018
1306
        # Since we don't have a .bzr directory, inherit the
1019
1307
        # mode from the root directory
1020
 
        temp_control = LockableFiles(transport, '', TransportLock)
 
1308
        temp_control = lockable_files.LockableFiles(transport,
 
1309
                            '', lockable_files.TransportLock)
1021
1310
        temp_control._transport.mkdir('.bzr',
1022
1311
                                      # FIXME: RBC 20060121 don't peek under
1023
1312
                                      # the covers
1032
1321
                      ('branch-format', self.get_format_string()),
1033
1322
                      ]
1034
1323
        # NB: no need to escape relative paths that are url safe.
1035
 
        control_files = LockableFiles(control, self._lock_file_name, 
1036
 
                                      self._lock_class)
 
1324
        control_files = lockable_files.LockableFiles(control,
 
1325
                            self._lock_file_name, self._lock_class)
1037
1326
        control_files.create_lock()
1038
1327
        control_files.lock_write()
1039
1328
        try:
1052
1341
        """
1053
1342
        return True
1054
1343
 
 
1344
    def same_model(self, target_format):
 
1345
        return (self.repository_format.rich_root_data == 
 
1346
            target_format.rich_root_data)
 
1347
 
1055
1348
    @classmethod
1056
1349
    def known_formats(klass):
1057
1350
        """Return all the known formats.
1077
1370
        _found is a private parameter, do not use it.
1078
1371
        """
1079
1372
        if not _found:
1080
 
            assert isinstance(BzrDirFormat.find_format(transport),
1081
 
                              self.__class__)
 
1373
            found_format = BzrDirFormat.find_format(transport)
 
1374
            if not isinstance(found_format, self.__class__):
 
1375
                raise AssertionError("%s was asked to open %s, but it seems to need "
 
1376
                        "format %s" 
 
1377
                        % (self, transport, found_format))
1082
1378
        return self._open(transport)
1083
1379
 
1084
1380
    def _open(self, transport):
1095
1391
 
1096
1392
    @classmethod
1097
1393
    def register_control_format(klass, format):
1098
 
        """Register a format that does not use '.bzrdir' for its control dir.
 
1394
        """Register a format that does not use '.bzr' for its control dir.
1099
1395
 
1100
1396
        TODO: This should be pulled up into a 'ControlDirFormat' base class
1101
1397
        which BzrDirFormat can inherit from, and renamed to register_format 
1105
1401
        klass._control_formats.append(format)
1106
1402
 
1107
1403
    @classmethod
 
1404
    def register_control_server_format(klass, format):
 
1405
        """Register a control format for client-server environments.
 
1406
 
 
1407
        These formats will be tried before ones registered with
 
1408
        register_control_format.  This gives implementations that decide to the
 
1409
        chance to grab it before anything looks at the contents of the format
 
1410
        file.
 
1411
        """
 
1412
        klass._control_server_formats.append(format)
 
1413
 
 
1414
    @classmethod
 
1415
    @symbol_versioning.deprecated_method(symbol_versioning.zero_fourteen)
1108
1416
    def set_default_format(klass, format):
 
1417
        klass._set_default_format(format)
 
1418
 
 
1419
    @classmethod
 
1420
    def _set_default_format(klass, format):
 
1421
        """Set default format (for testing behavior of defaults only)"""
1109
1422
        klass._default_format = format
1110
1423
 
1111
1424
    def __str__(self):
1121
1434
        klass._control_formats.remove(format)
1122
1435
 
1123
1436
 
1124
 
# register BzrDirFormat as a control format
1125
 
BzrDirFormat.register_control_format(BzrDirFormat)
1126
 
 
1127
 
 
1128
1437
class BzrDirFormat4(BzrDirFormat):
1129
1438
    """Bzr dir format 4.
1130
1439
 
1138
1447
    removed in format 5; write support for this format has been removed.
1139
1448
    """
1140
1449
 
1141
 
    _lock_class = TransportLock
 
1450
    _lock_class = lockable_files.TransportLock
1142
1451
 
1143
1452
    def get_format_string(self):
1144
1453
        """See BzrDirFormat.get_format_string()."""
1172
1481
 
1173
1482
    def __return_repository_format(self):
1174
1483
        """Circular import protection."""
1175
 
        from bzrlib.repository import RepositoryFormat4
1176
 
        return RepositoryFormat4(self)
 
1484
        from bzrlib.repofmt.weaverepo import RepositoryFormat4
 
1485
        return RepositoryFormat4()
1177
1486
    repository_format = property(__return_repository_format)
1178
1487
 
1179
1488
 
1188
1497
       Unhashed stores in the repository.
1189
1498
    """
1190
1499
 
1191
 
    _lock_class = TransportLock
 
1500
    _lock_class = lockable_files.TransportLock
1192
1501
 
1193
1502
    def get_format_string(self):
1194
1503
        """See BzrDirFormat.get_format_string()."""
1212
1521
        Except when they are being cloned.
1213
1522
        """
1214
1523
        from bzrlib.branch import BzrBranchFormat4
1215
 
        from bzrlib.repository import RepositoryFormat5
 
1524
        from bzrlib.repofmt.weaverepo import RepositoryFormat5
1216
1525
        from bzrlib.workingtree import WorkingTreeFormat2
1217
1526
        result = (super(BzrDirFormat5, self).initialize_on_transport(transport))
1218
1527
        RepositoryFormat5().initialize(result, _internal=True)
1219
1528
        if not _cloning:
1220
 
            BzrBranchFormat4().initialize(result)
1221
 
            WorkingTreeFormat2().initialize(result)
 
1529
            branch = BzrBranchFormat4().initialize(result)
 
1530
            try:
 
1531
                WorkingTreeFormat2().initialize(result)
 
1532
            except errors.NotLocalUrl:
 
1533
                # Even though we can't access the working tree, we need to
 
1534
                # create its control files.
 
1535
                WorkingTreeFormat2().stub_initialize_remote(branch.control_files)
1222
1536
        return result
1223
1537
 
1224
1538
    def _open(self, transport):
1227
1541
 
1228
1542
    def __return_repository_format(self):
1229
1543
        """Circular import protection."""
1230
 
        from bzrlib.repository import RepositoryFormat5
1231
 
        return RepositoryFormat5(self)
 
1544
        from bzrlib.repofmt.weaverepo import RepositoryFormat5
 
1545
        return RepositoryFormat5()
1232
1546
    repository_format = property(__return_repository_format)
1233
1547
 
1234
1548
 
1242
1556
     - Format 6 repositories [always]
1243
1557
    """
1244
1558
 
1245
 
    _lock_class = TransportLock
 
1559
    _lock_class = lockable_files.TransportLock
1246
1560
 
1247
1561
    def get_format_string(self):
1248
1562
        """See BzrDirFormat.get_format_string()."""
1266
1580
        Except when they are being cloned.
1267
1581
        """
1268
1582
        from bzrlib.branch import BzrBranchFormat4
1269
 
        from bzrlib.repository import RepositoryFormat6
 
1583
        from bzrlib.repofmt.weaverepo import RepositoryFormat6
1270
1584
        from bzrlib.workingtree import WorkingTreeFormat2
1271
1585
        result = super(BzrDirFormat6, self).initialize_on_transport(transport)
1272
1586
        RepositoryFormat6().initialize(result, _internal=True)
1273
1587
        if not _cloning:
1274
 
            BzrBranchFormat4().initialize(result)
 
1588
            branch = BzrBranchFormat4().initialize(result)
1275
1589
            try:
1276
1590
                WorkingTreeFormat2().initialize(result)
1277
1591
            except errors.NotLocalUrl:
1278
 
                # emulate pre-check behaviour for working tree and silently 
1279
 
                # fail.
1280
 
                pass
 
1592
                # Even though we can't access the working tree, we need to
 
1593
                # create its control files.
 
1594
                WorkingTreeFormat2().stub_initialize_remote(branch.control_files)
1281
1595
        return result
1282
1596
 
1283
1597
    def _open(self, transport):
1286
1600
 
1287
1601
    def __return_repository_format(self):
1288
1602
        """Circular import protection."""
1289
 
        from bzrlib.repository import RepositoryFormat6
1290
 
        return RepositoryFormat6(self)
 
1603
        from bzrlib.repofmt.weaverepo import RepositoryFormat6
 
1604
        return RepositoryFormat6()
1291
1605
    repository_format = property(__return_repository_format)
1292
1606
 
1293
1607
 
1302
1616
     - Format 7 repositories [optional]
1303
1617
    """
1304
1618
 
1305
 
    _lock_class = LockDir
 
1619
    _lock_class = lockdir.LockDir
 
1620
 
 
1621
    def __init__(self):
 
1622
        self._workingtree_format = None
 
1623
        self._branch_format = None
 
1624
 
 
1625
    def __eq__(self, other):
 
1626
        if other.__class__ is not self.__class__:
 
1627
            return False
 
1628
        if other.repository_format != self.repository_format:
 
1629
            return False
 
1630
        if other.workingtree_format != self.workingtree_format:
 
1631
            return False
 
1632
        return True
 
1633
 
 
1634
    def __ne__(self, other):
 
1635
        return not self == other
 
1636
 
 
1637
    def get_branch_format(self):
 
1638
        if self._branch_format is None:
 
1639
            from bzrlib.branch import BranchFormat
 
1640
            self._branch_format = BranchFormat.get_default_format()
 
1641
        return self._branch_format
 
1642
 
 
1643
    def set_branch_format(self, format):
 
1644
        self._branch_format = format
1306
1645
 
1307
1646
    def get_converter(self, format=None):
1308
1647
        """See BzrDirFormat.get_converter()."""
1338
1677
 
1339
1678
    repository_format = property(__return_repository_format, __set_repository_format)
1340
1679
 
1341
 
 
 
1680
    def __get_workingtree_format(self):
 
1681
        if self._workingtree_format is None:
 
1682
            from bzrlib.workingtree import WorkingTreeFormat
 
1683
            self._workingtree_format = WorkingTreeFormat.get_default_format()
 
1684
        return self._workingtree_format
 
1685
 
 
1686
    def __set_workingtree_format(self, wt_format):
 
1687
        self._workingtree_format = wt_format
 
1688
 
 
1689
    workingtree_format = property(__get_workingtree_format,
 
1690
                                  __set_workingtree_format)
 
1691
 
 
1692
 
 
1693
# Register bzr control format
 
1694
BzrDirFormat.register_control_format(BzrDirFormat)
 
1695
 
 
1696
# Register bzr formats
1342
1697
BzrDirFormat.register_format(BzrDirFormat4())
1343
1698
BzrDirFormat.register_format(BzrDirFormat5())
1344
1699
BzrDirFormat.register_format(BzrDirFormat6())
1345
1700
__default_format = BzrDirMetaFormat1()
1346
1701
BzrDirFormat.register_format(__default_format)
1347
 
BzrDirFormat.set_default_format(__default_format)
1348
 
 
1349
 
 
1350
 
class BzrDirTestProviderAdapter(object):
1351
 
    """A tool to generate a suite testing multiple bzrdir formats at once.
1352
 
 
1353
 
    This is done by copying the test once for each transport and injecting
1354
 
    the transport_server, transport_readonly_server, and bzrdir_format
1355
 
    classes into each copy. Each copy is also given a new id() to make it
1356
 
    easy to identify.
1357
 
    """
1358
 
 
1359
 
    def __init__(self, transport_server, transport_readonly_server, formats):
1360
 
        self._transport_server = transport_server
1361
 
        self._transport_readonly_server = transport_readonly_server
1362
 
        self._formats = formats
1363
 
    
1364
 
    def adapt(self, test):
1365
 
        result = TestSuite()
1366
 
        for format in self._formats:
1367
 
            new_test = deepcopy(test)
1368
 
            new_test.transport_server = self._transport_server
1369
 
            new_test.transport_readonly_server = self._transport_readonly_server
1370
 
            new_test.bzrdir_format = format
1371
 
            def make_new_test_id():
1372
 
                new_id = "%s(%s)" % (new_test.id(), format.__class__.__name__)
1373
 
                return lambda: new_id
1374
 
            new_test.id = make_new_test_id()
1375
 
            result.addTest(new_test)
1376
 
        return result
 
1702
BzrDirFormat._default_format = __default_format
1377
1703
 
1378
1704
 
1379
1705
class Converter(object):
1466
1792
        self.bzrdir.transport.delete_tree('text-store')
1467
1793
 
1468
1794
    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)
 
1795
        inv = xml4.serializer_v4.read_inventory(
 
1796
                    self.branch.control_files.get('inventory'))
 
1797
        new_inv_xml = xml5.serializer_v5.write_inventory_to_string(inv)
1471
1798
        # FIXME inventory is a working tree change.
1472
 
        self.branch.control_files.put('inventory', new_inv_xml)
 
1799
        self.branch.control_files.put('inventory', StringIO(new_inv_xml))
1473
1800
 
1474
1801
    def _write_all_weaves(self):
1475
1802
        controlweaves = WeaveStore(self.bzrdir.transport, prefixed=False)
1499
1826
                                                      prefixed=False,
1500
1827
                                                      compressed=True))
1501
1828
        try:
1502
 
            transaction = bzrlib.transactions.WriteTransaction()
 
1829
            transaction = WriteTransaction()
1503
1830
            for i, rev_id in enumerate(self.converted_revs):
1504
1831
                self.pb.update('write revision', i, len(self.converted_revs))
1505
1832
                _revision_store.add_revision(self.revisions[rev_id], transaction)
1531
1858
    def _load_old_inventory(self, rev_id):
1532
1859
        assert rev_id not in self.converted_revs
1533
1860
        old_inv_xml = self.branch.repository.inventory_store.get(rev_id).read()
1534
 
        inv = serializer_v4.read_inventory_from_string(old_inv_xml)
 
1861
        inv = xml4.serializer_v4.read_inventory_from_string(old_inv_xml)
 
1862
        inv.revision_id = rev_id
1535
1863
        rev = self.revisions[rev_id]
1536
1864
        if rev.inventory_sha1:
1537
1865
            assert rev.inventory_sha1 == sha_string(old_inv_xml), \
1541
1869
    def _load_updated_inventory(self, rev_id):
1542
1870
        assert rev_id in self.converted_revs
1543
1871
        inv_xml = self.inv_weave.get_text(rev_id)
1544
 
        inv = bzrlib.xml5.serializer_v5.read_inventory_from_string(inv_xml)
 
1872
        inv = xml5.serializer_v5.read_inventory_from_string(inv_xml)
1545
1873
        return inv
1546
1874
 
1547
1875
    def _convert_one_rev(self, rev_id):
1557
1885
    def _store_new_weave(self, rev, inv, present_parents):
1558
1886
        # the XML is now updated with text versions
1559
1887
        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'), \
 
1888
            entries = inv.iter_entries()
 
1889
            entries.next()
 
1890
            for path, ie in entries:
 
1891
                assert getattr(ie, 'revision', None) is not None, \
1565
1892
                    'no revision on {%s} in {%s}' % \
1566
1893
                    (file_id, rev.revision_id)
1567
 
        new_inv_xml = bzrlib.xml5.serializer_v5.write_inventory_to_string(inv)
 
1894
        new_inv_xml = xml5.serializer_v5.write_inventory_to_string(inv)
1568
1895
        new_inv_sha1 = sha_string(new_inv_xml)
1569
1896
        self.inv_weave.add_lines(rev.revision_id, 
1570
1897
                                 present_parents,
1579
1906
        mutter('converting texts of revision {%s}',
1580
1907
               rev_id)
1581
1908
        parent_invs = map(self._load_updated_inventory, present_parents)
1582
 
        for file_id in inv:
1583
 
            ie = inv[file_id]
 
1909
        entries = inv.iter_entries()
 
1910
        entries.next()
 
1911
        for path, ie in entries:
1584
1912
            self._convert_file_version(rev, ie, parent_invs)
1585
1913
 
1586
1914
    def _convert_file_version(self, rev, ie, parent_invs):
1589
1917
        The file needs to be added into the weave if it is a merge
1590
1918
        of >=2 parents or if it's changed from its parent.
1591
1919
        """
1592
 
        if ie.kind == 'root_directory':
1593
 
            return
1594
1920
        file_id = ie.file_id
1595
1921
        rev_id = rev.revision_id
1596
1922
        w = self.text_weaves.get(file_id)
1604
1930
                                                  entry_vf=w)
1605
1931
        for old_revision in previous_entries:
1606
1932
                # if this fails, its a ghost ?
1607
 
                assert old_revision in self.converted_revs 
 
1933
                assert old_revision in self.converted_revs, \
 
1934
                    "Revision {%s} not in converted_revs" % old_revision
1608
1935
        self.snapshot_ie(previous_entries, ie, w, rev_id)
1609
1936
        del ie.text_id
1610
1937
        assert getattr(ie, 'revision', None) is not None
1697
2024
 
1698
2025
    def convert(self, to_convert, pb):
1699
2026
        """See Converter.convert()."""
 
2027
        from bzrlib.repofmt.weaverepo import RepositoryFormat7
 
2028
        from bzrlib.branch import BzrBranchFormat5
1700
2029
        self.bzrdir = to_convert
1701
2030
        self.pb = pb
1702
2031
        self.count = 0
1731
2060
        # we hard code the formats here because we are converting into
1732
2061
        # the meta format. The meta format upgrader can take this to a 
1733
2062
        # future format within each component.
1734
 
        self.put_format('repository', bzrlib.repository.RepositoryFormat7())
 
2063
        self.put_format('repository', RepositoryFormat7())
1735
2064
        for entry in repository_names:
1736
2065
            self.move_entry('repository', entry)
1737
2066
 
1738
2067
        self.step('Upgrading branch      ')
1739
2068
        self.bzrdir.transport.mkdir('branch', mode=self.dir_mode)
1740
2069
        self.make_lock('branch')
1741
 
        self.put_format('branch', bzrlib.branch.BzrBranchFormat5())
 
2070
        self.put_format('branch', BzrBranchFormat5())
1742
2071
        branch_files = [('revision-history', True),
1743
2072
                        ('branch-name', True),
1744
2073
                        ('parent', False)]
1745
2074
        for entry in branch_files:
1746
2075
            self.move_entry('branch', entry)
1747
2076
 
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
2077
        checkout_files = [('pending-merges', True),
1754
2078
                          ('inventory', True),
1755
2079
                          ('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())
 
2080
        # If a mandatory checkout file is not present, the branch does not have
 
2081
        # a functional checkout. Do not create a checkout in the converted
 
2082
        # branch.
 
2083
        for name, mandatory in checkout_files:
 
2084
            if mandatory and name not in bzrcontents:
 
2085
                has_checkout = False
 
2086
                break
 
2087
        else:
 
2088
            has_checkout = True
 
2089
        if not has_checkout:
 
2090
            self.pb.note('No working tree.')
 
2091
            # If some checkout files are there, we may as well get rid of them.
 
2092
            for name, mandatory in checkout_files:
 
2093
                if name in bzrcontents:
 
2094
                    self.bzrdir.transport.delete(name)
 
2095
        else:
 
2096
            from bzrlib.workingtree import WorkingTreeFormat3
 
2097
            self.step('Upgrading working tree')
 
2098
            self.bzrdir.transport.mkdir('checkout', mode=self.dir_mode)
 
2099
            self.make_lock('checkout')
 
2100
            self.put_format(
 
2101
                'checkout', WorkingTreeFormat3())
 
2102
            self.bzrdir.transport.delete_multi(
 
2103
                self.garbage_inventories, self.pb)
 
2104
            for entry in checkout_files:
 
2105
                self.move_entry('checkout', entry)
 
2106
            if last_revision is not None:
 
2107
                self.bzrdir._control_files.put_utf8(
 
2108
                    'checkout/last-revision', last_revision)
 
2109
        self.bzrdir._control_files.put_utf8(
 
2110
            'branch-format', BzrDirMetaFormat1().get_format_string())
1762
2111
        return BzrDir.open(self.bzrdir.root_transport.base)
1763
2112
 
1764
2113
    def make_lock(self, name):
1765
2114
        """Make a lock for the new control dir name."""
1766
2115
        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)
 
2116
        ld = lockdir.LockDir(self.bzrdir.transport,
 
2117
                             '%s/lock' % name,
 
2118
                             file_modebits=self.file_mode,
 
2119
                             dir_modebits=self.dir_mode)
1771
2120
        ld.create()
1772
2121
 
1773
2122
    def move_entry(self, new_dir, entry):
1812
2161
                self.pb.note('starting repository conversion')
1813
2162
                converter = CopyConverter(self.target_format.repository_format)
1814
2163
                converter.convert(repo, pb)
 
2164
        try:
 
2165
            branch = self.bzrdir.open_branch()
 
2166
        except errors.NotBranchError:
 
2167
            pass
 
2168
        else:
 
2169
            # TODO: conversions of Branch and Tree should be done by
 
2170
            # InterXFormat lookups
 
2171
            # Avoid circular imports
 
2172
            from bzrlib import branch as _mod_branch
 
2173
            if (branch._format.__class__ is _mod_branch.BzrBranchFormat5 and
 
2174
                self.target_format.get_branch_format().__class__ is
 
2175
                _mod_branch.BzrBranchFormat6):
 
2176
                branch_converter = _mod_branch.Converter5to6()
 
2177
                branch_converter.convert(branch)
 
2178
        try:
 
2179
            tree = self.bzrdir.open_workingtree(recommend_upgrade=False)
 
2180
        except (errors.NoWorkingTree, errors.NotLocalUrl):
 
2181
            pass
 
2182
        else:
 
2183
            # TODO: conversions of Branch and Tree should be done by
 
2184
            # InterXFormat lookups
 
2185
            if (isinstance(tree, workingtree.WorkingTree3) and
 
2186
                not isinstance(tree, workingtree_4.WorkingTree4) and
 
2187
                isinstance(self.target_format.workingtree_format,
 
2188
                    workingtree_4.WorkingTreeFormat4)):
 
2189
                workingtree_4.Converter3to4().convert(tree)
1815
2190
        return to_convert
 
2191
 
 
2192
 
 
2193
# This is not in remote.py because it's small, and needs to be registered.
 
2194
# Putting it in remote.py creates a circular import problem.
 
2195
# we can make it a lazy object if the control formats is turned into something
 
2196
# like a registry.
 
2197
class RemoteBzrDirFormat(BzrDirMetaFormat1):
 
2198
    """Format representing bzrdirs accessed via a smart server"""
 
2199
 
 
2200
    def get_format_description(self):
 
2201
        return 'bzr remote bzrdir'
 
2202
    
 
2203
    @classmethod
 
2204
    def probe_transport(klass, transport):
 
2205
        """Return a RemoteBzrDirFormat object if it looks possible."""
 
2206
        try:
 
2207
            client = transport.get_smart_client()
 
2208
        except (NotImplementedError, AttributeError,
 
2209
                errors.TransportNotPossible):
 
2210
            # no smart server, so not a branch for this format type.
 
2211
            raise errors.NotBranchError(path=transport.base)
 
2212
        else:
 
2213
            # Send a 'hello' request in protocol version one, and decline to
 
2214
            # open it if the server doesn't support our required version (2) so
 
2215
            # that the VFS-based transport will do it.
 
2216
            request = client.get_request()
 
2217
            smart_protocol = protocol.SmartClientRequestProtocolOne(request)
 
2218
            server_version = smart_protocol.query_version()
 
2219
            if server_version != 2:
 
2220
                raise errors.NotBranchError(path=transport.base)
 
2221
            return klass()
 
2222
 
 
2223
    def initialize_on_transport(self, transport):
 
2224
        try:
 
2225
            # hand off the request to the smart server
 
2226
            shared_medium = transport.get_shared_medium()
 
2227
        except errors.NoSmartMedium:
 
2228
            # TODO: lookup the local format from a server hint.
 
2229
            local_dir_format = BzrDirMetaFormat1()
 
2230
            return local_dir_format.initialize_on_transport(transport)
 
2231
        client = _SmartClient(shared_medium)
 
2232
        path = client.remote_path_from_transport(transport)
 
2233
        response = _SmartClient(shared_medium).call('BzrDirFormat.initialize',
 
2234
                                                    path)
 
2235
        assert response[0] in ('ok', ), 'unexpected response code %s' % (response,)
 
2236
        return remote.RemoteBzrDir(transport)
 
2237
 
 
2238
    def _open(self, transport):
 
2239
        return remote.RemoteBzrDir(transport)
 
2240
 
 
2241
    def __eq__(self, other):
 
2242
        if not isinstance(other, RemoteBzrDirFormat):
 
2243
            return False
 
2244
        return self.get_format_description() == other.get_format_description()
 
2245
 
 
2246
 
 
2247
BzrDirFormat.register_control_server_format(RemoteBzrDirFormat)
 
2248
 
 
2249
 
 
2250
class BzrDirFormatInfo(object):
 
2251
 
 
2252
    def __init__(self, native, deprecated, hidden):
 
2253
        self.deprecated = deprecated
 
2254
        self.native = native
 
2255
        self.hidden = hidden
 
2256
 
 
2257
 
 
2258
class BzrDirFormatRegistry(registry.Registry):
 
2259
    """Registry of user-selectable BzrDir subformats.
 
2260
    
 
2261
    Differs from BzrDirFormat._control_formats in that it provides sub-formats,
 
2262
    e.g. BzrDirMeta1 with weave repository.  Also, it's more user-oriented.
 
2263
    """
 
2264
 
 
2265
    def register_metadir(self, key,
 
2266
             repository_format, help, native=True, deprecated=False,
 
2267
             branch_format=None,
 
2268
             tree_format=None,
 
2269
             hidden=False):
 
2270
        """Register a metadir subformat.
 
2271
 
 
2272
        These all use a BzrDirMetaFormat1 bzrdir, but can be parameterized
 
2273
        by the Repository format.
 
2274
 
 
2275
        :param repository_format: The fully-qualified repository format class
 
2276
            name as a string.
 
2277
        :param branch_format: Fully-qualified branch format class name as
 
2278
            a string.
 
2279
        :param tree_format: Fully-qualified tree format class name as
 
2280
            a string.
 
2281
        """
 
2282
        # This should be expanded to support setting WorkingTree and Branch
 
2283
        # formats, once BzrDirMetaFormat1 supports that.
 
2284
        def _load(full_name):
 
2285
            mod_name, factory_name = full_name.rsplit('.', 1)
 
2286
            try:
 
2287
                mod = __import__(mod_name, globals(), locals(),
 
2288
                        [factory_name])
 
2289
            except ImportError, e:
 
2290
                raise ImportError('failed to load %s: %s' % (full_name, e))
 
2291
            try:
 
2292
                factory = getattr(mod, factory_name)
 
2293
            except AttributeError:
 
2294
                raise AttributeError('no factory %s in module %r'
 
2295
                    % (full_name, mod))
 
2296
            return factory()
 
2297
 
 
2298
        def helper():
 
2299
            bd = BzrDirMetaFormat1()
 
2300
            if branch_format is not None:
 
2301
                bd.set_branch_format(_load(branch_format))
 
2302
            if tree_format is not None:
 
2303
                bd.workingtree_format = _load(tree_format)
 
2304
            if repository_format is not None:
 
2305
                bd.repository_format = _load(repository_format)
 
2306
            return bd
 
2307
        self.register(key, helper, help, native, deprecated, hidden)
 
2308
 
 
2309
    def register(self, key, factory, help, native=True, deprecated=False,
 
2310
                 hidden=False):
 
2311
        """Register a BzrDirFormat factory.
 
2312
        
 
2313
        The factory must be a callable that takes one parameter: the key.
 
2314
        It must produce an instance of the BzrDirFormat when called.
 
2315
 
 
2316
        This function mainly exists to prevent the info object from being
 
2317
        supplied directly.
 
2318
        """
 
2319
        registry.Registry.register(self, key, factory, help, 
 
2320
            BzrDirFormatInfo(native, deprecated, hidden))
 
2321
 
 
2322
    def register_lazy(self, key, module_name, member_name, help, native=True,
 
2323
                      deprecated=False, hidden=False):
 
2324
        registry.Registry.register_lazy(self, key, module_name, member_name, 
 
2325
            help, BzrDirFormatInfo(native, deprecated, hidden))
 
2326
 
 
2327
    def set_default(self, key):
 
2328
        """Set the 'default' key to be a clone of the supplied key.
 
2329
        
 
2330
        This method must be called once and only once.
 
2331
        """
 
2332
        registry.Registry.register(self, 'default', self.get(key), 
 
2333
            self.get_help(key), info=self.get_info(key))
 
2334
 
 
2335
    def set_default_repository(self, key):
 
2336
        """Set the FormatRegistry default and Repository default.
 
2337
        
 
2338
        This is a transitional method while Repository.set_default_format
 
2339
        is deprecated.
 
2340
        """
 
2341
        if 'default' in self:
 
2342
            self.remove('default')
 
2343
        self.set_default(key)
 
2344
        format = self.get('default')()
 
2345
        assert isinstance(format, BzrDirMetaFormat1)
 
2346
 
 
2347
    def make_bzrdir(self, key):
 
2348
        return self.get(key)()
 
2349
 
 
2350
    def help_topic(self, topic):
 
2351
        output = textwrap.dedent("""\
 
2352
            Bazaar directory formats
 
2353
            ------------------------
 
2354
 
 
2355
            These formats can be used for creating branches, working trees, and
 
2356
            repositories.
 
2357
 
 
2358
            """)
 
2359
        default_help = self.get_help('default')
 
2360
        help_pairs = []
 
2361
        for key in self.keys():
 
2362
            if key == 'default':
 
2363
                continue
 
2364
            help = self.get_help(key)
 
2365
            if help == default_help:
 
2366
                default_realkey = key
 
2367
            else:
 
2368
                help_pairs.append((key, help))
 
2369
 
 
2370
        def wrapped(key, help, info):
 
2371
            if info.native:
 
2372
                help = '(native) ' + help
 
2373
            return '  %s:\n%s\n\n' % (key, 
 
2374
                    textwrap.fill(help, initial_indent='    ', 
 
2375
                    subsequent_indent='    '))
 
2376
        output += wrapped('%s/default' % default_realkey, default_help,
 
2377
                          self.get_info('default'))
 
2378
        deprecated_pairs = []
 
2379
        for key, help in help_pairs:
 
2380
            info = self.get_info(key)
 
2381
            if info.hidden:
 
2382
                continue
 
2383
            elif info.deprecated:
 
2384
                deprecated_pairs.append((key, help))
 
2385
            else:
 
2386
                output += wrapped(key, help, info)
 
2387
        if len(deprecated_pairs) > 0:
 
2388
            output += "Deprecated formats\n------------------\n\n"
 
2389
            for key, help in deprecated_pairs:
 
2390
                info = self.get_info(key)
 
2391
                output += wrapped(key, help, info)
 
2392
 
 
2393
        return output
 
2394
 
 
2395
 
 
2396
format_registry = BzrDirFormatRegistry()
 
2397
format_registry.register('weave', BzrDirFormat6,
 
2398
    'Pre-0.8 format.  Slower than knit and does not'
 
2399
    ' support checkouts or shared repositories.',
 
2400
    deprecated=True)
 
2401
format_registry.register_metadir('knit',
 
2402
    'bzrlib.repofmt.knitrepo.RepositoryFormatKnit1',
 
2403
    'Format using knits.  Recommended for interoperation with bzr <= 0.14.',
 
2404
    branch_format='bzrlib.branch.BzrBranchFormat5',
 
2405
    tree_format='bzrlib.workingtree.WorkingTreeFormat3')
 
2406
format_registry.register_metadir('metaweave',
 
2407
    'bzrlib.repofmt.weaverepo.RepositoryFormat7',
 
2408
    'Transitional format in 0.8.  Slower than knit.',
 
2409
    branch_format='bzrlib.branch.BzrBranchFormat5',
 
2410
    tree_format='bzrlib.workingtree.WorkingTreeFormat3',
 
2411
    deprecated=True)
 
2412
format_registry.register_metadir('dirstate',
 
2413
    'bzrlib.repofmt.knitrepo.RepositoryFormatKnit1',
 
2414
    help='New in 0.15: Fast local operations. Compatible with bzr 0.8 and '
 
2415
        'above when accessed over the network.',
 
2416
    branch_format='bzrlib.branch.BzrBranchFormat5',
 
2417
    # this uses bzrlib.workingtree.WorkingTreeFormat4 because importing
 
2418
    # directly from workingtree_4 triggers a circular import.
 
2419
    tree_format='bzrlib.workingtree.WorkingTreeFormat4',
 
2420
    )
 
2421
format_registry.register_metadir('dirstate-tags',
 
2422
    'bzrlib.repofmt.knitrepo.RepositoryFormatKnit1',
 
2423
    help='New in 0.15: Fast local operations and improved scaling for '
 
2424
        'network operations. Additionally adds support for tags.'
 
2425
        ' Incompatible with bzr < 0.15.',
 
2426
    branch_format='bzrlib.branch.BzrBranchFormat6',
 
2427
    tree_format='bzrlib.workingtree.WorkingTreeFormat4',
 
2428
    )
 
2429
format_registry.register_metadir('dirstate-with-subtree',
 
2430
    'bzrlib.repofmt.knitrepo.RepositoryFormatKnit3',
 
2431
    help='New in 0.15: Fast local operations and improved scaling for '
 
2432
        'network operations. Additionally adds support for versioning nested '
 
2433
        'bzr branches. Incompatible with bzr < 0.15.',
 
2434
    branch_format='bzrlib.branch.BzrBranchFormat6',
 
2435
    tree_format='bzrlib.workingtree.WorkingTreeFormat4',
 
2436
    hidden=True,
 
2437
    )
 
2438
format_registry.set_default('dirstate')