148
157
def clone(self, url, revision_id=None, force_new_repo=False):
149
158
"""Clone this bzrdir and its contents to url verbatim.
151
If urls last component does not exist, it will be created.
153
if revision_id is not None, then the clone operation may tune
154
itself to download less data.
155
:param force_new_repo: Do not use a shared repository for the target
156
even if one is available.
159
result = self._format.initialize(url)
160
If url's last component does not exist, it will be created.
162
if revision_id is not None, then the clone operation may tune
163
itself to download less data.
164
:param force_new_repo: Do not use a shared repository for the target
165
even if one is available.
167
return self.clone_on_transport(get_transport(url),
168
revision_id=revision_id,
169
force_new_repo=force_new_repo)
171
def clone_on_transport(self, transport, revision_id=None,
172
force_new_repo=False):
173
"""Clone this bzrdir and its contents to transport verbatim.
175
If the target directory does not exist, it will be created.
177
if revision_id is not None, then the clone operation may tune
178
itself to download less data.
179
:param force_new_repo: Do not use a shared repository for the target
180
even if one is available.
182
transport.ensure_base()
183
result = self._format.initialize_on_transport(transport)
161
185
local_repo = self.find_repository()
162
186
except errors.NoRepositoryPresent:
187
211
except errors.NotBranchError:
190
self.open_workingtree().clone(result)
191
except (errors.NoWorkingTree, errors.NotLocalUrl):
214
result_repo = result.find_repository()
215
except errors.NoRepositoryPresent:
217
if result_repo is None or result_repo.make_working_trees():
219
self.open_workingtree().clone(result)
220
except (errors.NoWorkingTree, errors.NotLocalUrl):
195
224
# TODO: This should be given a Transport, and should chdir up; otherwise
196
225
# this will open a new connection.
197
226
def _make_tail(self, url):
198
head, tail = urlutils.split(url)
199
if tail and tail != '.':
200
t = get_transport(head)
203
except errors.FileExists:
227
t = get_transport(url)
206
# TODO: Should take a Transport
208
def create(cls, base, format=None):
231
def create(cls, base, format=None, possible_transports=None):
209
232
"""Create a new BzrDir at the url 'base'.
211
This will call the current default formats initialize with base
212
as the only parameter.
214
234
:param format: If supplied, the format of branch to create. If not
215
235
supplied, the default is used.
236
:param possible_transports: If supplied, a list of transports that
237
can be reused to share a remote connection.
217
239
if cls is not BzrDir:
218
240
raise AssertionError("BzrDir.create always creates the default"
219
241
" format, not one of %r" % cls)
220
head, tail = urlutils.split(base)
221
if tail and tail != '.':
222
t = get_transport(head)
225
except errors.FileExists:
242
t = get_transport(base, possible_transports)
227
244
if format is None:
228
245
format = BzrDirFormat.get_default_format()
229
return format.initialize(safe_unicode(base))
246
return format.initialize_on_transport(t)
249
def find_bzrdirs(transport, evaluate=None, list_current=None):
250
"""Find bzrdirs recursively from current location.
252
This is intended primarily as a building block for more sophisticated
253
functionality, like finding trees under a directory, or finding
254
branches that use a given repository.
255
:param evaluate: An optional callable that yields recurse, value,
256
where recurse controls whether this bzrdir is recursed into
257
and value is the value to yield. By default, all bzrdirs
258
are recursed into, and the return value is the bzrdir.
259
:param list_current: if supplied, use this function to list the current
260
directory, instead of Transport.list_dir
261
:return: a generator of found bzrdirs, or whatever evaluate returns.
263
if list_current is None:
264
def list_current(transport):
265
return transport.list_dir('')
267
def evaluate(bzrdir):
270
pending = [transport]
271
while len(pending) > 0:
272
current_transport = pending.pop()
275
bzrdir = BzrDir.open_from_transport(current_transport)
276
except errors.NotBranchError:
279
recurse, value = evaluate(bzrdir)
282
subdirs = list_current(current_transport)
283
except errors.NoSuchFile:
286
for subdir in sorted(subdirs, reverse=True):
287
pending.append(current_transport.clone(subdir))
290
def find_branches(transport):
291
"""Find all branches under a transport.
293
This will find all branches below the transport, including branches
294
inside other branches. Where possible, it will use
295
Repository.find_branches.
297
To list all the branches that use a particular Repository, see
298
Repository.find_branches
300
def evaluate(bzrdir):
302
repository = bzrdir.open_repository()
303
except errors.NoRepositoryPresent:
306
return False, (None, repository)
308
branch = bzrdir.open_branch()
309
except errors.NotBranchError:
310
return True, (None, None)
312
return True, (branch, None)
314
for branch, repo in BzrDir.find_bzrdirs(transport, evaluate=evaluate):
316
branches.extend(repo.find_branches())
317
if branch is not None:
318
branches.append(branch)
322
def destroy_repository(self):
323
"""Destroy the repository in this BzrDir"""
324
raise NotImplementedError(self.destroy_repository)
231
326
def create_branch(self):
232
327
"""Create a branch in this BzrDir.
234
The bzrdirs format will control what branch format is created.
329
The bzrdir's format will control what branch format is created.
235
330
For more control see BranchFormatXX.create(a_bzrdir).
237
332
raise NotImplementedError(self.create_branch)
334
def destroy_branch(self):
335
"""Destroy the branch in this BzrDir"""
336
raise NotImplementedError(self.destroy_branch)
240
339
def create_branch_and_repo(base, force_new_repo=False, format=None):
241
340
"""Create a new BzrDir, Branch and Repository at the url 'base'.
243
This will use the current default BzrDirFormat, and use whatever
342
This will use the current default BzrDirFormat unless one is
343
specified, and use whatever
244
344
repository format that that uses via bzrdir.create_branch and
245
345
create_repository. If a shared repository is available that is used
267
369
def create_branch_convenience(base, force_new_repo=False,
268
force_new_tree=None, format=None):
370
force_new_tree=None, format=None,
371
possible_transports=None):
269
372
"""Create a new BzrDir, Branch and Repository at the url 'base'.
271
374
This is a convenience function - it will use an existing repository
272
375
if possible, can be told explicitly whether to create a working tree or
275
This will use the current default BzrDirFormat, and use whatever
378
This will use the current default BzrDirFormat unless one is
379
specified, and use whatever
276
380
repository format that that uses via bzrdir.create_branch and
277
381
create_repository. If a shared repository is available that is used
278
382
preferentially. Whatever repository is used, its tree creation policy
287
391
:param force_new_repo: If True a new repository is always created.
288
392
:param force_new_tree: If True or False force creation of a tree or
289
393
prevent such creation respectively.
290
:param format: Override for the for the bzrdir format to create
394
:param format: Override for the bzrdir format to create.
395
:param possible_transports: An optional reusable transports list.
292
397
if force_new_tree:
293
398
# check for non local urls
294
t = get_transport(safe_unicode(base))
399
t = get_transport(base, possible_transports)
295
400
if not isinstance(t, LocalTransport):
296
401
raise errors.NotLocalUrl(base)
297
bzrdir = BzrDir.create(base, format)
402
bzrdir = BzrDir.create(base, format, possible_transports)
298
403
repo = bzrdir._find_or_create_repository(force_new_repo)
299
404
result = bzrdir.create_branch()
300
if force_new_tree or (repo.make_working_trees() and
405
if force_new_tree or (repo.make_working_trees() and
301
406
force_new_tree is None):
303
408
bzrdir.create_workingtree()
304
409
except errors.NotLocalUrl:
414
@deprecated_function(zero_ninetyone)
309
415
def create_repository(base, shared=False, format=None):
310
416
"""Create a new BzrDir and Repository at the url 'base'.
331
440
'base' must be a local path or a file:// url.
333
This will use the current default BzrDirFormat, and use whatever
442
This will use the current default BzrDirFormat unless one is
443
specified, and use whatever
334
444
repository format that that uses for bzrdirformat.create_workingtree,
335
445
create_branch and create_repository.
447
:param format: Override for the bzrdir format to create.
337
448
:return: The WorkingTree object.
339
t = get_transport(safe_unicode(base))
450
t = get_transport(base)
340
451
if not isinstance(t, LocalTransport):
341
452
raise errors.NotLocalUrl(base)
342
bzrdir = BzrDir.create_branch_and_repo(safe_unicode(base),
453
bzrdir = BzrDir.create_branch_and_repo(base,
343
454
force_new_repo=True,
344
455
format=format).bzrdir
345
456
return bzrdir.create_workingtree()
347
def create_workingtree(self, revision_id=None):
458
def create_workingtree(self, revision_id=None, from_branch=None,
459
accelerator_tree=None, hardlink=False):
348
460
"""Create a working tree at this BzrDir.
350
revision_id: create it as of this revision id.
462
:param revision_id: create it as of this revision id.
463
:param from_branch: override bzrdir branch (for lightweight checkouts)
464
:param accelerator_tree: A tree which can be used for retrieving file
465
contents more quickly than the revision tree, i.e. a workingtree.
466
The revision tree will be used for cases where accelerator_tree's
467
content is different.
352
469
raise NotImplementedError(self.create_workingtree)
354
def retire_bzrdir(self):
471
def retire_bzrdir(self, limit=10000):
355
472
"""Permanently disable the bzrdir.
357
474
This is done by renaming it to give the user some ability to recover
621
745
raise errors.NotBranchError(path=url)
622
746
a_transport = new_t
748
def _get_tree_branch(self):
749
"""Return the branch and tree, if any, for this bzrdir.
751
Return None for tree if not present or inaccessible.
752
Raise NotBranchError if no branch is present.
753
:return: (tree, branch)
756
tree = self.open_workingtree()
757
except (errors.NoWorkingTree, errors.NotLocalUrl):
759
branch = self.open_branch()
765
def open_tree_or_branch(klass, location):
766
"""Return the branch and working tree at a location.
768
If there is no tree at the location, tree will be None.
769
If there is no branch at the location, an exception will be
771
:return: (tree, branch)
773
bzrdir = klass.open(location)
774
return bzrdir._get_tree_branch()
625
777
def open_containing_tree_or_branch(klass, location):
626
778
"""Return the branch and working tree contained by a location.
632
784
relpath is the portion of the path that is contained by the branch.
634
786
bzrdir, relpath = klass.open_containing(location)
636
tree = bzrdir.open_workingtree()
637
except (errors.NoWorkingTree, errors.NotLocalUrl):
639
branch = bzrdir.open_branch()
787
tree, branch = bzrdir._get_tree_branch()
642
788
return tree, branch, relpath
644
790
def open_repository(self, _unsupported=False):
645
791
"""Open the repository object at this BzrDir if one is present.
647
This will not follow the Branch object pointer - its strictly a direct
793
This will not follow the Branch object pointer - it's strictly a direct
648
794
open facility. Most client code should use open_branch().repository to
649
795
get at a repository.
651
_unsupported is a private parameter, not part of the api.
797
:param _unsupported: a private parameter, not part of the api.
652
798
TODO: static convenience version of this?
654
800
raise NotImplementedError(self.open_repository)
656
802
def open_workingtree(self, _unsupported=False,
657
recommend_upgrade=True):
803
recommend_upgrade=True, from_branch=None):
658
804
"""Open the workingtree object at this BzrDir if one is present.
660
806
:param recommend_upgrade: Optional keyword parameter, when True (the
661
807
default), emit through the ui module a recommendation that the user
662
808
upgrade the working tree when the workingtree being opened is old
663
809
(but still fully supported).
810
:param from_branch: override bzrdir branch (for lightweight checkouts)
665
812
raise NotImplementedError(self.open_workingtree)
782
937
result.create_repository()
783
938
elif source_repository is not None and result_repo is None:
784
939
# have source, and want to make a new target repo
785
result_repo = source_repository.sprout(result, revision_id=revision_id)
940
result_repo = source_repository.sprout(result,
941
revision_id=revision_id)
787
943
# fetch needed content into target.
788
944
if source_repository is not None:
789
945
# would rather do
790
# source_repository.copy_content_into(result_repo, revision_id=revision_id)
946
# source_repository.copy_content_into(result_repo,
947
# revision_id=revision_id)
791
948
# so we can override the copy method
792
949
result_repo.fetch(source_repository, revision_id=revision_id)
793
950
if source_branch is not None:
794
951
source_branch.sprout(result, revision_id=revision_id)
796
953
result.create_branch()
797
# TODO: jam 20060426 we probably need a test in here in the
798
# case that the newly sprouted branch is a remote one
799
if result_repo is None or result_repo.make_working_trees():
800
wt = result.create_workingtree()
954
if isinstance(target_transport, LocalTransport) and (
955
result_repo is None or result_repo.make_working_trees()):
956
wt = result.create_workingtree(accelerator_tree=accelerator_tree,
803
960
if wt.path2id('') is None:
877
1034
"""See BzrDir.create_branch."""
878
1035
return self.open_branch()
1037
def destroy_branch(self):
1038
"""See BzrDir.destroy_branch."""
1039
raise errors.UnsupportedOperation(self.destroy_branch, self)
880
1041
def create_repository(self, shared=False):
881
1042
"""See BzrDir.create_repository."""
883
1044
raise errors.IncompatibleFormat('shared repository', self._format)
884
1045
return self.open_repository()
886
def create_workingtree(self, revision_id=None):
1047
def destroy_repository(self):
1048
"""See BzrDir.destroy_repository."""
1049
raise errors.UnsupportedOperation(self.destroy_repository, self)
1051
def create_workingtree(self, revision_id=None, from_branch=None,
1052
accelerator_tree=None, hardlink=False):
887
1053
"""See BzrDir.create_workingtree."""
888
1054
# this looks buggy but is not -really-
889
1055
# because this format creates the workingtree when the bzrdir is
1052
1222
"""See BzrDir.create_branch."""
1053
1223
return self._format.get_branch_format().initialize(self)
1225
def destroy_branch(self):
1226
"""See BzrDir.create_branch."""
1227
self.transport.delete_tree('branch')
1055
1229
def create_repository(self, shared=False):
1056
1230
"""See BzrDir.create_repository."""
1057
1231
return self._format.repository_format.initialize(self, shared)
1059
def create_workingtree(self, revision_id=None):
1233
def destroy_repository(self):
1234
"""See BzrDir.destroy_repository."""
1235
self.transport.delete_tree('repository')
1237
def create_workingtree(self, revision_id=None, from_branch=None,
1238
accelerator_tree=None, hardlink=False):
1060
1239
"""See BzrDir.create_workingtree."""
1061
from bzrlib.workingtree import WorkingTreeFormat
1062
return self._format.workingtree_format.initialize(self, revision_id)
1240
return self._format.workingtree_format.initialize(
1241
self, revision_id, from_branch=from_branch,
1242
accelerator_tree=accelerator_tree, hardlink=hardlink)
1064
1244
def destroy_workingtree(self):
1065
1245
"""See BzrDir.destroy_workingtree."""
1066
1246
wt = self.open_workingtree(recommend_upgrade=False)
1067
1247
repository = wt.branch.repository
1068
1248
empty = repository.revision_tree(_mod_revision.NULL_REVISION)
1069
wt.revert([], old_tree=empty)
1249
wt.revert(old_tree=empty)
1070
1250
self.destroy_workingtree_metadata()
1072
1252
def destroy_workingtree_metadata(self):
1694
1879
BzrDirFormat._default_format = __default_format
1697
class BzrDirTestProviderAdapter(object):
1698
"""A tool to generate a suite testing multiple bzrdir formats at once.
1700
This is done by copying the test once for each transport and injecting
1701
the transport_server, transport_readonly_server, and bzrdir_format
1702
classes into each copy. Each copy is also given a new id() to make it
1706
def __init__(self, vfs_factory, transport_server, transport_readonly_server,
1708
"""Create an object to adapt tests.
1710
:param vfs_server: A factory to create a Transport Server which has
1711
all the VFS methods working, and is writable.
1713
self._vfs_factory = vfs_factory
1714
self._transport_server = transport_server
1715
self._transport_readonly_server = transport_readonly_server
1716
self._formats = formats
1718
def adapt(self, test):
1719
result = unittest.TestSuite()
1720
for format in self._formats:
1721
new_test = deepcopy(test)
1722
new_test.vfs_transport_factory = self._vfs_factory
1723
new_test.transport_server = self._transport_server
1724
new_test.transport_readonly_server = self._transport_readonly_server
1725
new_test.bzrdir_format = format
1726
def make_new_test_id():
1727
new_id = "%s(%s)" % (new_test.id(), format.__class__.__name__)
1728
return lambda: new_id
1729
new_test.id = make_new_test_id()
1730
result.addTest(new_test)
1734
1882
class Converter(object):
1735
1883
"""Converts a disk format object from one format to another."""
1953
2101
w = Weave(file_id)
1954
2102
self.text_weaves[file_id] = w
1955
2103
text_changed = False
1956
previous_entries = ie.find_previous_heads(parent_invs,
1960
for old_revision in previous_entries:
1961
# if this fails, its a ghost ?
1962
assert old_revision in self.converted_revs, \
1963
"Revision {%s} not in converted_revs" % old_revision
2104
parent_candiate_entries = ie.parent_candidates(parent_invs)
2105
for old_revision in parent_candiate_entries.keys():
2106
# if this fails, its a ghost ?
2107
assert old_revision in self.converted_revs, \
2108
"Revision {%s} not in converted_revs" % old_revision
2109
heads = graph.Graph(self).heads(parent_candiate_entries.keys())
2110
# XXX: Note that this is unordered - and this is tolerable because
2111
# the previous code was also unordered.
2112
previous_entries = dict((head, parent_candiate_entries[head]) for head
1964
2114
self.snapshot_ie(previous_entries, ie, w, rev_id)
1966
2116
assert getattr(ie, 'revision', None) is not None
2118
@symbol_versioning.deprecated_method(symbol_versioning.one_one)
2119
def get_parents(self, revision_ids):
2120
for revision_id in revision_ids:
2121
yield self.revisions[revision_id].parent_ids
2123
def get_parent_map(self, revision_ids):
2124
"""See graph._StackedParentsProvider.get_parent_map"""
2125
return dict((revision_id, self.revisions[revision_id])
2126
for revision_id in revision_ids
2127
if revision_id in self.revisions)
1968
2129
def snapshot_ie(self, previous_revisions, ie, w, rev_id):
1969
2130
# TODO: convert this logic, which is ~= snapshot to
1970
2131
# a call to:. This needs the path figured out. rather than a work_tree
2233
2394
def probe_transport(klass, transport):
2234
2395
"""Return a RemoteBzrDirFormat object if it looks possible."""
2236
client = transport.get_smart_client()
2397
medium = transport.get_smart_medium()
2237
2398
except (NotImplementedError, AttributeError,
2238
errors.TransportNotPossible):
2399
errors.TransportNotPossible, errors.NoSmartMedium):
2239
2400
# no smart server, so not a branch for this format type.
2240
2401
raise errors.NotBranchError(path=transport.base)
2242
# Send a 'hello' request in protocol version one, and decline to
2243
# open it if the server doesn't support our required version (2) so
2244
# that the VFS-based transport will do it.
2245
request = client.get_request()
2246
smart_protocol = protocol.SmartClientRequestProtocolOne(request)
2247
server_version = smart_protocol.query_version()
2403
# Decline to open it if the server doesn't support our required
2404
# version (2) so that the VFS-based transport will do it.
2406
server_version = medium.protocol_version()
2407
except errors.SmartProtocolError:
2408
# Apparently there's no usable smart server there, even though
2409
# the medium supports the smart protocol.
2410
raise errors.NotBranchError(path=transport.base)
2248
2411
if server_version != 2:
2249
2412
raise errors.NotBranchError(path=transport.base)
2252
2415
def initialize_on_transport(self, transport):
2254
2417
# hand off the request to the smart server
2255
medium = transport.get_smart_medium()
2418
client_medium = transport.get_smart_medium()
2256
2419
except errors.NoSmartMedium:
2257
2420
# TODO: lookup the local format from a server hint.
2258
2421
local_dir_format = BzrDirMetaFormat1()
2259
2422
return local_dir_format.initialize_on_transport(transport)
2260
client = _SmartClient(medium)
2423
client = _SmartClient(client_medium, transport.base)
2261
2424
path = client.remote_path_from_transport(transport)
2262
response = _SmartClient(medium).call('BzrDirFormat.initialize', path)
2425
response = client.call('BzrDirFormat.initialize', path)
2263
2426
assert response[0] in ('ok', ), 'unexpected response code %s' % (response,)
2264
2427
return remote.RemoteBzrDir(transport)
2344
2520
This function mainly exists to prevent the info object from being
2345
2521
supplied directly.
2347
registry.Registry.register(self, key, factory, help,
2348
BzrDirFormatInfo(native, deprecated, hidden))
2523
registry.Registry.register(self, key, factory, help,
2524
BzrDirFormatInfo(native, deprecated, hidden, experimental))
2526
self._aliases.add(key)
2350
2528
def register_lazy(self, key, module_name, member_name, help, native=True,
2351
deprecated=False, hidden=False):
2352
registry.Registry.register_lazy(self, key, module_name, member_name,
2353
help, BzrDirFormatInfo(native, deprecated, hidden))
2529
deprecated=False, hidden=False, experimental=False, alias=False):
2530
registry.Registry.register_lazy(self, key, module_name, member_name,
2531
help, BzrDirFormatInfo(native, deprecated, hidden, experimental))
2533
self._aliases.add(key)
2355
2535
def set_default(self, key):
2356
2536
"""Set the 'default' key to be a clone of the supplied key.
2358
2538
This method must be called once and only once.
2360
registry.Registry.register(self, 'default', self.get(key),
2540
registry.Registry.register(self, 'default', self.get(key),
2361
2541
self.get_help(key), info=self.get_info(key))
2542
self._aliases.add('default')
2363
2544
def set_default_repository(self, key):
2364
2545
"""Set the FormatRegistry default and Repository default.
2398
2577
def wrapped(key, help, info):
2399
2578
if info.native:
2400
2579
help = '(native) ' + help
2401
return ' %s:\n%s\n\n' % (key,
2580
return ':%s:\n%s\n\n' % (key,
2402
2581
textwrap.fill(help, initial_indent=' ',
2403
2582
subsequent_indent=' '))
2404
output += wrapped('%s/default' % default_realkey, default_help,
2405
self.get_info('default'))
2583
if default_realkey is not None:
2584
output += wrapped(default_realkey, '(default) %s' % default_help,
2585
self.get_info('default'))
2406
2586
deprecated_pairs = []
2587
experimental_pairs = []
2407
2588
for key, help in help_pairs:
2408
2589
info = self.get_info(key)
2409
2590
if info.hidden:
2411
2592
elif info.deprecated:
2412
2593
deprecated_pairs.append((key, help))
2594
elif info.experimental:
2595
experimental_pairs.append((key, help))
2414
2597
output += wrapped(key, help, info)
2598
if len(experimental_pairs) > 0:
2599
output += "Experimental formats are shown below.\n\n"
2600
for key, help in experimental_pairs:
2601
info = self.get_info(key)
2602
output += wrapped(key, help, info)
2415
2603
if len(deprecated_pairs) > 0:
2416
output += "Deprecated formats\n------------------\n\n"
2604
output += "Deprecated formats are shown below.\n\n"
2417
2605
for key, help in deprecated_pairs:
2418
2606
info = self.get_info(key)
2419
2607
output += wrapped(key, help, info)
2461
2656
'bzr branches. Incompatible with bzr < 0.15.',
2462
2657
branch_format='bzrlib.branch.BzrBranchFormat6',
2463
2658
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
2466
format_registry.set_default('dirstate')
2662
format_registry.register_metadir('pack-0.92',
2663
'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack1',
2664
help='New in 0.92: Pack-based format with data compatible with '
2665
'dirstate-tags format repositories. Interoperates with '
2666
'bzr repositories before 0.92 but cannot be read by bzr < 0.92. '
2667
'Previously called knitpack-experimental. '
2668
'For more information, see '
2669
'http://doc.bazaar-vcs.org/latest/developers/packrepo.html.',
2670
branch_format='bzrlib.branch.BzrBranchFormat6',
2671
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
2673
format_registry.register_metadir('pack-0.92-subtree',
2674
'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack3',
2675
help='New in 0.92: Pack-based format with data compatible with '
2676
'dirstate-with-subtree format repositories. Interoperates with '
2677
'bzr repositories before 0.92 but cannot be read by bzr < 0.92. '
2678
'Previously called knitpack-experimental. '
2679
'For more information, see '
2680
'http://doc.bazaar-vcs.org/latest/developers/packrepo.html.',
2681
branch_format='bzrlib.branch.BzrBranchFormat6',
2682
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
2686
format_registry.register_metadir('rich-root-pack',
2687
'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack4',
2688
help='New in 1.0: Pack-based format with data compatible with '
2689
'rich-root format repositories. Incompatible with'
2691
branch_format='bzrlib.branch.BzrBranchFormat6',
2692
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
2694
# The following two formats should always just be aliases.
2695
format_registry.register_metadir('development',
2696
'bzrlib.repofmt.pack_repo.RepositoryFormatPackDevelopment0',
2697
help='Current development format. Can convert data to and from pack-0.92 '
2698
'(and anything compatible with pack-0.92) format repositories. '
2699
'Repositories in this format can only be read by bzr.dev. '
2701
'http://doc.bazaar-vcs.org/latest/developers/development-repo.html '
2703
branch_format='bzrlib.branch.BzrBranchFormat6',
2704
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
2708
format_registry.register_metadir('development-subtree',
2709
'bzrlib.repofmt.pack_repo.RepositoryFormatPackDevelopment0Subtree',
2710
help='Current development format, subtree variant. Can convert data to and '
2711
'from pack-0.92 (and anything compatible with pack-0.92) format '
2712
'repositories. Repositories in this format can only be read by '
2713
'bzr.dev. Please read '
2714
'http://doc.bazaar-vcs.org/latest/developers/development-repo.html '
2716
branch_format='bzrlib.branch.BzrBranchFormat6',
2717
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
2721
# And the development formats which the will have aliased one of follow:
2722
format_registry.register_metadir('development0',
2723
'bzrlib.repofmt.pack_repo.RepositoryFormatPackDevelopment0',
2724
help='Trivial rename of pack-0.92 to provide a development format. '
2726
'http://doc.bazaar-vcs.org/latest/developers/development-repo.html '
2728
branch_format='bzrlib.branch.BzrBranchFormat6',
2729
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
2733
format_registry.register_metadir('development0-subtree',
2734
'bzrlib.repofmt.pack_repo.RepositoryFormatPackDevelopment0Subtree',
2735
help='Trivial rename of pack-0.92-subtree to provide a development format. '
2737
'http://doc.bazaar-vcs.org/latest/developers/development-repo.html '
2739
branch_format='bzrlib.branch.BzrBranchFormat6',
2740
tree_format='bzrlib.workingtree.WorkingTreeFormat4',
2744
format_registry.set_default('pack-0.92')
added
removed
bzrlib/bzrdir.py
