← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/bzrdir.py

Merged bzr.dev

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/bzrdir.py
46
46
    registry,
47
47
    revision as _mod_revision,
48
48
    repository as _mod_repository,
 
49
    symbol_versioning,
49
50
    urlutils,
50
51
    xml4,
51
52
    xml5,
204
205
 
205
206
    # TODO: Should take a Transport
206
207
    @classmethod
207
 
    def create(cls, base):
 
208
    def create(cls, base, format=None):
208
209
        """Create a new BzrDir at the url 'base'.
209
210
        
210
211
        This will call the current default formats initialize with base
211
212
        as the only parameter.
212
213
 
213
 
        If you need a specific format, consider creating an instance
214
 
        of that and calling initialize().
 
214
        :param format: If supplied, the format of branch to create.  If not
 
215
            supplied, the default is used.
215
216
        """
216
217
        if cls is not BzrDir:
217
 
            raise AssertionError("BzrDir.create always creates the default format, "
218
 
                    "not one of %r" % cls)
 
218
            raise AssertionError("BzrDir.create always creates the default"
 
219
                " format, not one of %r" % cls)
219
220
        head, tail = urlutils.split(base)
220
221
        if tail and tail != '.':
221
222
            t = get_transport(head)
223
224
                t.mkdir(tail)
224
225
            except errors.FileExists:
225
226
                pass
226
 
        return BzrDirFormat.get_default_format().initialize(safe_unicode(base))
 
227
        if format is None:
 
228
            format = BzrDirFormat.get_default_format()
 
229
        return format.initialize(safe_unicode(base))
227
230
 
228
231
    def create_branch(self):
229
232
        """Create a branch in this BzrDir.
234
237
        raise NotImplementedError(self.create_branch)
235
238
 
236
239
    @staticmethod
237
 
    def create_branch_and_repo(base, force_new_repo=False):
 
240
    def create_branch_and_repo(base, force_new_repo=False, format=None):
238
241
        """Create a new BzrDir, Branch and Repository at the url 'base'.
239
242
 
240
243
        This will use the current default BzrDirFormat, and use whatever 
247
250
        :param base: The URL to create the branch at.
248
251
        :param force_new_repo: If True a new repository is always created.
249
252
        """
250
 
        bzrdir = BzrDir.create(base)
 
253
        bzrdir = BzrDir.create(base, format)
251
254
        bzrdir._find_or_create_repository(force_new_repo)
252
255
        return bzrdir.create_branch()
253
256
 
291
294
            t = get_transport(safe_unicode(base))
292
295
            if not isinstance(t, LocalTransport):
293
296
                raise errors.NotLocalUrl(base)
294
 
        if format is None:
295
 
            bzrdir = BzrDir.create(base)
296
 
        else:
297
 
            bzrdir = format.initialize(base)
 
297
        bzrdir = BzrDir.create(base, format)
298
298
        repo = bzrdir._find_or_create_repository(force_new_repo)
299
299
        result = bzrdir.create_branch()
300
300
        if force_new_tree or (repo.make_working_trees() and 
306
306
        return result
307
307
        
308
308
    @staticmethod
309
 
    def create_repository(base, shared=False):
 
309
    def create_repository(base, shared=False, format=None):
310
310
        """Create a new BzrDir and Repository at the url 'base'.
311
311
 
312
 
        This will use the current default BzrDirFormat, and use whatever 
313
 
        repository format that that uses for bzrdirformat.create_repository.
 
312
        If no format is supplied, this will default to the current default
 
313
        BzrDirFormat by default, and use whatever repository format that that
 
314
        uses for bzrdirformat.create_repository.
314
315
 
315
316
        :param shared: Create a shared repository rather than a standalone
316
317
                       repository.
320
321
        it should take no parameters and construct whatever repository format
321
322
        that child class desires.
322
323
        """
323
 
        bzrdir = BzrDir.create(base)
 
324
        bzrdir = BzrDir.create(base, format)
324
325
        return bzrdir.create_repository(shared)
325
326
 
326
327
    @staticmethod
327
 
    def create_standalone_workingtree(base):
 
328
    def create_standalone_workingtree(base, format=None):
328
329
        """Create a new BzrDir, WorkingTree, Branch and Repository at 'base'.
329
330
 
330
331
        'base' must be a local path or a file:// url.
339
340
        if not isinstance(t, LocalTransport):
340
341
            raise errors.NotLocalUrl(base)
341
342
        bzrdir = BzrDir.create_branch_and_repo(safe_unicode(base),
342
 
                                               force_new_repo=True).bzrdir
 
343
                                               force_new_repo=True,
 
344
                                               format=format).bzrdir
343
345
        return bzrdir.create_workingtree()
344
346
 
345
347
    def create_workingtree(self, revision_id=None):
556
558
                raise errors.NotBranchError(path=url)
557
559
            a_transport = new_t
558
560
 
 
561
    @classmethod
 
562
    def open_containing_tree_or_branch(klass, location):
 
563
        """Return the branch and working tree contained by a location.
 
564
 
 
565
        Returns (tree, branch, relpath).
 
566
        If there is no tree at containing the location, tree will be None.
 
567
        If there is no branch containing the location, an exception will be
 
568
        raised
 
569
        relpath is the portion of the path that is contained by the branch.
 
570
        """
 
571
        bzrdir, relpath = klass.open_containing(location)
 
572
        try:
 
573
            tree = bzrdir.open_workingtree()
 
574
        except (errors.NoWorkingTree, errors.NotLocalUrl):
 
575
            tree = None
 
576
            branch = bzrdir.open_branch()
 
577
        else:
 
578
            branch = tree.branch
 
579
        return tree, branch, relpath
 
580
 
559
581
    def open_repository(self, _unsupported=False):
560
582
        """Open the repository object at this BzrDir if one is present.
561
583
 
1208
1230
        klass._control_formats.append(format)
1209
1231
 
1210
1232
    @classmethod
 
1233
    @symbol_versioning.deprecated_method(symbol_versioning.zero_fourteen)
1211
1234
    def set_default_format(klass, format):
 
1235
        klass._set_default_format(format)
 
1236
 
 
1237
    @classmethod
 
1238
    def _set_default_format(klass, format):
 
1239
        """Set default format (for testing behavior of defaults only)"""
1212
1240
        klass._default_format = format
1213
1241
 
1214
1242
    def __str__(self):
1452
1480
BzrDirFormat.register_format(BzrDirFormat6())
1453
1481
__default_format = BzrDirMetaFormat1()
1454
1482
BzrDirFormat.register_format(__default_format)
1455
 
BzrDirFormat.set_default_format(__default_format)
 
1483
BzrDirFormat._default_format = __default_format
1456
1484
 
1457
1485
 
1458
1486
class BzrDirTestProviderAdapter(object):
1999
2027
        registry.Registry.register(self, 'default', self.get(key), 
2000
2028
            self.get_help(key), info=self.get_info(key))
2001
2029
 
 
2030
    def set_default_repository(self, key):
 
2031
        """Set the FormatRegistry default and Repository default.
 
2032
        
 
2033
        This is a transitional method while Repository.set_default_format
 
2034
        is deprecated.
 
2035
        """
 
2036
        if 'default' in self:
 
2037
            self.remove('default')
 
2038
        self.set_default(key)
 
2039
        format = self.get('default')()
 
2040
        assert isinstance(format, BzrDirMetaFormat1)
 
2041
 
2002
2042
    def make_bzrdir(self, key):
2003
2043
        return self.get(key)()
2004
2044