← 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: 2006-07-06 03:15:29 UTC
  • mfrom: (1711.2.78 jam-integration)
  • Revision ID: pqm@pqm.ubuntu.com-20060706031529-e189d8c3f42076be
(jam) allow plugins to include benchmarks

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/bzrdir.py
1
 
# Copyright (C) 2005, 2006, 2007 Canonical Ltd
2
 
#
 
1
# Copyright (C) 2005, 2006 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: Can we move specific formats into separate modules to make this file
24
 
# smaller?
 
23
# TODO: remove unittest dependency; put that stuff inside the test suite
25
24
 
 
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(), """
32
28
from stat import S_ISDIR
 
29
from unittest import TestSuite
33
30
 
34
31
import bzrlib
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
 
    )
 
32
import bzrlib.errors as errors
 
33
from bzrlib.lockable_files import LockableFiles, TransportLock
 
34
from bzrlib.lockdir import LockDir
50
35
from bzrlib.osutils import (
51
 
    sha_strings,
52
 
    sha_string,
53
 
    )
54
 
from bzrlib.smart.client import _SmartClient
55
 
from bzrlib.smart import protocol
 
36
                            abspath,
 
37
                            pathjoin,
 
38
                            safe_unicode,
 
39
                            sha_strings,
 
40
                            sha_string,
 
41
                            )
56
42
from bzrlib.store.revision.text import TextRevisionStore
57
43
from bzrlib.store.text import TextStore
58
44
from bzrlib.store.versioned import WeaveStore
 
45
from bzrlib.trace import mutter
59
46
from bzrlib.transactions import WriteTransaction
60
 
from bzrlib.transport import (
61
 
    do_catching_redirections,
62
 
    get_transport,
63
 
    )
 
47
from bzrlib.transport import get_transport
 
48
from bzrlib.transport.local import LocalTransport
 
49
import bzrlib.urlutils as urlutils
64
50
from bzrlib.weave import Weave
65
 
""")
66
 
 
67
 
from bzrlib.trace import (
68
 
    mutter,
69
 
    note,
70
 
    )
71
 
from bzrlib.transport.local import LocalTransport
 
51
from bzrlib.xml4 import serializer_v4
 
52
import bzrlib.xml5
72
53
 
73
54
 
74
55
class BzrDir(object):
89
70
        If there is a tree, the tree is opened and break_lock() called.
90
71
        Otherwise, branch is tried, and finally repository.
91
72
        """
92
 
        # XXX: This seems more like a UI function than something that really
93
 
        # belongs in this class.
94
73
        try:
95
74
            thing_to_unlock = self.open_workingtree()
96
75
        except (errors.NotLocalUrl, errors.NoWorkingTree):
107
86
        """Return true if this bzrdir is one whose format we can convert from."""
108
87
        return True
109
88
 
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
 
 
115
89
    @staticmethod
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.
 
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.
131
94
        """
132
 
        # TODO: perhaps move this into a base Format class; it's not BzrDir
133
 
        # specific. mbp 20070323
134
95
        if not allow_unsupported and not format.is_supported():
135
96
            # see open_downlevel to open legacy branches.
136
97
            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)
142
98
 
143
 
    def clone(self, url, revision_id=None, force_new_repo=False):
 
99
    def clone(self, url, revision_id=None, basis=None, force_new_repo=False):
144
100
        """Clone this bzrdir and its contents to url verbatim.
145
101
 
146
102
        If urls last component does not exist, it will be created.
150
106
        :param force_new_repo: Do not use a shared repository for the target 
151
107
                               even if one is available.
152
108
        """
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)
 
109
        self._make_tail(url)
 
110
        basis_repo, basis_branch, basis_tree = self._get_basis_components(basis)
 
111
        result = self._format.initialize(url)
170
112
        try:
171
113
            local_repo = self.find_repository()
172
114
        except errors.NoRepositoryPresent:
176
118
            if force_new_repo:
177
119
                result_repo = local_repo.clone(
178
120
                    result,
179
 
                    revision_id=revision_id)
 
121
                    revision_id=revision_id,
 
122
                    basis=basis_repo)
180
123
                result_repo.set_make_working_trees(local_repo.make_working_trees())
181
124
            else:
182
125
                try:
183
126
                    result_repo = result.find_repository()
184
127
                    # 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)
185
132
                    result_repo.fetch(local_repo, revision_id=revision_id)
186
133
                except errors.NoRepositoryPresent:
187
134
                    # needed to make one anyway.
188
135
                    result_repo = local_repo.clone(
189
136
                        result,
190
 
                        revision_id=revision_id)
 
137
                        revision_id=revision_id,
 
138
                        basis=basis_repo)
191
139
                    result_repo.set_make_working_trees(local_repo.make_working_trees())
192
140
        # 1 if there is a branch present
193
141
        #   make sure its content is available in the target repository
197
145
        except errors.NotBranchError:
198
146
            pass
199
147
        try:
200
 
            self.open_workingtree().clone(result)
 
148
            self.open_workingtree().clone(result, basis=basis_tree)
201
149
        except (errors.NoWorkingTree, errors.NotLocalUrl):
202
150
            pass
203
151
        return result
204
152
 
 
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
 
205
174
    # TODO: This should be given a Transport, and should chdir up; otherwise
