To get this branch, use:
bzr branch
http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar
« back to all changes in this revision
Viewing changes to bzrlib/builtins.py
- browse files at revision 4912.2.3
- compare with another revision
- compare with revision 5200.3.2
- download diff
- download tarball
- view history from revision 4912.2.3
- Committer: Martin Pool
- Date: 2010-10-08 04:38:25 UTC
- mfrom: (5462 +trunk)
- mto: This revision was merged to the branch mainline in revision 5478.
- Revision ID: mbp@sourcefrog.net-20101008043825-b181r8bo5r3qwb6j
merge trunk
- files added:
- .testr.conf
- apport
- bzrlib/doc_generate/builders
- bzrlib/doc_generate/writers
- bzrlib/help_topics/es
- bzrlib/plugins/bash_completion
- bzrlib/plugins/bash_completion/tests
- bzrlib/plugins/news_merge
- bzrlib/plugins/news_merge/tests
- bzrlib/tests/doc_generate
- bzrlib/tests/doc_generate/builders
- bzrlib/tests/doc_generate/writers
- bzrlib/tests/per_bzrdir
- bzrlib/tests/per_controldir_colo
- contrib/debian
- doc/en/whats-new
- files removed:
- bzrlib/benchmarks
- bzrlib/benchmarks/tree_creator
- files renamed:
- bzrlib/doc_generate/sphinx_conf.py => bzrlib/doc_generate/conf.py
- bzrlib/help_topics/en/conflicts.txt => bzrlib/help_topics/en/conflict-types.txt
- doc/es/user-guide/resolving_conflicts.txt => bzrlib/help_topics/es/conflict-types.txt
- bzrlib/tests/per_bzrdir/ => bzrlib/tests/per_controldir/
- bzrlib/tests/per_bzrdir/test_bzrdir.py => bzrlib/tests/per_controldir/test_controldir.py
- bzrlib/tests/test_bencode.py => bzrlib/tests/test__bencode.py
- files modified:
- .bzrignore
added
removed
bzrlib/builtins.py
1
# Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009 Canonical Ltd
1
# Copyright (C) 2005-2010 Canonical Ltd
2
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
20
20
21
21
from bzrlib.lazy_import import lazy_import
22
22
lazy_import(globals(), """
23
import codecs
24
23
import cStringIO
25
24
import sys
26
25
import time
31
30
bundle,
32
31
btree_index,
33
32
bzrdir,
33
directory_service,
34
34
delta,
35
config,
35
config as _mod_config,
36
36
errors,
37
37
globbing,
38
38
hooks,
53
53
)
54
54
from bzrlib.branch import Branch
55
55
from bzrlib.conflicts import ConflictList
56
from bzrlib.transport import memory
56
57
from bzrlib.revisionspec import RevisionSpec, RevisionInfo
57
58
from bzrlib.smtp_connection import SMTPConnection
58
59
from bzrlib.workingtree import WorkingTree
59
60
""")
60
61
61
from bzrlib.commands import Command, display_command
62
from bzrlib.commands import (
63
Command,
64
builtin_command_registry,
65
display_command,
66
)
62
67
from bzrlib.option import (
63
68
ListOption,
64
69
Option,
69
74
from bzrlib.trace import mutter, note, warning, is_quiet, get_verbosity_level
70
75
71
76
77
@symbol_versioning.deprecated_function(symbol_versioning.deprecated_in((2, 3, 0)))
72
78
def tree_files(file_list, default_branch=u'.', canonicalize=True,
73
79
apply_view=True):
74
try:
75
return internal_tree_files(file_list, default_branch, canonicalize,
76
apply_view)
77
except errors.FileInWrongBranch, e:
78
raise errors.BzrCommandError("%s is not in the same branch as %s" %
79
(e.path, file_list[0]))
80
return internal_tree_files(file_list, default_branch, canonicalize,
81
apply_view)
80
82
81
83
82
84
def tree_files_for_add(file_list):
146
148
147
149
# XXX: Bad function name; should possibly also be a class method of
148
150
# WorkingTree rather than a function.
151
@symbol_versioning.deprecated_function(symbol_versioning.deprecated_in((2, 3, 0)))
149
152
def internal_tree_files(file_list, default_branch=u'.', canonicalize=True,
150
153
apply_view=True):
151
154
"""Convert command-line paths to a WorkingTree and relative paths.
152
155
156
Deprecated: use WorkingTree.open_containing_paths instead.
157
153
158
This is typically used for command-line processors that take one or
154
159
more filenames, and infer the workingtree that contains them.
155
160
165
170
166
171
:return: workingtree, [relative_paths]
167
172
"""
168
if file_list is None or len(file_list) == 0:
169
tree = WorkingTree.open_containing(default_branch)[0]
170
if tree.supports_views() and apply_view:
171
view_files = tree.views.lookup_view()
172
if view_files:
173
file_list = view_files
174
view_str = views.view_display_str(view_files)
175
note("Ignoring files outside view. View is %s" % view_str)
176
return tree, file_list
177
tree = WorkingTree.open_containing(osutils.realpath(file_list[0]))[0]
178
return tree, safe_relpath_files(tree, file_list, canonicalize,
179
apply_view=apply_view)
180
181
182
def safe_relpath_files(tree, file_list, canonicalize=True, apply_view=True):
183
"""Convert file_list into a list of relpaths in tree.
184
185
:param tree: A tree to operate on.
186
:param file_list: A list of user provided paths or None.
187
:param apply_view: if True and a view is set, apply it or check that
188
specified files are within it
189
:return: A list of relative paths.
190
:raises errors.PathNotChild: When a provided path is in a different tree
191
than tree.
192
"""
193
if file_list is None:
194
return None
195
if tree.supports_views() and apply_view:
196
view_files = tree.views.lookup_view()
197
else:
198
view_files = []
199
new_list = []
200
# tree.relpath exists as a "thunk" to osutils, but canonical_relpath
201
# doesn't - fix that up here before we enter the loop.
202
if canonicalize:
203
fixer = lambda p: osutils.canonical_relpath(tree.basedir, p)
204
else:
205
fixer = tree.relpath
206
for filename in file_list:
207
try:
208
relpath = fixer(osutils.dereference_path(filename))
209
if view_files and not osutils.is_inside_any(view_files, relpath):
210
raise errors.FileOutsideView(filename, view_files)
211
new_list.append(relpath)
212
except errors.PathNotChild:
213
raise errors.FileInWrongBranch(tree.branch, filename)
214
return new_list
173
return WorkingTree.open_containing_paths(
174
file_list, default_directory='.',
175
canonicalize=True,
176
apply_view=True)
215
177
216
178
217
179
def _get_view_info_for_change_reporter(tree):
226
188
return view_info
227
189
228
190
191
def _open_directory_or_containing_tree_or_branch(filename, directory):
192
"""Open the tree or branch containing the specified file, unless
193
the --directory option is used to specify a different branch."""
194
if directory is not None:
195
return (None, Branch.open(directory), filename)
196
return bzrdir.BzrDir.open_containing_tree_or_branch(filename)
197
198
229
199
# TODO: Make sure no commands unconditionally use the working directory as a
230
200
# branch. If a filename argument is used, the first of them should be used to
231
201
# specify the branch. (Perhaps this can be factored out into some kind of
233
203
# opens the branch?)
234
204
235
205
class cmd_status(Command):
236
"""Display status summary.
206
__doc__ = """Display status summary.
237
207
238
208
This reports on versioned and unknown files, reporting them
239
209
grouped by state. Possible states are:
309
279
raise errors.BzrCommandError('bzr status --revision takes exactly'
310
280
' one or two revision specifiers')
311
281
312
tree, relfile_list = tree_files(file_list)
282
tree, relfile_list = WorkingTree.open_containing_paths(file_list)
313
283
# Avoid asking for specific files when that is not needed.
314
284
if relfile_list == ['']:
315
285
relfile_list = None
326
296
327
297
328
298
class cmd_cat_revision(Command):
329
"""Write out metadata for a revision.
299
__doc__ = """Write out metadata for a revision.
330
300
331
301
The revision to print can either be specified by a specific
332
302
revision identifier, or you can use --revision.
334
304
335
305
hidden = True
336
306
takes_args = ['revision_id?']
337
takes_options = ['revision']
307
takes_options = ['directory', 'revision']
338
308
# cat-revision is more for frontends so should be exact
339
309
encoding = 'strict'
340
310
311
def print_revision(self, revisions, revid):
312
stream = revisions.get_record_stream([(revid,)], 'unordered', True)
313
record = stream.next()
314
if record.storage_kind == 'absent':
315
raise errors.NoSuchRevision(revisions, revid)
316
revtext = record.get_bytes_as('fulltext')
317
self.outf.write(revtext.decode('utf-8'))
318
341
319
@display_command
342
def run(self, revision_id=None, revision=None):
320
def run(self, revision_id=None, revision=None, directory=u'.'):
343
321
if revision_id is not None and revision is not None:
344
322
raise errors.BzrCommandError('You can only supply one of'
345
323
' revision_id or --revision')
346
324
if revision_id is None and revision is None:
347
325
raise errors.BzrCommandError('You must supply either'
348
326
' --revision or a revision_id')
349
b = WorkingTree.open_containing(u'.')[0].branch
350
351
# TODO: jam 20060112 should cat-revision always output utf-8?
352
if revision_id is not None:
353
revision_id = osutils.safe_revision_id(revision_id, warn=False)
354
try:
355
self.outf.write(b.repository.get_revision_xml(revision_id).decode('utf-8'))
356
except errors.NoSuchRevision:
357
msg = "The repository %s contains no revision %s." % (b.repository.base,
358
revision_id)
359
raise errors.BzrCommandError(msg)
360
elif revision is not None:
361
for rev in revision:
362
if rev is None:
363
raise errors.BzrCommandError('You cannot specify a NULL'
364
' revision.')
365
rev_id = rev.as_revision_id(b)
366
self.outf.write(b.repository.get_revision_xml(rev_id).decode('utf-8'))
367
327
b = WorkingTree.open_containing(directory)[0].branch
328
329
revisions = b.repository.revisions
330
if revisions is None:
331
raise errors.BzrCommandError('Repository %r does not support '
332
'access to raw revision texts')
333
334
b.repository.lock_read()
335
try:
336
# TODO: jam 20060112 should cat-revision always output utf-8?
337
if revision_id is not None:
338
revision_id = osutils.safe_revision_id(revision_id, warn=False)
339
try:
340
self.print_revision(revisions, revision_id)
341
except errors.NoSuchRevision:
342
msg = "The repository %s contains no revision %s." % (
343
b.repository.base, revision_id)
344
raise errors.BzrCommandError(msg)
345
elif revision is not None:
346
for rev in revision:
347
if rev is None:
348
raise errors.BzrCommandError(
349
'You cannot specify a NULL revision.')
350
rev_id = rev.as_revision_id(b)
351
self.print_revision(revisions, rev_id)
352
finally:
353
b.repository.unlock()
354
368
355
369
356
class cmd_dump_btree(Command):
370
"""Dump the contents of a btree index file to stdout.
357
__doc__ = """Dump the contents of a btree index file to stdout.
371
358
372
359
PATH is a btree index file, it can be any URL. This includes things like
373
360
.bzr/repository/pack-names, or .bzr/repository/indices/a34b3a...ca4a4.iix
437
424
for node in bt.iter_all_entries():
438
425
# Node is made up of:
439
426
# (index, key, value, [references])
440
refs_as_tuples = static_tuple.as_tuples(node[3])
427
try:
428
refs = node[3]
429
except IndexError:
430
refs_as_tuples = None
431
else:
432
refs_as_tuples = static_tuple.as_tuples(refs)
441
433
as_tuple = (tuple(node[1]), node[2], refs_as_tuples)
442
434
self.outf.write('%s\n' % (as_tuple,))
443
435
444
436
445
437
class cmd_remove_tree(Command):
446
"""Remove the working tree from a given branch/checkout.
438
__doc__ = """Remove the working tree from a given branch/checkout.
447
439
448
440
Since a lightweight checkout is little more than a working tree
449
441
this will refuse to run against one.
451
443
To re-create the working tree, use "bzr checkout".
452
444
"""
453
445
_see_also = ['checkout', 'working-trees']
454
takes_args = ['location?']
446
takes_args = ['location*']
455
447
takes_options = [
456
448
Option('force',
457
449
help='Remove the working tree even if it has '
458
'uncommitted changes.'),
450
'uncommitted or shelved changes.'),
459
451
]
460
452
461
def run(self, location='.', force=False):
462
d = bzrdir.BzrDir.open(location)
463
464
try:
465
working = d.open_workingtree()
466
except errors.NoWorkingTree:
467
raise errors.BzrCommandError("No working tree to remove")
468
except errors.NotLocalUrl:
469
raise errors.BzrCommandError("You cannot remove the working tree"
470
" of a remote path")
471
if not force:
472
if (working.has_changes()):
473
raise errors.UncommittedChanges(working)
474
475
working_path = working.bzrdir.root_transport.base
476
branch_path = working.branch.bzrdir.root_transport.base
477
if working_path != branch_path:
478
raise errors.BzrCommandError("You cannot remove the working tree"
479
" from a lightweight checkout")
480
481
d.destroy_workingtree()
453
def run(self, location_list, force=False):
454
if not location_list:
455
location_list=['.']
456
457
for location in location_list:
458
d = bzrdir.BzrDir.open(location)
459
460
try:
461
working = d.open_workingtree()
462
except errors.NoWorkingTree:
463
raise errors.BzrCommandError("No working tree to remove")
464
except errors.NotLocalUrl:
465
raise errors.BzrCommandError("You cannot remove the working tree"
466
" of a remote path")
467
if not force:
468
if (working.has_changes()):
469
raise errors.UncommittedChanges(working)
470
if working.get_shelf_manager().last_shelf() is not None:
471
raise errors.ShelvedChanges(working)
472
473
if working.user_url != working.branch.user_url:
474
raise errors.BzrCommandError("You cannot remove the working tree"
475
" from a lightweight checkout")
476
477
d.destroy_workingtree()
482
478
483
479
484
480
class cmd_revno(Command):
485
"""Show current revision number.
481
__doc__ = """Show current revision number.
486
482
487
483
This is equal to the number of revisions on this branch.
488
484
"""
498
494
if tree:
499
495
try:
500
496
wt = WorkingTree.open_containing(location)[0]
501
wt.lock_read()
497
self.add_cleanup(wt.lock_read().unlock)
502
498
except (errors.NoWorkingTree, errors.NotLocalUrl):
503
499
raise errors.NoWorkingTree(location)
500
revid = wt.last_revision()
504
501
try:
505
revid = wt.last_revision()
506
try:
507
revno_t = wt.branch.revision_id_to_dotted_revno(revid)
508
except errors.NoSuchRevision:
509
revno_t = ('???',)
510
revno = ".".join(str(n) for n in revno_t)
511
finally:
512
wt.unlock()
502
revno_t = wt.branch.revision_id_to_dotted_revno(revid)
503
except errors.NoSuchRevision:
504
revno_t = ('???',)
505
revno = ".".join(str(n) for n in revno_t)
513
506
else:
514
507
b = Branch.open_containing(location)[0]
515
b.lock_read()
516
try:
517
revno = b.revno()
518
finally:
519
b.unlock()
520
508
self.add_cleanup(b.lock_read().unlock)
509
revno = b.revno()
510
self.cleanup_now()
521
511
self.outf.write(str(revno) + '\n')
522
512
523
513
524
514
class cmd_revision_info(Command):
525
"""Show revision number and revision id for a given revision identifier.
515
__doc__ = """Show revision number and revision id for a given revision identifier.
526
516
"""
527
517
hidden = True
528
518
takes_args = ['revision_info*']
529
519
takes_options = [
530
520
'revision',
531
Option('directory',
521
custom_help('directory',
532
522
help='Branch to examine, '
533
'rather than the one containing the working directory.',
534
short_name='d',
535
type=unicode,
536
),
523
'rather than the one containing the working directory.'),
537
524
Option('tree', help='Show revno of working tree'),
538
525
]
539
526
544
531
try:
545
532
wt = WorkingTree.open_containing(directory)[0]
546
533
b = wt.branch
547
wt.lock_read()
534
self.add_cleanup(wt.lock_read().unlock)
548
535
except (errors.NoWorkingTree, errors.NotLocalUrl):
549
536
wt = None
550
537
b = Branch.open_containing(directory)[0]
551
b.lock_read()
552
try:
553
revision_ids = []
554
if revision is not None:
555
revision_ids.extend(rev.as_revision_id(b) for rev in revision)
556
if revision_info_list is not None:
557
for rev_str in revision_info_list:
558
rev_spec = RevisionSpec.from_string(rev_str)
559
revision_ids.append(rev_spec.as_revision_id(b))
560
# No arguments supplied, default to the last revision
561
if len(revision_ids) == 0:
562
if tree:
563
if wt is None:
564
raise errors.NoWorkingTree(directory)
565
revision_ids.append(wt.last_revision())
566
else:
567
revision_ids.append(b.last_revision())
568
569
revinfos = []
570
maxlen = 0
571
for revision_id in revision_ids:
572
try:
573
dotted_revno = b.revision_id_to_dotted_revno(revision_id)
574
revno = '.'.join(str(i) for i in dotted_revno)
575
except errors.NoSuchRevision:
576
revno = '???'
577
maxlen = max(maxlen, len(revno))
578
revinfos.append([revno, revision_id])
579
finally:
580
if wt is None:
581
b.unlock()
538
self.add_cleanup(b.lock_read().unlock)
539
revision_ids = []
540
if revision is not None:
541
revision_ids.extend(rev.as_revision_id(b) for rev in revision)
542
if revision_info_list is not None:
543
for rev_str in revision_info_list:
544
rev_spec = RevisionSpec.from_string(rev_str)
545
revision_ids.append(rev_spec.as_revision_id(b))
546
# No arguments supplied, default to the last revision
547
if len(revision_ids) == 0:
548
if tree:
549
if wt is None:
550
raise errors.NoWorkingTree(directory)
551
revision_ids.append(wt.last_revision())
582
552
else:
583
wt.unlock()
584
553
revision_ids.append(b.last_revision())
554
555
revinfos = []
556
maxlen = 0
557
for revision_id in revision_ids:
558
try:
559
dotted_revno = b.revision_id_to_dotted_revno(revision_id)
560
revno = '.'.join(str(i) for i in dotted_revno)
561
except errors.NoSuchRevision:
562
revno = '???'
563
maxlen = max(maxlen, len(revno))
564
revinfos.append([revno, revision_id])
565
566
self.cleanup_now()
585
567
for ri in revinfos:
586
568
self.outf.write('%*s %s\n' % (maxlen, ri[0], ri[1]))
587
569
588
570
589
571
class cmd_add(Command):
590
"""Add specified files or directories.
572
__doc__ = """Add specified files or directories.
591
573
592
574
In non-recursive mode, all the named items are added, regardless
593
575
of whether they were previously ignored. A warning is given if
658
640
should_print=(not is_quiet()))
659
641
660
642
if base_tree:
661
base_tree.lock_read()
662
try:
663
tree, file_list = tree_files_for_add(file_list)
664
added, ignored = tree.smart_add(file_list, not
665
no_recurse, action=action, save=not dry_run)
666
finally:
667
if base_tree is not None:
668
base_tree.unlock()
643
self.add_cleanup(base_tree.lock_read().unlock)
644
tree, file_list = tree_files_for_add(file_list)
645
added, ignored = tree.smart_add(file_list, not
646
no_recurse, action=action, save=not dry_run)
647
self.cleanup_now()
669
648
if len(ignored) > 0:
670
649
if verbose:
671
650
for glob in sorted(ignored.keys()):
675
654
676
655
677
656
class cmd_mkdir(Command):
678
"""Create a new versioned directory.
657
__doc__ = """Create a new versioned directory.
679
658
680
659
This is equivalent to creating the directory and then adding it.
681
660
"""
685
664
686
665
def run(self, dir_list):
687
666
for d in dir_list:
688
os.mkdir(d)
689
667
wt, dd = WorkingTree.open_containing(d)
690
wt.add([dd])
691
self.outf.write('added %s\n' % d)
668
base = os.path.dirname(dd)
669
id = wt.path2id(base)
670
if id != None:
671
os.mkdir(d)
672
wt.add([dd])
673
self.outf.write('added %s\n' % d)
674
else:
675
raise errors.NotVersionedError(path=base)
692
676
693
677
694
678
class cmd_relpath(Command):
695
"""Show path of a file relative to root"""
679
__doc__ = """Show path of a file relative to root"""
696
680
697
681
takes_args = ['filename']
698
682
hidden = True
707
691
708
692
709
693
class cmd_inventory(Command):
710
"""Show inventory of the current working copy or a revision.
694
__doc__ = """Show inventory of the current working copy or a revision.
711
695
712
696
It is possible to limit the output to a particular entry
713
697
type using the --kind option. For example: --kind file.
733
717
raise errors.BzrCommandError('invalid kind %r specified' % (kind,))
734
718
735
719
revision = _get_one_revision('inventory', revision)
736
work_tree, file_list = tree_files(file_list)
737
work_tree.lock_read()
738
try:
739
if revision is not None:
740
tree = revision.as_tree(work_tree.branch)
741
742
extra_trees = [work_tree]
743
tree.lock_read()
744
else:
745
tree = work_tree
746
extra_trees = []
747
748
if file_list is not None:
749
file_ids = tree.paths2ids(file_list, trees=extra_trees,
750
require_versioned=True)
751
# find_ids_across_trees may include some paths that don't
752
# exist in 'tree'.
753
entries = sorted((tree.id2path(file_id), tree.inventory[file_id])
754
for file_id in file_ids if file_id in tree)
755
else:
756
entries = tree.inventory.entries()
757
finally:
758
tree.unlock()
759
if tree is not work_tree:
760
work_tree.unlock()
761
720
work_tree, file_list = WorkingTree.open_containing_paths(file_list)
721
self.add_cleanup(work_tree.lock_read().unlock)
722
if revision is not None:
723
tree = revision.as_tree(work_tree.branch)
724
725
extra_trees = [work_tree]
726
self.add_cleanup(tree.lock_read().unlock)
727
else:
728
tree = work_tree
729
extra_trees = []
730
731
if file_list is not None:
732
file_ids = tree.paths2ids(file_list, trees=extra_trees,
733
require_versioned=True)
734
# find_ids_across_trees may include some paths that don't
735
# exist in 'tree'.
736
entries = sorted((tree.id2path(file_id), tree.inventory[file_id])
737
for file_id in file_ids if file_id in tree)
738
else:
739
entries = tree.inventory.entries()
740
741
self.cleanup_now()
762
742
for path, entry in entries:
763
743
if kind and kind != entry.kind:
764
744
continue
770
750
771
751
772
752
class cmd_mv(Command):
773
"""Move or rename a file.
753
__doc__ = """Move or rename a file.
774
754
775
755
:Usage:
776
756
bzr mv OLDNAME NEWNAME
808
788
names_list = []
809
789
if len(names_list) < 2:
810
790
raise errors.BzrCommandError("missing file argument")
811
tree, rel_names = tree_files(names_list, canonicalize=False)
812
tree.lock_tree_write()
813
try:
814
self._run(tree, names_list, rel_names, after)
815
finally:
816
tree.unlock()
791
tree, rel_names = WorkingTree.open_containing_paths(names_list, canonicalize=False)
792
self.add_cleanup(tree.lock_tree_write().unlock)
793
self._run(tree, names_list, rel_names, after)
817
794
818
795
def run_auto(self, names_list, after, dry_run):
819
796
if names_list is not None and len(names_list) > 1:
822
799
if after:
823
800
raise errors.BzrCommandError('--after cannot be specified with'
824
801
' --auto.')
825
work_tree, file_list = tree_files(names_list, default_branch='.')
826
work_tree.lock_tree_write()
827
try:
828
rename_map.RenameMap.guess_renames(work_tree, dry_run)
829
finally:
830
work_tree.unlock()
802
work_tree, file_list = WorkingTree.open_containing_paths(
803
names_list, default_directory='.')
804
self.add_cleanup(work_tree.lock_tree_write().unlock)
805
rename_map.RenameMap.guess_renames(work_tree, dry_run)
831
806
832
807
def _run(self, tree, names_list, rel_names, after):
833
808
into_existing = osutils.isdir(names_list[-1])
911
886
912
887
913
888
class cmd_pull(Command):
914
"""Turn this branch into a mirror of another branch.
889
__doc__ = """Turn this branch into a mirror of another branch.
915
890
916
891
By default, this command only works on branches that have not diverged.
917
892
Branches are considered diverged if the destination branch's most recent
940
915
takes_options = ['remember', 'overwrite', 'revision',
941
916
custom_help('verbose',
942
917
help='Show logs of pulled revisions.'),
943
Option('directory',
918
custom_help('directory',
944
919
help='Branch to pull into, '
945
'rather than the one containing the working directory.',
946
short_name='d',
947
type=unicode,
948
),
920
'rather than the one containing the working directory.'),
949
921
Option('local',
950
922
help="Perform a local pull in a bound "
951
923
"branch. Local pulls are not applied to "
952
924
"the master branch."
953
925
),
926
Option('show-base',
927
help="Show base revision text in conflicts.")
954
928
]
955
929
takes_args = ['location?']
956
930
encoding_type = 'replace'
957
931
958
932
def run(self, location=None, remember=False, overwrite=False,
959
933
revision=None, verbose=False,
960
directory=None, local=False):
934
directory=None, local=False,
935
show_base=False):
961
936
# FIXME: too much stuff is in the command class
962
937
revision_id = None
963
938
mergeable = None
966
941
try:
967
942
tree_to = WorkingTree.open_containing(directory)[0]
968
943
branch_to = tree_to.branch
944
self.add_cleanup(tree_to.lock_write().unlock)
969
945
except errors.NoWorkingTree:
970
946
tree_to = None
971
947
branch_to = Branch.open_containing(directory)[0]
972
948
self.add_cleanup(branch_to.lock_write().unlock)
949
950
if tree_to is None and show_base:
951
raise errors.BzrCommandError("Need working tree for --show-base.")
952
973
953
if local and not branch_to.get_bound_location():
974
954
raise errors.LocalRequiresBoundBranch()
975
955
1005
985
else:
1006
986
branch_from = Branch.open(location,
1007
987
possible_transports=possible_transports)
988
self.add_cleanup(branch_from.lock_read().unlock)
1008
989
1009
990
if branch_to.get_parent() is None or remember:
1010
991
branch_to.set_parent(branch_from.base)
1011
992
1012
if branch_from is not branch_to:
1013
branch_from.lock_read()
1014
try:
1015
if revision is not None:
1016
revision_id = revision.as_revision_id(branch_from)
1017
1018
branch_to.lock_write()
1019
try:
1020
if tree_to is not None:
1021
view_info = _get_view_info_for_change_reporter(tree_to)
1022
change_reporter = delta._ChangeReporter(
1023
unversioned_filter=tree_to.is_ignored,
1024
view_info=view_info)
1025
result = tree_to.pull(
1026
branch_from, overwrite, revision_id, change_reporter,
1027
possible_transports=possible_transports, local=local)
1028
else:
1029
result = branch_to.pull(
1030
branch_from, overwrite, revision_id, local=local)
1031
1032
result.report(self.outf)
1033
if verbose and result.old_revid != result.new_revid:
1034
log.show_branch_change(
1035
branch_to, self.outf, result.old_revno,
1036
result.old_revid)
1037
finally:
1038
branch_to.unlock()
1039
finally:
1040
if branch_from is not branch_to:
1041
branch_from.unlock()
993
if revision is not None:
994
revision_id = revision.as_revision_id(branch_from)
995
996
if tree_to is not None:
997
view_info = _get_view_info_for_change_reporter(tree_to)
998
change_reporter = delta._ChangeReporter(
999
unversioned_filter=tree_to.is_ignored,
1000
view_info=view_info)
1001
result = tree_to.pull(
1002
branch_from, overwrite, revision_id, change_reporter,
1003
possible_transports=possible_transports, local=local,
1004
show_base=show_base)
1005
else:
1006
result = branch_to.pull(
1007
branch_from, overwrite, revision_id, local=local)
1008
1009
result.report(self.outf)
1010
if verbose and result.old_revid != result.new_revid:
1011
log.show_branch_change(
1012
branch_to, self.outf, result.old_revno,
1013
result.old_revid)
1042
1014
1043
1015
1044
1016
class cmd_push(Command):
1045
"""Update a mirror of this branch.
1017
__doc__ = """Update a mirror of this branch.
1046
1018
1047
1019
The target branch will not have its working tree populated because this
1048
1020
is both expensive, and is not supported on remote file systems.
1072
1044
Option('create-prefix',
1073
1045
help='Create the path leading up to the branch '
1074
1046
'if it does not already exist.'),
1075
Option('directory',
1047
custom_help('directory',
1076
1048
help='Branch to push from, '
1077
'rather than the one containing the working directory.',
1078
short_name='d',
1079
type=unicode,
1080
),
1049
'rather than the one containing the working directory.'),
1081
1050
Option('use-existing-dir',
1082
1051
help='By default push will fail if the target'
1083
1052
' directory exists, but does not already'
1109
1078
# Get the source branch
1110
1079
(tree, br_from,
1111
1080
_unused) = bzrdir.BzrDir.open_containing_tree_or_branch(directory)
1112
if strict is None:
1113
strict = br_from.get_config().get_user_option_as_bool('push_strict')
1114
if strict is None: strict = True # default value
1115
1081
# Get the tip's revision_id
1116
1082
revision = _get_one_revision('push', revision)
1117
1083
if revision is not None:
1118
1084
revision_id = revision.in_history(br_from).rev_id
1119
1085
else:
1120
1086
revision_id = None
1121
if strict and tree is not None and revision_id is None:
1122
if (tree.has_changes()):
1123
raise errors.UncommittedChanges(
1124
tree, more='Use --no-strict to force the push.')
1125
if tree.last_revision() != tree.branch.last_revision():
1126
# The tree has lost sync with its branch, there is little
1127
# chance that the user is aware of it but he can still force
1128
# the push with --no-strict
1129
raise errors.OutOfDateTree(
1130
tree, more='Use --no-strict to force the push.')
1131
1087
if tree is not None and revision_id is None:
1088
tree.check_changed_or_out_of_date(
1089
strict, 'push_strict',
1090
more_error='Use --no-strict to force the push.',
1091
more_warning='Uncommitted changes will not be pushed.')
1132
1092
# Get the stacked_on branch, if any
1133
1093
if stacked_on is not None:
1134
1094
stacked_on = urlutils.normalize_url(stacked_on)
1166
1126
1167
1127
1168
1128
class cmd_branch(Command):
1169
"""Create a new branch that is a copy of an existing branch.
1129
__doc__ = """Create a new branch that is a copy of an existing branch.
1170
1130
1171
1131
If the TO_LOCATION is omitted, the last component of the FROM_LOCATION will
1172
1132
be used. In other words, "branch ../foo/bar" will attempt to create ./bar.
1181
1141
1182
1142
_see_also = ['checkout']
1183
1143
takes_args = ['from_location', 'to_location?']
1184
takes_options = ['revision', Option('hardlink',
1185
help='Hard-link working tree files where possible.'),
1144
takes_options = ['revision',
1145
Option('hardlink', help='Hard-link working tree files where possible.'),
1146
Option('files-from', type=str,
1147
help="Get file contents from this tree."),
1186
1148
Option('no-tree',
1187
1149
help="Create a branch without a working-tree."),
1188
1150
Option('switch',
1199
1161
' directory exists, but does not already'
1200
1162
' have a control directory. This flag will'
1201
1163
' allow branch to proceed.'),
1164
Option('bind',
1165
help="Bind new branch to from location."),
1202
1166
]
1203
1167
aliases = ['get', 'clone']
1204
1168
1205
1169
def run(self, from_location, to_location=None, revision=None,
1206
1170
hardlink=False, stacked=False, standalone=False, no_tree=False,
1207
use_existing_dir=False, switch=False):
1171
use_existing_dir=False, switch=False, bind=False,
1172
files_from=None):
1208
1173
from bzrlib import switch as _mod_switch
1209
1174
from bzrlib.tag import _merge_tags_if_possible
1210
1175
accelerator_tree, br_from = bzrdir.BzrDir.open_tree_or_branch(
1211
1176
from_location)
1177
if not (hardlink or files_from):
1178
# accelerator_tree is usually slower because you have to read N
1179
# files (no readahead, lots of seeks, etc), but allow the user to
1180
# explicitly request it
1181
accelerator_tree = None
1182
if files_from is not None and files_from != from_location:
1183
accelerator_tree = WorkingTree.open(files_from)
1212
1184
revision = _get_one_revision('branch', revision)
1213
br_from.lock_read()
1185
self.add_cleanup(br_from.lock_read().unlock)
1186
if revision is not None:
1187
revision_id = revision.as_revision_id(br_from)
1188
else:
1189
# FIXME - wt.last_revision, fallback to branch, fall back to
1190
# None or perhaps NULL_REVISION to mean copy nothing
1191
# RBC 20060209
1192
revision_id = br_from.last_revision()
1193
if to_location is None:
1194
to_location = urlutils.derive_to_location(from_location)
1195
to_transport = transport.get_transport(to_location)
1214
1196
try:
1215
if revision is not None:
1216
revision_id = revision.as_revision_id(br_from)
1197
to_transport.mkdir('.')
1198
except errors.FileExists:
1199
if not use_existing_dir:
1200
raise errors.BzrCommandError('Target directory "%s" '
1201
'already exists.' % to_location)
1217
1202
else:
1218
# FIXME - wt.last_revision, fallback to branch, fall back to
1219
# None or perhaps NULL_REVISION to mean copy nothing
1220
# RBC 20060209
1221
revision_id = br_from.last_revision()
1222
if to_location is None:
1223
to_location = urlutils.derive_to_location(from_location)
1224
to_transport = transport.get_transport(to_location)
1225
try:
1226
to_transport.mkdir('.')
1227
except errors.FileExists:
1228
if not use_existing_dir:
1229
raise errors.BzrCommandError('Target directory "%s" '
1230
'already exists.' % to_location)
1203
try:
1204
bzrdir.BzrDir.open_from_transport(to_transport)
1205
except errors.NotBranchError:
1206
pass
1231
1207
else:
1232
try:
1233
bzrdir.BzrDir.open_from_transport(to_transport)
1234
except errors.NotBranchError:
1235
pass
1236
else:
1237
raise errors.AlreadyBranchError(to_location)
1238
except errors.NoSuchFile:
1239
raise errors.BzrCommandError('Parent of "%s" does not exist.'
1240
% to_location)
1241
try:
1242
# preserve whatever source format we have.
1243
dir = br_from.bzrdir.sprout(to_transport.base, revision_id,
1244
possible_transports=[to_transport],
1245
accelerator_tree=accelerator_tree,
1246
hardlink=hardlink, stacked=stacked,
1247
force_new_repo=standalone,
1248
create_tree_if_local=not no_tree,
1249
source_branch=br_from)
1250
branch = dir.open_branch()
1251
except errors.NoSuchRevision:
1252
to_transport.delete_tree('.')
1253
msg = "The branch %s has no revision %s." % (from_location,
1254
revision)
1255
raise errors.BzrCommandError(msg)
1256
_merge_tags_if_possible(br_from, branch)
1257
# If the source branch is stacked, the new branch may
1258
# be stacked whether we asked for that explicitly or not.
1259
# We therefore need a try/except here and not just 'if stacked:'
1260
try:
1261
note('Created new stacked branch referring to %s.' %
1262
branch.get_stacked_on_url())
1263
except (errors.NotStacked, errors.UnstackableBranchFormat,
1264
errors.UnstackableRepositoryFormat), e:
1265
note('Branched %d revision(s).' % branch.revno())
1266
if switch:
1267
# Switch to the new branch
1268
wt, _ = WorkingTree.open_containing('.')
1269
_mod_switch.switch(wt.bzrdir, branch)
1270
note('Switched to branch: %s',
1271
urlutils.unescape_for_display(branch.base, 'utf-8'))
1272
finally:
1273
br_from.unlock()
1208
raise errors.AlreadyBranchError(to_location)
1209
except errors.NoSuchFile:
1210
raise errors.BzrCommandError('Parent of "%s" does not exist.'
1211
% to_location)
1212
try:
1213
# preserve whatever source format we have.
1214
dir = br_from.bzrdir.sprout(to_transport.base, revision_id,
1215
possible_transports=[to_transport],
1216
accelerator_tree=accelerator_tree,
1217
hardlink=hardlink, stacked=stacked,
1218
force_new_repo=standalone,
1219
create_tree_if_local=not no_tree,
1220
source_branch=br_from)
1221
branch = dir.open_branch()
1222
except errors.NoSuchRevision:
1223
to_transport.delete_tree('.')
1224
msg = "The branch %s has no revision %s." % (from_location,
1225
revision)
1226
raise errors.BzrCommandError(msg)
1227
_merge_tags_if_possible(br_from, branch)
1228
# If the source branch is stacked, the new branch may
1229
# be stacked whether we asked for that explicitly or not.
1230
# We therefore need a try/except here and not just 'if stacked:'
1231
try:
1232
note('Created new stacked branch referring to %s.' %
1233
branch.get_stacked_on_url())
1234
except (errors.NotStacked, errors.UnstackableBranchFormat,
1235
errors.UnstackableRepositoryFormat), e:
1236
note('Branched %d revision(s).' % branch.revno())
1237
if bind:
1238
# Bind to the parent
1239
parent_branch = Branch.open(from_location)
1240
branch.bind(parent_branch)
1241
note('New branch bound to %s' % from_location)
1242
if switch:
1243
# Switch to the new branch
1244
wt, _ = WorkingTree.open_containing('.')
1245
_mod_switch.switch(wt.bzrdir, branch)
1246
note('Switched to branch: %s',
1247
urlutils.unescape_for_display(branch.base, 'utf-8'))
1274
1248
1275
1249
1276
1250
class cmd_checkout(Command):
1277
"""Create a new checkout of an existing branch.
1251
__doc__ = """Create a new checkout of an existing branch.
1278
1252
1279
1253
If BRANCH_LOCATION is omitted, checkout will reconstitute a working tree for
1280
1254
the branch found in '.'. This is useful if you have removed the working tree
1319
1293
to_location = branch_location
1320
1294
accelerator_tree, source = bzrdir.BzrDir.open_tree_or_branch(
1321
1295
branch_location)
1296
if not (hardlink or files_from):
1297
# accelerator_tree is usually slower because you have to read N
1298
# files (no readahead, lots of seeks, etc), but allow the user to
1299
# explicitly request it
1300
accelerator_tree = None
1322
1301
revision = _get_one_revision('checkout', revision)
1323
if files_from is not None:
1302
if files_from is not None and files_from != branch_location:
1324
1303
accelerator_tree = WorkingTree.open(files_from)
1325
1304
if revision is not None:
1326
1305
revision_id = revision.as_revision_id(source)
1343
1322
1344
1323
1345
1324
class cmd_renames(Command):
1346
"""Show list of renamed files.
1325
__doc__ = """Show list of renamed files.
1347
1326
"""
1348
1327
# TODO: Option to show renames between two historical versions.
1349
1328
1354
1333
@display_command
1355
1334
def run(self, dir=u'.'):
1356
1335
tree = WorkingTree.open_containing(dir)[0]
1357
tree.lock_read()
1358
try:
1359
new_inv = tree.inventory
1360
old_tree = tree.basis_tree()
1361
old_tree.lock_read()
1362
try:
1363
old_inv = old_tree.inventory
1364
renames = []
1365
iterator = tree.iter_changes(old_tree, include_unchanged=True)
1366
for f, paths, c, v, p, n, k, e in iterator:
1367
if paths[0] == paths[1]:
1368
continue
1369
if None in (paths):
1370
continue
1371
renames.append(paths)
1372
renames.sort()
1373
for old_name, new_name in renames:
1374
self.outf.write("%s => %s\n" % (old_name, new_name))
1375
finally:
1376
old_tree.unlock()
1377
finally:
1378
tree.unlock()
1336
self.add_cleanup(tree.lock_read().unlock)
1337
new_inv = tree.inventory
1338
old_tree = tree.basis_tree()
1339
self.add_cleanup(old_tree.lock_read().unlock)
1340
old_inv = old_tree.inventory
1341
renames = []
1342
iterator = tree.iter_changes(old_tree, include_unchanged=True)
1343
for f, paths, c, v, p, n, k, e in iterator:
1344
if paths[0] == paths[1]:
1345
continue
1346
if None in (paths):
1347
continue
1348
renames.append(paths)
1349
renames.sort()
1350
for old_name, new_name in renames:
1351
self.outf.write("%s => %s\n" % (old_name, new_name))
1379
1352
1380
1353
1381
1354
class cmd_update(Command):
1382
"""Update a tree to have the latest code committed to its branch.
1355
__doc__ = """Update a tree to have the latest code committed to its branch.
1383
1356
1384
1357
This will perform a merge into the working tree, and may generate
1385
1358
conflicts. If you have any local changes, you will still
1387
1360
1388
1361
If you want to discard your local changes, you can just do a
1389
1362
'bzr revert' instead of 'bzr commit' after the update.
1363
1364
If you want to restore a file that has been removed locally, use
1365
'bzr revert' instead of 'bzr update'.
1366
1367
If the tree's branch is bound to a master branch, it will also update
1368
the branch from the master.
1390
1369
"""
1391
1370
1392
1371
_see_also = ['pull', 'working-trees', 'status-flags']
1393
1372
takes_args = ['dir?']
1373
takes_options = ['revision',
1374
Option('show-base',
1375
help="Show base revision text in conflicts."),
1376
]
1394
1377
aliases = ['up']
1395
1378
1396
def run(self, dir='.'):
1379
def run(self, dir='.', revision=None, show_base=None):
1380
if revision is not None and len(revision) != 1:
1381
raise errors.BzrCommandError(
1382
"bzr update --revision takes exactly one revision")
1397
1383
tree = WorkingTree.open_containing(dir)[0]
1384
branch = tree.branch
1398
1385
possible_transports = []
1399
master = tree.branch.get_master_branch(
1386
master = branch.get_master_branch(
1400
1387
possible_transports=possible_transports)
1401
1388
if master is not None:
1402
tree.lock_write()
1403
1389
branch_location = master.base
1390
tree.lock_write()
1404
1391
else:
1392
branch_location = tree.branch.base
1405
1393
tree.lock_tree_write()
1406
branch_location = tree.branch.base
1394
self.add_cleanup(tree.unlock)
1407
1395
# get rid of the final '/' and be ready for display
1408
branch_location = urlutils.unescape_for_display(branch_location[:-1],
1409
self.outf.encoding)
1396
branch_location = urlutils.unescape_for_display(
1397
branch_location.rstrip('/'),
1398
self.outf.encoding)
1399
existing_pending_merges = tree.get_parent_ids()[1:]
1400
if master is None:
1401
old_tip = None
1402
else:
1403
# may need to fetch data into a heavyweight checkout
1404
# XXX: this may take some time, maybe we should display a
1405
# message
1406
old_tip = branch.update(possible_transports)
1407
if revision is not None:
1408
revision_id = revision[0].as_revision_id(branch)
1409
else:
1410
revision_id = branch.last_revision()
1411
if revision_id == _mod_revision.ensure_null(tree.last_revision()):
1412
revno = branch.revision_id_to_dotted_revno(revision_id)
1413
note("Tree is up to date at revision %s of branch %s" %
1414
('.'.join(map(str, revno)), branch_location))
1415
return 0
1416
view_info = _get_view_info_for_change_reporter(tree)
1417
change_reporter = delta._ChangeReporter(
1418
unversioned_filter=tree.is_ignored,
1419
view_info=view_info)
1410
1420
try:
1411
existing_pending_merges = tree.get_parent_ids()[1:]
1412
last_rev = _mod_revision.ensure_null(tree.last_revision())
1413
if last_rev == _mod_revision.ensure_null(
1414
tree.branch.last_revision()):
1415
# may be up to date, check master too.
1416
if master is None or last_rev == _mod_revision.ensure_null(
1417
master.last_revision()):
1418
revno = tree.branch.revision_id_to_revno(last_rev)
1419
note('Tree is up to date at revision %d of branch %s'
1420
% (revno, branch_location))
1421
return 0
1422
view_info = _get_view_info_for_change_reporter(tree)
1423
1421
conflicts = tree.update(
1424
delta._ChangeReporter(unversioned_filter=tree.is_ignored,
1425
view_info=view_info), possible_transports=possible_transports)
1426
revno = tree.branch.revision_id_to_revno(
1427
_mod_revision.ensure_null(tree.last_revision()))
1428
note('Updated to revision %d of branch %s' %
1429
(revno, branch_location))
1430
if tree.get_parent_ids()[1:] != existing_pending_merges:
1431
note('Your local commits will now show as pending merges with '
1432
"'bzr status', and can be committed with 'bzr commit'.")
1433
if conflicts != 0:
1434
return 1
1435
else:
1436
return 0
1437
finally:
1438
tree.unlock()
1422
change_reporter,
1423
possible_transports=possible_transports,
1424
revision=revision_id,
1425
old_tip=old_tip,
1426
show_base=show_base)
1427
except errors.NoSuchRevision, e:
1428
raise errors.BzrCommandError(
1429
"branch has no revision %s\n"
1430
"bzr update --revision only works"
1431
" for a revision in the branch history"
1432
% (e.revision))
1433
revno = tree.branch.revision_id_to_dotted_revno(
1434
_mod_revision.ensure_null(tree.last_revision()))
1435
note('Updated to revision %s of branch %s' %
1436
('.'.join(map(str, revno)), branch_location))
1437
parent_ids = tree.get_parent_ids()
1438
if parent_ids[1:] and parent_ids[1:] != existing_pending_merges:
1439
note('Your local commits will now show as pending merges with '
1440
"'bzr status', and can be committed with 'bzr commit'.")
1441
if conflicts != 0:
1442
return 1
1443
else:
1444
return 0
1439
1445
1440
1446
1441
1447
class cmd_info(Command):
1442
"""Show information about a working tree, branch or repository.
1448
__doc__ = """Show information about a working tree, branch or repository.
1443
1449
1444
1450
This command will show all known locations and formats associated to the
1445
1451
tree, branch or repository.
1483
1489
1484
1490
1485
1491
class cmd_remove(Command):
1486
"""Remove files or directories.
1492
__doc__ = """Remove files or directories.
1487
1493
1488
This makes bzr stop tracking changes to the specified files. bzr will delete
1489
them if they can easily be recovered using revert. If no options or
1490
parameters are given bzr will scan for files that are being tracked by bzr
1491
but missing in your tree and stop tracking them for you.
1494
This makes Bazaar stop tracking changes to the specified files. Bazaar will
1495
delete them if they can easily be recovered using revert otherwise they
1496
will be backed up (adding an extention of the form .~#~). If no options or
1497
parameters are given Bazaar will scan for files that are being tracked by
1498
Bazaar but missing in your tree and stop tracking them for you.
1492
1499
"""
1493
1500
takes_args = ['file*']
1494
1501
takes_options = ['verbose',
1496
1503
RegistryOption.from_kwargs('file-deletion-strategy',
1497
1504
'The file deletion mode to be used.',
1498
1505
title='Deletion Strategy', value_switches=True, enum_switch=False,
1499
safe='Only delete files if they can be'
1500
' safely recovered (default).',
1506
safe='Backup changed files (default).',
1501
1507
keep='Delete from bzr but leave the working copy.',
1502
1508
force='Delete all the specified files, even if they can not be '
1503
1509
'recovered and even if they are non-empty directories.')]
1506
1512
1507
1513
def run(self, file_list, verbose=False, new=False,
1508
1514
file_deletion_strategy='safe'):
1509
tree, file_list = tree_files(file_list)
1515
tree, file_list = WorkingTree.open_containing_paths(file_list)
1510
1516
1511
1517
if file_list is not None:
1512
1518
file_list = [f for f in file_list]
1513
1519
1514
tree.lock_write()
1515
try:
1516
# Heuristics should probably all move into tree.remove_smart or
1517
# some such?
1518
if new:
1519
added = tree.changes_from(tree.basis_tree(),
1520
specific_files=file_list).added
1521
file_list = sorted([f[0] for f in added], reverse=True)
1522
if len(file_list) == 0:
1523
raise errors.BzrCommandError('No matching files.')
1524
elif file_list is None:
1525
# missing files show up in iter_changes(basis) as
1526
# versioned-with-no-kind.
1527
missing = []
1528
for change in tree.iter_changes(tree.basis_tree()):
1529
# Find paths in the working tree that have no kind:
1530
if change[1][1] is not None and change[6][1] is None:
1531
missing.append(change[1][1])
1532
file_list = sorted(missing, reverse=True)
1533
file_deletion_strategy = 'keep'
1534
tree.remove(file_list, verbose=verbose, to_file=self.outf,
1535
keep_files=file_deletion_strategy=='keep',
1536
force=file_deletion_strategy=='force')
1537
finally:
1538
tree.unlock()
1520
self.add_cleanup(tree.lock_write().unlock)
1521
# Heuristics should probably all move into tree.remove_smart or
1522
# some such?
1523
if new:
1524
added = tree.changes_from(tree.basis_tree(),
1525
specific_files=file_list).added
1526
file_list = sorted([f[0] for f in added], reverse=True)
1527
if len(file_list) == 0:
1528
raise errors.BzrCommandError('No matching files.')
1529
elif file_list is None:
1530
# missing files show up in iter_changes(basis) as
1531
# versioned-with-no-kind.
1532
missing = []
1533
for change in tree.iter_changes(tree.basis_tree()):
1534
# Find paths in the working tree that have no kind:
1535
if change[1][1] is not None and change[6][1] is None:
1536
missing.append(change[1][1])
1537
file_list = sorted(missing, reverse=True)
1538
file_deletion_strategy = 'keep'
1539
tree.remove(file_list, verbose=verbose, to_file=self.outf,
1540
keep_files=file_deletion_strategy=='keep',
1541
force=file_deletion_strategy=='force')
1539
1542
1540
1543
1541
1544
class cmd_file_id(Command):
1542
"""Print file_id of a particular file or directory.
1545
__doc__ = """Print file_id of a particular file or directory.
1543
1546
1544
1547
The file_id is assigned when the file is first added and remains the
1545
1548
same through all revisions where the file exists, even when it is
1561
1564
1562
1565
1563
1566
class cmd_file_path(Command):
1564
"""Print path of file_ids to a file or directory.
1567
__doc__ = """Print path of file_ids to a file or directory.
1565
1568
1566
1569
This prints one line for each directory down to the target,
1567
1570
starting at the branch root.
1583
1586
1584
1587
1585
1588
class cmd_reconcile(Command):
1586
"""Reconcile bzr metadata in a branch.
1589
__doc__ = """Reconcile bzr metadata in a branch.
1587
1590
1588
1591
This can correct data mismatches that may have been caused by
1589
1592
previous ghost operations or bzr upgrades. You should only
1603
1606
1604
1607
_see_also = ['check']
1605
1608
takes_args = ['branch?']
1609
takes_options = [
1610
Option('canonicalize-chks',
1611
help='Make sure CHKs are in canonical form (repairs '
1612
'bug 522637).',
1613
hidden=True),
1614
]
1606
1615
1607
def run(self, branch="."):
1616
def run(self, branch=".", canonicalize_chks=False):
1608
1617
from bzrlib.reconcile import reconcile
1609
1618
dir = bzrdir.BzrDir.open(branch)
1610
reconcile(dir)
1619
reconcile(dir, canonicalize_chks=canonicalize_chks)
1611
1620
1612
1621
1613
1622
class cmd_revision_history(Command):
1614
"""Display the list of revision ids on a branch."""
1623
__doc__ = """Display the list of revision ids on a branch."""
1615
1624
1616
1625
_see_also = ['log']
1617
1626
takes_args = ['location?']
1627
1636
1628
1637
1629
1638
class cmd_ancestry(Command):
1630
"""List all revisions merged into this branch."""
1639
__doc__ = """List all revisions merged into this branch."""
1631
1640
1632
1641
_see_also = ['log', 'revision-history']
1633
1642
takes_args = ['location?']
1652
1661
1653
1662
1654
1663
class cmd_init(Command):
1655
"""Make a directory into a versioned branch.
1664
__doc__ = """Make a directory into a versioned branch.
1656
1665
1657
1666
Use this to create an empty branch, or before importing an
1658
1667
existing project.
1761
1770
1762
1771
1763
1772
class cmd_init_repository(Command):
1764
"""Create a shared repository for branches to share storage space.
1773
__doc__ = """Create a shared repository for branches to share storage space.
1765
1774
1766
1775
New branches created under the repository directory will store their
1767
1776
revisions in the repository, not in the branch directory. For branches
1821
1830
1822
1831
1823
1832
class cmd_diff(Command):
1824
"""Show differences in the working tree, between revisions or branches.
1833
__doc__ = """Show differences in the working tree, between revisions or branches.
1825
1834
1826
1835
If no arguments are given, all changes for the current tree are listed.
1827
1836
If files are given, only the changes in those files are listed.
1889
1898
Same as 'bzr diff' but prefix paths with old/ and new/::
1890
1899
1891
1900
bzr diff --prefix old/:new/
1901
1902
Show the differences using a custom diff program with options::
1903
1904
bzr diff --using /usr/bin/diff --diff-options -wu
1892
1905
"""
1893
1906
_see_also = ['status']
1894
1907
takes_args = ['file*']
1913
1926
help='Use this command to compare files.',
1914
1927
type=unicode,
1915
1928
),
1929
RegistryOption('format',
1930
help='Diff format to use.',
1931
lazy_registry=('bzrlib.diff', 'format_registry'),
1932
value_switches=False, title='Diff format'),
1916
1933
]
1917
1934
aliases = ['di', 'dif']
1918
1935
encoding_type = 'exact'
1919
1936
1920
1937
@display_command
1921
1938
def run(self, revision=None, file_list=None, diff_options=None,
1922
prefix=None, old=None, new=None, using=None):
1923
from bzrlib.diff import get_trees_and_branches_to_diff, show_diff_trees
1939
prefix=None, old=None, new=None, using=None, format=None):
1940
from bzrlib.diff import (get_trees_and_branches_to_diff_locked,
1941
show_diff_trees)
1924
1942
1925
1943
if (prefix is None) or (prefix == '0'):
1926
1944
# diff -p0 format
1940
1958
raise errors.BzrCommandError('bzr diff --revision takes exactly'
1941
1959
' one or two revision specifiers')
1942
1960
1961
if using is not None and format is not None:
1962
raise errors.BzrCommandError('--using and --format are mutually '
1963
'exclusive.')
1964
1943
1965
(old_tree, new_tree,
1944
1966
old_branch, new_branch,
1945
specific_files, extra_trees) = get_trees_and_branches_to_diff(
1946
file_list, revision, old, new, apply_view=True)
1967
specific_files, extra_trees) = get_trees_and_branches_to_diff_locked(
1968
file_list, revision, old, new, self.add_cleanup, apply_view=True)
1969
# GNU diff on Windows uses ANSI encoding for filenames
1970
path_encoding = osutils.get_diff_header_encoding()
1947
1971
return show_diff_trees(old_tree, new_tree, sys.stdout,
1948
1972
specific_files=specific_files,
1949
1973
external_diff_options=diff_options,
1950
1974
old_label=old_label, new_label=new_label,
1951
extra_trees=extra_trees, using=using)
1975
extra_trees=extra_trees,
1976
path_encoding=path_encoding,
1977
using=using,
1978
format_cls=format)
1952
1979
1953
1980
1954
1981
class cmd_deleted(Command):
1955
"""List files deleted in the working tree.
1982
__doc__ = """List files deleted in the working tree.
1956
1983
"""
1957
1984
# TODO: Show files deleted since a previous revision, or
1958
1985
# between two revisions.
1961
1988
# level of effort but possibly much less IO. (Or possibly not,
1962
1989
# if the directories are very large...)
1963
1990
_see_also = ['status', 'ls']
1964
takes_options = ['show-ids']
1991
takes_options = ['directory', 'show-ids']
1965
1992
1966
1993
@display_command
1967
def run(self, show_ids=False):
1968
tree = WorkingTree.open_containing(u'.')[0]
1969
tree.lock_read()
1970
try:
1971
old = tree.basis_tree()
1972
old.lock_read()
1973
try:
1974
for path, ie in old.inventory.iter_entries():
1975
if not tree.has_id(ie.file_id):
1976
self.outf.write(path)
1977
if show_ids:
1978
self.outf.write(' ')
1979
self.outf.write(ie.file_id)
1980
self.outf.write('\n')
1981
finally:
1982
old.unlock()
1983
finally:
1984
tree.unlock()
1994
def run(self, show_ids=False, directory=u'.'):
1995
tree = WorkingTree.open_containing(directory)[0]
1996
self.add_cleanup(tree.lock_read().unlock)
1997
old = tree.basis_tree()
1998
self.add_cleanup(old.lock_read().unlock)
1999
for path, ie in old.inventory.iter_entries():
2000
if not tree.has_id(ie.file_id):
2001
self.outf.write(path)
2002
if show_ids:
2003
self.outf.write(' ')
2004
self.outf.write(ie.file_id)
2005
self.outf.write('\n')
1985
2006
1986
2007
1987
2008
class cmd_modified(Command):
1988
"""List files modified in working tree.
2009
__doc__ = """List files modified in working tree.
1989
2010
"""
1990
2011
1991
2012
hidden = True
1992
2013
_see_also = ['status', 'ls']
1993
takes_options = [
1994
Option('null',
1995
help='Write an ascii NUL (\\0) separator '
1996
'between files rather than a newline.')
1997
]
2014
takes_options = ['directory', 'null']
1998
2015
1999
2016
@display_command
2000
def run(self, null=False):
2001
tree = WorkingTree.open_containing(u'.')[0]
2017
def run(self, null=False, directory=u'.'):
2018
tree = WorkingTree.open_containing(directory)[0]
2002
2019
td = tree.changes_from(tree.basis_tree())
2003
2020
for path, id, kind, text_modified, meta_modified in td.modified:
2004
2021
if null:
2008
2025
2009
2026
2010
2027
class cmd_added(Command):
2011
"""List files added in working tree.
2028
__doc__ = """List files added in working tree.
2012
2029
"""
2013
2030
2014
2031
hidden = True
2015
2032
_see_also = ['status', 'ls']
2016
takes_options = [
2017
Option('null',
2018
help='Write an ascii NUL (\\0) separator '
2019
'between files rather than a newline.')
2020
]
2033
takes_options = ['directory', 'null']
2021
2034
2022
2035
@display_command
2023
def run(self, null=False):
2024
wt = WorkingTree.open_containing(u'.')[0]
2025
wt.lock_read()
2026
try:
2027
basis = wt.basis_tree()
2028
basis.lock_read()
2029
try:
2030
basis_inv = basis.inventory
2031
inv = wt.inventory
2032
for file_id in inv:
2033
if file_id in basis_inv:
2034
continue
2035
if inv.is_root(file_id) and len(basis_inv) == 0:
2036
continue
2037
path = inv.id2path(file_id)
2038
if not os.access(osutils.abspath(path), os.F_OK):
2039
continue
2040
if null:
2041
self.outf.write(path + '\0')
2042
else:
2043
self.outf.write(osutils.quotefn(path) + '\n')
2044
finally:
2045
basis.unlock()
2046
finally:
2047
wt.unlock()
2036
def run(self, null=False, directory=u'.'):
2037
wt = WorkingTree.open_containing(directory)[0]
2038
self.add_cleanup(wt.lock_read().unlock)
2039
basis = wt.basis_tree()
2040
self.add_cleanup(basis.lock_read().unlock)
2041
basis_inv = basis.inventory
2042
inv = wt.inventory
2043
for file_id in inv:
2044
if file_id in basis_inv:
2045
continue
2046
if inv.is_root(file_id) and len(basis_inv) == 0:
2047
continue
2048
path = inv.id2path(file_id)
2049
if not os.access(osutils.pathjoin(wt.basedir, path), os.F_OK):
2050
continue
2051
if null:
2052
self.outf.write(path + '\0')
2053
else:
2054
self.outf.write(osutils.quotefn(path) + '\n')
2048
2055
2049
2056
2050
2057
class cmd_root(Command):
2051
"""Show the tree root directory.
2058
__doc__ = """Show the tree root directory.
2052
2059
2053
2060
The root is the nearest enclosing directory with a .bzr control
2054
2061
directory."""
2078
2085
2079
2086
2080
2087
class cmd_log(Command):
2081
"""Show historical log for a branch or subset of a branch.
2088
__doc__ = """Show historical log for a branch or subset of a branch.
2082
2089
2083
2090
log is bzr's default tool for exploring the history of a branch.
2084
2091
The branch to use is taken from the first parameter. If no parameters
2195
2202
:Tips & tricks:
2196
2203
2197
2204
GUI tools and IDEs are often better at exploring history than command
2198
line tools. You may prefer qlog or glog from the QBzr and Bzr-Gtk packages
2199
respectively for example. (TortoiseBzr uses qlog for displaying logs.) See
2200
http://bazaar-vcs.org/BzrPlugins and http://bazaar-vcs.org/IDEIntegration.
2201
2202
Web interfaces are often better at exploring history than command line
2203
tools, particularly for branches on servers. You may prefer Loggerhead
2204
or one of its alternatives. See http://bazaar-vcs.org/WebInterface.
2205
line tools: you may prefer qlog or viz from qbzr or bzr-gtk, the
2206
bzr-explorer shell, or the Loggerhead web interface. See the Plugin
2207
Guide <http://doc.bazaar.canonical.com/plugins/en/> and
2208
<http://wiki.bazaar.canonical.com/IDEIntegration>.
2205
2209
2206
2210
You may find it useful to add the aliases below to ``bazaar.conf``::
2207
2211
2248
2252
help='Show just the specified revision.'
2249
2253
' See also "help revisionspec".'),
2250
2254
'log-format',
2255
RegistryOption('authors',
2256
'What names to list as authors - first, all or committer.',
2257
title='Authors',
2258
lazy_registry=('bzrlib.log', 'author_list_registry'),
2259
),
2251
2260
Option('levels',
2252
2261
short_name='n',
2253
2262
help='Number of levels to display - 0 for all, 1 for flat.',
2268
2277
help='Show changes made in each revision as a patch.'),
2269
2278
Option('include-merges',
2270
2279
help='Show merged revisions like --levels 0 does.'),
2280
Option('exclude-common-ancestry',
2281
help='Display only the revisions that are not part'
2282
' of both ancestries (require -rX..Y)'
2283
)
2271
2284
]
2272
2285
encoding_type = 'replace'
2273
2286
2283
2296
message=None,
2284
2297
limit=None,
2285
2298
show_diff=False,
2286
include_merges=False):
2299
include_merges=False,
2300
authors=None,
2301
exclude_common_ancestry=False,
2302
):
2287
2303
from bzrlib.log import (
2288
2304
Logger,
2289
2305
make_log_request_dict,
2290
2306
_get_info_for_log_files,
2291
2307
)
2292
2308
direction = (forward and 'forward') or 'reverse'
2309
if (exclude_common_ancestry
2310
and (revision is None or len(revision) != 2)):
2311
raise errors.BzrCommandError(
2312
'--exclude-common-ancestry requires -r with two revisions')
2293
2313
if include_merges:
2294
2314
if levels is None:
2295
2315
levels = 0
2308
2328
2309
2329
file_ids = []
2310
2330
filter_by_dir = False
2311
b = None
2312
try:
2313
if file_list:
2314
# find the file ids to log and check for directory filtering
2315
b, file_info_list, rev1, rev2 = _get_info_for_log_files(
2316
revision, file_list)
2317
for relpath, file_id, kind in file_info_list:
2318
if file_id is None:
2319
raise errors.BzrCommandError(
2320
"Path unknown at end or start of revision range: %s" %
2321
relpath)
2322
# If the relpath is the top of the tree, we log everything
2323
if relpath == '':
2324
file_ids = []
2325
break
2326
else:
2327
file_ids.append(file_id)
2328
filter_by_dir = filter_by_dir or (
2329
kind in ['directory', 'tree-reference'])
2330
else:
2331
# log everything
2332
# FIXME ? log the current subdir only RBC 20060203
2333
if revision is not None \
2334
and len(revision) > 0 and revision[0].get_branch():
2335
location = revision[0].get_branch()
2331
if file_list:
2332
# find the file ids to log and check for directory filtering
2333
b, file_info_list, rev1, rev2 = _get_info_for_log_files(
2334
revision, file_list, self.add_cleanup)
2335
for relpath, file_id, kind in file_info_list:
2336
if file_id is None:
2337
raise errors.BzrCommandError(
2338
"Path unknown at end or start of revision range: %s" %
2339
relpath)
2340
# If the relpath is the top of the tree, we log everything
2341
if relpath == '':
2342
file_ids = []
2343
break
2336
2344
else:
2337
location = '.'
2338
dir, relpath = bzrdir.BzrDir.open_containing(location)
2339
b = dir.open_branch()
2340
b.lock_read()
2341
rev1, rev2 = _get_revision_range(revision, b, self.name())
2342
2343
# Decide on the type of delta & diff filtering to use
2344
# TODO: add an --all-files option to make this configurable & consistent
2345
if not verbose:
2346
delta_type = None
2347
else:
2348
delta_type = 'full'
2349
if not show_diff:
2350
diff_type = None
2351
elif file_ids:
2352
diff_type = 'partial'
2353
else:
2354
diff_type = 'full'
2355
2356
# Build the log formatter
2357
if log_format is None:
2358
log_format = log.log_formatter_registry.get_default(b)
2359
# Make a non-encoding output to include the diffs - bug 328007
2360
unencoded_output = ui.ui_factory.make_output_stream(encoding_type='exact')
2361
lf = log_format(show_ids=show_ids, to_file=self.outf,
2362
to_exact_file=unencoded_output,
2363
show_timezone=timezone,
2364
delta_format=get_verbosity_level(),
2365
levels=levels,
2366
show_advice=levels is None)
2367
2368
# Choose the algorithm for doing the logging. It's annoying
2369
# having multiple code paths like this but necessary until
2370
# the underlying repository format is faster at generating
2371
# deltas or can provide everything we need from the indices.
2372
# The default algorithm - match-using-deltas - works for
2373
# multiple files and directories and is faster for small
2374
# amounts of history (200 revisions say). However, it's too
2375
# slow for logging a single file in a repository with deep
2376
# history, i.e. > 10K revisions. In the spirit of "do no
2377
# evil when adding features", we continue to use the
2378
# original algorithm - per-file-graph - for the "single
2379
# file that isn't a directory without showing a delta" case.
2380
partial_history = revision and b.repository._format.supports_chks
2381
match_using_deltas = (len(file_ids) != 1 or filter_by_dir
2382
or delta_type or partial_history)
2383
2384
# Build the LogRequest and execute it
2385
if len(file_ids) == 0:
2386
file_ids = None
2387
rqst = make_log_request_dict(
2388
direction=direction, specific_fileids=file_ids,
2389
start_revision=rev1, end_revision=rev2, limit=limit,
2390
message_search=message, delta_type=delta_type,
2391
diff_type=diff_type, _match_using_deltas=match_using_deltas)
2392
Logger(b, rqst).show(lf)
2393
finally:
2394
if b is not None:
2395
b.unlock()
2345
file_ids.append(file_id)
2346
filter_by_dir = filter_by_dir or (
2347
kind in ['directory', 'tree-reference'])
2348
else:
2349
# log everything
2350
# FIXME ? log the current subdir only RBC 20060203
2351
if revision is not None \
2352
and len(revision) > 0 and revision[0].get_branch():
2353
location = revision[0].get_branch()
2354
else:
2355
location = '.'
2356
dir, relpath = bzrdir.BzrDir.open_containing(location)
2357
b = dir.open_branch()
2358
self.add_cleanup(b.lock_read().unlock)
2359
rev1, rev2 = _get_revision_range(revision, b, self.name())
2360
2361
# Decide on the type of delta & diff filtering to use
2362
# TODO: add an --all-files option to make this configurable & consistent
2363
if not verbose:
2364
delta_type = None
2365
else:
2366
delta_type = 'full'
2367
if not show_diff:
2368
diff_type = None
2369
elif file_ids:
2370
diff_type = 'partial'
2371
else:
2372
diff_type = 'full'
2373
2374
# Build the log formatter
2375
if log_format is None:
2376
log_format = log.log_formatter_registry.get_default(b)
2377
# Make a non-encoding output to include the diffs - bug 328007
2378
unencoded_output = ui.ui_factory.make_output_stream(encoding_type='exact')
2379
lf = log_format(show_ids=show_ids, to_file=self.outf,
2380
to_exact_file=unencoded_output,
2381
show_timezone=timezone,
2382
delta_format=get_verbosity_level(),
2383
levels=levels,
2384
show_advice=levels is None,
2385
author_list_handler=authors)
2386
2387
# Choose the algorithm for doing the logging. It's annoying
2388
# having multiple code paths like this but necessary until
2389
# the underlying repository format is faster at generating
2390
# deltas or can provide everything we need from the indices.
2391
# The default algorithm - match-using-deltas - works for
2392
# multiple files and directories and is faster for small
2393
# amounts of history (200 revisions say). However, it's too
2394
# slow for logging a single file in a repository with deep
2395
# history, i.e. > 10K revisions. In the spirit of "do no
2396
# evil when adding features", we continue to use the
2397
# original algorithm - per-file-graph - for the "single
2398
# file that isn't a directory without showing a delta" case.
2399
partial_history = revision and b.repository._format.supports_chks
2400
match_using_deltas = (len(file_ids) != 1 or filter_by_dir
2401
or delta_type or partial_history)
2402
2403
# Build the LogRequest and execute it
2404
if len(file_ids) == 0:
2405
file_ids = None
2406
rqst = make_log_request_dict(
2407
direction=direction, specific_fileids=file_ids,
2408
start_revision=rev1, end_revision=rev2, limit=limit,
2409
message_search=message, delta_type=delta_type,
2410
diff_type=diff_type, _match_using_deltas=match_using_deltas,
2411
exclude_common_ancestry=exclude_common_ancestry,
2412
)
2413
Logger(b, rqst).show(lf)
2396
2414
2397
2415
2398
2416
def _get_revision_range(revisionspec_list, branch, command_name):
2416
2434
raise errors.BzrCommandError(
2417
2435
"bzr %s doesn't accept two revisions in different"
2418
2436
" branches." % command_name)
2419
rev1 = start_spec.in_history(branch)
2437
if start_spec.spec is None:
2438
# Avoid loading all the history.
2439
rev1 = RevisionInfo(branch, None, None)
2440
else:
2441
rev1 = start_spec.in_history(branch)
2420
2442
# Avoid loading all of history when we know a missing
2421
2443
# end of range means the last revision ...
2422
2444
if end_spec.spec is None:
2451
2473
2452
2474
2453
2475
class cmd_touching_revisions(Command):
2454
"""Return revision-ids which affected a particular file.
2476
__doc__ = """Return revision-ids which affected a particular file.
2455
2477
2456
2478
A more user-friendly interface is "bzr log FILE".
2457
2479
"""
2464
2486
tree, relpath = WorkingTree.open_containing(filename)
2465
2487
file_id = tree.path2id(relpath)
2466
2488
b = tree.branch
2467
b.lock_read()
2468
try:
2469
touching_revs = log.find_touching_revisions(b, file_id)
2470
for revno, revision_id, what in touching_revs:
2471
self.outf.write("%6d %s\n" % (revno, what))
2472
finally:
2473
b.unlock()
2489
self.add_cleanup(b.lock_read().unlock)
2490
touching_revs = log.find_touching_revisions(b, file_id)
2491
for revno, revision_id, what in touching_revs:
2492
self.outf.write("%6d %s\n" % (revno, what))
2474
2493
2475
2494
2476
2495
class cmd_ls(Command):
2477
"""List files in a tree.
2496
__doc__ = """List files in a tree.
2478
2497
"""
2479
2498
2480
2499
_see_also = ['status', 'cat']
2486
2505
help='Recurse into subdirectories.'),
2487
2506
Option('from-root',
2488
2507
help='Print paths relative to the root of the branch.'),
2489
Option('unknown', help='Print unknown files.'),
2508
Option('unknown', short_name='u',
2509
help='Print unknown files.'),
2490
2510
Option('versioned', help='Print versioned files.',
2491
2511
short_name='V'),
2492
Option('ignored', help='Print ignored files.'),
2493
Option('null',
2494
help='Write an ascii NUL (\\0) separator '
2495
'between files rather than a newline.'),
2496
Option('kind',
2512
Option('ignored', short_name='i',
2513
help='Print ignored files.'),
2514
Option('kind', short_name='k',
2497
2515
help='List entries of a particular kind: file, directory, symlink.',
2498
2516
type=unicode),
2517
'null',
2499
2518
'show-ids',
2519
'directory',
2500
2520
]
2501
2521
@display_command
2502
2522
def run(self, revision=None, verbose=False,
2503
2523
recursive=False, from_root=False,
2504
2524
unknown=False, versioned=False, ignored=False,
2505
null=False, kind=None, show_ids=False, path=None):
2525
null=False, kind=None, show_ids=False, path=None, directory=None):
2506
2526
2507
2527
if kind and kind not in ('file', 'directory', 'symlink'):
2508
2528
raise errors.BzrCommandError('invalid kind specified')
2520
2540
raise errors.BzrCommandError('cannot specify both --from-root'
2521
2541
' and PATH')
2522
2542
fs_path = path
2523
tree, branch, relpath = bzrdir.BzrDir.open_containing_tree_or_branch(
2524
fs_path)
2543
tree, branch, relpath = \
2544
_open_directory_or_containing_tree_or_branch(fs_path, directory)
2525
2545
2526
2546
# Calculate the prefix to use
2527
2547
prefix = None
2542
2562
view_str = views.view_display_str(view_files)
2543
2563
note("Ignoring files outside view. View is %s" % view_str)
2544
2564
2545
tree.lock_read()
2546
try:
2547
for fp, fc, fkind, fid, entry in tree.list_files(include_root=False,
2548
from_dir=relpath, recursive=recursive):
2549
# Apply additional masking
2550
if not all and not selection[fc]:
2551
continue
2552
if kind is not None and fkind != kind:
2553
continue
2554
if apply_view:
2555
try:
2556
if relpath:
2557
fullpath = osutils.pathjoin(relpath, fp)
2558
else:
2559
fullpath = fp
2560
views.check_path_in_view(tree, fullpath)
2561
except errors.FileOutsideView:
2562
continue
2565
self.add_cleanup(tree.lock_read().unlock)
2566
for fp, fc, fkind, fid, entry in tree.list_files(include_root=False,
2567
from_dir=relpath, recursive=recursive):
2568
# Apply additional masking
2569
if not all and not selection[fc]:
2570
continue
2571
if kind is not None and fkind != kind:
2572
continue
2573
if apply_view:
2574
try:
2575
if relpath:
2576
fullpath = osutils.pathjoin(relpath, fp)
2577
else:
2578
fullpath = fp
2579
views.check_path_in_view(tree, fullpath)
2580
except errors.FileOutsideView:
2581
continue
2563
2582
2564
# Output the entry
2565
if prefix:
2566
fp = osutils.pathjoin(prefix, fp)
2567
kindch = entry.kind_character()
2568
outstring = fp + kindch
2569
ui.ui_factory.clear_term()
2570
if verbose:
2571
outstring = '%-8s %s' % (fc, outstring)
2572
if show_ids and fid is not None:
2573
outstring = "%-50s %s" % (outstring, fid)
2583
# Output the entry
2584
if prefix:
2585
fp = osutils.pathjoin(prefix, fp)
2586
kindch = entry.kind_character()
2587
outstring = fp + kindch
2588
ui.ui_factory.clear_term()
2589
if verbose:
2590
outstring = '%-8s %s' % (fc, outstring)
2591
if show_ids and fid is not None:
2592
outstring = "%-50s %s" % (outstring, fid)
2593
self.outf.write(outstring + '\n')
2594
elif null:
2595
self.outf.write(fp + '\0')
2596
if show_ids:
2597
if fid is not None:
2598
self.outf.write(fid)
2599
self.outf.write('\0')
2600
self.outf.flush()
2601
else:
2602
if show_ids:
2603
if fid is not None:
2604
my_id = fid
2605
else:
2606
my_id = ''
2607
self.outf.write('%-50s %s\n' % (outstring, my_id))
2608
else:
2574
2609
self.outf.write(outstring + '\n')
2575
elif null:
2576
self.outf.write(fp + '\0')
2577
if show_ids:
2578
if fid is not None:
2579
self.outf.write(fid)
2580
self.outf.write('\0')
2581
self.outf.flush()
2582
else:
2583
if show_ids:
2584
if fid is not None:
2585
my_id = fid
2586
else:
2587
my_id = ''
2588
self.outf.write('%-50s %s\n' % (outstring, my_id))
2589
else:
2590
self.outf.write(outstring + '\n')
2591
finally:
2592
tree.unlock()
2593
2610
2594
2611
2595
2612
class cmd_unknowns(Command):
2596
"""List unknown files.
2613
__doc__ = """List unknown files.
2597
2614
"""
2598
2615
2599
2616
hidden = True
2600
2617
_see_also = ['ls']
2618
takes_options = ['directory']
2601
2619
2602
2620
@display_command
2603
def run(self):
2604
for f in WorkingTree.open_containing(u'.')[0].unknowns():
2621
def run(self, directory=u'.'):
2622
for f in WorkingTree.open_containing(directory)[0].unknowns():
2605
2623
self.outf.write(osutils.quotefn(f) + '\n')
2606
2624
2607
2625
2608
2626
class cmd_ignore(Command):
2609
"""Ignore specified files or patterns.
2627
__doc__ = """Ignore specified files or patterns.
2610
2628
2611
2629
See ``bzr help patterns`` for details on the syntax of patterns.
2612
2630
2620
2638
After adding, editing or deleting that file either indirectly by
2621
2639
using this command or directly by using an editor, be sure to commit
2622
2640
it.
2641
2642
Bazaar also supports a global ignore file ~/.bazaar/ignore. On Windows
2643
the global ignore file can be found in the application data directory as
2644
C:\\Documents and Settings\\<user>\\Application Data\\Bazaar\\2.0\\ignore.
2645
Global ignores are not touched by this command. The global ignore file
2646
can be edited directly using an editor.
2647
2648
Patterns prefixed with '!' are exceptions to ignore patterns and take
2649
precedence over regular ignores. Such exceptions are used to specify
2650
files that should be versioned which would otherwise be ignored.
2651
2652
Patterns prefixed with '!!' act as regular ignore patterns, but have
2653
precedence over the '!' exception patterns.
2623
2654
2624
2655
Note: ignore patterns containing shell wildcards must be quoted from
2625
2656
the shell on Unix.
2629
2660
2630
2661
bzr ignore ./Makefile
2631
2662
2632
Ignore class files in all directories::
2663
Ignore .class files in all directories...::
2633
2664
2634
2665
bzr ignore "*.class"
2635
2666
2667
...but do not ignore "special.class"::
2668
2669
bzr ignore "!special.class"
2670
2636
2671
Ignore .o files under the lib directory::
2637
2672
2638
2673
bzr ignore "lib/**/*.o"
2644
2679
Ignore everything but the "debian" toplevel directory::
2645
2680
2646
2681
bzr ignore "RE:(?!debian/).*"
2682
2683
Ignore everything except the "local" toplevel directory,
2684
but always ignore "*~" autosave files, even under local/::
2685
2686
bzr ignore "*"
2687
bzr ignore "!./local"
2688
bzr ignore "!!*~"
2647
2689
"""
2648
2690
2649
2691
_see_also = ['status', 'ignored', 'patterns']
2650
2692
takes_args = ['name_pattern*']
2651
takes_options = [
2652
Option('old-default-rules',
2653
help='Write out the ignore rules bzr < 0.9 always used.')
2693
takes_options = ['directory',
2694
Option('default-rules',
2695
help='Display the default ignore rules that bzr uses.')
2654
2696
]
2655
2697
2656
def run(self, name_pattern_list=None, old_default_rules=None):
2698
def run(self, name_pattern_list=None, default_rules=None,
2699
directory=u'.'):
2657
2700
from bzrlib import ignores
2658
if old_default_rules is not None:
2659
# dump the rules and exit
2660
for pattern in ignores.OLD_DEFAULTS:
2661
print pattern
2701
if default_rules is not None:
2702
# dump the default rules and exit
2703
for pattern in ignores.USER_DEFAULTS:
2704
self.outf.write("%s\n" % pattern)
2662
2705
return
2663
2706
if not name_pattern_list:
2664
2707
raise errors.BzrCommandError("ignore requires at least one "
2665
"NAME_PATTERN or --old-default-rules")
2708
"NAME_PATTERN or --default-rules.")
2666
2709
name_pattern_list = [globbing.normalize_pattern(p)
2667
2710
for p in name_pattern_list]
2711
bad_patterns = ''
2712
for p in name_pattern_list:
2713
if not globbing.Globster.is_pattern_valid(p):
2714
bad_patterns += ('\n %s' % p)
2715
if bad_patterns:
2716
msg = ('Invalid ignore pattern(s) found. %s' % bad_patterns)
2717
ui.ui_factory.show_error(msg)
2718
raise errors.InvalidPattern('')
2668
2719
for name_pattern in name_pattern_list:
2669
2720
if (name_pattern[0] == '/' or
2670
2721
(len(name_pattern) > 1 and name_pattern[1] == ':')):
2671
2722
raise errors.BzrCommandError(
2672
2723
"NAME_PATTERN should not be an absolute path")
2673
tree, relpath = WorkingTree.open_containing(u'.')
2724
tree, relpath = WorkingTree.open_containing(directory)
2674
2725
ignores.tree_ignores_add_patterns(tree, name_pattern_list)
2675
2726
ignored = globbing.Globster(name_pattern_list)
2676
2727
matches = []
2677
tree.lock_read()
2728
self.add_cleanup(tree.lock_read().unlock)
2678
2729
for entry in tree.list_files():
2679
2730
id = entry[3]
2680
2731
if id is not None:
2681
2732
filename = entry[0]
2682
2733
if ignored.match(filename):
2683
matches.append(filename.encode('utf-8'))
2684
tree.unlock()
2734
matches.append(filename)
2685
2735
if len(matches) > 0:
2686
print "Warning: the following files are version controlled and" \
2687
" match your ignore pattern:\n%s" \
2688
"\nThese files will continue to be version controlled" \
2689
" unless you 'bzr remove' them." % ("\n".join(matches),)
2736
self.outf.write("Warning: the following files are version controlled and"
2737
" match your ignore pattern:\n%s"
2738
"\nThese files will continue to be version controlled"
2739
" unless you 'bzr remove' them.\n" % ("\n".join(matches),))
2690
2740
2691
2741
2692
2742
class cmd_ignored(Command):
2693
"""List ignored files and the patterns that matched them.
2743
__doc__ = """List ignored files and the patterns that matched them.
2694
2744
2695
2745
List all the ignored files and the ignore pattern that caused the file to
2696
2746
be ignored.
2702
2752
2703
2753
encoding_type = 'replace'
2704
2754
_see_also = ['ignore', 'ls']
2755
takes_options = ['directory']
2705
2756
2706
2757
@display_command
2707
def run(self):
2708
tree = WorkingTree.open_containing(u'.')[0]
2709
tree.lock_read()
2710
try:
2711
for path, file_class, kind, file_id, entry in tree.list_files():
2712
if file_class != 'I':
2713
continue
2714
## XXX: Slightly inefficient since this was already calculated
2715
pat = tree.is_ignored(path)
2716
self.outf.write('%-50s %s\n' % (path, pat))
2717
finally:
2718
tree.unlock()
2758
def run(self, directory=u'.'):
2759
tree = WorkingTree.open_containing(directory)[0]
2760
self.add_cleanup(tree.lock_read().unlock)
2761
for path, file_class, kind, file_id, entry in tree.list_files():
2762
if file_class != 'I':
2763
continue
2764
## XXX: Slightly inefficient since this was already calculated
2765
pat = tree.is_ignored(path)
2766
self.outf.write('%-50s %s\n' % (path, pat))
2719
2767
2720
2768
2721
2769
class cmd_lookup_revision(Command):
2722
"""Lookup the revision-id from a revision-number
2770
__doc__ = """Lookup the revision-id from a revision-number
2723
2771
2724
2772
:Examples:
2725
2773
bzr lookup-revision 33
2726
2774
"""
2727
2775
hidden = True
2728
2776
takes_args = ['revno']
2777
takes_options = ['directory']
2729
2778
2730
2779
@display_command
2731
def run(self, revno):
2780
def run(self, revno, directory=u'.'):
2732
2781
try:
2733
2782
revno = int(revno)
2734
2783
except ValueError:
2735
raise errors.BzrCommandError("not a valid revision-number: %r" % revno)
2736
2737
print WorkingTree.open_containing(u'.')[0].branch.get_rev_id(revno)
2784
raise errors.BzrCommandError("not a valid revision-number: %r"
2785
% revno)
2786
revid = WorkingTree.open_containing(directory)[0].branch.get_rev_id(revno)
2787
self.outf.write("%s\n" % revid)
2738
2788
2739
2789
2740
2790
class cmd_export(Command):
2741
"""Export current or past revision to a destination directory or archive.
2791
__doc__ = """Export current or past revision to a destination directory or archive.
2742
2792
2743
2793
If no revision is specified this exports the last committed revision.
2744
2794
2766
2816
================= =========================
2767
2817
"""
2768
2818
takes_args = ['dest', 'branch_or_subdir?']
2769
takes_options = [
2819
takes_options = ['directory',
2770
2820
Option('format',
2771
2821
help="Type of file to export to.",
2772
2822
type=unicode),
2776
2826
Option('root',
2777
2827
type=str,
2778
2828
help="Name of the root directory inside the exported file."),
2829
Option('per-file-timestamps',
2830
help='Set modification time of files to that of the last '
2831
'revision in which it was changed.'),
2779
2832
]
2780
2833
def run(self, dest, branch_or_subdir=None, revision=None, format=None,
2781
root=None, filters=False):
2834
root=None, filters=False, per_file_timestamps=False, directory=u'.'):
2782
2835
from bzrlib.export import export
2783
2836
2784
2837
if branch_or_subdir is None:
2785
tree = WorkingTree.open_containing(u'.')[0]
2838
tree = WorkingTree.open_containing(directory)[0]
2786
2839
b = tree.branch
2787
2840
subdir = None
2788
2841
else:
2791
2844
2792
2845
rev_tree = _get_one_revision_tree('export', revision, branch=b, tree=tree)
2793
2846
try:
2794
export(rev_tree, dest, format, root, subdir, filtered=filters)
2847
export(rev_tree, dest, format, root, subdir, filtered=filters,
2848
per_file_timestamps=per_file_timestamps)
2795
2849
except errors.NoSuchExportFormat, e:
2796
2850
raise errors.BzrCommandError('Unsupported export format: %s' % e.format)
2797
2851
2798
2852
2799
2853
class cmd_cat(Command):
2800
"""Write the contents of a file as of a given revision to standard output.
2854
__doc__ = """Write the contents of a file as of a given revision to standard output.
2801
2855
2802
2856
If no revision is nominated, the last revision is used.
2803
2857
2806
2860
"""
2807
2861
2808
2862
_see_also = ['ls']
2809
takes_options = [
2863
takes_options = ['directory',
2810
2864
Option('name-from-revision', help='The path name in the old tree.'),
2811
2865
Option('filters', help='Apply content filters to display the '
2812
2866
'convenience form.'),
2817
2871
2818
2872
@display_command
2819
2873
def run(self, filename, revision=None, name_from_revision=False,
2820
filters=False):
2874
filters=False, directory=None):
2821
2875
if revision is not None and len(revision) != 1:
2822
2876
raise errors.BzrCommandError("bzr cat --revision takes exactly"
2823
2877
" one revision specifier")
2824
2878
tree, branch, relpath = \
2825
bzrdir.BzrDir.open_containing_tree_or_branch(filename)
2826
branch.lock_read()
2827
try:
2828
return self._run(tree, branch, relpath, filename, revision,
2829
name_from_revision, filters)
2830
finally:
2831
branch.unlock()
2879
_open_directory_or_containing_tree_or_branch(filename, directory)
2880
self.add_cleanup(branch.lock_read().unlock)
2881
return self._run(tree, branch, relpath, filename, revision,
2882
name_from_revision, filters)
2832
2883
2833
2884
def _run(self, tree, b, relpath, filename, revision, name_from_revision,
2834
2885
filtered):
2835
2886
if tree is None:
2836
2887
tree = b.basis_tree()
2837
2888
rev_tree = _get_one_revision_tree('cat', revision, branch=b)
2889
self.add_cleanup(rev_tree.lock_read().unlock)
2838
2890
2839
2891
old_file_id = rev_tree.path2id(relpath)
2840
2892
2875
2927
chunks = content.splitlines(True)
2876
2928
content = filtered_output_bytes(chunks, filters,
2877
2929
ContentFilterContext(relpath, rev_tree))
2930
self.cleanup_now()
2878
2931
self.outf.writelines(content)
2879
2932
else:
2933
self.cleanup_now()
2880
2934
self.outf.write(content)
2881
2935
2882
2936
2883
2937
class cmd_local_time_offset(Command):
2884
"""Show the offset in seconds from GMT to local time."""
2938
__doc__ = """Show the offset in seconds from GMT to local time."""
2885
2939
hidden = True
2886
2940
@display_command
2887
2941
def run(self):
2888
print osutils.local_time_offset()
2942
self.outf.write("%s\n" % osutils.local_time_offset())
2889
2943
2890
2944
2891
2945
2892
2946
class cmd_commit(Command):
2893
"""Commit changes into a new revision.
2947
__doc__ = """Commit changes into a new revision.
2894
2948
2895
2949
An explanatory message needs to be given for each commit. This is
2896
2950
often done by using the --message option (getting the message from the
3004
3058
"the master branch until a normal commit "
3005
3059
"is performed."
3006
3060
),
3007
Option('show-diff',
3061
Option('show-diff', short_name='p',
3008
3062
help='When no message is supplied, show the diff along'
3009
3063
' with the status summary in the message editor.'),
3010
3064
]
3059
3113
3060
3114
properties = {}
3061
3115
3062
tree, selected_list = tree_files(selected_list)
3116
tree, selected_list = WorkingTree.open_containing_paths(selected_list)
3063
3117
if selected_list == ['']:
3064
3118
# workaround - commit of root of tree should be exactly the same
3065
3119
# as just default commit in that tree, and succeed even though
3090
3144
'(use --file "%(f)s" to take commit message from that file)'
3091
3145
% { 'f': message })
3092
3146
ui.ui_factory.show_warning(warning_msg)
3147
if '\r' in message:
3148
message = message.replace('\r\n', '\n')
3149
message = message.replace('\r', '\n')
3150
if file:
3151
raise errors.BzrCommandError(
3152
"please specify either --message or --file")
3093
3153
3094
3154
def get_message(commit_obj):
3095
3155
"""Callback to get commit message"""
3096
my_message = message
3097
if my_message is not None and '\r' in my_message:
3098
my_message = my_message.replace('\r\n', '\n')
3099
my_message = my_message.replace('\r', '\n')
3100
if my_message is None and not file:
3101
t = make_commit_message_template_encoded(tree,
3156
if file:
3157
f = open(file)
3158
try:
3159
my_message = f.read().decode(osutils.get_user_encoding())
3160
finally:
3161
f.close()
3162
elif message is not None:
3163
my_message = message
3164
else:
3165
# No message supplied: make one up.
3166
# text is the status of the tree
3167
text = make_commit_message_template_encoded(tree,
3102
3168
selected_list, diff=show_diff,
3103
3169
output_encoding=osutils.get_user_encoding())
3170
# start_message is the template generated from hooks
3171
# XXX: Warning - looks like hooks return unicode,
3172
# make_commit_message_template_encoded returns user encoding.
3173
# We probably want to be using edit_commit_message instead to
3174
# avoid this.
3104
3175
start_message = generate_commit_message_template(commit_obj)
3105
my_message = edit_commit_message_encoded(t,
3176
my_message = edit_commit_message_encoded(text,
3106
3177
start_message=start_message)
3107
3178
if my_message is None:
3108
3179
raise errors.BzrCommandError("please specify a commit"
3109
3180
" message with either --message or --file")
3110
elif my_message and file:
3111
raise errors.BzrCommandError(
3112
"please specify either --message or --file")
3113
if file:
3114
my_message = codecs.open(file, 'rt',
3115
osutils.get_user_encoding()).read()
3116
3181
if my_message == "":
3117
3182
raise errors.BzrCommandError("empty commit message specified")
3118
3183
return my_message
3128
3193
reporter=None, verbose=verbose, revprops=properties,
3129
3194
authors=author, timestamp=commit_stamp,
3130
3195
timezone=offset,
3131
exclude=safe_relpath_files(tree, exclude))
3196
exclude=tree.safe_relpath_files(exclude))
3132
3197
except PointlessCommit:
3133
# FIXME: This should really happen before the file is read in;
3134
# perhaps prepare the commit; get the message; then actually commit
3135
3198
raise errors.BzrCommandError("No changes to commit."
3136
3199
" Use --unchanged to commit anyhow.")
3137
3200
except ConflictsInTree:
3142
3205
raise errors.BzrCommandError("Commit refused because there are"
3143
3206
" unknown files in the working tree.")
3144
3207
except errors.BoundBranchOutOfDate, e:
3145
raise errors.BzrCommandError(str(e) + "\n"
3146
'To commit to master branch, run update and then commit.\n'
3147
'You can also pass --local to commit to continue working '
3148
'disconnected.')
3208
e.extra_help = ("\n"
3209
'To commit to master branch, run update and then commit.\n'
3210
'You can also pass --local to commit to continue working '
3211
'disconnected.')
3212
raise
3149
3213
3150
3214
3151
3215
class cmd_check(Command):
3152
"""Validate working tree structure, branch consistency and repository history.
3216
__doc__ = """Validate working tree structure, branch consistency and repository history.
3153
3217
3154
3218
This command checks various invariants about branch and repository storage
3155
3219
to detect data corruption or bzr bugs.
3219
3283
3220
3284
3221
3285
class cmd_upgrade(Command):
3222
"""Upgrade branch storage to current format.
3286
__doc__ = """Upgrade branch storage to current format.
3223
3287
3224
3288
The check command or bzr developers may sometimes advise you to run
3225
3289
this command. When the default format has changed you may also be warned
3243
3307
3244
3308
3245
3309
class cmd_whoami(Command):
3246
"""Show or set bzr user id.
3310
__doc__ = """Show or set bzr user id.
3247
3311
3248
3312
:Examples:
3249
3313
Show the email of the current user::
3254
3318
3255
3319
bzr whoami "Frank Chu <fchu@example.com>"
3256
3320
"""
3257
takes_options = [ Option('email',
3321
takes_options = [ 'directory',
3322
Option('email',
3258
3323
help='Display email address only.'),
3259
3324
Option('branch',
3260
3325
help='Set identity for the current branch instead of '
3264
3329
encoding_type = 'replace'
3265
3330
3266
3331
@display_command
3267
def run(self, email=False, branch=False, name=None):
3332
def run(self, email=False, branch=False, name=None, directory=None):
3268
3333
if name is None:
3269
# use branch if we're inside one; otherwise global config
3270
try:
3271
c = Branch.open_containing('.')[0].get_config()
3272
except errors.NotBranchError:
3273
c = config.GlobalConfig()
3334
if directory is None:
3335
# use branch if we're inside one; otherwise global config
3336
try:
3337
c = Branch.open_containing(u'.')[0].get_config()
3338
except errors.NotBranchError:
3339
c = _mod_config.GlobalConfig()
3340
else:
3341
c = Branch.open(directory).get_config()
3274
3342
if email:
3275
3343
self.outf.write(c.user_email() + '\n')
3276
3344
else:
3279
3347
3280
3348
# display a warning if an email address isn't included in the given name.
3281
3349
try:
3282
config.extract_email_address(name)
3350
_mod_config.extract_email_address(name)
3283
3351
except errors.NoEmailInUsername, e:
3284
3352
warning('"%s" does not seem to contain an email address. '
3285
3353
'This is allowed, but not recommended.', name)
3286
3354
3287
3355
# use global config unless --branch given
3288
3356
if branch:
3289
c = Branch.open_containing('.')[0].get_config()
3357
if directory is None:
3358
c = Branch.open_containing(u'.')[0].get_config()
3359
else:
3360
c = Branch.open(directory).get_config()
3290
3361
else:
3291
c = config.GlobalConfig()
3362
c = _mod_config.GlobalConfig()
3292
3363
c.set_user_option('email', name)
3293
3364
3294
3365
3295
3366
class cmd_nick(Command):
3296
"""Print or set the branch nickname.
3367
__doc__ = """Print or set the branch nickname.
3297
3368
3298
3369
If unset, the tree root directory name is used as the nickname.
3299
3370
To print the current nickname, execute with no argument.
3304
3375
3305
3376
_see_also = ['info']
3306
3377
takes_args = ['nickname?']
3307
def run(self, nickname=None):
3308
branch = Branch.open_containing(u'.')[0]
3378
takes_options = ['directory']
3379
def run(self, nickname=None, directory=u'.'):
3380
branch = Branch.open_containing(directory)[0]
3309
3381
if nickname is None:
3310
3382
self.printme(branch)
3311
3383
else:
3313
3385
3314
3386
@display_command
3315
3387
def printme(self, branch):
3316
print branch.nick
3388
self.outf.write('%s\n' % branch.nick)
3317
3389
3318
3390
3319
3391
class cmd_alias(Command):
3320
"""Set/unset and display aliases.
3392
__doc__ = """Set/unset and display aliases.
3321
3393
3322
3394
:Examples:
3323
3395
Show the current aliases::
3360
3432
'bzr alias --remove expects an alias to remove.')
3361
3433
# If alias is not found, print something like:
3362
3434
# unalias: foo: not found
3363
c = config.GlobalConfig()
3435
c = _mod_config.GlobalConfig()
3364
3436
c.unset_alias(alias_name)
3365
3437
3366
3438
@display_command
3367
3439
def print_aliases(self):
3368
3440
"""Print out the defined aliases in a similar format to bash."""
3369
aliases = config.GlobalConfig().get_aliases()
3441
aliases = _mod_config.GlobalConfig().get_aliases()
3370
3442
for key, value in sorted(aliases.iteritems()):
3371
3443
self.outf.write('bzr alias %s="%s"\n' % (key, value))
3372
3444
3382
3454
3383
3455
def set_alias(self, alias_name, alias_command):
3384
3456
"""Save the alias in the global config."""
3385
c = config.GlobalConfig()
3457
c = _mod_config.GlobalConfig()
3386
3458
c.set_alias(alias_name, alias_command)
3387
3459
3388
3460
3389
3461
class cmd_selftest(Command):
3390
"""Run internal test suite.
3462
__doc__ = """Run internal test suite.
3391
3463
3392
3464
If arguments are given, they are regular expressions that say which tests
3393
3465
should run. Tests matching any expression are run, and other tests are
3423
3495
If you set BZR_TEST_PDB=1 when running selftest, failing tests will drop
3424
3496
into a pdb postmortem session.
3425
3497
3498
The --coverage=DIRNAME global option produces a report with covered code
3499
indicated.
3500
3426
3501
:Examples:
3427
3502
Run only tests relating to 'ignore'::
3428
3503
3437
3512
def get_transport_type(typestring):
3438
3513
"""Parse and return a transport specifier."""
3439
3514
if typestring == "sftp":
3440
from bzrlib.transport.sftp import SFTPAbsoluteServer
3441
return SFTPAbsoluteServer
3515
from bzrlib.tests import stub_sftp
3516
return stub_sftp.SFTPAbsoluteServer
3442
3517
if typestring == "memory":
3443
from bzrlib.transport.memory import MemoryServer
3444
return MemoryServer
3518
from bzrlib.tests import test_server
3519
return memory.MemoryServer
3445
3520
if typestring == "fakenfs":
3446
from bzrlib.transport.fakenfs import FakeNFSServer
3447
return FakeNFSServer
3521
from bzrlib.tests import test_server
3522
return test_server.FakeNFSServer
3448
3523
msg = "No known transport type %s. Supported types are: sftp\n" %\
3449
3524
(typestring)
3450
3525
raise errors.BzrCommandError(msg)
3461
3536
'throughout the test suite.',
3462
3537
type=get_transport_type),
3463
3538
Option('benchmark',
3464
help='Run the benchmarks rather than selftests.'),
3539
help='Run the benchmarks rather than selftests.',
3540
hidden=True),
3465
3541
Option('lsprof-timed',
3466
3542
help='Generate lsprof output for benchmarked'
3467
3543
' sections of code.'),
3468
3544
Option('lsprof-tests',
3469
3545
help='Generate lsprof output for each test.'),
3470
Option('cache-dir', type=str,
3471
help='Cache intermediate benchmark output in this '
3472
'directory.'),
3473
3546
Option('first',
3474
3547
help='Run all tests, but run specified tests first.',
3475
3548
short_name='f',
3509
3582
3510
3583
def run(self, testspecs_list=None, verbose=False, one=False,
3511
3584
transport=None, benchmark=None,
3512
lsprof_timed=None, cache_dir=None,
3585
lsprof_timed=None,
3513
3586
first=False, list_only=False,
3514
3587
randomize=None, exclude=None, strict=False,
3515
3588
load_list=None, debugflag=None, starting_with=None, subunit=False,
3516
3589
parallel=None, lsprof_tests=False):
3517
from bzrlib.tests import selftest
3518
import bzrlib.benchmarks as benchmarks
3519
from bzrlib.benchmarks import tree_creator
3520
3521
# Make deprecation warnings visible, unless -Werror is set
3522
symbol_versioning.activate_deprecation_warnings(override=False)
3523
3524
if cache_dir is not None:
3525
tree_creator.TreeCreator.CACHE_ROOT = osutils.abspath(cache_dir)
3590
from bzrlib import tests
3591
3526
3592
if testspecs_list is not None:
3527
3593
pattern = '|'.join(testspecs_list)
3528
3594
else:
3534
3600
raise errors.BzrCommandError("subunit not available. subunit "
3535
3601
"needs to be installed to use --subunit.")
3536
3602
self.additional_selftest_args['runner_class'] = SubUnitBzrRunner
3603
# On Windows, disable automatic conversion of '\n' to '\r\n' in
3604
# stdout, which would corrupt the subunit stream.
3605
# FIXME: This has been fixed in subunit trunk (>0.0.5) so the
3606
# following code can be deleted when it's sufficiently deployed
3607
# -- vila/mgz 20100514
3608
if (sys.platform == "win32"
3609
and getattr(sys.stdout, 'fileno', None) is not None):
3610
import msvcrt
3611
msvcrt.setmode(sys.stdout.fileno(), os.O_BINARY)
3537
3612
if parallel:
3538
3613
self.additional_selftest_args.setdefault(
3539
3614
'suite_decorators', []).append(parallel)
3540
3615
if benchmark:
3541
test_suite_factory = benchmarks.test_suite
3542
# Unless user explicitly asks for quiet, be verbose in benchmarks
3543
verbose = not is_quiet()
3544
# TODO: should possibly lock the history file...
3545
benchfile = open(".perf_history", "at", buffering=1)
3546
else:
3547
test_suite_factory = None
3548
benchfile = None
3616
raise errors.BzrCommandError(
3617
"--benchmark is no longer supported from bzr 2.2; "
3618
"use bzr-usertest instead")
3619
test_suite_factory = None
3620
selftest_kwargs = {"verbose": verbose,
3621
"pattern": pattern,
3622
"stop_on_failure": one,
3623
"transport": transport,
3624
"test_suite_factory": test_suite_factory,
3625
"lsprof_timed": lsprof_timed,
3626
"lsprof_tests": lsprof_tests,
3627
"matching_tests_first": first,
3628
"list_only": list_only,
3629
"random_seed": randomize,
3630
"exclude_pattern": exclude,
3631
"strict": strict,
3632
"load_list": load_list,
3633
"debug_flags": debugflag,
3634
"starting_with": starting_with
3635
}
3636
selftest_kwargs.update(self.additional_selftest_args)
3637
3638
# Make deprecation warnings visible, unless -Werror is set
3639
cleanup = symbol_versioning.activate_deprecation_warnings(
3640
override=False)
3549
3641
try:
3550
selftest_kwargs = {"verbose": verbose,
3551
"pattern": pattern,
3552
"stop_on_failure": one,
3553
"transport": transport,
3554
"test_suite_factory": test_suite_factory,
3555
"lsprof_timed": lsprof_timed,
3556
"lsprof_tests": lsprof_tests,
3557
"bench_history": benchfile,
3558
"matching_tests_first": first,
3559
"list_only": list_only,
3560
"random_seed": randomize,
3561
"exclude_pattern": exclude,
3562
"strict": strict,
3563
"load_list": load_list,
3564
"debug_flags": debugflag,
3565
"starting_with": starting_with
3566
}
3567
selftest_kwargs.update(self.additional_selftest_args)
3568
result = selftest(**selftest_kwargs)
3642
result = tests.selftest(**selftest_kwargs)
3569
3643
finally:
3570
if benchfile is not None:
3571
benchfile.close()
3644
cleanup()
3572
3645
return int(not result)
3573
3646
3574
3647
3575
3648
class cmd_version(Command):
3576
"""Show version of bzr."""
3649
__doc__ = """Show version of bzr."""
3577
3650
3578
3651
encoding_type = 'replace'
3579
3652
takes_options = [
3590
3663
3591
3664
3592
3665
class cmd_rocks(Command):
3593
"""Statement of optimism."""
3666
__doc__ = """Statement of optimism."""
3594
3667
3595
3668
hidden = True
3596
3669
3597
3670
@display_command
3598
3671
def run(self):
3599
print "It sure does!"
3672
self.outf.write("It sure does!\n")
3600
3673
3601
3674
3602
3675
class cmd_find_merge_base(Command):
3603
"""Find and print a base revision for merging two branches."""
3676
__doc__ = """Find and print a base revision for merging two branches."""
3604
3677
# TODO: Options to specify revisions on either side, as if
3605
3678
# merging only part of the history.
3606
3679
takes_args = ['branch', 'other']
3612
3685
3613
3686
branch1 = Branch.open_containing(branch)[0]
3614
3687
branch2 = Branch.open_containing(other)[0]
3615
branch1.lock_read()
3616
try:
3617
branch2.lock_read()
3618
try:
3619
last1 = ensure_null(branch1.last_revision())
3620
last2 = ensure_null(branch2.last_revision())
3621
3622
graph = branch1.repository.get_graph(branch2.repository)
3623
base_rev_id = graph.find_unique_lca(last1, last2)
3624
3625
print 'merge base is revision %s' % base_rev_id
3626
finally:
3627
branch2.unlock()
3628
finally:
3629
branch1.unlock()
3688
self.add_cleanup(branch1.lock_read().unlock)
3689
self.add_cleanup(branch2.lock_read().unlock)
3690
last1 = ensure_null(branch1.last_revision())
3691
last2 = ensure_null(branch2.last_revision())
3692
3693
graph = branch1.repository.get_graph(branch2.repository)
3694
base_rev_id = graph.find_unique_lca(last1, last2)
3695
3696
self.outf.write('merge base is revision %s\n' % base_rev_id)
3630
3697
3631
3698
3632
3699
class cmd_merge(Command):
3633
"""Perform a three-way merge.
3700
__doc__ = """Perform a three-way merge.
3634
3701
3635
3702
The source of the merge can be specified either in the form of a branch,
3636
3703
or in the form of a path to a file containing a merge directive generated
3665
3732
committed to record the result of the merge.
3666
3733
3667
3734
merge refuses to run if there are any uncommitted changes, unless
3668
--force is given.
3735
--force is given. The --force option can also be used to create a
3736
merge revision which has more than two parents.
3737
3738
If one would like to merge changes from the working tree of the other
3739
branch without merging any committed revisions, the --uncommitted option
3740
can be given.
3669
3741
3670
3742
To select only some changes to merge, use "merge -i", which will prompt
3671
3743
you to apply each diff hunk and file change, similar to "shelve".
3686
3758
To apply a merge directive contained in /tmp/merge::
3687
3759
3688
3760
bzr merge /tmp/merge
3761
3762
To create a merge revision with three parents from two branches
3763
feature1a and feature1b:
3764
3765
bzr merge ../feature1a
3766
bzr merge ../feature1b --force
3767
bzr commit -m 'revision with three parents'
3689
3768
"""
3690
3769
3691
3770
encoding_type = 'exact'
3707
3786
' completely merged into the source, pull from the'
3708
3787
' source rather than merging. When this happens,'
3709
3788
' you do not need to commit the result.'),
3710
Option('directory',
3789
custom_help('directory',
3711
3790
help='Branch to merge into, '
3712
'rather than the one containing the working directory.',
3713
short_name='d',
3714
type=unicode,
3715
),
3791
'rather than the one containing the working directory.'),
3716
3792
Option('preview', help='Instead of merging, show a diff of the'
3717
3793
' merge.'),
3718
3794
Option('interactive', help='Select changes interactively.',
3749
3825
view_info = _get_view_info_for_change_reporter(tree)
3750
3826
change_reporter = delta._ChangeReporter(
3751
3827
unversioned_filter=tree.is_ignored, view_info=view_info)
3752
cleanups = []
3753
try:
3754
pb = ui.ui_factory.nested_progress_bar()
3755
cleanups.append(pb.finished)
3756
tree.lock_write()
3757
cleanups.append(tree.unlock)
3758
if location is not None:
3759
try:
3760
mergeable = bundle.read_mergeable_from_url(location,
3761
possible_transports=possible_transports)
3762
except errors.NotABundle:
3763
mergeable = None
3764
else:
3765
if uncommitted:
3766
raise errors.BzrCommandError('Cannot use --uncommitted'
3767
' with bundles or merge directives.')
3768
3769
if revision is not None:
3770
raise errors.BzrCommandError(
3771
'Cannot use -r with merge directives or bundles')
3772
merger, verified = _mod_merge.Merger.from_mergeable(tree,
3773
mergeable, pb)
3774
3775
if merger is None and uncommitted:
3776
if revision is not None and len(revision) > 0:
3777
raise errors.BzrCommandError('Cannot use --uncommitted and'
3778
' --revision at the same time.')
3779
merger = self.get_merger_from_uncommitted(tree, location, pb,
3780
cleanups)
3781
allow_pending = False
3782
3783
if merger is None:
3784
merger, allow_pending = self._get_merger_from_branch(tree,
3785
location, revision, remember, possible_transports, pb)
3786
3787
merger.merge_type = merge_type
3788
merger.reprocess = reprocess
3789
merger.show_base = show_base
3790
self.sanity_check_merger(merger)
3791
if (merger.base_rev_id == merger.other_rev_id and
3792
merger.other_rev_id is not None):
3793
note('Nothing to do.')
3828
pb = ui.ui_factory.nested_progress_bar()
3829
self.add_cleanup(pb.finished)
3830
self.add_cleanup(tree.lock_write().unlock)
3831
if location is not None:
3832
try:
3833
mergeable = bundle.read_mergeable_from_url(location,
3834
possible_transports=possible_transports)
3835
except errors.NotABundle:
3836
mergeable = None
3837
else:
3838
if uncommitted:
3839
raise errors.BzrCommandError('Cannot use --uncommitted'
3840
' with bundles or merge directives.')
3841
3842
if revision is not None:
3843
raise errors.BzrCommandError(
3844
'Cannot use -r with merge directives or bundles')
3845
merger, verified = _mod_merge.Merger.from_mergeable(tree,
3846
mergeable, None)
3847
3848
if merger is None and uncommitted:
3849
if revision is not None and len(revision) > 0:
3850
raise errors.BzrCommandError('Cannot use --uncommitted and'
3851
' --revision at the same time.')
3852
merger = self.get_merger_from_uncommitted(tree, location, None)
3853
allow_pending = False
3854
3855
if merger is None:
3856
merger, allow_pending = self._get_merger_from_branch(tree,
3857
location, revision, remember, possible_transports, None)
3858
3859
merger.merge_type = merge_type
3860
merger.reprocess = reprocess
3861
merger.show_base = show_base
3862
self.sanity_check_merger(merger)
3863
if (merger.base_rev_id == merger.other_rev_id and
3864
merger.other_rev_id is not None):
3865
note('Nothing to do.')
3866
return 0
3867
if pull:
3868
if merger.interesting_files is not None:
3869
raise errors.BzrCommandError('Cannot pull individual files')
3870
if (merger.base_rev_id == tree.last_revision()):
3871
result = tree.pull(merger.other_branch, False,
3872
merger.other_rev_id)
3873
result.report(self.outf)
3794
3874
return 0
3795
if pull:
3796
if merger.interesting_files is not None:
3797
raise errors.BzrCommandError('Cannot pull individual files')
3798
if (merger.base_rev_id == tree.last_revision()):
3799
result = tree.pull(merger.other_branch, False,
3800
merger.other_rev_id)
3801
result.report(self.outf)
3802
return 0
3803
if merger.this_basis is None:
3804
raise errors.BzrCommandError(
3805
"This branch has no commits."
3806
" (perhaps you would prefer 'bzr pull')")
3807
if preview:
3808
return self._do_preview(merger, cleanups)
3809
elif interactive:
3810
return self._do_interactive(merger, cleanups)
3811
else:
3812
return self._do_merge(merger, change_reporter, allow_pending,
3813
verified)
3814
finally:
3815
for cleanup in reversed(cleanups):
3816
cleanup()
3875
if merger.this_basis is None:
3876
raise errors.BzrCommandError(
3877
"This branch has no commits."
3878
" (perhaps you would prefer 'bzr pull')")
3879
if preview:
3880
return self._do_preview(merger)
3881
elif interactive:
3882
return self._do_interactive(merger)
3883
else:
3884
return self._do_merge(merger, change_reporter, allow_pending,
3885
verified)
3817
3886
3818
def _get_preview(self, merger, cleanups):
3887
def _get_preview(self, merger):
3819
3888
tree_merger = merger.make_merger()
3820
3889
tt = tree_merger.make_preview_transform()
3821
cleanups.append(tt.finalize)
3890
self.add_cleanup(tt.finalize)
3822
3891
result_tree = tt.get_preview_tree()
3823
3892
return result_tree
3824
3893
3825
def _do_preview(self, merger, cleanups):
3894
def _do_preview(self, merger):
3826
3895
from bzrlib.diff import show_diff_trees
3827
result_tree = self._get_preview(merger, cleanups)
3896
result_tree = self._get_preview(merger)
3897
path_encoding = osutils.get_diff_header_encoding()
3828
3898
show_diff_trees(merger.this_tree, result_tree, self.outf,
3829
old_label='', new_label='')
3899
old_label='', new_label='',
3900
path_encoding=path_encoding)
3830
3901
3831
3902
def _do_merge(self, merger, change_reporter, allow_pending, verified):
3832
3903
merger.change_reporter = change_reporter
3840
3911
else:
3841
3912
return 0
3842
3913
3843
def _do_interactive(self, merger, cleanups):
3914
def _do_interactive(self, merger):
3844
3915
"""Perform an interactive merge.
3845
3916
3846
3917
This works by generating a preview tree of the merge, then using
3848
3919
and the preview tree.
3849
3920
"""
3850
3921
from bzrlib import shelf_ui
3851
result_tree = self._get_preview(merger, cleanups)
3922
result_tree = self._get_preview(merger)
3852
3923
writer = bzrlib.option.diff_writer_registry.get()
3853
3924
shelver = shelf_ui.Shelver(merger.this_tree, result_tree, destroy=True,
3854
3925
reporter=shelf_ui.ApplyReporter(),
3922
3993
allow_pending = True
3923
3994
return merger, allow_pending
3924
3995
3925
def get_merger_from_uncommitted(self, tree, location, pb, cleanups):
3996
def get_merger_from_uncommitted(self, tree, location, pb):
3926
3997
"""Get a merger for uncommitted changes.
3927
3998
3928
3999
:param tree: The tree the merger should apply to.
3929
4000
:param location: The location containing uncommitted changes.
3930
4001
:param pb: The progress bar to use for showing progress.
3931
:param cleanups: A list of operations to perform to clean up the
3932
temporary directories, unfinalized objects, etc.
3933
4002
"""
3934
4003
location = self._select_branch_location(tree, location)[0]
3935
4004
other_tree, other_path = WorkingTree.open_containing(location)
3987
4056
3988
4057
3989
4058
class cmd_remerge(Command):
3990
"""Redo a merge.
4059
__doc__ = """Redo a merge.
3991
4060
3992
4061
Use this if you want to try a different merge technique while resolving
3993
4062
conflicts. Some merge techniques are better than others, and remerge
4018
4087
4019
4088
def run(self, file_list=None, merge_type=None, show_base=False,
4020
4089
reprocess=False):
4090
from bzrlib.conflicts import restore
4021
4091
if merge_type is None:
4022
4092
merge_type = _mod_merge.Merge3Merger
4023
tree, file_list = tree_files(file_list)
4024
tree.lock_write()
4025
try:
4026
parents = tree.get_parent_ids()
4027
if len(parents) != 2:
4028
raise errors.BzrCommandError("Sorry, remerge only works after normal"
4029
" merges. Not cherrypicking or"
4030
" multi-merges.")
4031
repository = tree.branch.repository
4032
interesting_ids = None
4033
new_conflicts = []
4034
conflicts = tree.conflicts()
4035
if file_list is not None:
4036
interesting_ids = set()
4037
for filename in file_list:
4038
file_id = tree.path2id(filename)
4039
if file_id is None:
4040
raise errors.NotVersionedError(filename)
4041
interesting_ids.add(file_id)
4042
if tree.kind(file_id) != "directory":
4043
continue
4093
tree, file_list = WorkingTree.open_containing_paths(file_list)
4094
self.add_cleanup(tree.lock_write().unlock)
4095
parents = tree.get_parent_ids()
4096
if len(parents) != 2:
4097
raise errors.BzrCommandError("Sorry, remerge only works after normal"
4098
" merges. Not cherrypicking or"
4099
" multi-merges.")
4100
repository = tree.branch.repository
4101
interesting_ids = None
4102
new_conflicts = []
4103
conflicts = tree.conflicts()
4104
if file_list is not None:
4105
interesting_ids = set()
4106
for filename in file_list:
4107
file_id = tree.path2id(filename)
4108
if file_id is None:
4109
raise errors.NotVersionedError(filename)
4110
interesting_ids.add(file_id)
4111
if tree.kind(file_id) != "directory":
4112
continue
4044
4113
4045
for name, ie in tree.inventory.iter_entries(file_id):
4046
interesting_ids.add(ie.file_id)
4047
new_conflicts = conflicts.select_conflicts(tree, file_list)[0]
4048
else:
4049
# Remerge only supports resolving contents conflicts
4050
allowed_conflicts = ('text conflict', 'contents conflict')
4051
restore_files = [c.path for c in conflicts
4052
if c.typestring in allowed_conflicts]
4053
_mod_merge.transform_tree(tree, tree.basis_tree(), interesting_ids)
4054
tree.set_conflicts(ConflictList(new_conflicts))
4055
if file_list is not None:
4056
restore_files = file_list
4057
for filename in restore_files:
4058
try:
4059
restore(tree.abspath(filename))
4060
except errors.NotConflicted:
4061
pass
4062
# Disable pending merges, because the file texts we are remerging
4063
# have not had those merges performed. If we use the wrong parents
4064
# list, we imply that the working tree text has seen and rejected
4065
# all the changes from the other tree, when in fact those changes
4066
# have not yet been seen.
4067
pb = ui.ui_factory.nested_progress_bar()
4068
tree.set_parent_ids(parents[:1])
4114
for name, ie in tree.inventory.iter_entries(file_id):
4115
interesting_ids.add(ie.file_id)
4116
new_conflicts = conflicts.select_conflicts(tree, file_list)[0]
4117
else:
4118
# Remerge only supports resolving contents conflicts
4119
allowed_conflicts = ('text conflict', 'contents conflict')
4120
restore_files = [c.path for c in conflicts
4121
if c.typestring in allowed_conflicts]
4122
_mod_merge.transform_tree(tree, tree.basis_tree(), interesting_ids)
4123
tree.set_conflicts(ConflictList(new_conflicts))
4124
if file_list is not None:
4125
restore_files = file_list
4126
for filename in restore_files:
4069
4127
try:
4070
merger = _mod_merge.Merger.from_revision_ids(pb,
4071
tree, parents[1])
4072
merger.interesting_ids = interesting_ids
4073
merger.merge_type = merge_type
4074
merger.show_base = show_base
4075
merger.reprocess = reprocess
4076
conflicts = merger.do_merge()
4077
finally:
4078
tree.set_parent_ids(parents)
4079
pb.finished()
4128
restore(tree.abspath(filename))
4129
except errors.NotConflicted:
4130
pass
4131
# Disable pending merges, because the file texts we are remerging
4132
# have not had those merges performed. If we use the wrong parents
4133
# list, we imply that the working tree text has seen and rejected
4134
# all the changes from the other tree, when in fact those changes
4135
# have not yet been seen.
4136
tree.set_parent_ids(parents[:1])
4137
try:
4138
merger = _mod_merge.Merger.from_revision_ids(None, tree, parents[1])
4139
merger.interesting_ids = interesting_ids
4140
merger.merge_type = merge_type
4141
merger.show_base = show_base
4142
merger.reprocess = reprocess
4143
conflicts = merger.do_merge()
4080
4144
finally:
4081
tree.unlock()
4145
tree.set_parent_ids(parents)
4082
4146
if conflicts > 0:
4083
4147
return 1
4084
4148
else:
4086
4150
4087
4151
4088
4152
class cmd_revert(Command):
4089
"""Revert files to a previous revision.
4153
__doc__ = """Revert files to a previous revision.
4090
4154
4091
4155
Giving a list of files will revert only those files. Otherwise, all files
4092
4156
will be reverted. If the revision is not specified with '--revision', the
4111
4175
created as above. Directories containing unknown files will not be
4112
4176
deleted.
4113
4177
4114
The working tree contains a list of pending merged revisions, which will
4115
be included as parents in the next commit. Normally, revert clears that
4116
list as well as reverting the files. If any files are specified, revert
4117
leaves the pending merge list alone and reverts only the files. Use "bzr
4118
revert ." in the tree root to revert all files but keep the merge record,
4119
and "bzr revert --forget-merges" to clear the pending merge list without
4178
The working tree contains a list of revisions that have been merged but
4179
not yet committed. These revisions will be included as additional parents
4180
of the next commit. Normally, using revert clears that list as well as
4181
reverting the files. If any files are specified, revert leaves the list
4182
of uncommitted merges alone and reverts only the files. Use ``bzr revert
4183
.`` in the tree root to revert all files but keep the recorded merges,
4184
and ``bzr revert --forget-merges`` to clear the pending merge list without
4120
4185
reverting any files.
4121
4186
4122
Using "bzr revert --forget-merges", it is possible to apply the changes
4123
from an arbitrary merge as a single revision. To do this, perform the
4124
merge as desired. Then doing revert with the "--forget-merges" option will
4125
keep the content of the tree as it was, but it will clear the list of
4126
pending merges. The next commit will then contain all of the changes that
4127
would have been in the merge, but without any mention of the other parent
4128
revisions. Because this technique forgets where these changes originated,
4129
it may cause additional conflicts on later merges involving the source and
4187
Using "bzr revert --forget-merges", it is possible to apply all of the
4188
changes from a branch in a single revision. To do this, perform the merge
4189
as desired. Then doing revert with the "--forget-merges" option will keep
4190
the content of the tree as it was, but it will clear the list of pending
4191
merges. The next commit will then contain all of the changes that are
4192
present in the other branch, but without any other parent revisions.
4193
Because this technique forgets where these changes originated, it may
4194
cause additional conflicts on later merges involving the same source and
4130
4195
target branches.
4131
4196
"""
4132
4197
4141
4206
4142
4207
def run(self, revision=None, no_backup=False, file_list=None,
4143
4208
forget_merges=None):
4144
tree, file_list = tree_files(file_list)
4145
tree.lock_write()
4146
try:
4147
if forget_merges:
4148
tree.set_parent_ids(tree.get_parent_ids()[:1])
4149
else:
4150
self._revert_tree_to_revision(tree, revision, file_list, no_backup)
4151
finally:
4152
tree.unlock()
4209
tree, file_list = WorkingTree.open_containing_paths(file_list)
4210
self.add_cleanup(tree.lock_tree_write().unlock)
4211
if forget_merges:
4212
tree.set_parent_ids(tree.get_parent_ids()[:1])
4213
else:
4214
self._revert_tree_to_revision(tree, revision, file_list, no_backup)
4153
4215
4154
4216
@staticmethod
4155
4217
def _revert_tree_to_revision(tree, revision, file_list, no_backup):
4156
4218
rev_tree = _get_one_revision_tree('revert', revision, tree=tree)
4157
pb = ui.ui_factory.nested_progress_bar()
4158
try:
4159
tree.revert(file_list, rev_tree, not no_backup, pb,
4160
report_changes=True)
4161
finally:
4162
pb.finished()
4219
tree.revert(file_list, rev_tree, not no_backup, None,
4220
report_changes=True)
4163
4221
4164
4222
4165
4223
class cmd_assert_fail(Command):
4166
"""Test reporting of assertion failures"""
4224
__doc__ = """Test reporting of assertion failures"""
4167
4225
# intended just for use in testing
4168
4226
4169
4227
hidden = True
4173
4231
4174
4232
4175
4233
class cmd_help(Command):
4176
"""Show help on a command or other topic.
4234
__doc__ = """Show help on a command or other topic.
4177
4235
"""
4178
4236
4179
4237
_see_also = ['topics']
4192
4250
4193
4251
4194
4252
class cmd_shell_complete(Command):
4195
"""Show appropriate completions for context.
4253
__doc__ = """Show appropriate completions for context.
4196
4254
4197
4255
For a list of all available commands, say 'bzr shell-complete'.
4198
4256
"""
4207
4265
4208
4266
4209
4267
class cmd_missing(Command):
4210
"""Show unmerged/unpulled revisions between two branches.
4268
__doc__ = """Show unmerged/unpulled revisions between two branches.
4211
4269
4212
4270
OTHER_BRANCH may be local or remote.
4213
4271
4244
4302
_see_also = ['merge', 'pull']
4245
4303
takes_args = ['other_branch?']
4246
4304
takes_options = [
4305
'directory',
4247
4306
Option('reverse', 'Reverse the order of revisions.'),
4248
4307
Option('mine-only',
4249
4308
'Display changes in the local branch only.'),
4271
4330
theirs_only=False,
4272
4331
log_format=None, long=False, short=False, line=False,
4273
4332
show_ids=False, verbose=False, this=False, other=False,
4274
include_merges=False, revision=None, my_revision=None):
4333
include_merges=False, revision=None, my_revision=None,
4334
directory=u'.'):
4275
4335
from bzrlib.missing import find_unmerged, iter_log_revisions
4276
4336
def message(s):
4277
4337
if not is_quiet():
4290
4350
elif theirs_only:
4291
4351
restrict = 'remote'
4292
4352
4293
local_branch = Branch.open_containing(u".")[0]
4353
local_branch = Branch.open_containing(directory)[0]
4354
self.add_cleanup(local_branch.lock_read().unlock)
4355
4294
4356
parent = local_branch.get_parent()
4295
4357
if other_branch is None:
4296
4358
other_branch = parent
4305
4367
remote_branch = Branch.open(other_branch)
4306
4368
if remote_branch.base == local_branch.base:
4307
4369
remote_branch = local_branch
4370
else:
4371
self.add_cleanup(remote_branch.lock_read().unlock)
4308
4372
4309
4373
local_revid_range = _revision_range_to_revid_range(
4310
4374
_get_revision_range(my_revision, local_branch,
4314
4378
_get_revision_range(revision,
4315
4379
remote_branch, self.name()))
4316
4380
4317
local_branch.lock_read()
4318
try:
4319
remote_branch.lock_read()
4320
try:
4321
local_extra, remote_extra = find_unmerged(
4322
local_branch, remote_branch, restrict,
4323
backward=not reverse,
4324
include_merges=include_merges,
4325
local_revid_range=local_revid_range,
4326
remote_revid_range=remote_revid_range)
4327
4328
if log_format is None:
4329
registry = log.log_formatter_registry
4330
log_format = registry.get_default(local_branch)
4331
lf = log_format(to_file=self.outf,
4332
show_ids=show_ids,
4333
show_timezone='original')
4334
4335
status_code = 0
4336
if local_extra and not theirs_only:
4337
message("You have %d extra revision(s):\n" %
4338
len(local_extra))
4339
for revision in iter_log_revisions(local_extra,
4340
local_branch.repository,
4341
verbose):
4342
lf.log_revision(revision)
4343
printed_local = True
4344
status_code = 1
4345
else:
4346
printed_local = False
4347
4348
if remote_extra and not mine_only:
4349
if printed_local is True:
4350
message("\n\n\n")
4351
message("You are missing %d revision(s):\n" %
4352
len(remote_extra))
4353
for revision in iter_log_revisions(remote_extra,
4354
remote_branch.repository,
4355
verbose):
4356
lf.log_revision(revision)
4357
status_code = 1
4358
4359
if mine_only and not local_extra:
4360
# We checked local, and found nothing extra
4361
message('This branch is up to date.\n')
4362
elif theirs_only and not remote_extra:
4363
# We checked remote, and found nothing extra
4364
message('Other branch is up to date.\n')
4365
elif not (mine_only or theirs_only or local_extra or
4366
remote_extra):
4367
# We checked both branches, and neither one had extra
4368
# revisions
4369
message("Branches are up to date.\n")
4370
finally:
4371
remote_branch.unlock()
4372
finally:
4373
local_branch.unlock()
4381
local_extra, remote_extra = find_unmerged(
4382
local_branch, remote_branch, restrict,
4383
backward=not reverse,
4384
include_merges=include_merges,
4385
local_revid_range=local_revid_range,
4386
remote_revid_range=remote_revid_range)
4387
4388
if log_format is None:
4389
registry = log.log_formatter_registry
4390
log_format = registry.get_default(local_branch)
4391
lf = log_format(to_file=self.outf,
4392
show_ids=show_ids,
4393
show_timezone='original')
4394
4395
status_code = 0
4396
if local_extra and not theirs_only:
4397
message("You have %d extra revision(s):\n" %
4398
len(local_extra))
4399
for revision in iter_log_revisions(local_extra,
4400
local_branch.repository,
4401
verbose):
4402
lf.log_revision(revision)
4403
printed_local = True
4404
status_code = 1
4405
else:
4406
printed_local = False
4407
4408
if remote_extra and not mine_only:
4409
if printed_local is True:
4410
message("\n\n\n")
4411
message("You are missing %d revision(s):\n" %
4412
len(remote_extra))
4413
for revision in iter_log_revisions(remote_extra,
4414
remote_branch.repository,
4415
verbose):
4416
lf.log_revision(revision)
4417
status_code = 1
4418
4419
if mine_only and not local_extra:
4420
# We checked local, and found nothing extra
4421
message('This branch is up to date.\n')
4422
elif theirs_only and not remote_extra:
4423
# We checked remote, and found nothing extra
4424
message('Other branch is up to date.\n')
4425
elif not (mine_only or theirs_only or local_extra or
4426
remote_extra):
4427
# We checked both branches, and neither one had extra
4428
# revisions
4429
message("Branches are up to date.\n")
4430
self.cleanup_now()
4374
4431
if not status_code and parent is None and other_branch is not None:
4375
local_branch.lock_write()
4376
try:
4377
# handle race conditions - a parent might be set while we run.
4378
if local_branch.get_parent() is None:
4379
local_branch.set_parent(remote_branch.base)
4380
finally:
4381
local_branch.unlock()
4432
self.add_cleanup(local_branch.lock_write().unlock)
4433
# handle race conditions - a parent might be set while we run.
4434
if local_branch.get_parent() is None:
4435
local_branch.set_parent(remote_branch.base)
4382
4436
return status_code
4383
4437
4384
4438
4385
4439
class cmd_pack(Command):
4386
"""Compress the data within a repository."""
4440
__doc__ = """Compress the data within a repository.
4441
4442
This operation compresses the data within a bazaar repository. As
4443
bazaar supports automatic packing of repository, this operation is
4444
normally not required to be done manually.
4445
4446
During the pack operation, bazaar takes a backup of existing repository
4447
data, i.e. pack files. This backup is eventually removed by bazaar
4448
automatically when it is safe to do so. To save disk space by removing
4449
the backed up pack files, the --clean-obsolete-packs option may be
4450
used.
4451
4452
Warning: If you use --clean-obsolete-packs and your machine crashes
4453
during or immediately after repacking, you may be left with a state
4454
where the deletion has been written to disk but the new packs have not
4455
been. In this case the repository may be unusable.
4456
"""
4387
4457
4388
4458
_see_also = ['repositories']
4389
4459
takes_args = ['branch_or_repo?']
4460
takes_options = [
4461
Option('clean-obsolete-packs', 'Delete obsolete packs to save disk space.'),
4462
]
4390
4463
4391
def run(self, branch_or_repo='.'):
4464
def run(self, branch_or_repo='.', clean_obsolete_packs=False):
4392
4465
dir = bzrdir.BzrDir.open_containing(branch_or_repo)[0]
4393
4466
try:
4394
4467
branch = dir.open_branch()
4395
4468
repository = branch.repository
4396
4469
except errors.NotBranchError:
4397
4470
repository = dir.open_repository()
4398
repository.pack()
4471
repository.pack(clean_obsolete_packs=clean_obsolete_packs)
4399
4472
4400
4473
4401
4474
class cmd_plugins(Command):
4402
"""List the installed plugins.
4475
__doc__ = """List the installed plugins.
4403
4476
4404
4477
This command displays the list of installed plugins including
4405
4478
version of plugin and a short description of each.
4412
4485
adding new commands, providing additional network transports and
4413
4486
customizing log output.
4414
4487
4415
See the Bazaar web site, http://bazaar-vcs.org, for further
4416
information on plugins including where to find them and how to
4417
install them. Instructions are also provided there on how to
4418
write new plugins using the Python programming language.
4488
See the Bazaar Plugin Guide <http://doc.bazaar.canonical.com/plugins/en/>
4489
for further information on plugins including where to find them and how to
4490
install them. Instructions are also provided there on how to write new
4491
plugins using the Python programming language.
4419
4492
"""
4420
4493
takes_options = ['verbose']
4421
4494
4436
4509
doc = '(no description)'
4437
4510
result.append((name_ver, doc, plugin.path()))
4438
4511
for name_ver, doc, path in sorted(result):
4439
print name_ver
4440
print ' ', doc
4512
self.outf.write("%s\n" % name_ver)
4513
self.outf.write(" %s\n" % doc)
4441
4514
if verbose:
4442
print ' ', path
4443
print
4515
self.outf.write(" %s\n" % path)
4516
self.outf.write("\n")
4444
4517
4445
4518
4446
4519
class cmd_testament(Command):
4447
"""Show testament (signing-form) of a revision."""
4520
__doc__ = """Show testament (signing-form) of a revision."""
4448
4521
takes_options = [
4449
4522
'revision',
4450
4523
Option('long', help='Produce long-format testament.'),
4462
4535
b = Branch.open_containing(branch)[0]
4463
4536
else:
4464
4537
b = Branch.open(branch)
4465
b.lock_read()
4466
try:
4467
if revision is None:
4468
rev_id = b.last_revision()
4469
else:
4470
rev_id = revision[0].as_revision_id(b)
4471
t = testament_class.from_revision(b.repository, rev_id)
4472
if long:
4473
sys.stdout.writelines(t.as_text_lines())
4474
else:
4475
sys.stdout.write(t.as_short_text())
4476
finally:
4477
b.unlock()
4538
self.add_cleanup(b.lock_read().unlock)
4539
if revision is None:
4540
rev_id = b.last_revision()
4541
else:
4542
rev_id = revision[0].as_revision_id(b)
4543
t = testament_class.from_revision(b.repository, rev_id)
4544
if long:
4545
sys.stdout.writelines(t.as_text_lines())
4546
else:
4547
sys.stdout.write(t.as_short_text())
4478
4548
4479
4549
4480
4550
class cmd_annotate(Command):
4481
"""Show the origin of each line in a file.
4551
__doc__ = """Show the origin of each line in a file.
4482
4552
4483
4553
This prints out the given file with an annotation on the left side
4484
4554
indicating which revision, author and date introduced the change.
4495
4565
Option('long', help='Show commit date in annotations.'),
4496
4566
'revision',
4497
4567
'show-ids',
4568
'directory',
4498
4569
]
4499
4570
encoding_type = 'exact'
4500
4571
4501
4572
@display_command
4502
4573
def run(self, filename, all=False, long=False, revision=None,
4503
show_ids=False):
4574
show_ids=False, directory=None):
4504
4575
from bzrlib.annotate import annotate_file, annotate_file_tree
4505
4576
wt, branch, relpath = \
4506
bzrdir.BzrDir.open_containing_tree_or_branch(filename)
4507
if wt is not None:
4508
wt.lock_read()
4509
else:
4510
branch.lock_read()
4511
try:
4512
tree = _get_one_revision_tree('annotate', revision, branch=branch)
4513
if wt is not None:
4514
file_id = wt.path2id(relpath)
4515
else:
4516
file_id = tree.path2id(relpath)
4517
if file_id is None:
4518
raise errors.NotVersionedError(filename)
4519
file_version = tree.inventory[file_id].revision
4520
if wt is not None and revision is None:
4521
# If there is a tree and we're not annotating historical
4522
# versions, annotate the working tree's content.
4523
annotate_file_tree(wt, file_id, self.outf, long, all,
4524
show_ids=show_ids)
4525
else:
4526
annotate_file(branch, file_version, file_id, long, all, self.outf,
4527
show_ids=show_ids)
4528
finally:
4529
if wt is not None:
4530
wt.unlock()
4531
else:
4532
branch.unlock()
4577
_open_directory_or_containing_tree_or_branch(filename, directory)
4578
if wt is not None:
4579
self.add_cleanup(wt.lock_read().unlock)
4580
else:
4581
self.add_cleanup(branch.lock_read().unlock)
4582
tree = _get_one_revision_tree('annotate', revision, branch=branch)
4583
self.add_cleanup(tree.lock_read().unlock)
4584
if wt is not None:
4585
file_id = wt.path2id(relpath)
4586
else:
4587
file_id = tree.path2id(relpath)
4588
if file_id is None:
4589
raise errors.NotVersionedError(filename)
4590
file_version = tree.inventory[file_id].revision
4591
if wt is not None and revision is None:
4592
# If there is a tree and we're not annotating historical
4593
# versions, annotate the working tree's content.
4594
annotate_file_tree(wt, file_id, self.outf, long, all,
4595
show_ids=show_ids)
4596
else:
4597
annotate_file(branch, file_version, file_id, long, all, self.outf,
4598
show_ids=show_ids)
4533
4599
4534
4600
4535
4601
class cmd_re_sign(Command):
4536
"""Create a digital signature for an existing revision."""
4602
__doc__ = """Create a digital signature for an existing revision."""
4537
4603
# TODO be able to replace existing ones.
4538
4604
4539
4605
hidden = True # is this right ?
4540
4606
takes_args = ['revision_id*']
4541
takes_options = ['revision']
4607
takes_options = ['directory', 'revision']
4542
4608
4543
def run(self, revision_id_list=None, revision=None):
4609
def run(self, revision_id_list=None, revision=None, directory=u'.'):
4544
4610
if revision_id_list is not None and revision is not None:
4545
4611
raise errors.BzrCommandError('You can only supply one of revision_id or --revision')
4546
4612
if revision_id_list is None and revision is None:
4547
4613
raise errors.BzrCommandError('You must supply either --revision or a revision_id')
4548
b = WorkingTree.open_containing(u'.')[0].branch
4549
b.lock_write()
4550
try:
4551
return self._run(b, revision_id_list, revision)
4552
finally:
4553
b.unlock()
4614
b = WorkingTree.open_containing(directory)[0].branch
4615
self.add_cleanup(b.lock_write().unlock)
4616
return self._run(b, revision_id_list, revision)
4554
4617
4555
4618
def _run(self, b, revision_id_list, revision):
4556
4619
import bzrlib.gpg as gpg
4601
4664
4602
4665
4603
4666
class cmd_bind(Command):
4604
"""Convert the current branch into a checkout of the supplied branch.
4667
__doc__ = """Convert the current branch into a checkout of the supplied branch.
4668
If no branch is supplied, rebind to the last bound location.
4605
4669
4606
4670
Once converted into a checkout, commits must succeed on the master branch
4607
4671
before they will be applied to the local branch.
4613
4677
4614
4678
_see_also = ['checkouts', 'unbind']
4615
4679
takes_args = ['location?']
4616
takes_options = []
4680
takes_options = ['directory']
4617
4681
4618
def run(self, location=None):
4619
b, relpath = Branch.open_containing(u'.')
4682
def run(self, location=None, directory=u'.'):
4683
b, relpath = Branch.open_containing(directory)
4620
4684
if location is None:
4621
4685
try:
4622
4686
location = b.get_old_bound_location()
4625
4689
'This format does not remember old locations.')
4626
4690
else:
4627
4691
if location is None:
4628
raise errors.BzrCommandError('No location supplied and no '
4629
'previous location known')
4692
if b.get_bound_location() is not None:
4693
raise errors.BzrCommandError('Branch is already bound')
4694
else:
4695
raise errors.BzrCommandError('No location supplied '
4696
'and no previous location known')
4630
4697
b_other = Branch.open(location)
4631
4698
try:
4632
4699
b.bind(b_other)
4638
4705
4639
4706
4640
4707
class cmd_unbind(Command):
4641
"""Convert the current checkout into a regular branch.
4708
__doc__ = """Convert the current checkout into a regular branch.
4642
4709
4643
4710
After unbinding, the local branch is considered independent and subsequent
4644
4711
commits will be local only.
4646
4713
4647
4714
_see_also = ['checkouts', 'bind']
4648
4715
takes_args = []
4649
takes_options = []
4716
takes_options = ['directory']
4650
4717
4651
def run(self):
4652
b, relpath = Branch.open_containing(u'.')
4718
def run(self, directory=u'.'):
4719
b, relpath = Branch.open_containing(directory)
4653
4720
if not b.unbind():
4654
4721
raise errors.BzrCommandError('Local branch is not bound')
4655
4722
4656
4723
4657
4724
class cmd_uncommit(Command):
4658
"""Remove the last committed revision.
4725
__doc__ = """Remove the last committed revision.
4659
4726
4660
4727
--verbose will print out what is being removed.
4661
4728
--dry-run will go through all the motions, but not actually
4701
4768
b = control.open_branch()
4702
4769
4703
4770
if tree is not None:
4704
tree.lock_write()
4771
self.add_cleanup(tree.lock_write().unlock)
4705
4772
else:
4706
b.lock_write()
4707
try:
4708
return self._run(b, tree, dry_run, verbose, revision, force,
4709
local=local)
4710
finally:
4711
if tree is not None:
4712
tree.unlock()
4713
else:
4714
b.unlock()
4773
self.add_cleanup(b.lock_write().unlock)
4774
return self._run(b, tree, dry_run, verbose, revision, force, local=local)
4715
4775
4716
4776
def _run(self, b, tree, dry_run, verbose, revision, force, local=False):
4717
4777
from bzrlib.log import log_formatter, show_log
4749
4809
end_revision=last_revno)
4750
4810
4751
4811
if dry_run:
4752
print 'Dry-run, pretending to remove the above revisions.'
4753
if not force:
4754
val = raw_input('Press <enter> to continue')
4812
self.outf.write('Dry-run, pretending to remove'
4813
' the above revisions.\n')
4755
4814
else:
4756
print 'The above revision(s) will be removed.'
4757
if not force:
4758
val = raw_input('Are you sure [y/N]? ')
4759
if val.lower() not in ('y', 'yes'):
4760
print 'Canceled'
4761
return 0
4815
self.outf.write('The above revision(s) will be removed.\n')
4816
4817
if not force:
4818
if not ui.ui_factory.confirm_action(
4819
'Uncommit these revisions',
4820
'bzrlib.builtins.uncommit',
4821
{}):
4822
self.outf.write('Canceled\n')
4823
return 0
4762
4824
4763
4825
mutter('Uncommitting from {%s} to {%s}',
4764
4826
last_rev_id, rev_id)
4765
4827
uncommit(b, tree=tree, dry_run=dry_run, verbose=verbose,
4766
4828
revno=revno, local=local)
4767
note('You can restore the old tip by running:\n'
4768
' bzr pull . -r revid:%s', last_rev_id)
4829
self.outf.write('You can restore the old tip by running:\n'
4830
' bzr pull . -r revid:%s\n' % last_rev_id)
4769
4831
4770
4832
4771
4833
class cmd_break_lock(Command):
4772
"""Break a dead lock on a repository, branch or working directory.
4834
__doc__ = """Break a dead lock.
4835
4836
This command breaks a lock on a repository, branch, working directory or
4837
config file.
4773
4838
4774
4839
CAUTION: Locks should only be broken when you are sure that the process
4775
4840
holding the lock has been stopped.
4776
4841
4777
You can get information on what locks are open via the 'bzr info' command.
4842
You can get information on what locks are open via the 'bzr info
4843
[location]' command.
4778
4844
4779
4845
:Examples:
4780
4846
bzr break-lock
4847
bzr break-lock bzr+ssh://example.com/bzr/foo
4848
bzr break-lock --conf ~/.bazaar
4781
4849
"""
4850
4782
4851
takes_args = ['location?']
4852
takes_options = [
4853
Option('config',
4854
help='LOCATION is the directory where the config lock is.'),
4855
Option('force',
4856
help='Do not ask for confirmation before breaking the lock.'),
4857
]
4783
4858
4784
def run(self, location=None, show=False):
4859
def run(self, location=None, config=False, force=False):
4785
4860
if location is None:
4786
4861
location = u'.'
4787
control, relpath = bzrdir.BzrDir.open_containing(location)
4788
try:
4789
control.break_lock()
4790
except NotImplementedError:
4791
pass
4862
if force:
4863
ui.ui_factory = ui.ConfirmationUserInterfacePolicy(ui.ui_factory,
4864
None,
4865
{'bzrlib.lockdir.break': True})
4866
if config:
4867
conf = _mod_config.LockableConfig(file_name=location)
4868
conf.break_lock()
4869
else:
4870
control, relpath = bzrdir.BzrDir.open_containing(location)
4871
try:
4872
control.break_lock()
4873
except NotImplementedError:
4874
pass
4792
4875
4793
4876
4794
4877
class cmd_wait_until_signalled(Command):
4795
"""Test helper for test_start_and_stop_bzr_subprocess_send_signal.
4878
__doc__ = """Test helper for test_start_and_stop_bzr_subprocess_send_signal.
4796
4879
4797
4880
This just prints a line to signal when it is ready, then blocks on stdin.
4798
4881
"""
4806
4889
4807
4890
4808
4891
class cmd_serve(Command):
4809
"""Run the bzr server."""
4892
__doc__ = """Run the bzr server."""
4810
4893
4811
4894
aliases = ['server']
4812
4895
4823
4906
'result in a dynamically allocated port. The default port '
4824
4907
'depends on the protocol.',
4825
4908
type=str),
4826
Option('directory',
4827
help='Serve contents of this directory.',
4828
type=unicode),
4909
custom_help('directory',
4910
help='Serve contents of this directory.'),
4829
4911
Option('allow-writes',
4830
4912
help='By default the server is a readonly server. Supplying '
4831
4913
'--allow-writes enables write access to the contents of '
4858
4940
4859
4941
def run(self, port=None, inet=False, directory=None, allow_writes=False,
4860
4942
protocol=None):
4861
from bzrlib.transport import get_transport, transport_server_registry
4943
from bzrlib import transport
4862
4944
if directory is None:
4863
4945
directory = os.getcwd()
4864
4946
if protocol is None:
4865
protocol = transport_server_registry.get()
4947
protocol = transport.transport_server_registry.get()
4866
4948
host, port = self.get_host_and_port(port)
4867
4949
url = urlutils.local_path_to_url(directory)
4868
4950
if not allow_writes:
4869
4951
url = 'readonly+' + url
4870
transport = get_transport(url)
4871
protocol(transport, host, port, inet)
4952
t = transport.get_transport(url)
4953
protocol(t, host, port, inet)
4872
4954
4873
4955
4874
4956
class cmd_join(Command):
4875
"""Combine a tree into its containing tree.
4957
__doc__ = """Combine a tree into its containing tree.
4876
4958
4877
4959
This command requires the target tree to be in a rich-root format.
4878
4960
4880
4962
not part of it. (Such trees can be produced by "bzr split", but also by
4881
4963
running "bzr branch" with the target inside a tree.)
4882
4964
4883
The result is a combined tree, with the subtree no longer an independant
4965
The result is a combined tree, with the subtree no longer an independent
4884
4966
part. This is marked as a merge of the subtree into the containing tree,
4885
4967
and all history is preserved.
4886
4968
"""
4918
5000
4919
5001
4920
5002
class cmd_split(Command):
4921
"""Split a subdirectory of a tree into a separate tree.
5003
__doc__ = """Split a subdirectory of a tree into a separate tree.
4922
5004
4923
5005
This command will produce a target tree in a format that supports
4924
5006
rich roots, like 'rich-root' or 'rich-root-pack'. These formats cannot be
4944
5026
4945
5027
4946
5028
class cmd_merge_directive(Command):
4947
"""Generate a merge directive for auto-merge tools.
5029
__doc__ = """Generate a merge directive for auto-merge tools.
4948
5030
4949
5031
A directive requests a merge to be performed, and also provides all the
4950
5032
information necessary to do so. This means it must either include a
4967
5049
_see_also = ['send']
4968
5050
4969
5051
takes_options = [
5052
'directory',
4970
5053
RegistryOption.from_kwargs('patch-type',
4971
5054
'The type of patch to include in the directive.',
4972
5055
title='Patch type',
4985
5068
encoding_type = 'exact'
4986
5069
4987
5070
def run(self, submit_branch=None, public_branch=None, patch_type='bundle',
4988
sign=False, revision=None, mail_to=None, message=None):
5071
sign=False, revision=None, mail_to=None, message=None,
5072
directory=u'.'):
4989
5073
from bzrlib.revision import ensure_null, NULL_REVISION
4990
5074
include_patch, include_bundle = {
4991
5075
'plain': (False, False),
4992
5076
'diff': (True, False),
4993
5077
'bundle': (True, True),
4994
5078
}[patch_type]
4995
branch = Branch.open('.')
5079
branch = Branch.open(directory)
4996
5080
stored_submit_branch = branch.get_submit_branch()
4997
5081
if submit_branch is None:
4998
5082
submit_branch = stored_submit_branch
5043
5127
5044
5128
5045
5129
class cmd_send(Command):
5046
"""Mail or create a merge-directive for submitting changes.
5130
__doc__ = """Mail or create a merge-directive for submitting changes.
5047
5131
5048
5132
A merge directive provides many things needed for requesting merges:
5049
5133
5055
5139
directly from the merge directive, without retrieving data from a
5056
5140
branch.
5057
5141
5058
If --no-bundle is specified, then public_branch is needed (and must be
5059
up-to-date), so that the receiver can perform the merge using the
5060
public_branch. The public_branch is always included if known, so that
5061
people can check it later.
5062
5063
The submit branch defaults to the parent, but can be overridden. Both
5064
submit branch and public branch will be remembered if supplied.
5065
5066
If a public_branch is known for the submit_branch, that public submit
5067
branch is used in the merge instructions. This means that a local mirror
5068
can be used as your actual submit branch, once you have set public_branch
5069
for that mirror.
5142
`bzr send` creates a compact data set that, when applied using bzr
5143
merge, has the same effect as merging from the source branch.
5144
5145
By default the merge directive is self-contained and can be applied to any
5146
branch containing submit_branch in its ancestory without needing access to
5147
the source branch.
5148
5149
If --no-bundle is specified, then Bazaar doesn't send the contents of the
5150
revisions, but only a structured request to merge from the
5151
public_location. In that case the public_branch is needed and it must be
5152
up-to-date and accessible to the recipient. The public_branch is always
5153
included if known, so that people can check it later.
5154
5155
The submit branch defaults to the parent of the source branch, but can be
5156
overridden. Both submit branch and public branch will be remembered in
5157
branch.conf the first time they are used for a particular branch. The
5158
source branch defaults to that containing the working directory, but can
5159
be changed using --from.
5160
5161
In order to calculate those changes, bzr must analyse the submit branch.
5162
Therefore it is most efficient for the submit branch to be a local mirror.
5163
If a public location is known for the submit_branch, that location is used
5164
in the merge directive.
5165
5166
The default behaviour is to send the merge directive by mail, unless -o is
5167
given, in which case it is sent to a file.
5070
5168
5071
5169
Mail is sent using your preferred mail program. This should be transparent
5072
on Windows (it uses MAPI). On Linux, it requires the xdg-email utility.
5170
on Windows (it uses MAPI). On Unix, it requires the xdg-email utility.
5073
5171
If the preferred client can't be found (or used), your editor will be used.
5074
5172
5075
5173
To use a specific mail program, set the mail_client configuration option.
5092
5190
5093
5191
The merge directives created by bzr send may be applied using bzr merge or
5094
5192
bzr pull by specifying a file containing a merge directive as the location.
5193
5194
bzr send makes extensive use of public locations to map local locations into
5195
URLs that can be used by other people. See `bzr help configuration` to
5196
set them, and use `bzr info` to display them.
5095
5197
"""
5096
5198
5097
5199
encoding_type = 'exact'
5113
5215
short_name='f',
5114
5216
type=unicode),
5115
5217
Option('output', short_name='o',
5116
help='Write merge directive to this file; '
5218
help='Write merge directive to this file or directory; '
5117
5219
'use - for stdout.',
5118
5220
type=unicode),
5119
5221
Option('strict',
5142
5244
5143
5245
5144
5246
class cmd_bundle_revisions(cmd_send):
5145
"""Create a merge-directive for submitting changes.
5247
__doc__ = """Create a merge-directive for submitting changes.
5146
5248
5147
5249
A merge directive provides many things needed for requesting merges:
5148
5250
5215
5317
5216
5318
5217
5319
class cmd_tag(Command):
5218
"""Create, remove or modify a tag naming a revision.
5320
__doc__ = """Create, remove or modify a tag naming a revision.
5219
5321
5220
5322
Tags give human-meaningful names to revisions. Commands that take a -r
5221
5323
(--revision) option can be given -rtag:X, where X is any previously
5229
5331
5230
5332
To rename a tag (change the name but keep it on the same revsion), run ``bzr
5231
5333
tag new-name -r tag:old-name`` and then ``bzr tag --delete oldname``.
5334
5335
If no tag name is specified it will be determined through the
5336
'automatic_tag_name' hook. This can e.g. be used to automatically tag
5337
upstream releases by reading configure.ac. See ``bzr help hooks`` for
5338
details.
5232
5339
"""
5233
5340
5234
5341
_see_also = ['commit', 'tags']
5235
takes_args = ['tag_name']
5342
takes_args = ['tag_name?']
5236
5343
takes_options = [
5237
5344
Option('delete',
5238
5345
help='Delete this tag rather than placing it.',
5239
5346
),
5240
Option('directory',
5241
help='Branch in which to place the tag.',
5242
short_name='d',
5243
type=unicode,
5244
),
5347
custom_help('directory',
5348
help='Branch in which to place the tag.'),
5245
5349
Option('force',
5246
5350
help='Replace existing tags.',
5247
5351
),
5248
5352
'revision',
5249
5353
]
5250
5354
5251
def run(self, tag_name,
5355
def run(self, tag_name=None,
5252
5356
delete=None,
5253
5357
directory='.',
5254
5358
force=None,
5255
5359
revision=None,
5256
5360
):
5257
5361
branch, relpath = Branch.open_containing(directory)
5258
branch.lock_write()
5259
try:
5260
if delete:
5261
branch.tags.delete_tag(tag_name)
5262
self.outf.write('Deleted tag %s.\n' % tag_name)
5362
self.add_cleanup(branch.lock_write().unlock)
5363
if delete:
5364
if tag_name is None:
5365
raise errors.BzrCommandError("No tag specified to delete.")
5366
branch.tags.delete_tag(tag_name)
5367
self.outf.write('Deleted tag %s.\n' % tag_name)
5368
else:
5369
if revision:
5370
if len(revision) != 1:
5371
raise errors.BzrCommandError(
5372
"Tags can only be placed on a single revision, "
5373
"not on a range")
5374
revision_id = revision[0].as_revision_id(branch)
5263
5375
else:
5264
if revision:
5265
if len(revision) != 1:
5266
raise errors.BzrCommandError(
5267
"Tags can only be placed on a single revision, "
5268
"not on a range")
5269
revision_id = revision[0].as_revision_id(branch)
5270
else:
5271
revision_id = branch.last_revision()
5272
if (not force) and branch.tags.has_tag(tag_name):
5273
raise errors.TagAlreadyExists(tag_name)
5274
branch.tags.set_tag(tag_name, revision_id)
5275
self.outf.write('Created tag %s.\n' % tag_name)
5276
finally:
5277
branch.unlock()
5376
revision_id = branch.last_revision()
5377
if tag_name is None:
5378
tag_name = branch.automatic_tag_name(revision_id)
5379
if tag_name is None:
5380
raise errors.BzrCommandError(
5381
"Please specify a tag name.")
5382
if (not force) and branch.tags.has_tag(tag_name):
5383
raise errors.TagAlreadyExists(tag_name)
5384
branch.tags.set_tag(tag_name, revision_id)
5385
self.outf.write('Created tag %s.\n' % tag_name)
5278
5386
5279
5387
5280
5388
class cmd_tags(Command):
5281
"""List tags.
5389
__doc__ = """List tags.
5282
5390
5283
5391
This command shows a table of tag names and the revisions they reference.
5284
5392
"""
5285
5393
5286
5394
_see_also = ['tag']
5287
5395
takes_options = [
5288
Option('directory',
5289
help='Branch whose tags should be displayed.',
5290
short_name='d',
5291
type=unicode,
5292
),
5396
custom_help('directory',
5397
help='Branch whose tags should be displayed.'),
5293
5398
RegistryOption.from_kwargs('sort',
5294
5399
'Sort tags by different criteria.', title='Sorting',
5295
5400
alpha='Sort tags lexicographically (default).',
5312
5417
if not tags:
5313
5418
return
5314
5419
5315
branch.lock_read()
5316
try:
5317
if revision:
5318
graph = branch.repository.get_graph()
5319
rev1, rev2 = _get_revision_range(revision, branch, self.name())
5320
revid1, revid2 = rev1.rev_id, rev2.rev_id
5321
# only show revisions between revid1 and revid2 (inclusive)
5322
tags = [(tag, revid) for tag, revid in tags if
5323
graph.is_between(revid, revid1, revid2)]
5324
if sort == 'alpha':
5325
tags.sort()
5326
elif sort == 'time':
5327
timestamps = {}
5328
for tag, revid in tags:
5329
try:
5330
revobj = branch.repository.get_revision(revid)
5331
except errors.NoSuchRevision:
5332
timestamp = sys.maxint # place them at the end
5333
else:
5334
timestamp = revobj.timestamp
5335
timestamps[revid] = timestamp
5336
tags.sort(key=lambda x: timestamps[x[1]])
5337
if not show_ids:
5338
# [ (tag, revid), ... ] -> [ (tag, dotted_revno), ... ]
5339
for index, (tag, revid) in enumerate(tags):
5340
try:
5341
revno = branch.revision_id_to_dotted_revno(revid)
5342
if isinstance(revno, tuple):
5343
revno = '.'.join(map(str, revno))
5344
except errors.NoSuchRevision:
5345
# Bad tag data/merges can lead to tagged revisions
5346
# which are not in this branch. Fail gracefully ...
5347
revno = '?'
5348
tags[index] = (tag, revno)
5349
finally:
5350
branch.unlock()
5420
self.add_cleanup(branch.lock_read().unlock)
5421
if revision:
5422
graph = branch.repository.get_graph()
5423
rev1, rev2 = _get_revision_range(revision, branch, self.name())
5424
revid1, revid2 = rev1.rev_id, rev2.rev_id
5425
# only show revisions between revid1 and revid2 (inclusive)
5426
tags = [(tag, revid) for tag, revid in tags if
5427
graph.is_between(revid, revid1, revid2)]
5428
if sort == 'alpha':
5429
tags.sort()
5430
elif sort == 'time':
5431
timestamps = {}
5432
for tag, revid in tags:
5433
try:
5434
revobj = branch.repository.get_revision(revid)
5435
except errors.NoSuchRevision:
5436
timestamp = sys.maxint # place them at the end
5437
else:
5438
timestamp = revobj.timestamp
5439
timestamps[revid] = timestamp
5440
tags.sort(key=lambda x: timestamps[x[1]])
5441
if not show_ids:
5442
# [ (tag, revid), ... ] -> [ (tag, dotted_revno), ... ]
5443
for index, (tag, revid) in enumerate(tags):
5444
try:
5445
revno = branch.revision_id_to_dotted_revno(revid)
5446
if isinstance(revno, tuple):
5447
revno = '.'.join(map(str, revno))
5448
except errors.NoSuchRevision:
5449
# Bad tag data/merges can lead to tagged revisions
5450
# which are not in this branch. Fail gracefully ...
5451
revno = '?'
5452
tags[index] = (tag, revno)
5453
self.cleanup_now()
5351
5454
for tag, revspec in tags:
5352
5455
self.outf.write('%-20s %s\n' % (tag, revspec))
5353
5456
5354
5457
5355
5458
class cmd_reconfigure(Command):
5356
"""Reconfigure the type of a bzr directory.
5459
__doc__ = """Reconfigure the type of a bzr directory.
5357
5460
5358
5461
A target configuration must be specified.
5359
5462
5444
5547
5445
5548
5446
5549
class cmd_switch(Command):
5447
"""Set the branch of a checkout and update.
5550
__doc__ = """Set the branch of a checkout and update.
5448
5551
5449
5552
For lightweight checkouts, this changes the branch being referenced.
5450
5553
For heavyweight checkouts, this checks that there are no local commits
5466
5569
that of the master.
5467
5570
"""
5468
5571
5469
takes_args = ['to_location']
5470
takes_options = [Option('force',
5572
takes_args = ['to_location?']
5573
takes_options = ['directory',
5574
Option('force',
5471
5575
help='Switch even if local commits will be lost.'),
5576
'revision',
5472
5577
Option('create-branch', short_name='b',
5473
5578
help='Create the target branch from this one before'
5474
5579
' switching to it.'),
5475
]
5580
]
5476
5581
5477
def run(self, to_location, force=False, create_branch=False):
5582
def run(self, to_location=None, force=False, create_branch=False,
5583
revision=None, directory=u'.'):
5478
5584
from bzrlib import switch
5479
tree_location = '.'
5585
tree_location = directory
5586
revision = _get_one_revision('switch', revision)
5480
5587
control_dir = bzrdir.BzrDir.open_containing(tree_location)[0]
5588
if to_location is None:
5589
if revision is None:
5590
raise errors.BzrCommandError('You must supply either a'
5591
' revision or a location')
5592
to_location = tree_location
5481
5593
try:
5482
5594
branch = control_dir.open_branch()
5483
5595
had_explicit_nick = branch.get_config().has_explicit_nickname()
5488
5600
if branch is None:
5489
5601
raise errors.BzrCommandError('cannot create branch without'
5490
5602
' source branch')
5603
to_location = directory_service.directories.dereference(
5604
to_location)
5491
5605
if '/' not in to_location and '\\' not in to_location:
5492
5606
# This path is meant to be relative to the existing branch
5493
5607
this_url = self._get_branch_location(control_dir)
5495
5609
to_branch = branch.bzrdir.sprout(to_location,
5496
5610
possible_transports=[branch.bzrdir.root_transport],
5497
5611
source_branch=branch).open_branch()
5498
# try:
5499
# from_branch = control_dir.open_branch()
5500
# except errors.NotBranchError:
5501
# raise BzrCommandError('Cannot create a branch from this'
5502
# ' location when we cannot open this branch')
5503
# from_branch.bzrdir.sprout(
5504
pass
5505
5612
else:
5506
5613
try:
5507
5614
to_branch = Branch.open(to_location)
5509
5616
this_url = self._get_branch_location(control_dir)
5510
5617
to_branch = Branch.open(
5511
5618
urlutils.join(this_url, '..', to_location))
5512
switch.switch(control_dir, to_branch, force)
5619
if revision is not None:
5620
revision = revision.as_revision_id(to_branch)
5621
switch.switch(control_dir, to_branch, force, revision_id=revision)
5513
5622
if had_explicit_nick:
5514
5623
branch = control_dir.open_branch() #get the new branch!
5515
5624
branch.nick = to_branch.nick
5535
5644
5536
5645
5537
5646
class cmd_view(Command):
5538
"""Manage filtered views.
5647
__doc__ = """Manage filtered views.
5539
5648
5540
5649
Views provide a mask over the tree so that users can focus on
5541
5650
a subset of a tree when doing their work. After creating a view,
5621
5730
name=None,
5622
5731
switch=None,
5623
5732
):
5624
tree, file_list = tree_files(file_list, apply_view=False)
5733
tree, file_list = WorkingTree.open_containing_paths(file_list,
5734
apply_view=False)
5625
5735
current_view, view_dict = tree.views.get_view_info()
5626
5736
if name is None:
5627
5737
name = current_view
5689
5799
5690
5800
5691
5801
class cmd_hooks(Command):
5692
"""Show hooks."""
5802
__doc__ = """Show hooks."""
5693
5803
5694
5804
hidden = True
5695
5805
5708
5818
self.outf.write(" <no hooks installed>\n")
5709
5819
5710
5820
5821
class cmd_remove_branch(Command):
5822
__doc__ = """Remove a branch.
5823
5824
This will remove the branch from the specified location but
5825
will keep any working tree or repository in place.
5826
5827
:Examples:
5828
5829
Remove the branch at repo/trunk::
5830
5831
bzr remove-branch repo/trunk
5832
5833
"""
5834
5835
takes_args = ["location?"]
5836
5837
aliases = ["rmbranch"]
5838
5839
def run(self, location=None):
5840
if location is None:
5841
location = "."
5842
branch = Branch.open_containing(location)[0]
5843
branch.bzrdir.destroy_branch()
5844
5845
5711
5846
class cmd_shelve(Command):
5712
"""Temporarily set aside some changes from the current tree.
5847
__doc__ = """Temporarily set aside some changes from the current tree.
5713
5848
5714
5849
Shelve allows you to temporarily put changes you've made "on the shelf",
5715
5850
ie. out of the way, until a later time when you can bring them back from
5736
5871
takes_args = ['file*']
5737
5872
5738
5873
takes_options = [
5874
'directory',
5739
5875
'revision',
5740
5876
Option('all', help='Shelve all changes.'),
5741
5877
'message',
5750
5886
_see_also = ['unshelve']
5751
5887
5752
5888
def run(self, revision=None, all=False, file_list=None, message=None,
5753
writer=None, list=False, destroy=False):
5889
writer=None, list=False, destroy=False, directory=u'.'):
5754
5890
if list:
5755
5891
return self.run_for_list()
5756
5892
from bzrlib.shelf_ui import Shelver
5758
5894
writer = bzrlib.option.diff_writer_registry.get()
5759
5895
try:
5760
5896
shelver = Shelver.from_args(writer(sys.stdout), revision, all,
5761
file_list, message, destroy=destroy)
5897
file_list, message, destroy=destroy, directory=directory)
5762
5898
try:
5763
5899
shelver.run()
5764
5900
finally:
5768
5904
5769
5905
def run_for_list(self):
5770
5906
tree = WorkingTree.open_containing('.')[0]
5771
tree.lock_read()
5772
try:
5773
manager = tree.get_shelf_manager()
5774
shelves = manager.active_shelves()
5775
if len(shelves) == 0:
5776
note('No shelved changes.')
5777
return 0
5778
for shelf_id in reversed(shelves):
5779
message = manager.get_metadata(shelf_id).get('message')
5780
if message is None:
5781
message = '<no message>'
5782
self.outf.write('%3d: %s\n' % (shelf_id, message))
5783
return 1
5784
finally:
5785
tree.unlock()
5907
self.add_cleanup(tree.lock_read().unlock)
5908
manager = tree.get_shelf_manager()
5909
shelves = manager.active_shelves()
5910
if len(shelves) == 0:
5911
note('No shelved changes.')
5912
return 0
5913
for shelf_id in reversed(shelves):
5914
message = manager.get_metadata(shelf_id).get('message')
5915
if message is None:
5916
message = '<no message>'
5917
self.outf.write('%3d: %s\n' % (shelf_id, message))
5918
return 1
5786
5919
5787
5920
5788
5921
class cmd_unshelve(Command):
5789
"""Restore shelved changes.
5922
__doc__ = """Restore shelved changes.
5790
5923
5791
5924
By default, the most recently shelved changes are restored. However if you
5792
5925
specify a shelf by id those changes will be restored instead. This works
5795
5928
5796
5929
takes_args = ['shelf_id?']
5797
5930
takes_options = [
5931
'directory',
5798
5932
RegistryOption.from_kwargs(
5799
5933
'action', help="The action to perform.",
5800
5934
enum_switch=False, value_switches=True,
5801
5935
apply="Apply changes and remove from the shelf.",
5802
5936
dry_run="Show changes, but do not apply or remove them.",
5937
preview="Instead of unshelving the changes, show the diff that "
5938
"would result from unshelving.",
5803
5939
delete_only="Delete changes without applying them.",
5804
5940
keep="Apply changes but don't delete them.",
5805
5941
)
5806
5942
]
5807
5943
_see_also = ['shelve']
5808
5944
5809
def run(self, shelf_id=None, action='apply'):
5945
def run(self, shelf_id=None, action='apply', directory=u'.'):
5810
5946
from bzrlib.shelf_ui import Unshelver
5811
unshelver = Unshelver.from_args(shelf_id, action)
5947
unshelver = Unshelver.from_args(shelf_id, action, directory=directory)
5812
5948
try:
5813
5949
unshelver.run()
5814
5950
finally:
5816
5952
5817
5953
5818
5954
class cmd_clean_tree(Command):
5819
"""Remove unwanted files from working tree.
5955
__doc__ = """Remove unwanted files from working tree.
5820
5956
5821
5957
By default, only unknown files, not ignored files, are deleted. Versioned
5822
5958
files are never deleted.
5830
5966
5831
5967
To check what clean-tree will do, use --dry-run.
5832
5968
"""
5833
takes_options = [Option('ignored', help='Delete all ignored files.'),
5969
takes_options = ['directory',
5970
Option('ignored', help='Delete all ignored files.'),
5834
5971
Option('detritus', help='Delete conflict files, merge'
5835
5972
' backups, and failed selftest dirs.'),
5836
5973
Option('unknown',
5839
5976
' deleting them.'),
5840
5977
Option('force', help='Do not prompt before deleting.')]
5841
5978
def run(self, unknown=False, ignored=False, detritus=False, dry_run=False,
5842
force=False):
5979
force=False, directory=u'.'):
5843
5980
from bzrlib.clean_tree import clean_tree
5844
5981
if not (unknown or ignored or detritus):
5845
5982
unknown = True
5846
5983
if dry_run:
5847
5984
force = True
5848
clean_tree('.', unknown=unknown, ignored=ignored, detritus=detritus,
5849
dry_run=dry_run, no_prompt=force)
5985
clean_tree(directory, unknown=unknown, ignored=ignored,
5986
detritus=detritus, dry_run=dry_run, no_prompt=force)
5850
5987
5851
5988
5852
5989
class cmd_reference(Command):
5853
"""list, view and set branch locations for nested trees.
5990
__doc__ = """list, view and set branch locations for nested trees.
5854
5991
5855
5992
If no arguments are provided, lists the branch locations for nested trees.
5856
5993
If one argument is provided, display the branch location for that tree.
5896
6033
self.outf.write('%s %s\n' % (path, location))
5897
6034
5898
6035
5899
# these get imported and then picked up by the scan for cmd_*
5900
# TODO: Some more consistent way to split command definitions across files;
5901
# we do need to load at least some information about them to know of
5902
# aliases. ideally we would avoid loading the implementation until the
5903
# details were needed.
5904
from bzrlib.cmd_version_info import cmd_version_info
5905
from bzrlib.conflicts import cmd_resolve, cmd_conflicts, restore
5906
from bzrlib.bundle.commands import (
5907
cmd_bundle_info,
5908
)
5909
from bzrlib.foreign import cmd_dpush
5910
from bzrlib.sign_my_commits import cmd_sign_my_commits
5911
from bzrlib.weave_commands import cmd_versionedfile_list, \
5912
cmd_weave_plan_merge, cmd_weave_merge_text
6036
def _register_lazy_builtins():
6037
# register lazy builtins from other modules; called at startup and should
6038
# be only called once.
6039
for (name, aliases, module_name) in [
6040
('cmd_bundle_info', [], 'bzrlib.bundle.commands'),
6041
('cmd_dpush', [], 'bzrlib.foreign'),
6042
('cmd_version_info', [], 'bzrlib.cmd_version_info'),
6043
('cmd_resolve', ['resolved'], 'bzrlib.conflicts'),
6044
('cmd_conflicts', [], 'bzrlib.conflicts'),
6045
('cmd_sign_my_commits', [], 'bzrlib.sign_my_commits'),
6046
]:
6047
builtin_command_registry.register_lazy(name, aliases, module_name)
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0