206
175
    # this will open a new connection.
207
176
    def _make_tail(self, url):
208
 
        t = get_transport(url)
209
 
        t.ensure_base()
 
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
210
184
 
 
185
    # TODO: Should take a Transport
211
186
    @classmethod
212
 
    def create(cls, base, format=None, possible_transports=None):
 
187
    def create(cls, base):
213
188
        """Create a new BzrDir at the url 'base'.
214
189
        
215
190
        This will call the current default formats initialize with base
216
191
        as the only parameter.
217
192
 
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.
 
193
        If you need a specific format, consider creating an instance
 
194
        of that and calling initialize().
222
195
        """
223
196
        if cls is not BzrDir:
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)
 
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))
231
207
 
232
208
    def create_branch(self):
233
209
        """Create a branch in this BzrDir.
238
214
        raise NotImplementedError(self.create_branch)
239
215
 
240
216
    @staticmethod
241
 
    def create_branch_and_repo(base, force_new_repo=False, format=None):
 
217
    def create_branch_and_repo(base, force_new_repo=False):
242
218
        """Create a new BzrDir, Branch and Repository at the url 'base'.
243
219
 
244
220
        This will use the current default BzrDirFormat, and use whatever 
251
227
        :param base: The URL to create the branch at.
252
228
        :param force_new_repo: If True a new repository is always created.
253
229
        """
254
 
        bzrdir = BzrDir.create(base, format)
 
230
        bzrdir = BzrDir.create(base)
255
231
        bzrdir._find_or_create_repository(force_new_repo)
256
232
        return bzrdir.create_branch()
257
233
 
266
242
        
267
243
    @staticmethod
268
244
    def create_branch_convenience(base, force_new_repo=False,
269
 
                                  force_new_tree=None, format=None,
270
 
                                  possible_transports=None):
 
245
                                  force_new_tree=None, format=None):
271
246
        """Create a new BzrDir, Branch and Repository at the url 'base'.
272
247
 
273
248
        This is a convenience function - it will use an existing repository
289
264
        :param force_new_repo: If True a new repository is always created.
290
265
        :param force_new_tree: If True or False force creation of a tree or 
291
266
                               prevent such creation respectively.
292
 
        :param format: Override for the for the bzrdir format to create.
293
 
        :param possible_transports: An optional reusable transports list.
 
267
        :param format: Override for the for the bzrdir format to create
294
268
        """
295
269
        if force_new_tree:
296
270
            # check for non local urls
297
 
            t = get_transport(base, possible_transports)
 
271
            t = get_transport(safe_unicode(base))
298
272
            if not isinstance(t, LocalTransport):
299
273
                raise errors.NotLocalUrl(base)
300
 
        bzrdir = BzrDir.create(base, format, possible_transports)
 
274
        if format is None:
 
275
            bzrdir = BzrDir.create(base)
 
276
        else:
 
277
            bzrdir = format.initialize(base)
301
278
        repo = bzrdir._find_or_create_repository(force_new_repo)
302
279
        result = bzrdir.create_branch()
303
 
        if force_new_tree or (repo.make_working_trees() and
 
280
        if force_new_tree or (repo.make_working_trees() and 
304
281
                              force_new_tree is None):
305
282
            try:
306
283
                bzrdir.create_workingtree()
307
284
            except errors.NotLocalUrl:
308
285
                pass
309
286
        return result
310
 
 
 
287
        
311
288
    @staticmethod
312
 
    def create_repository(base, shared=False, format=None):
 
289
    def create_repository(base, shared=False):
313
290
        """Create a new BzrDir and Repository at the url 'base'.
314
291
 
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.
 
292
        This will use the current default BzrDirFormat, and use whatever 
 
293
        repository format that that uses for bzrdirformat.create_repository.
318
294
 
319
 
        :param shared: Create a shared repository rather than a standalone
 
295
        ;param shared: Create a shared repository rather than a standalone
320
296
                       repository.
321
297
        The Repository object is returned.
322
298
 
324
300
        it should take no parameters and construct whatever repository format
325
301
        that child class desires.
326
302
        """
327
 
        bzrdir = BzrDir.create(base, format)
328
 
        return bzrdir.create_repository(shared)
 
303
        bzrdir = BzrDir.create(base)
 
304
        return bzrdir.create_repository()
329
305
 
330
306
    @staticmethod
331
 
    def create_standalone_workingtree(base, format=None):
 
307
    def create_standalone_workingtree(base):
332
308
        """Create a new BzrDir, WorkingTree, Branch and Repository at 'base'.
333
309
 
334
310
        'base' must be a local path or a file:// url.
337
313
        repository format that that uses for bzrdirformat.create_workingtree,
338
314
        create_branch and create_repository.
339
315
 
340
 
        :return: The WorkingTree object.
 
316
        The WorkingTree object is returned.
341
317
        """
342
 
        t = get_transport(base)
 
318
        t = get_transport(safe_unicode(base))
343
319
        if not isinstance(t, LocalTransport):
344
320
            raise errors.NotLocalUrl(base)
345
 
        bzrdir = BzrDir.create_branch_and_repo(base,
346
 
                                               force_new_repo=True,
347
 
                                               format=format).bzrdir
 
321
        bzrdir = BzrDir.create_branch_and_repo(safe_unicode(base),
 
322
                                               force_new_repo=True).bzrdir
348
323
        return bzrdir.create_workingtree()
349
324
 
350
325
    def create_workingtree(self, revision_id=None):
354
329
        """
355
330
        raise NotImplementedError(self.create_workingtree)
356
331
 
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
 
 
391
332
    def find_repository(self):
392
333
        """Find the repository that should be used for a_bzrdir.
393
334
 
418
359
                    break
419
360
                else:
420
361
                    continue
421
 
            if ((found_bzrdir.root_transport.base ==
 
362
            if ((found_bzrdir.root_transport.base == 
422
363
                 self.root_transport.base) or repository.is_shared()):
423
364
                return repository
424
365
            else:
425
366
                raise errors.NoRepositoryPresent(self)
426
367
        raise errors.NoRepositoryPresent(self)
427
368
 
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
 
 
437
369
    def get_branch_transport(self, branch_format):
438
370
        """Get the transport for use by branch format in this BzrDir.
439
371
 
464
396
        """Get the transport for use by workingtree format in this BzrDir.
465
397
 
466
398
        Note that bzr dirs that do not support format strings will raise
467
 
        IncompatibleFormat if the workingtree format they are given has a
468
 
        format string, and vice versa.
 
399
        IncompatibleFormat if the workingtree format they are given has
 
400
        a format string, and vice versa.
469
401
 
470
402
        If workingtree_format is None, the transport is returned with no 
471
403
        checking. if it is not None, then the returned transport is
528
460
        _unsupported is a private parameter to the BzrDir class.
529
461
        """
530
462
        t = get_transport(base)
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
 
 
 
463
        mutter("trying to open %r with transport %r", base, t)
 
464
        format = BzrDirFormat.find_format(t)
572
465
        BzrDir._check_supported(format, _unsupported)
573
 
        return format.open(transport, _found=True)
 
466
        return format.open(t, _found=True)
574
467
 
575
468
    def open_branch(self, unsupported=False):
576
469
        """Open the branch object at this BzrDir if one is present.
583
476
        raise NotImplementedError(self.open_branch)
584
477
 
585
478
    @staticmethod
586
 
    def open_containing(url, possible_transports=None):
 
479
    def open_containing(url):
587
480
        """Open an existing branch which contains url.
588
481
        
589
482
        :param url: url to search from.
590
483
        See open_containing_from_transport for more detail.
591
484
        """
592
 
        transport = get_transport(url, possible_transports)
593
 
        return BzrDir.open_containing_from_transport(transport)
 
485
        return BzrDir.open_containing_from_transport(get_transport(url))
594
486
    
595
487
    @staticmethod
596
488
    def open_containing_from_transport(a_transport):
611
503
        url = a_transport.base
612
504
        while True:
613
505
            try:
614
 
                result = BzrDir.open_from_transport(a_transport)
615
 
                return result, urlutils.unescape(a_transport.relpath(url))
 
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))
616
509
            except errors.NotBranchError, e:
 
510
                ## mutter('not a branch in: %r %s', a_transport.base, e)
617
511
                pass
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)
 
512
            new_t = a_transport.clone('..')
623
513
            if new_t.base == a_transport.base:
624
514
                # reached the root, whatever that may be
625
515
                raise errors.NotBranchError(path=url)
626
516
            a_transport = new_t
627
517
 
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
 
 
648
518
    def open_repository(self, _unsupported=False):
649
519
        """Open the repository object at this BzrDir if one is present.
650
520
 
657
527
        """
658
528
        raise NotImplementedError(self.open_repository)
659
529
 
660
 
    def open_workingtree(self, _unsupported=False,
661
 
            recommend_upgrade=True):
 
530
    def open_workingtree(self, _unsupported=False):
662
531
        """Open the workingtree object at this BzrDir if one is present.
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).
 
532
        
 
533
        TODO: static convenience version of this?
668
534
        """
669
535
        raise NotImplementedError(self.open_workingtree)
670
536
 
692
558
        workingtree and discards it, and that's somewhat expensive.) 
693
559
        """
694
560
        try:
695
 
            self.open_workingtree(recommend_upgrade=False)
 
561
            self.open_workingtree()
696
562
            return True
697
563
        except errors.NoWorkingTree:
698
564
            return False
699
565
 
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):
 
566
    def sprout(self, url, revision_id=None, basis=None, force_new_repo=False):
750
567
        """Create a copy of this bzrdir prepared for use as a new line of
751
568
        development.
752
569
 
760
577
        if revision_id is not None, then the clone operation may tune
761
578
            itself to download less data.
762
579
        """
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)
 
580
        self._make_tail(url)
 
581
        result = self._format.initialize(url)
 
582
        basis_repo, basis_branch, basis_tree = self._get_basis_components(basis)
767
583
        try:
768
584
            source_branch = self.open_branch()
769
585
            source_repository = source_branch.repository
772
588
            try:
773
589
                source_repository = self.open_repository()
774
590
            except errors.NoRepositoryPresent:
775
 
                source_repository = None
 
591
                # copy the entire basis one if there is one
 
592
                # but there is no repository.
 
593
                source_repository = basis_repo
776
594
        if force_new_repo:
777
595
            result_repo = None
778
596
        else:
787
605
            result.create_repository()
788
606
        elif source_repository is not None and result_repo is None:
789
607
            # have source, and want to make a new target repo
790
 
            result_repo = source_repository.sprout(result,
791
 
                                                   revision_id=revision_id)
792
 
        else:
 
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:
793
613
            # fetch needed content into target.
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)
 
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)
800
619
        if source_branch is not None:
801
620
            source_branch.sprout(result, revision_id=revision_id)
802
621
        else:
803
622
            result.create_branch()
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()
 
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()
842
627
        return result
843
628
 
844
629
 
848
633
    def __init__(self, _transport, _format):
849
634
        """See BzrDir.__init__."""
850
635
        super(BzrDirPreSplitOut, self).__init__(_transport, _format)
851
 
        assert self._format._lock_class == lockable_files.TransportLock
 
636
        assert self._format._lock_class == TransportLock
852
637
        assert self._format._lock_file_name == 'branch-lock'
853
 
        self._control_files = lockable_files.LockableFiles(
854
 
                                            self.get_branch_transport(None),
 
638
        self._control_files = LockableFiles(self.get_branch_transport(None),
855
639
                                            self._format._lock_file_name,
856
640
                                            self._format._lock_class)
857
641
 
859
643
        """Pre-splitout bzrdirs do not suffer from stale locks."""
860
644
        raise NotImplementedError(self.break_lock)
861
645
 
862
 
    def clone(self, url, revision_id=None, force_new_repo=False):
 
646
    def clone(self, url, revision_id=None, basis=None, force_new_repo=False):
863
647
        """See BzrDir.clone()."""
864
648
        from bzrlib.workingtree import WorkingTreeFormat2
865
649
        self._make_tail(url)
866
650
        result = self._format._initialize_for_clone(url)
867
 
        self.open_repository().clone(result, revision_id=revision_id)
 
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)
868
653
        from_branch = self.open_branch()
869
654
        from_branch.clone(result, revision_id=revision_id)
870
655
        try:
871
 
            self.open_workingtree().clone(result)
 
656
            self.open_workingtree().clone(result, basis=basis_tree)
872
657
        except errors.NotLocalUrl:
873
658
            # make a new one, this format always has to have one.
874
659
            try:
892
677
    def create_workingtree(self, revision_id=None):
893
678
        """See BzrDir.create_workingtree."""
894
679
        # this looks buggy but is not -really-
895
 
        # because this format creates the workingtree when the bzrdir is
896
 
        # created
897
680
        # clone and sprout will have set the revision_id
898
681
        # and that will have set it for us, its only
899
682
        # specific uses of create_workingtree in isolation
900
683
        # that can do wonky stuff here, and that only
901
684
        # happens for creating checkouts, which cannot be 
902
685
        # done on this format anyway. So - acceptable wart.
903
 
        result = self.open_workingtree(recommend_upgrade=False)
 
686
        result = self.open_workingtree()
904
687
        if revision_id is not None:
905
 
            if revision_id == _mod_revision.NULL_REVISION:
906
 
                result.set_parent_ids([])
907
 
            else:
908
 
                result.set_parent_ids([revision_id])
 
688
            result.set_last_revision(revision_id)
909
689
        return result
910
690
 
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
 
 
920
691
    def get_branch_transport(self, branch_format):
921
692
        """See BzrDir.get_branch_transport()."""
922
693
        if branch_format is None:
962
733
        self._check_supported(format, unsupported)
963
734
        return format.open(self, _found=True)
964
735
 
965
 
    def sprout(self, url, revision_id=None, force_new_repo=False,
966
 
               possible_transports=None):
 
736
    def sprout(self, url, revision_id=None, basis=None):
967
737
        """See BzrDir.sprout()."""
968
738
        from bzrlib.workingtree import WorkingTreeFormat2
969
739
        self._make_tail(url)
970
740
        result = self._format._initialize_for_clone(url)
 
741
        basis_repo, basis_branch, basis_tree = self._get_basis_components(basis)
971
742
        try:
972
 
            self.open_repository().clone(result, revision_id=revision_id)
 
743
            self.open_repository().clone(result, revision_id=revision_id, basis=basis_repo)
973
744
        except errors.NoRepositoryPresent:
974
745
            pass
975
746
        try:
997
768
 
998
769
    def open_repository(self):
999
770
        """See BzrDir.open_repository."""
1000
 
        from bzrlib.repofmt.weaverepo import RepositoryFormat4
 
771
        from bzrlib.repository import RepositoryFormat4
1001
772
        return RepositoryFormat4().open(self, _found=True)
1002
773
 
1003
774
 
1009
780
 
1010
781
    def open_repository(self):
1011
782
        """See BzrDir.open_repository."""
1012
 
        from bzrlib.repofmt.weaverepo import RepositoryFormat5
 
783
        from bzrlib.repository import RepositoryFormat5
1013
784
        return RepositoryFormat5().open(self, _found=True)
1014
785
 
1015
 
    def open_workingtree(self, _unsupported=False,
1016
 
            recommend_upgrade=True):
 
786
    def open_workingtree(self, _unsupported=False):
1017
787
        """See BzrDir.create_workingtree."""
1018
788
        from bzrlib.workingtree import WorkingTreeFormat2
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)
 
789
        return WorkingTreeFormat2().open(self, _found=True)
1023
790
 
1024
791
 
1025
792
class BzrDir6(BzrDirPreSplitOut):
1030
797
 
1031
798
    def open_repository(self):
1032
799
        """See BzrDir.open_repository."""
1033
 
        from bzrlib.repofmt.weaverepo import RepositoryFormat6
 
800
        from bzrlib.repository import RepositoryFormat6
1034
801
        return RepositoryFormat6().open(self, _found=True)
1035
802
 
1036
 
    def open_workingtree(self, _unsupported=False,
1037
 
        recommend_upgrade=True):
 
803
    def open_workingtree(self, _unsupported=False):
1038
804
        """See BzrDir.create_workingtree."""
1039
 
        # we don't warn here about upgrades; that ought to be handled for the
1040
 
        # bzrdir as a whole
1041
805
        from bzrlib.workingtree import WorkingTreeFormat2
1042
806
        return WorkingTreeFormat2().open(self, _found=True)
1043
807
 
1057
821
 
1058
822
    def create_branch(self):
1059
823
        """See BzrDir.create_branch."""
1060
 
        return self._format.get_branch_format().initialize(self)
 
824
        from bzrlib.branch import BranchFormat
 
825
        return BranchFormat.get_default_format().initialize(self)
1061
826
 
1062
827
    def create_repository(self, shared=False):
1063
828
        """See BzrDir.create_repository."""
1066
831
    def create_workingtree(self, revision_id=None):
1067
832
        """See BzrDir.create_workingtree."""
1068
833
        from bzrlib.workingtree import WorkingTreeFormat
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)
 
834
        return WorkingTreeFormat.get_default_format().initialize(self, revision_id)
1089
835
 
1090
836
    def _get_mkdir_mode(self):
1091
837
        """Figure out the mode to use when creating a bzrdir subdir."""
1092
 
        temp_control = lockable_files.LockableFiles(self.transport, '',
1093
 
                                     lockable_files.TransportLock)
 
838
        temp_control = LockableFiles(self.transport, '', TransportLock)
1094
839
        return temp_control._dir_mode
1095
840
 
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
 
 
1102
841
    def get_branch_transport(self, branch_format):
1103
842
        """See BzrDir.get_branch_transport()."""
1104
843
        if branch_format is None:
1156
895
                return True
1157
896
        except errors.NoRepositoryPresent:
1158
897
            pass
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
 
898
        # currently there are no other possible conversions for meta1 formats.
1174
899
        return False
1175
900
 
1176
901
    def open_branch(self, unsupported=False):
1177
902
        """See BzrDir.open_branch."""
1178
 
        format = self.find_branch_format()
 
903
        from bzrlib.branch import BranchFormat
 
904
        format = BranchFormat.find_format(self)
1179
905
        self._check_supported(format, unsupported)
1180
906
        return format.open(self, _found=True)
1181
907
 
1186
912
        self._check_supported(format, unsupported)
1187
913
        return format.open(self, _found=True)
1188
914
 
1189
 
    def open_workingtree(self, unsupported=False,
1190
 
            recommend_upgrade=True):
 
915
    def open_workingtree(self, unsupported=False):
1191
916
        """See BzrDir.open_workingtree."""
1192
917
        from bzrlib.workingtree import WorkingTreeFormat
1193
918
        format = WorkingTreeFormat.find_format(self)
1194
 
        self._check_supported(format, unsupported,
1195
 
            recommend_upgrade,
1196
 
            basedir=self.root_transport.base)
 
919
        self._check_supported(format, unsupported)
1197
920
        return format.open(self, _found=True)
1198
921
 
1199
922
 
1226
949
    This is a list of BzrDirFormat objects.
1227
950
    """
1228
951
 
1229
 
    _control_server_formats = []
1230
 
    """The registered control server formats, e.g. RemoteBzrDirs.
1231
 
 
1232
 
    This is a list of BzrDirFormat objects.
1233
 
    """
1234
 
 
1235
952
    _lock_file_name = 'branch-lock'
1236
953
 
1237
954
    # _lock_class must be set in subclasses to the lock type, typ.
1238
955
    # TransportLock or LockDir
1239
956
 
1240
957
    @classmethod
1241
 
    def find_format(klass, transport, _server_formats=True):
 
958
    def find_format(klass, transport):
1242
959
        """Return the format present at transport."""
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:
 
960
        for format in klass._control_formats:
1248
961
            try:
1249
962
                return format.probe_transport(transport)
1250
963
            except errors.NotBranchError:
1254
967
 
1255
968
    @classmethod
1256
969
    def probe_transport(klass, transport):
1257
 
        """Return the .bzrdir style format present in a directory."""
 
970
        """Return the .bzrdir style transport present at URL."""
1258
971
        try:
1259
972
            format_string = transport.get(".bzr/branch-format").read()
1260
973
        except errors.NoSuchFile:
1292
1005
        """
1293
1006
        raise NotImplementedError(self.get_converter)
1294
1007
 
1295
 
    def initialize(self, url, possible_transports=None):
 
1008
    def initialize(self, url):
1296
1009
        """Create a bzr control dir at this url and return an opened copy.
1297
1010
        
1298
1011
        Subclasses should typically override initialize_on_transport
1299
1012
        instead of this method.
1300
1013
        """
1301
 
        return self.initialize_on_transport(get_transport(url,
1302
 
                                                          possible_transports))
 
1014
        return self.initialize_on_transport(get_transport(url))
1303
1015
 
1304
1016
    def initialize_on_transport(self, transport):
1305
1017
        """Initialize a new bzrdir in the base directory of a Transport."""
1306
1018
        # Since we don't have a .bzr directory, inherit the
1307
1019
        # mode from the root directory
1308
 
        temp_control = lockable_files.LockableFiles(transport,
1309
 
                            '', lockable_files.TransportLock)
 
1020
        temp_control = LockableFiles(transport, '', TransportLock)
1310
1021
        temp_control._transport.mkdir('.bzr',
1311
1022
                                      # FIXME: RBC 20060121 don't peek under
1312
1023
                                      # the covers
1321
1032
                      ('branch-format', self.get_format_string()),
1322
1033
                      ]
1323
1034
        # NB: no need to escape relative paths that are url safe.
1324
 
        control_files = lockable_files.LockableFiles(control,
1325
 
                            self._lock_file_name, self._lock_class)
 
1035
        control_files = LockableFiles(control, self._lock_file_name, 
 
1036
                                      self._lock_class)
1326
1037
        control_files.create_lock()
1327
1038
        control_files.lock_write()
1328
1039
        try:
1341
1052
        """
1342
1053
        return True
1343
1054
 
1344
 
    def same_model(self, target_format):
1345
 
        return (self.repository_format.rich_root_data == 
1346
 
            target_format.rich_root_data)
1347
 
 
1348
1055
    @classmethod
1349
1056
    def known_formats(klass):
1350
1057
        """Return all the known formats.
1370
1077
        _found is a private parameter, do not use it.
1371
1078
        """
1372
1079
        if not _found:
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))
 
1080
            assert isinstance(BzrDirFormat.find_format(transport),
 
1081
                              self.__class__)
1378
1082
        return self._open(transport)
1379
1083
 
1380
1084
    def _open(self, transport):
1391
1095
 
1392
1096
    @classmethod
1393
1097
    def register_control_format(klass, format):
1394
 
        """Register a format that does not use '.bzr' for its control dir.
 
1098
        """Register a format that does not use '.bzrdir' for its control dir.
1395
1099
 
1396
1100
        TODO: This should be pulled up into a 'ControlDirFormat' base class
1397
1101
        which BzrDirFormat can inherit from, and renamed to register_format 
1401
1105
        klass._control_formats.append(format)
1402
1106
 
1403
1107
    @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)
1416
1108
    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)"""
1422
1109
        klass._default_format = format
1423
1110
 
1424
1111
    def __str__(self):
1434
1121
        klass._control_formats.remove(format)
1435
1122
 
1436
1123
 
 
1124
# register BzrDirFormat as a control format
 
1125
BzrDirFormat.register_control_format(BzrDirFormat)
 
1126
 
 
1127
 
1437
1128
class BzrDirFormat4(BzrDirFormat):
1438
1129
    """Bzr dir format 4.
1439
1130
 
1447
1138
    removed in format 5; write support for this format has been removed.
1448
1139
    """
1449
1140
 
1450
 
    _lock_class = lockable_files.TransportLock
 
1141
    _lock_class = TransportLock
1451
1142
 
1452
1143
    def get_format_string(self):
1453
1144
        """See BzrDirFormat.get_format_string()."""
1481
1172
 
1482
1173
    def __return_repository_format(self):
1483
1174
        """Circular import protection."""
1484
 
        from bzrlib.repofmt.weaverepo import RepositoryFormat4
1485
 
        return RepositoryFormat4()
 
1175
        from bzrlib.repository import RepositoryFormat4
 
1176
        return RepositoryFormat4(self)
1486
1177
    repository_format = property(__return_repository_format)
1487
1178
 
1488
1179
 
1497
1188
       Unhashed stores in the repository.
1498
1189
    """
1499
1190
 
1500
 
    _lock_class = lockable_files.TransportLock
 
1191
    _lock_class = TransportLock
1501
1192
 
1502
1193
    def get_format_string(self):
1503
1194
        """See BzrDirFormat.get_format_string()."""
1521
1212
        Except when they are being cloned.
1522
1213
        """
1523
1214
        from bzrlib.branch import BzrBranchFormat4
1524
 
        from bzrlib.repofmt.weaverepo import RepositoryFormat5
 
1215
        from bzrlib.repository import RepositoryFormat5
1525
1216
        from bzrlib.workingtree import WorkingTreeFormat2
1526
1217
        result = (super(BzrDirFormat5, self).initialize_on_transport(transport))
1527
1218
        RepositoryFormat5().initialize(result, _internal=True)
1528
1219
        if not _cloning:
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)
 
1220
            BzrBranchFormat4().initialize(result)
 
1221
            WorkingTreeFormat2().initialize(result)
1536
1222
        return result
1537
1223
 
1538
1224
    def _open(self, transport):
1541
1227
 
1542
1228
    def __return_repository_format(self):
1543
1229
        """Circular import protection."""
1544
 
        from bzrlib.repofmt.weaverepo import RepositoryFormat5
1545
 
        return RepositoryFormat5()
 
1230
        from bzrlib.repository import RepositoryFormat5
 
1231
        return RepositoryFormat5(self)
1546
1232
    repository_format = property(__return_repository_format)
1547
1233
 
1548
1234
 
1556
1242
     - Format 6 repositories [always]
1557
1243
    """
1558
1244
 
1559
 
    _lock_class = lockable_files.TransportLock
 
1245
    _lock_class = TransportLock
1560
1246
 
1561
1247
    def get_format_string(self):
1562
1248
        """See BzrDirFormat.get_format_string()."""
1580
1266
        Except when they are being cloned.
1581
1267
        """
1582
1268
        from bzrlib.branch import BzrBranchFormat4
1583
 
        from bzrlib.repofmt.weaverepo import RepositoryFormat6
 
1269
        from bzrlib.repository import RepositoryFormat6
1584
1270
        from bzrlib.workingtree import WorkingTreeFormat2
1585
1271
        result = super(BzrDirFormat6, self).initialize_on_transport(transport)
1586
1272
        RepositoryFormat6().initialize(result, _internal=True)
1587
1273
        if not _cloning:
1588
 
            branch = BzrBranchFormat4().initialize(result)
 
1274
            BzrBranchFormat4().initialize(result)
1589
1275
            try:
1590
1276
                WorkingTreeFormat2().initialize(result)
1591
1277
            except errors.NotLocalUrl:
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)
 
1278
                # emulate pre-check behaviour for working tree and silently 
 
1279
                # fail.
 
1280
                pass
1595
1281
        return result
1596
1282
 
1597
1283
    def _open(self, transport):
1600
1286
 
1601
1287
    def __return_repository_format(self):
1602
1288
        """Circular import protection."""
1603
 
        from bzrlib.repofmt.weaverepo import RepositoryFormat6
1604
 
        return RepositoryFormat6()
 
1289
        from bzrlib.repository import RepositoryFormat6
 
1290
        return RepositoryFormat6(self)
1605
1291
    repository_format = property(__return_repository_format)
1606
1292
 
1607
1293
 
1616
1302
     - Format 7 repositories [optional]
1617
1303
    """
1618
1304
 
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
 
1305
    _lock_class = LockDir
1645
1306
 
1646
1307
    def get_converter(self, format=None):
1647
1308
        """See BzrDirFormat.get_converter()."""
1677
1338
 
1678
1339
    repository_format = property(__return_repository_format, __set_repository_format)
1679
1340
 
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
 
1341
 
1697
1342
BzrDirFormat.register_format(BzrDirFormat4())
1698
1343
BzrDirFormat.register_format(BzrDirFormat5())
1699
1344
BzrDirFormat.register_format(BzrDirFormat6())
1700
1345
__default_format = BzrDirMetaFormat1()
1701
1346
BzrDirFormat.register_format(__default_format)
1702
 
BzrDirFormat._default_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
1703
1377
 
1704
1378
 
1705
1379
class Converter(object):
1792
1466
        self.bzrdir.transport.delete_tree('text-store')
1793
1467
 
1794
1468
    def _convert_working_inv(self):
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)
 
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)
1798
1471
        # FIXME inventory is a working tree change.
1799
 
        self.branch.control_files.put('inventory', StringIO(new_inv_xml))
 
1472
        self.branch.control_files.put('inventory', new_inv_xml)
1800
1473
 
1801
1474
    def _write_all_weaves(self):
1802
1475
        controlweaves = WeaveStore(self.bzrdir.transport, prefixed=False)
1826
1499
                                                      prefixed=False,
1827
1500
                                                      compressed=True))
1828
1501
        try:
1829
 
            transaction = WriteTransaction()
 
1502
            transaction = bzrlib.transactions.WriteTransaction()
1830
1503
            for i, rev_id in enumerate(self.converted_revs):
1831
1504
                self.pb.update('write revision', i, len(self.converted_revs))
1832
1505
                _revision_store.add_revision(self.revisions[rev_id], transaction)
1858
1531
    def _load_old_inventory(self, rev_id):
1859
1532
        assert rev_id not in self.converted_revs
1860
1533
        old_inv_xml = self.branch.repository.inventory_store.get(rev_id).read()
1861
 
        inv = xml4.serializer_v4.read_inventory_from_string(old_inv_xml)
1862
 
        inv.revision_id = rev_id
 
1534
        inv = serializer_v4.read_inventory_from_string(old_inv_xml)
1863
1535
        rev = self.revisions[rev_id]
1864
1536
        if rev.inventory_sha1:
1865
1537
            assert rev.inventory_sha1 == sha_string(old_inv_xml), \
1869
1541
    def _load_updated_inventory(self, rev_id):
1870
1542
        assert rev_id in self.converted_revs
1871
1543
        inv_xml = self.inv_weave.get_text(rev_id)
1872
 
        inv = xml5.serializer_v5.read_inventory_from_string(inv_xml)
 
1544
        inv = bzrlib.xml5.serializer_v5.read_inventory_from_string(inv_xml)
1873
1545
        return inv
1874
1546
 
1875
1547
    def _convert_one_rev(self, rev_id):
1885
1557
    def _store_new_weave(self, rev, inv, present_parents):
1886
1558
        # the XML is now updated with text versions
1887
1559
        if __debug__:
1888
 
            entries = inv.iter_entries()
1889
 
            entries.next()
1890
 
            for path, ie in entries:
1891
 
                assert getattr(ie, 'revision', None) is not None, \
 
1560
            for file_id in inv:
 
1561
                ie = inv[file_id]
 
1562
                if ie.kind == 'root_directory':
 
1563
                    continue
 
1564
                assert hasattr(ie, 'revision'), \
1892
1565
                    'no revision on {%s} in {%s}' % \
1893
1566
                    (file_id, rev.revision_id)
1894
 
        new_inv_xml = xml5.serializer_v5.write_inventory_to_string(inv)
 
1567
        new_inv_xml = bzrlib.xml5.serializer_v5.write_inventory_to_string(inv)
1895
1568
        new_inv_sha1 = sha_string(new_inv_xml)
1896
1569
        self.inv_weave.add_lines(rev.revision_id, 
1897
1570
                                 present_parents,
1906
1579
        mutter('converting texts of revision {%s}',
1907
1580
               rev_id)
1908
1581
        parent_invs = map(self._load_updated_inventory, present_parents)
1909
 
        entries = inv.iter_entries()
1910
 
        entries.next()
1911
 
        for path, ie in entries:
 
1582
        for file_id in inv:
 
1583
            ie = inv[file_id]
1912
1584
            self._convert_file_version(rev, ie, parent_invs)
1913
1585
 
1914
1586
    def _convert_file_version(self, rev, ie, parent_invs):
1917
1589
        The file needs to be added into the weave if it is a merge
1918
1590
        of >=2 parents or if it's changed from its parent.
1919
1591
        """
 
1592
        if ie.kind == 'root_directory':
 
1593
            return
1920
1594
        file_id = ie.file_id
1921
1595
        rev_id = rev.revision_id
1922
1596
        w = self.text_weaves.get(file_id)
1930
1604
                                                  entry_vf=w)
1931
1605
        for old_revision in previous_entries:
1932
1606
                # if this fails, its a ghost ?
1933
 
                assert old_revision in self.converted_revs, \
1934
 
                    "Revision {%s} not in converted_revs" % old_revision
 
1607
                assert old_revision in self.converted_revs 
1935
1608
        self.snapshot_ie(previous_entries, ie, w, rev_id)
1936
1609
        del ie.text_id
1937
1610
        assert getattr(ie, 'revision', None) is not None
2024
1697
 
2025
1698
    def convert(self, to_convert, pb):
2026
1699
        """See Converter.convert()."""
2027
 
        from bzrlib.repofmt.weaverepo import RepositoryFormat7
2028
 
        from bzrlib.branch import BzrBranchFormat5
2029
1700
        self.bzrdir = to_convert
2030
1701
        self.pb = pb
2031
1702
        self.count = 0
2060
1731
        # we hard code the formats here because we are converting into
2061
1732
        # the meta format. The meta format upgrader can take this to a 
2062
1733
        # future format within each component.
2063
 
        self.put_format('repository', RepositoryFormat7())
 
1734
        self.put_format('repository', bzrlib.repository.RepositoryFormat7())
2064
1735
        for entry in repository_names:
2065
1736
            self.move_entry('repository', entry)
2066
1737
 
2067
1738
        self.step('Upgrading branch      ')
2068
1739
        self.bzrdir.transport.mkdir('branch', mode=self.dir_mode)
2069
1740
        self.make_lock('branch')
2070
 
        self.put_format('branch', BzrBranchFormat5())
 
1741
        self.put_format('branch', bzrlib.branch.BzrBranchFormat5())
2071
1742
        branch_files = [('revision-history', True),
2072
1743
                        ('branch-name', True),
2073
1744
                        ('parent', False)]
2074
1745
        for entry in branch_files:
2075
1746
            self.move_entry('branch', entry)
2076
1747
 
 
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)
2077
1753
        checkout_files = [('pending-merges', True),
2078
1754
                          ('inventory', True),
2079
1755
                          ('stat-cache', False)]
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())
 
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())
2111
1762
        return BzrDir.open(self.bzrdir.root_transport.base)
2112
1763
 
2113
1764
    def make_lock(self, name):
2114
1765
        """Make a lock for the new control dir name."""
2115
1766
        self.step('Make %s lock' % name)
2116
 
        ld = lockdir.LockDir(self.bzrdir.transport,
2117
 
                             '%s/lock' % name,
2118
 
                             file_modebits=self.file_mode,
2119
 
                             dir_modebits=self.dir_mode)
 
1767
        ld = LockDir(self.bzrdir.transport, 
 
1768
                     '%s/lock' % name,
 
1769
                     file_modebits=self.file_mode,
 
1770
                     dir_modebits=self.dir_mode)
2120
1771
        ld.create()
2121
1772
 
2122
1773
    def move_entry(self, new_dir, entry):
2161
1812
                self.pb.note('starting repository conversion')
2162
1813
                converter = CopyConverter(self.target_format.repository_format)
2163
1814
                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)
2190
1815
        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')