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 5037.2.11
- compare with another revision
- download diff
- download tarball
- view history from revision 5037.2.11
- Committer: Martin Pool
- Date: 2010-02-23 02:32:52 UTC
- mto: This revision was merged to the branch mainline in revision 5054.
- Revision ID: mbp@sourcefrog.net-20100223023252-zk4ds0sbeuga82et
Clarify Launchpad setup example
- files added:
- contrib/bash/bzr
- files removed:
- .testr.conf
- bzrlib/plugins/bash_completion
- bzrlib/plugins/bash_completion/tests
- bzrlib/tests/per_bzrdir_colo
- doc/en/whats-new
- files renamed:
- apport/ => contrib/apport/
- apport/bzr-crashdb.conf => contrib/apport/bzr.conf
- files modified:
- .bzrignore
added
removed
bzrlib/builtins.py
60
60
from bzrlib.workingtree import WorkingTree
61
61
""")
62
62
63
from bzrlib.commands import (
64
Command,
65
builtin_command_registry,
66
display_command,
67
)
63
from bzrlib.commands import Command, display_command
68
64
from bzrlib.option import (
69
65
ListOption,
70
66
Option,
232
228
return view_info
233
229
234
230
235
def _open_directory_or_containing_tree_or_branch(filename, directory):
236
"""Open the tree or branch containing the specified file, unless
237
the --directory option is used to specify a different branch."""
238
if directory is not None:
239
return (None, Branch.open(directory), filename)
240
return bzrdir.BzrDir.open_containing_tree_or_branch(filename)
241
242
243
231
# TODO: Make sure no commands unconditionally use the working directory as a
244
232
# branch. If a filename argument is used, the first of them should be used to
245
233
# specify the branch. (Perhaps this can be factored out into some kind of
247
235
# opens the branch?)
248
236
249
237
class cmd_status(Command):
250
__doc__ = """Display status summary.
238
"""Display status summary.
251
239
252
240
This reports on versioned and unknown files, reporting them
253
241
grouped by state. Possible states are:
340
328
341
329
342
330
class cmd_cat_revision(Command):
343
__doc__ = """Write out metadata for a revision.
331
"""Write out metadata for a revision.
344
332
345
333
The revision to print can either be specified by a specific
346
334
revision identifier, or you can use --revision.
348
336
349
337
hidden = True
350
338
takes_args = ['revision_id?']
351
takes_options = ['directory', 'revision']
339
takes_options = ['revision']
352
340
# cat-revision is more for frontends so should be exact
353
341
encoding = 'strict'
354
342
355
def print_revision(self, revisions, revid):
356
stream = revisions.get_record_stream([(revid,)], 'unordered', True)
357
record = stream.next()
358
if record.storage_kind == 'absent':
359
raise errors.NoSuchRevision(revisions, revid)
360
revtext = record.get_bytes_as('fulltext')
361
self.outf.write(revtext.decode('utf-8'))
362
363
343
@display_command
364
def run(self, revision_id=None, revision=None, directory=u'.'):
344
def run(self, revision_id=None, revision=None):
365
345
if revision_id is not None and revision is not None:
366
346
raise errors.BzrCommandError('You can only supply one of'
367
347
' revision_id or --revision')
368
348
if revision_id is None and revision is None:
369
349
raise errors.BzrCommandError('You must supply either'
370
350
' --revision or a revision_id')
371
b = WorkingTree.open_containing(directory)[0].branch
372
373
revisions = b.repository.revisions
374
if revisions is None:
375
raise errors.BzrCommandError('Repository %r does not support '
376
'access to raw revision texts')
377
378
b.repository.lock_read()
379
try:
380
# TODO: jam 20060112 should cat-revision always output utf-8?
381
if revision_id is not None:
382
revision_id = osutils.safe_revision_id(revision_id, warn=False)
383
try:
384
self.print_revision(revisions, revision_id)
385
except errors.NoSuchRevision:
386
msg = "The repository %s contains no revision %s." % (
387
b.repository.base, revision_id)
388
raise errors.BzrCommandError(msg)
389
elif revision is not None:
390
for rev in revision:
391
if rev is None:
392
raise errors.BzrCommandError(
393
'You cannot specify a NULL revision.')
394
rev_id = rev.as_revision_id(b)
395
self.print_revision(revisions, rev_id)
396
finally:
397
b.repository.unlock()
398
351
b = WorkingTree.open_containing(u'.')[0].branch
352
353
# TODO: jam 20060112 should cat-revision always output utf-8?
354
if revision_id is not None:
355
revision_id = osutils.safe_revision_id(revision_id, warn=False)
356
try:
357
self.outf.write(b.repository.get_revision_xml(revision_id).decode('utf-8'))
358
except errors.NoSuchRevision:
359
msg = "The repository %s contains no revision %s." % (b.repository.base,
360
revision_id)
361
raise errors.BzrCommandError(msg)
362
elif revision is not None:
363
for rev in revision:
364
if rev is None:
365
raise errors.BzrCommandError('You cannot specify a NULL'
366
' revision.')
367
rev_id = rev.as_revision_id(b)
368
self.outf.write(b.repository.get_revision_xml(rev_id).decode('utf-8'))
369
399
370
400
371
class cmd_dump_btree(Command):
401
__doc__ = """Dump the contents of a btree index file to stdout.
372
"""Dump the contents of a btree index file to stdout.
402
373
403
374
PATH is a btree index file, it can be any URL. This includes things like
404
375
.bzr/repository/pack-names, or .bzr/repository/indices/a34b3a...ca4a4.iix
468
439
for node in bt.iter_all_entries():
469
440
# Node is made up of:
470
441
# (index, key, value, [references])
471
try:
472
refs = node[3]
473
except IndexError:
474
refs_as_tuples = None
475
else:
476
refs_as_tuples = static_tuple.as_tuples(refs)
442
refs_as_tuples = static_tuple.as_tuples(node[3])
477
443
as_tuple = (tuple(node[1]), node[2], refs_as_tuples)
478
444
self.outf.write('%s\n' % (as_tuple,))
479
445
480
446
481
447
class cmd_remove_tree(Command):
482
__doc__ = """Remove the working tree from a given branch/checkout.
448
"""Remove the working tree from a given branch/checkout.
483
449
484
450
Since a lightweight checkout is little more than a working tree
485
451
this will refuse to run against one.
512
478
if (working.has_changes()):
513
479
raise errors.UncommittedChanges(working)
514
480
515
if working.user_url != working.branch.user_url:
481
working_path = working.bzrdir.root_transport.base
482
branch_path = working.branch.bzrdir.root_transport.base
483
if working_path != branch_path:
516
484
raise errors.BzrCommandError("You cannot remove the working tree"
517
485
" from a lightweight checkout")
518
486
520
488
521
489
522
490
class cmd_revno(Command):
523
__doc__ = """Show current revision number.
491
"""Show current revision number.
524
492
525
493
This is equal to the number of revisions on this branch.
526
494
"""
536
504
if tree:
537
505
try:
538
506
wt = WorkingTree.open_containing(location)[0]
539
self.add_cleanup(wt.lock_read().unlock)
507
wt.lock_read()
540
508
except (errors.NoWorkingTree, errors.NotLocalUrl):
541
509
raise errors.NoWorkingTree(location)
510
self.add_cleanup(wt.unlock)
542
511
revid = wt.last_revision()
543
512
try:
544
513
revno_t = wt.branch.revision_id_to_dotted_revno(revid)
547
516
revno = ".".join(str(n) for n in revno_t)
548
517
else:
549
518
b = Branch.open_containing(location)[0]
550
self.add_cleanup(b.lock_read().unlock)
519
b.lock_read()
520
self.add_cleanup(b.unlock)
551
521
revno = b.revno()
552
522
self.cleanup_now()
553
523
self.outf.write(str(revno) + '\n')
554
524
555
525
556
526
class cmd_revision_info(Command):
557
__doc__ = """Show revision number and revision id for a given revision identifier.
527
"""Show revision number and revision id for a given revision identifier.
558
528
"""
559
529
hidden = True
560
530
takes_args = ['revision_info*']
561
531
takes_options = [
562
532
'revision',
563
custom_help('directory',
533
Option('directory',
564
534
help='Branch to examine, '
565
'rather than the one containing the working directory.'),
535
'rather than the one containing the working directory.',
536
short_name='d',
537
type=unicode,
538
),
566
539
Option('tree', help='Show revno of working tree'),
567
540
]
568
541
573
546
try:
574
547
wt = WorkingTree.open_containing(directory)[0]
575
548
b = wt.branch
576
self.add_cleanup(wt.lock_read().unlock)
549
wt.lock_read()
550
self.add_cleanup(wt.unlock)
577
551
except (errors.NoWorkingTree, errors.NotLocalUrl):
578
552
wt = None
579
553
b = Branch.open_containing(directory)[0]
580
self.add_cleanup(b.lock_read().unlock)
554
b.lock_read()
555
self.add_cleanup(b.unlock)
581
556
revision_ids = []
582
557
if revision is not None:
583
558
revision_ids.extend(rev.as_revision_id(b) for rev in revision)
611
586
612
587
613
588
class cmd_add(Command):
614
__doc__ = """Add specified files or directories.
589
"""Add specified files or directories.
615
590
616
591
In non-recursive mode, all the named items are added, regardless
617
592
of whether they were previously ignored. A warning is given if
682
657
should_print=(not is_quiet()))
683
658
684
659
if base_tree:
685
self.add_cleanup(base_tree.lock_read().unlock)
660
base_tree.lock_read()
661
self.add_cleanup(base_tree.unlock)
686
662
tree, file_list = tree_files_for_add(file_list)
687
663
added, ignored = tree.smart_add(file_list, not
688
664
no_recurse, action=action, save=not dry_run)
696
672
697
673
698
674
class cmd_mkdir(Command):
699
__doc__ = """Create a new versioned directory.
675
"""Create a new versioned directory.
700
676
701
677
This is equivalent to creating the directory and then adding it.
702
678
"""
706
682
707
683
def run(self, dir_list):
708
684
for d in dir_list:
685
os.mkdir(d)
709
686
wt, dd = WorkingTree.open_containing(d)
710
base = os.path.dirname(dd)
711
id = wt.path2id(base)
712
if id != None:
713
os.mkdir(d)
714
wt.add([dd])
715
self.outf.write('added %s\n' % d)
716
else:
717
raise errors.NotVersionedError(path=base)
687
wt.add([dd])
688
self.outf.write('added %s\n' % d)
718
689
719
690
720
691
class cmd_relpath(Command):
721
__doc__ = """Show path of a file relative to root"""
692
"""Show path of a file relative to root"""
722
693
723
694
takes_args = ['filename']
724
695
hidden = True
733
704
734
705
735
706
class cmd_inventory(Command):
736
__doc__ = """Show inventory of the current working copy or a revision.
707
"""Show inventory of the current working copy or a revision.
737
708
738
709
It is possible to limit the output to a particular entry
739
710
type using the --kind option. For example: --kind file.
760
731
761
732
revision = _get_one_revision('inventory', revision)
762
733
work_tree, file_list = tree_files(file_list)
763
self.add_cleanup(work_tree.lock_read().unlock)
734
work_tree.lock_read()
735
self.add_cleanup(work_tree.unlock)
764
736
if revision is not None:
765
737
tree = revision.as_tree(work_tree.branch)
766
738
767
739
extra_trees = [work_tree]
768
self.add_cleanup(tree.lock_read().unlock)
740
tree.lock_read()
741
self.add_cleanup(tree.unlock)
769
742
else:
770
743
tree = work_tree
771
744
extra_trees = []
792
765
793
766
794
767
class cmd_mv(Command):
795
__doc__ = """Move or rename a file.
768
"""Move or rename a file.
796
769
797
770
:Usage:
798
771
bzr mv OLDNAME NEWNAME
831
804
if len(names_list) < 2:
832
805
raise errors.BzrCommandError("missing file argument")
833
806
tree, rel_names = tree_files(names_list, canonicalize=False)
834
self.add_cleanup(tree.lock_tree_write().unlock)
807
tree.lock_tree_write()
808
self.add_cleanup(tree.unlock)
835
809
self._run(tree, names_list, rel_names, after)
836
810
837
811
def run_auto(self, names_list, after, dry_run):
842
816
raise errors.BzrCommandError('--after cannot be specified with'
843
817
' --auto.')
844
818
work_tree, file_list = tree_files(names_list, default_branch='.')
845
self.add_cleanup(work_tree.lock_tree_write().unlock)
819
work_tree.lock_tree_write()
820
self.add_cleanup(work_tree.unlock)
846
821
rename_map.RenameMap.guess_renames(work_tree, dry_run)
847
822
848
823
def _run(self, tree, names_list, rel_names, after):
927
902
928
903
929
904
class cmd_pull(Command):
930
__doc__ = """Turn this branch into a mirror of another branch.
905
"""Turn this branch into a mirror of another branch.
931
906
932
907
By default, this command only works on branches that have not diverged.
933
908
Branches are considered diverged if the destination branch's most recent
956
931
takes_options = ['remember', 'overwrite', 'revision',
957
932
custom_help('verbose',
958
933
help='Show logs of pulled revisions.'),
959
custom_help('directory',
934
Option('directory',
960
935
help='Branch to pull into, '
961
'rather than the one containing the working directory.'),
936
'rather than the one containing the working directory.',
937
short_name='d',
938
type=unicode,
939
),
962
940
Option('local',
963
941
help="Perform a local pull in a bound "
964
942
"branch. Local pulls are not applied to "
979
957
try:
980
958
tree_to = WorkingTree.open_containing(directory)[0]
981
959
branch_to = tree_to.branch
982
self.add_cleanup(tree_to.lock_write().unlock)
983
960
except errors.NoWorkingTree:
984
961
tree_to = None
985
962
branch_to = Branch.open_containing(directory)[0]
986
self.add_cleanup(branch_to.lock_write().unlock)
987
963
988
964
if local and not branch_to.get_bound_location():
989
965
raise errors.LocalRequiresBoundBranch()
990
966
1020
996
else:
1021
997
branch_from = Branch.open(location,
1022
998
possible_transports=possible_transports)
1023
self.add_cleanup(branch_from.lock_read().unlock)
1024
999
1025
1000
if branch_to.get_parent() is None or remember:
1026
1001
branch_to.set_parent(branch_from.base)
1027
1002
1003
if branch_from is not branch_to:
1004
branch_from.lock_read()
1005
self.add_cleanup(branch_from.unlock)
1028
1006
if revision is not None:
1029
1007
revision_id = revision.as_revision_id(branch_from)
1030
1008
1009
branch_to.lock_write()
1010
self.add_cleanup(branch_to.unlock)
1031
1011
if tree_to is not None:
1032
1012
view_info = _get_view_info_for_change_reporter(tree_to)
1033
1013
change_reporter = delta._ChangeReporter(
1048
1028
1049
1029
1050
1030
class cmd_push(Command):
1051
__doc__ = """Update a mirror of this branch.
1031
"""Update a mirror of this branch.
1052
1032
1053
1033
The target branch will not have its working tree populated because this
1054
1034
is both expensive, and is not supported on remote file systems.
1078
1058
Option('create-prefix',
1079
1059
help='Create the path leading up to the branch '
1080
1060
'if it does not already exist.'),
1081
custom_help('directory',
1061
Option('directory',
1082
1062
help='Branch to push from, '
1083
'rather than the one containing the working directory.'),
1063
'rather than the one containing the working directory.',
1064
short_name='d',
1065
type=unicode,
1066
),
1084
1067
Option('use-existing-dir',
1085
1068
help='By default push will fail if the target'
1086
1069
' directory exists, but does not already'
1112
1095
# Get the source branch
1113
1096
(tree, br_from,
1114
1097
_unused) = bzrdir.BzrDir.open_containing_tree_or_branch(directory)
1098
if strict is None:
1099
strict = br_from.get_config().get_user_option_as_bool('push_strict')
1100
if strict is None: strict = True # default value
1115
1101
# Get the tip's revision_id
1116
1102
revision = _get_one_revision('push', revision)
1117
1103
if revision is not None:
1118
1104
revision_id = revision.in_history(br_from).rev_id
1119
1105
else:
1120
1106
revision_id = None
1121
if tree is not None and revision_id is None:
1122
tree.check_changed_or_out_of_date(
1123
strict, 'push_strict',
1124
more_error='Use --no-strict to force the push.',
1125
more_warning='Uncommitted changes will not be pushed.')
1107
if strict and tree is not None and revision_id is None:
1108
if (tree.has_changes()):
1109
raise errors.UncommittedChanges(
1110
tree, more='Use --no-strict to force the push.')
1111
if tree.last_revision() != tree.branch.last_revision():
1112
# The tree has lost sync with its branch, there is little
1113
# chance that the user is aware of it but he can still force
1114
# the push with --no-strict
1115
raise errors.OutOfDateTree(
1116
tree, more='Use --no-strict to force the push.')
1117
1126
1118
# Get the stacked_on branch, if any
1127
1119
if stacked_on is not None:
1128
1120
stacked_on = urlutils.normalize_url(stacked_on)
1160
1152
1161
1153
1162
1154
class cmd_branch(Command):
1163
__doc__ = """Create a new branch that is a copy of an existing branch.
1155
"""Create a new branch that is a copy of an existing branch.
1164
1156
1165
1157
If the TO_LOCATION is omitted, the last component of the FROM_LOCATION will
1166
1158
be used. In other words, "branch ../foo/bar" will attempt to create ./bar.
1206
1198
accelerator_tree, br_from = bzrdir.BzrDir.open_tree_or_branch(
1207
1199
from_location)
1208
1200
revision = _get_one_revision('branch', revision)
1209
self.add_cleanup(br_from.lock_read().unlock)
1201
br_from.lock_read()
1202
self.add_cleanup(br_from.unlock)
1210
1203
if revision is not None:
1211
1204
revision_id = revision.as_revision_id(br_from)
1212
1205
else:
1272
1265
1273
1266
1274
1267
class cmd_checkout(Command):
1275
__doc__ = """Create a new checkout of an existing branch.
1268
"""Create a new checkout of an existing branch.
1276
1269
1277
1270
If BRANCH_LOCATION is omitted, checkout will reconstitute a working tree for
1278
1271
the branch found in '.'. This is useful if you have removed the working tree
1341
1334
1342
1335
1343
1336
class cmd_renames(Command):
1344
__doc__ = """Show list of renamed files.
1337
"""Show list of renamed files.
1345
1338
"""
1346
1339
# TODO: Option to show renames between two historical versions.
1347
1340
1352
1345
@display_command
1353
1346
def run(self, dir=u'.'):
1354
1347
tree = WorkingTree.open_containing(dir)[0]
1355
self.add_cleanup(tree.lock_read().unlock)
1348
tree.lock_read()
1349
self.add_cleanup(tree.unlock)
1356
1350
new_inv = tree.inventory
1357
1351
old_tree = tree.basis_tree()
1358
self.add_cleanup(old_tree.lock_read().unlock)
1352
old_tree.lock_read()
1353
self.add_cleanup(old_tree.unlock)
1359
1354
old_inv = old_tree.inventory
1360
1355
renames = []
1361
1356
iterator = tree.iter_changes(old_tree, include_unchanged=True)
1371
1366
1372
1367
1373
1368
class cmd_update(Command):
1374
__doc__ = """Update a tree to have the latest code committed to its branch.
1369
"""Update a tree to have the latest code committed to its branch.
1375
1370
1376
1371
This will perform a merge into the working tree, and may generate
1377
1372
conflicts. If you have any local changes, you will still
1399
1394
master = branch.get_master_branch(
1400
1395
possible_transports=possible_transports)
1401
1396
if master is not None:
1397
tree.lock_write()
1402
1398
branch_location = master.base
1403
tree.lock_write()
1404
1399
else:
1400
tree.lock_tree_write()
1405
1401
branch_location = tree.branch.base
1406
tree.lock_tree_write()
1407
1402
self.add_cleanup(tree.unlock)
1408
1403
# get rid of the final '/' and be ready for display
1409
branch_location = urlutils.unescape_for_display(
1410
branch_location.rstrip('/'),
1411
self.outf.encoding)
1404
branch_location = urlutils.unescape_for_display(branch_location[:-1],
1405
self.outf.encoding)
1412
1406
existing_pending_merges = tree.get_parent_ids()[1:]
1413
1407
if master is None:
1414
1408
old_tip = None
1422
1416
else:
1423
1417
revision_id = branch.last_revision()
1424
1418
if revision_id == _mod_revision.ensure_null(tree.last_revision()):
1425
revno = branch.revision_id_to_dotted_revno(revision_id)
1426
note("Tree is up to date at revision %s of branch %s" %
1427
('.'.join(map(str, revno)), branch_location))
1419
revno = branch.revision_id_to_revno(revision_id)
1420
note("Tree is up to date at revision %d of branch %s" %
1421
(revno, branch_location))
1428
1422
return 0
1429
1423
view_info = _get_view_info_for_change_reporter(tree)
1430
1424
change_reporter = delta._ChangeReporter(
1442
1436
"bzr update --revision only works"
1443
1437
" for a revision in the branch history"
1444
1438
% (e.revision))
1445
revno = tree.branch.revision_id_to_dotted_revno(
1439
revno = tree.branch.revision_id_to_revno(
1446
1440
_mod_revision.ensure_null(tree.last_revision()))
1447
note('Updated to revision %s of branch %s' %
1448
('.'.join(map(str, revno)), branch_location))
1449
parent_ids = tree.get_parent_ids()
1450
if parent_ids[1:] and parent_ids[1:] != existing_pending_merges:
1441
note('Updated to revision %d of branch %s' %
1442
(revno, branch_location))
1443
if tree.get_parent_ids()[1:] != existing_pending_merges:
1451
1444
note('Your local commits will now show as pending merges with '
1452
1445
"'bzr status', and can be committed with 'bzr commit'.")
1453
1446
if conflicts != 0:
1457
1450
1458
1451
1459
1452
class cmd_info(Command):
1460
__doc__ = """Show information about a working tree, branch or repository.
1453
"""Show information about a working tree, branch or repository.
1461
1454
1462
1455
This command will show all known locations and formats associated to the
1463
1456
tree, branch or repository.
1501
1494
1502
1495
1503
1496
class cmd_remove(Command):
1504
__doc__ = """Remove files or directories.
1497
"""Remove files or directories.
1505
1498
1506
1499
This makes bzr stop tracking changes to the specified files. bzr will delete
1507
1500
them if they can easily be recovered using revert. If no options or
1529
1522
if file_list is not None:
1530
1523
file_list = [f for f in file_list]
1531
1524
1532
self.add_cleanup(tree.lock_write().unlock)
1525
tree.lock_write()
1526
self.add_cleanup(tree.unlock)
1533
1527
# Heuristics should probably all move into tree.remove_smart or
1534
1528
# some such?
1535
1529
if new:
1554
1548
1555
1549
1556
1550
class cmd_file_id(Command):
1557
__doc__ = """Print file_id of a particular file or directory.
1551
"""Print file_id of a particular file or directory.
1558
1552
1559
1553
The file_id is assigned when the file is first added and remains the
1560
1554
same through all revisions where the file exists, even when it is
1576
1570
1577
1571
1578
1572
class cmd_file_path(Command):
1579
__doc__ = """Print path of file_ids to a file or directory.
1573
"""Print path of file_ids to a file or directory.
1580
1574
1581
1575
This prints one line for each directory down to the target,
1582
1576
starting at the branch root.
1598
1592
1599
1593
1600
1594
class cmd_reconcile(Command):
1601
__doc__ = """Reconcile bzr metadata in a branch.
1595
"""Reconcile bzr metadata in a branch.
1602
1596
1603
1597
This can correct data mismatches that may have been caused by
1604
1598
previous ghost operations or bzr upgrades. You should only
1626
1620
1627
1621
1628
1622
class cmd_revision_history(Command):
1629
__doc__ = """Display the list of revision ids on a branch."""
1623
"""Display the list of revision ids on a branch."""
1630
1624
1631
1625
_see_also = ['log']
1632
1626
takes_args = ['location?']
1642
1636
1643
1637
1644
1638
class cmd_ancestry(Command):
1645
__doc__ = """List all revisions merged into this branch."""
1639
"""List all revisions merged into this branch."""
1646
1640
1647
1641
_see_also = ['log', 'revision-history']
1648
1642
takes_args = ['location?']
1667
1661
1668
1662
1669
1663
class cmd_init(Command):
1670
__doc__ = """Make a directory into a versioned branch.
1664
"""Make a directory into a versioned branch.
1671
1665
1672
1666
Use this to create an empty branch, or before importing an
1673
1667
existing project.
1776
1770
1777
1771
1778
1772
class cmd_init_repository(Command):
1779
__doc__ = """Create a shared repository for branches to share storage space.
1773
"""Create a shared repository for branches to share storage space.
1780
1774
1781
1775
New branches created under the repository directory will store their
1782
1776
revisions in the repository, not in the branch directory. For branches
1836
1830
1837
1831
1838
1832
class cmd_diff(Command):
1839
__doc__ = """Show differences in the working tree, between revisions or branches.
1833
"""Show differences in the working tree, between revisions or branches.
1840
1834
1841
1835
If no arguments are given, all changes for the current tree are listed.
1842
1836
If files are given, only the changes in those files are listed.
1928
1922
help='Use this command to compare files.',
1929
1923
type=unicode,
1930
1924
),
1931
RegistryOption('format',
1932
help='Diff format to use.',
1933
lazy_registry=('bzrlib.diff', 'format_registry'),
1934
value_switches=False, title='Diff format'),
1935
1925
]
1936
1926
aliases = ['di', 'dif']
1937
1927
encoding_type = 'exact'
1938
1928
1939
1929
@display_command
1940
1930
def run(self, revision=None, file_list=None, diff_options=None,
1941
prefix=None, old=None, new=None, using=None, format=None):
1942
from bzrlib.diff import (get_trees_and_branches_to_diff_locked,
1943
show_diff_trees)
1931
prefix=None, old=None, new=None, using=None):
1932
from bzrlib.diff import get_trees_and_branches_to_diff, show_diff_trees
1944
1933
1945
1934
if (prefix is None) or (prefix == '0'):
1946
1935
# diff -p0 format
1960
1949
raise errors.BzrCommandError('bzr diff --revision takes exactly'
1961
1950
' one or two revision specifiers')
1962
1951
1963
if using is not None and format is not None:
1964
raise errors.BzrCommandError('--using and --format are mutually '
1965
'exclusive.')
1966
1967
1952
(old_tree, new_tree,
1968
1953
old_branch, new_branch,
1969
specific_files, extra_trees) = get_trees_and_branches_to_diff_locked(
1970
file_list, revision, old, new, self.add_cleanup, apply_view=True)
1954
specific_files, extra_trees) = get_trees_and_branches_to_diff(
1955
file_list, revision, old, new, apply_view=True)
1971
1956
return show_diff_trees(old_tree, new_tree, sys.stdout,
1972
1957
specific_files=specific_files,
1973
1958
external_diff_options=diff_options,
1974
1959
old_label=old_label, new_label=new_label,
1975
extra_trees=extra_trees, using=using,
1976
format_cls=format)
1960
extra_trees=extra_trees, using=using)
1977
1961
1978
1962
1979
1963
class cmd_deleted(Command):
1980
__doc__ = """List files deleted in the working tree.
1964
"""List files deleted in the working tree.
1981
1965
"""
1982
1966
# TODO: Show files deleted since a previous revision, or
1983
1967
# between two revisions.
1986
1970
# level of effort but possibly much less IO. (Or possibly not,
1987
1971
# if the directories are very large...)
1988
1972
_see_also = ['status', 'ls']
1989
takes_options = ['directory', 'show-ids']
1973
takes_options = ['show-ids']
1990
1974
1991
1975
@display_command
1992
def run(self, show_ids=False, directory=u'.'):
1993
tree = WorkingTree.open_containing(directory)[0]
1994
self.add_cleanup(tree.lock_read().unlock)
1976
def run(self, show_ids=False):
1977
tree = WorkingTree.open_containing(u'.')[0]
1978
tree.lock_read()
1979
self.add_cleanup(tree.unlock)
1995
1980
old = tree.basis_tree()
1996
self.add_cleanup(old.lock_read().unlock)
1981
old.lock_read()
1982
self.add_cleanup(old.unlock)
1997
1983
for path, ie in old.inventory.iter_entries():
1998
1984
if not tree.has_id(ie.file_id):
1999
1985
self.outf.write(path)
2004
1990
2005
1991
2006
1992
class cmd_modified(Command):
2007
__doc__ = """List files modified in working tree.
1993
"""List files modified in working tree.
2008
1994
"""
2009
1995
2010
1996
hidden = True
2011
1997
_see_also = ['status', 'ls']
2012
takes_options = ['directory', 'null']
1998
takes_options = [
1999
Option('null',
2000
help='Write an ascii NUL (\\0) separator '
2001
'between files rather than a newline.')
2002
]
2013
2003
2014
2004
@display_command
2015
def run(self, null=False, directory=u'.'):
2016
tree = WorkingTree.open_containing(directory)[0]
2005
def run(self, null=False):
2006
tree = WorkingTree.open_containing(u'.')[0]
2017
2007
td = tree.changes_from(tree.basis_tree())
2018
2008
for path, id, kind, text_modified, meta_modified in td.modified:
2019
2009
if null:
2023
2013
2024
2014
2025
2015
class cmd_added(Command):
2026
__doc__ = """List files added in working tree.
2016
"""List files added in working tree.
2027
2017
"""
2028
2018
2029
2019
hidden = True
2030
2020
_see_also = ['status', 'ls']
2031
takes_options = ['directory', 'null']
2021
takes_options = [
2022
Option('null',
2023
help='Write an ascii NUL (\\0) separator '
2024
'between files rather than a newline.')
2025
]
2032
2026
2033
2027
@display_command
2034
def run(self, null=False, directory=u'.'):
2035
wt = WorkingTree.open_containing(directory)[0]
2036
self.add_cleanup(wt.lock_read().unlock)
2028
def run(self, null=False):
2029
wt = WorkingTree.open_containing(u'.')[0]
2030
wt.lock_read()
2031
self.add_cleanup(wt.unlock)
2037
2032
basis = wt.basis_tree()
2038
self.add_cleanup(basis.lock_read().unlock)
2033
basis.lock_read()
2034
self.add_cleanup(basis.unlock)
2039
2035
basis_inv = basis.inventory
2040
2036
inv = wt.inventory
2041
2037
for file_id in inv:
2044
2040
if inv.is_root(file_id) and len(basis_inv) == 0:
2045
2041
continue
2046
2042
path = inv.id2path(file_id)
2047
if not os.access(osutils.pathjoin(wt.basedir, path), os.F_OK):
2043
if not os.access(osutils.abspath(path), os.F_OK):
2048
2044
continue
2049
2045
if null:
2050
2046
self.outf.write(path + '\0')
2053
2049
2054
2050
2055
2051
class cmd_root(Command):
2056
__doc__ = """Show the tree root directory.
2052
"""Show the tree root directory.
2057
2053
2058
2054
The root is the nearest enclosing directory with a .bzr control
2059
2055
directory."""
2083
2079
2084
2080
2085
2081
class cmd_log(Command):
2086
__doc__ = """Show historical log for a branch or subset of a branch.
2082
"""Show historical log for a branch or subset of a branch.
2087
2083
2088
2084
log is bzr's default tool for exploring the history of a branch.
2089
2085
The branch to use is taken from the first parameter. If no parameters
2250
2246
help='Show just the specified revision.'
2251
2247
' See also "help revisionspec".'),
2252
2248
'log-format',
2253
RegistryOption('authors',
2254
'What names to list as authors - first, all or committer.',
2255
title='Authors',
2256
lazy_registry=('bzrlib.log', 'author_list_registry'),
2257
),
2258
2249
Option('levels',
2259
2250
short_name='n',
2260
2251
help='Number of levels to display - 0 for all, 1 for flat.',
2275
2266
help='Show changes made in each revision as a patch.'),
2276
2267
Option('include-merges',
2277
2268
help='Show merged revisions like --levels 0 does.'),
2278
Option('exclude-common-ancestry',
2279
help='Display only the revisions that are not part'
2280
' of both ancestries (require -rX..Y)'
2281
)
2282
2269
]
2283
2270
encoding_type = 'replace'
2284
2271
2294
2281
message=None,
2295
2282
limit=None,
2296
2283
show_diff=False,
2297
include_merges=False,
2298
authors=None,
2299
exclude_common_ancestry=False,
2300
):
2284
include_merges=False):
2301
2285
from bzrlib.log import (
2302
2286
Logger,
2303
2287
make_log_request_dict,
2304
2288
_get_info_for_log_files,
2305
2289
)
2306
2290
direction = (forward and 'forward') or 'reverse'
2307
if (exclude_common_ancestry
2308
and (revision is None or len(revision) != 2)):
2309
raise errors.BzrCommandError(
2310
'--exclude-common-ancestry requires -r with two revisions')
2311
2291
if include_merges:
2312
2292
if levels is None:
2313
2293
levels = 0
2329
2309
if file_list:
2330
2310
# find the file ids to log and check for directory filtering
2331
2311
b, file_info_list, rev1, rev2 = _get_info_for_log_files(
2332
revision, file_list, self.add_cleanup)
2312
revision, file_list)
2313
self.add_cleanup(b.unlock)
2333
2314
for relpath, file_id, kind in file_info_list:
2334
2315
if file_id is None:
2335
2316
raise errors.BzrCommandError(
2353
2334
location = '.'
2354
2335
dir, relpath = bzrdir.BzrDir.open_containing(location)
2355
2336
b = dir.open_branch()
2356
self.add_cleanup(b.lock_read().unlock)
2337
b.lock_read()
2338
self.add_cleanup(b.unlock)
2357
2339
rev1, rev2 = _get_revision_range(revision, b, self.name())
2358
2340
2359
2341
# Decide on the type of delta & diff filtering to use
2379
2361
show_timezone=timezone,
2380
2362
delta_format=get_verbosity_level(),
2381
2363
levels=levels,
2382
show_advice=levels is None,
2383
author_list_handler=authors)
2364
show_advice=levels is None)
2384
2365
2385
2366
# Choose the algorithm for doing the logging. It's annoying
2386
2367
# having multiple code paths like this but necessary until
2405
2386
direction=direction, specific_fileids=file_ids,
2406
2387
start_revision=rev1, end_revision=rev2, limit=limit,
2407
2388
message_search=message, delta_type=delta_type,
2408
diff_type=diff_type, _match_using_deltas=match_using_deltas,
2409
exclude_common_ancestry=exclude_common_ancestry,
2410
)
2389
diff_type=diff_type, _match_using_deltas=match_using_deltas)
2411
2390
Logger(b, rqst).show(lf)
2412
2391
2413
2392
2432
2411
raise errors.BzrCommandError(
2433
2412
"bzr %s doesn't accept two revisions in different"
2434
2413
" branches." % command_name)
2435
if start_spec.spec is None:
2436
# Avoid loading all the history.
2437
rev1 = RevisionInfo(branch, None, None)
2438
else:
2439
rev1 = start_spec.in_history(branch)
2414
rev1 = start_spec.in_history(branch)
2440
2415
# Avoid loading all of history when we know a missing
2441
2416
# end of range means the last revision ...
2442
2417
if end_spec.spec is None:
2471
2446
2472
2447
2473
2448
class cmd_touching_revisions(Command):
2474
__doc__ = """Return revision-ids which affected a particular file.
2449
"""Return revision-ids which affected a particular file.
2475
2450
2476
2451
A more user-friendly interface is "bzr log FILE".
2477
2452
"""
2484
2459
tree, relpath = WorkingTree.open_containing(filename)
2485
2460
file_id = tree.path2id(relpath)
2486
2461
b = tree.branch
2487
self.add_cleanup(b.lock_read().unlock)
2462
b.lock_read()
2463
self.add_cleanup(b.unlock)
2488
2464
touching_revs = log.find_touching_revisions(b, file_id)
2489
2465
for revno, revision_id, what in touching_revs:
2490
2466
self.outf.write("%6d %s\n" % (revno, what))
2491
2467
2492
2468
2493
2469
class cmd_ls(Command):
2494
__doc__ = """List files in a tree.
2470
"""List files in a tree.
2495
2471
"""
2496
2472
2497
2473
_see_also = ['status', 'cat']
2503
2479
help='Recurse into subdirectories.'),
2504
2480
Option('from-root',
2505
2481
help='Print paths relative to the root of the branch.'),
2506
Option('unknown', short_name='u',
2507
help='Print unknown files.'),
2482
Option('unknown', help='Print unknown files.'),
2508
2483
Option('versioned', help='Print versioned files.',
2509
2484
short_name='V'),
2510
Option('ignored', short_name='i',
2511
help='Print ignored files.'),
2512
Option('kind', short_name='k',
2485
Option('ignored', help='Print ignored files.'),
2486
Option('null',
2487
help='Write an ascii NUL (\\0) separator '
2488
'between files rather than a newline.'),
2489
Option('kind',
2513
2490
help='List entries of a particular kind: file, directory, symlink.',
2514
2491
type=unicode),
2515
'null',
2516
2492
'show-ids',
2517
'directory',
2518
2493
]
2519
2494
@display_command
2520
2495
def run(self, revision=None, verbose=False,
2521
2496
recursive=False, from_root=False,
2522
2497
unknown=False, versioned=False, ignored=False,
2523
null=False, kind=None, show_ids=False, path=None, directory=None):
2498
null=False, kind=None, show_ids=False, path=None):
2524
2499
2525
2500
if kind and kind not in ('file', 'directory', 'symlink'):
2526
2501
raise errors.BzrCommandError('invalid kind specified')
2538
2513
raise errors.BzrCommandError('cannot specify both --from-root'
2539
2514
' and PATH')
2540
2515
fs_path = path
2541
tree, branch, relpath = \
2542
_open_directory_or_containing_tree_or_branch(fs_path, directory)
2516
tree, branch, relpath = bzrdir.BzrDir.open_containing_tree_or_branch(
2517
fs_path)
2543
2518
2544
2519
# Calculate the prefix to use
2545
2520
prefix = None
2560
2535
view_str = views.view_display_str(view_files)
2561
2536
note("Ignoring files outside view. View is %s" % view_str)
2562
2537
2563
self.add_cleanup(tree.lock_read().unlock)
2538
tree.lock_read()
2539
self.add_cleanup(tree.unlock)
2564
2540
for fp, fc, fkind, fid, entry in tree.list_files(include_root=False,
2565
2541
from_dir=relpath, recursive=recursive):
2566
2542
# Apply additional masking
2608
2584
2609
2585
2610
2586
class cmd_unknowns(Command):
2611
__doc__ = """List unknown files.
2587
"""List unknown files.
2612
2588
"""
2613
2589
2614
2590
hidden = True
2615
2591
_see_also = ['ls']
2616
takes_options = ['directory']
2617
2592
2618
2593
@display_command
2619
def run(self, directory=u'.'):
2620
for f in WorkingTree.open_containing(directory)[0].unknowns():
2594
def run(self):
2595
for f in WorkingTree.open_containing(u'.')[0].unknowns():
2621
2596
self.outf.write(osutils.quotefn(f) + '\n')
2622
2597
2623
2598
2624
2599
class cmd_ignore(Command):
2625
__doc__ = """Ignore specified files or patterns.
2600
"""Ignore specified files or patterns.
2626
2601
2627
2602
See ``bzr help patterns`` for details on the syntax of patterns.
2628
2603
2637
2612
using this command or directly by using an editor, be sure to commit
2638
2613
it.
2639
2614
2640
Bazaar also supports a global ignore file ~/.bazaar/ignore. On Windows
2641
the global ignore file can be found in the application data directory as
2642
C:\\Documents and Settings\\<user>\\Application Data\\Bazaar\\2.0\\ignore.
2643
Global ignores are not touched by this command. The global ignore file
2644
can be edited directly using an editor.
2645
2646
2615
Patterns prefixed with '!' are exceptions to ignore patterns and take
2647
2616
precedence over regular ignores. Such exceptions are used to specify
2648
2617
files that should be versioned which would otherwise be ignored.
2688
2657
2689
2658
_see_also = ['status', 'ignored', 'patterns']
2690
2659
takes_args = ['name_pattern*']
2691
takes_options = ['directory',
2692
Option('default-rules',
2693
help='Display the default ignore rules that bzr uses.')
2660
takes_options = [
2661
Option('old-default-rules',
2662
help='Write out the ignore rules bzr < 0.9 always used.')
2694
2663
]
2695
2664
2696
def run(self, name_pattern_list=None, default_rules=None,
2697
directory=u'.'):
2665
def run(self, name_pattern_list=None, old_default_rules=None):
2698
2666
from bzrlib import ignores
2699
if default_rules is not None:
2700
# dump the default rules and exit
2701
for pattern in ignores.USER_DEFAULTS:
2702
self.outf.write("%s\n" % pattern)
2667
if old_default_rules is not None:
2668
# dump the rules and exit
2669
for pattern in ignores.OLD_DEFAULTS:
2670
print pattern
2703
2671
return
2704
2672
if not name_pattern_list:
2705
2673
raise errors.BzrCommandError("ignore requires at least one "
2706
"NAME_PATTERN or --default-rules.")
2674
"NAME_PATTERN or --old-default-rules")
2707
2675
name_pattern_list = [globbing.normalize_pattern(p)
2708
2676
for p in name_pattern_list]
2709
2677
for name_pattern in name_pattern_list:
2711
2679
(len(name_pattern) > 1 and name_pattern[1] == ':')):
2712
2680
raise errors.BzrCommandError(
2713
2681
"NAME_PATTERN should not be an absolute path")
2714
tree, relpath = WorkingTree.open_containing(directory)
2682
tree, relpath = WorkingTree.open_containing(u'.')
2715
2683
ignores.tree_ignores_add_patterns(tree, name_pattern_list)
2716
2684
ignored = globbing.Globster(name_pattern_list)
2717
2685
matches = []
2721
2689
if id is not None:
2722
2690
filename = entry[0]
2723
2691
if ignored.match(filename):
2724
matches.append(filename)
2692
matches.append(filename.encode('utf-8'))
2725
2693
tree.unlock()
2726
2694
if len(matches) > 0:
2727
self.outf.write("Warning: the following files are version controlled and"
2728
" match your ignore pattern:\n%s"
2729
"\nThese files will continue to be version controlled"
2730
" unless you 'bzr remove' them.\n" % ("\n".join(matches),))
2695
print "Warning: the following files are version controlled and" \
2696
" match your ignore pattern:\n%s" \
2697
"\nThese files will continue to be version controlled" \
2698
" unless you 'bzr remove' them." % ("\n".join(matches),)
2731
2699
2732
2700
2733
2701
class cmd_ignored(Command):
2734
__doc__ = """List ignored files and the patterns that matched them.
2702
"""List ignored files and the patterns that matched them.
2735
2703
2736
2704
List all the ignored files and the ignore pattern that caused the file to
2737
2705
be ignored.
2743
2711
2744
2712
encoding_type = 'replace'
2745
2713
_see_also = ['ignore', 'ls']
2746
takes_options = ['directory']
2747
2714
2748
2715
@display_command
2749
def run(self, directory=u'.'):
2750
tree = WorkingTree.open_containing(directory)[0]
2751
self.add_cleanup(tree.lock_read().unlock)
2716
def run(self):
2717
tree = WorkingTree.open_containing(u'.')[0]
2718
tree.lock_read()
2719
self.add_cleanup(tree.unlock)
2752
2720
for path, file_class, kind, file_id, entry in tree.list_files():
2753
2721
if file_class != 'I':
2754
2722
continue
2758
2726
2759
2727
2760
2728
class cmd_lookup_revision(Command):
2761
__doc__ = """Lookup the revision-id from a revision-number
2729
"""Lookup the revision-id from a revision-number
2762
2730
2763
2731
:Examples:
2764
2732
bzr lookup-revision 33
2765
2733
"""
2766
2734
hidden = True
2767
2735
takes_args = ['revno']
2768
takes_options = ['directory']
2769
2736
2770
2737
@display_command
2771
def run(self, revno, directory=u'.'):
2738
def run(self, revno):
2772
2739
try:
2773
2740
revno = int(revno)
2774
2741
except ValueError:
2775
raise errors.BzrCommandError("not a valid revision-number: %r"
2776
% revno)
2777
revid = WorkingTree.open_containing(directory)[0].branch.get_rev_id(revno)
2778
self.outf.write("%s\n" % revid)
2742
raise errors.BzrCommandError("not a valid revision-number: %r" % revno)
2743
2744
print WorkingTree.open_containing(u'.')[0].branch.get_rev_id(revno)
2779
2745
2780
2746
2781
2747
class cmd_export(Command):
2782
__doc__ = """Export current or past revision to a destination directory or archive.
2748
"""Export current or past revision to a destination directory or archive.
2783
2749
2784
2750
If no revision is specified this exports the last committed revision.
2785
2751
2807
2773
================= =========================
2808
2774
"""
2809
2775
takes_args = ['dest', 'branch_or_subdir?']
2810
takes_options = ['directory',
2776
takes_options = [
2811
2777
Option('format',
2812
2778
help="Type of file to export to.",
2813
2779
type=unicode),
2817
2783
Option('root',
2818
2784
type=str,
2819
2785
help="Name of the root directory inside the exported file."),
2820
Option('per-file-timestamps',
2821
help='Set modification time of files to that of the last '
2822
'revision in which it was changed.'),
2823
2786
]
2824
2787
def run(self, dest, branch_or_subdir=None, revision=None, format=None,
2825
root=None, filters=False, per_file_timestamps=False, directory=u'.'):
2788
root=None, filters=False):
2826
2789
from bzrlib.export import export
2827
2790
2828
2791
if branch_or_subdir is None:
2829
tree = WorkingTree.open_containing(directory)[0]
2792
tree = WorkingTree.open_containing(u'.')[0]
2830
2793
b = tree.branch
2831
2794
subdir = None
2832
2795
else:
2835
2798
2836
2799
rev_tree = _get_one_revision_tree('export', revision, branch=b, tree=tree)
2837
2800
try:
2838
export(rev_tree, dest, format, root, subdir, filtered=filters,
2839
per_file_timestamps=per_file_timestamps)
2801
export(rev_tree, dest, format, root, subdir, filtered=filters)
2840
2802
except errors.NoSuchExportFormat, e:
2841
2803
raise errors.BzrCommandError('Unsupported export format: %s' % e.format)
2842
2804
2843
2805
2844
2806
class cmd_cat(Command):
2845
__doc__ = """Write the contents of a file as of a given revision to standard output.
2807
"""Write the contents of a file as of a given revision to standard output.
2846
2808
2847
2809
If no revision is nominated, the last revision is used.
2848
2810
2851
2813
"""
2852
2814
2853
2815
_see_also = ['ls']
2854
takes_options = ['directory',
2816
takes_options = [
2855
2817
Option('name-from-revision', help='The path name in the old tree.'),
2856
2818
Option('filters', help='Apply content filters to display the '
2857
2819
'convenience form.'),
2862
2824
2863
2825
@display_command
2864
2826
def run(self, filename, revision=None, name_from_revision=False,
2865
filters=False, directory=None):
2827
filters=False):
2866
2828
if revision is not None and len(revision) != 1:
2867
2829
raise errors.BzrCommandError("bzr cat --revision takes exactly"
2868
2830
" one revision specifier")
2869
2831
tree, branch, relpath = \
2870
_open_directory_or_containing_tree_or_branch(filename, directory)
2871
self.add_cleanup(branch.lock_read().unlock)
2832
bzrdir.BzrDir.open_containing_tree_or_branch(filename)
2833
branch.lock_read()
2834
self.add_cleanup(branch.unlock)
2872
2835
return self._run(tree, branch, relpath, filename, revision,
2873
2836
name_from_revision, filters)
2874
2837
2877
2840
if tree is None:
2878
2841
tree = b.basis_tree()
2879
2842
rev_tree = _get_one_revision_tree('cat', revision, branch=b)
2880
self.add_cleanup(rev_tree.lock_read().unlock)
2843
rev_tree.lock_read()
2844
self.add_cleanup(rev_tree.unlock)
2881
2845
2882
2846
old_file_id = rev_tree.path2id(relpath)
2883
2847
2926
2890
2927
2891
2928
2892
class cmd_local_time_offset(Command):
2929
__doc__ = """Show the offset in seconds from GMT to local time."""
2893
"""Show the offset in seconds from GMT to local time."""
2930
2894
hidden = True
2931
2895
@display_command
2932
2896
def run(self):
2933
self.outf.write("%s\n" % osutils.local_time_offset())
2897
print osutils.local_time_offset()
2934
2898
2935
2899
2936
2900
2937
2901
class cmd_commit(Command):
2938
__doc__ = """Commit changes into a new revision.
2902
"""Commit changes into a new revision.
2939
2903
2940
2904
An explanatory message needs to be given for each commit. This is
2941
2905
often done by using the --message option (getting the message from the
3049
3013
"the master branch until a normal commit "
3050
3014
"is performed."
3051
3015
),
3052
Option('show-diff', short_name='p',
3016
Option('show-diff',
3053
3017
help='When no message is supplied, show the diff along'
3054
3018
' with the status summary in the message editor.'),
3055
3019
]
3135
3099
'(use --file "%(f)s" to take commit message from that file)'
3136
3100
% { 'f': message })
3137
3101
ui.ui_factory.show_warning(warning_msg)
3138
if '\r' in message:
3139
message = message.replace('\r\n', '\n')
3140
message = message.replace('\r', '\n')
3141
if file:
3142
raise errors.BzrCommandError(
3143
"please specify either --message or --file")
3144
3102
3145
3103
def get_message(commit_obj):
3146
3104
"""Callback to get commit message"""
3147
if file:
3148
f = codecs.open(file, 'rt', osutils.get_user_encoding())
3149
try:
3150
my_message = f.read()
3151
finally:
3152
f.close()
3153
elif message is not None:
3154
my_message = message
3155
else:
3156
# No message supplied: make one up.
3157
# text is the status of the tree
3158
text = make_commit_message_template_encoded(tree,
3105
my_message = message
3106
if my_message is not None and '\r' in my_message:
3107
my_message = my_message.replace('\r\n', '\n')
3108
my_message = my_message.replace('\r', '\n')
3109
if my_message is None and not file:
3110
t = make_commit_message_template_encoded(tree,
3159
3111
selected_list, diff=show_diff,
3160
3112
output_encoding=osutils.get_user_encoding())
3161
# start_message is the template generated from hooks
3162
# XXX: Warning - looks like hooks return unicode,
3163
# make_commit_message_template_encoded returns user encoding.
3164
# We probably want to be using edit_commit_message instead to
3165
# avoid this.
3166
3113
start_message = generate_commit_message_template(commit_obj)
3167
my_message = edit_commit_message_encoded(text,
3114
my_message = edit_commit_message_encoded(t,
3168
3115
start_message=start_message)
3169
3116
if my_message is None:
3170
3117
raise errors.BzrCommandError("please specify a commit"
3171
3118
" message with either --message or --file")
3119
elif my_message and file:
3120
raise errors.BzrCommandError(
3121
"please specify either --message or --file")
3122
if file:
3123
my_message = codecs.open(file, 'rt',
3124
osutils.get_user_encoding()).read()
3172
3125
if my_message == "":
3173
3126
raise errors.BzrCommandError("empty commit message specified")
3174
3127
return my_message
3186
3139
timezone=offset,
3187
3140
exclude=safe_relpath_files(tree, exclude))
3188
3141
except PointlessCommit:
3142
# FIXME: This should really happen before the file is read in;
3143
# perhaps prepare the commit; get the message; then actually commit
3189
3144
raise errors.BzrCommandError("No changes to commit."
3190
3145
" Use --unchanged to commit anyhow.")
3191
3146
except ConflictsInTree:
3196
3151
raise errors.BzrCommandError("Commit refused because there are"
3197
3152
" unknown files in the working tree.")
3198
3153
except errors.BoundBranchOutOfDate, e:
3199
e.extra_help = ("\n"
3200
'To commit to master branch, run update and then commit.\n'
3201
'You can also pass --local to commit to continue working '
3202
'disconnected.')
3203
raise
3154
raise errors.BzrCommandError(str(e) + "\n"
3155
'To commit to master branch, run update and then commit.\n'
3156
'You can also pass --local to commit to continue working '
3157
'disconnected.')
3204
3158
3205
3159
3206
3160
class cmd_check(Command):
3207
__doc__ = """Validate working tree structure, branch consistency and repository history.
3161
"""Validate working tree structure, branch consistency and repository history.
3208
3162
3209
3163
This command checks various invariants about branch and repository storage
3210
3164
to detect data corruption or bzr bugs.
3274
3228
3275
3229
3276
3230
class cmd_upgrade(Command):
3277
__doc__ = """Upgrade branch storage to current format.
3231
"""Upgrade branch storage to current format.
3278
3232
3279
3233
The check command or bzr developers may sometimes advise you to run
3280
3234
this command. When the default format has changed you may also be warned
3298
3252
3299
3253
3300
3254
class cmd_whoami(Command):
3301
__doc__ = """Show or set bzr user id.
3255
"""Show or set bzr user id.
3302
3256
3303
3257
:Examples:
3304
3258
Show the email of the current user::
3348
3302
3349
3303
3350
3304
class cmd_nick(Command):
3351
__doc__ = """Print or set the branch nickname.
3305
"""Print or set the branch nickname.
3352
3306
3353
3307
If unset, the tree root directory name is used as the nickname.
3354
3308
To print the current nickname, execute with no argument.
3359
3313
3360
3314
_see_also = ['info']
3361
3315
takes_args = ['nickname?']
3362
takes_options = ['directory']
3363
def run(self, nickname=None, directory=u'.'):
3364
branch = Branch.open_containing(directory)[0]
3316
def run(self, nickname=None):
3317
branch = Branch.open_containing(u'.')[0]
3365
3318
if nickname is None:
3366
3319
self.printme(branch)
3367
3320
else:
3369
3322
3370
3323
@display_command
3371
3324
def printme(self, branch):
3372
self.outf.write('%s\n' % branch.nick)
3325
print branch.nick
3373
3326
3374
3327
3375
3328
class cmd_alias(Command):
3376
__doc__ = """Set/unset and display aliases.
3329
"""Set/unset and display aliases.
3377
3330
3378
3331
:Examples:
3379
3332
Show the current aliases::
3443
3396
3444
3397
3445
3398
class cmd_selftest(Command):
3446
__doc__ = """Run internal test suite.
3399
"""Run internal test suite.
3447
3400
3448
3401
If arguments are given, they are regular expressions that say which tests
3449
3402
should run. Tests matching any expression are run, and other tests are
3590
3543
raise errors.BzrCommandError("subunit not available. subunit "
3591
3544
"needs to be installed to use --subunit.")
3592
3545
self.additional_selftest_args['runner_class'] = SubUnitBzrRunner
3593
# On Windows, disable automatic conversion of '\n' to '\r\n' in
3594
# stdout, which would corrupt the subunit stream.
3595
# FIXME: This has been fixed in subunit trunk (>0.0.5) so the
3596
# following code can be deleted when it's sufficiently deployed
3597
# -- vila/mgz 20100514
3598
if (sys.platform == "win32"
3599
and getattr(sys.stdout, 'fileno', None) is not None):
3600
import msvcrt
3601
msvcrt.setmode(sys.stdout.fileno(), os.O_BINARY)
3602
3546
if parallel:
3603
3547
self.additional_selftest_args.setdefault(
3604
3548
'suite_decorators', []).append(parallel)
3635
3579
3636
3580
3637
3581
class cmd_version(Command):
3638
__doc__ = """Show version of bzr."""
3582
"""Show version of bzr."""
3639
3583
3640
3584
encoding_type = 'replace'
3641
3585
takes_options = [
3652
3596
3653
3597
3654
3598
class cmd_rocks(Command):
3655
__doc__ = """Statement of optimism."""
3599
"""Statement of optimism."""
3656
3600
3657
3601
hidden = True
3658
3602
3659
3603
@display_command
3660
3604
def run(self):
3661
self.outf.write("It sure does!\n")
3605
print "It sure does!"
3662
3606
3663
3607
3664
3608
class cmd_find_merge_base(Command):
3665
__doc__ = """Find and print a base revision for merging two branches."""
3609
"""Find and print a base revision for merging two branches."""
3666
3610
# TODO: Options to specify revisions on either side, as if
3667
3611
# merging only part of the history.
3668
3612
takes_args = ['branch', 'other']
3674
3618
3675
3619
branch1 = Branch.open_containing(branch)[0]
3676
3620
branch2 = Branch.open_containing(other)[0]
3677
self.add_cleanup(branch1.lock_read().unlock)
3678
self.add_cleanup(branch2.lock_read().unlock)
3621
branch1.lock_read()
3622
self.add_cleanup(branch1.unlock)
3623
branch2.lock_read()
3624
self.add_cleanup(branch2.unlock)
3679
3625
last1 = ensure_null(branch1.last_revision())
3680
3626
last2 = ensure_null(branch2.last_revision())
3681
3627
3682
3628
graph = branch1.repository.get_graph(branch2.repository)
3683
3629
base_rev_id = graph.find_unique_lca(last1, last2)
3684
3630
3685
self.outf.write('merge base is revision %s\n' % base_rev_id)
3631
print 'merge base is revision %s' % base_rev_id
3686
3632
3687
3633
3688
3634
class cmd_merge(Command):
3689
__doc__ = """Perform a three-way merge.
3635
"""Perform a three-way merge.
3690
3636
3691
3637
The source of the merge can be specified either in the form of a branch,
3692
3638
or in the form of a path to a file containing a merge directive generated
3775
3721
' completely merged into the source, pull from the'
3776
3722
' source rather than merging. When this happens,'
3777
3723
' you do not need to commit the result.'),
3778
custom_help('directory',
3724
Option('directory',
3779
3725
help='Branch to merge into, '
3780
'rather than the one containing the working directory.'),
3726
'rather than the one containing the working directory.',
3727
short_name='d',
3728
type=unicode,
3729
),
3781
3730
Option('preview', help='Instead of merging, show a diff of the'
3782
3731
' merge.'),
3783
3732
Option('interactive', help='Select changes interactively.',
3816
3765
unversioned_filter=tree.is_ignored, view_info=view_info)
3817
3766
pb = ui.ui_factory.nested_progress_bar()
3818
3767
self.add_cleanup(pb.finished)
3819
self.add_cleanup(tree.lock_write().unlock)
3768
tree.lock_write()
3769
self.add_cleanup(tree.unlock)
3820
3770
if location is not None:
3821
3771
try:
3822
3772
mergeable = bundle.read_mergeable_from_url(location,
4043
3993
4044
3994
4045
3995
class cmd_remerge(Command):
4046
__doc__ = """Redo a merge.
3996
"""Redo a merge.
4047
3997
4048
3998
Use this if you want to try a different merge technique while resolving
4049
3999
conflicts. Some merge techniques are better than others, and remerge
4074
4024
4075
4025
def run(self, file_list=None, merge_type=None, show_base=False,
4076
4026
reprocess=False):
4077
from bzrlib.conflicts import restore
4078
4027
if merge_type is None:
4079
4028
merge_type = _mod_merge.Merge3Merger
4080
4029
tree, file_list = tree_files(file_list)
4081
self.add_cleanup(tree.lock_write().unlock)
4030
tree.lock_write()
4031
self.add_cleanup(tree.unlock)
4082
4032
parents = tree.get_parent_ids()
4083
4033
if len(parents) != 2:
4084
4034
raise errors.BzrCommandError("Sorry, remerge only works after normal"
4137
4087
4138
4088
4139
4089
class cmd_revert(Command):
4140
__doc__ = """Revert files to a previous revision.
4090
"""Revert files to a previous revision.
4141
4091
4142
4092
Giving a list of files will revert only those files. Otherwise, all files
4143
4093
will be reverted. If the revision is not specified with '--revision', the
4194
4144
def run(self, revision=None, no_backup=False, file_list=None,
4195
4145
forget_merges=None):
4196
4146
tree, file_list = tree_files(file_list)
4197
self.add_cleanup(tree.lock_tree_write().unlock)
4147
tree.lock_write()
4148
self.add_cleanup(tree.unlock)
4198
4149
if forget_merges:
4199
4150
tree.set_parent_ids(tree.get_parent_ids()[:1])
4200
4151
else:
4208
4159
4209
4160
4210
4161
class cmd_assert_fail(Command):
4211
__doc__ = """Test reporting of assertion failures"""
4162
"""Test reporting of assertion failures"""
4212
4163
# intended just for use in testing
4213
4164
4214
4165
hidden = True
4218
4169
4219
4170
4220
4171
class cmd_help(Command):
4221
__doc__ = """Show help on a command or other topic.
4172
"""Show help on a command or other topic.
4222
4173
"""
4223
4174
4224
4175
_see_also = ['topics']
4237
4188
4238
4189
4239
4190
class cmd_shell_complete(Command):
4240
__doc__ = """Show appropriate completions for context.
4191
"""Show appropriate completions for context.
4241
4192
4242
4193
For a list of all available commands, say 'bzr shell-complete'.
4243
4194
"""
4252
4203
4253
4204
4254
4205
class cmd_missing(Command):
4255
__doc__ = """Show unmerged/unpulled revisions between two branches.
4206
"""Show unmerged/unpulled revisions between two branches.
4256
4207
4257
4208
OTHER_BRANCH may be local or remote.
4258
4209
4336
4287
restrict = 'remote'
4337
4288
4338
4289
local_branch = Branch.open_containing(u".")[0]
4339
self.add_cleanup(local_branch.lock_read().unlock)
4340
4341
4290
parent = local_branch.get_parent()
4342
4291
if other_branch is None:
4343
4292
other_branch = parent
4352
4301
remote_branch = Branch.open(other_branch)
4353
4302
if remote_branch.base == local_branch.base:
4354
4303
remote_branch = local_branch
4355
else:
4356
self.add_cleanup(remote_branch.lock_read().unlock)
4357
4304
4305
local_branch.lock_read()
4306
self.add_cleanup(local_branch.unlock)
4358
4307
local_revid_range = _revision_range_to_revid_range(
4359
4308
_get_revision_range(my_revision, local_branch,
4360
4309
self.name()))
4361
4310
4311
remote_branch.lock_read()
4312
self.add_cleanup(remote_branch.unlock)
4362
4313
remote_revid_range = _revision_range_to_revid_range(
4363
4314
_get_revision_range(revision,
4364
4315
remote_branch, self.name()))
4414
4365
message("Branches are up to date.\n")
4415
4366
self.cleanup_now()
4416
4367
if not status_code and parent is None and other_branch is not None:
4417
self.add_cleanup(local_branch.lock_write().unlock)
4368
local_branch.lock_write()
4369
self.add_cleanup(local_branch.unlock)
4418
4370
# handle race conditions - a parent might be set while we run.
4419
4371
if local_branch.get_parent() is None:
4420
4372
local_branch.set_parent(remote_branch.base)
4422
4374
4423
4375
4424
4376
class cmd_pack(Command):
4425
__doc__ = """Compress the data within a repository.
4426
4427
This operation compresses the data within a bazaar repository. As
4428
bazaar supports automatic packing of repository, this operation is
4429
normally not required to be done manually.
4430
4431
During the pack operation, bazaar takes a backup of existing repository
4432
data, i.e. pack files. This backup is eventually removed by bazaar
4433
automatically when it is safe to do so. To save disk space by removing
4434
the backed up pack files, the --clean-obsolete-packs option may be
4435
used.
4436
4437
Warning: If you use --clean-obsolete-packs and your machine crashes
4438
during or immediately after repacking, you may be left with a state
4439
where the deletion has been written to disk but the new packs have not
4440
been. In this case the repository may be unusable.
4441
"""
4377
"""Compress the data within a repository."""
4442
4378
4443
4379
_see_also = ['repositories']
4444
4380
takes_args = ['branch_or_repo?']
4445
takes_options = [
4446
Option('clean-obsolete-packs', 'Delete obsolete packs to save disk space.'),
4447
]
4448
4381
4449
def run(self, branch_or_repo='.', clean_obsolete_packs=False):
4382
def run(self, branch_or_repo='.'):
4450
4383
dir = bzrdir.BzrDir.open_containing(branch_or_repo)[0]
4451
4384
try:
4452
4385
branch = dir.open_branch()
4453
4386
repository = branch.repository
4454
4387
except errors.NotBranchError:
4455
4388
repository = dir.open_repository()
4456
repository.pack(clean_obsolete_packs=clean_obsolete_packs)
4389
repository.pack()
4457
4390
4458
4391
4459
4392
class cmd_plugins(Command):
4460
__doc__ = """List the installed plugins.
4393
"""List the installed plugins.
4461
4394
4462
4395
This command displays the list of installed plugins including
4463
4396
version of plugin and a short description of each.
4494
4427
doc = '(no description)'
4495
4428
result.append((name_ver, doc, plugin.path()))
4496
4429
for name_ver, doc, path in sorted(result):
4497
self.outf.write("%s\n" % name_ver)
4498
self.outf.write(" %s\n" % doc)
4430
print name_ver
4431
print ' ', doc
4499
4432
if verbose:
4500
self.outf.write(" %s\n" % path)
4501
self.outf.write("\n")
4433
print ' ', path
4434
print
4502
4435
4503
4436
4504
4437
class cmd_testament(Command):
4505
__doc__ = """Show testament (signing-form) of a revision."""
4438
"""Show testament (signing-form) of a revision."""
4506
4439
takes_options = [
4507
4440
'revision',
4508
4441
Option('long', help='Produce long-format testament.'),
4520
4453
b = Branch.open_containing(branch)[0]
4521
4454
else:
4522
4455
b = Branch.open(branch)
4523
self.add_cleanup(b.lock_read().unlock)
4456
b.lock_read()
4457
self.add_cleanup(b.unlock)
4524
4458
if revision is None:
4525
4459
rev_id = b.last_revision()
4526
4460
else:
4533
4467
4534
4468
4535
4469
class cmd_annotate(Command):
4536
__doc__ = """Show the origin of each line in a file.
4470
"""Show the origin of each line in a file.
4537
4471
4538
4472
This prints out the given file with an annotation on the left side
4539
4473
indicating which revision, author and date introduced the change.
4550
4484
Option('long', help='Show commit date in annotations.'),
4551
4485
'revision',
4552
4486
'show-ids',
4553
'directory',
4554
4487
]
4555
4488
encoding_type = 'exact'
4556
4489
4557
4490
@display_command
4558
4491
def run(self, filename, all=False, long=False, revision=None,
4559
show_ids=False, directory=None):
4492
show_ids=False):
4560
4493
from bzrlib.annotate import annotate_file, annotate_file_tree
4561
4494
wt, branch, relpath = \
4562
_open_directory_or_containing_tree_or_branch(filename, directory)
4495
bzrdir.BzrDir.open_containing_tree_or_branch(filename)
4563
4496
if wt is not None:
4564
self.add_cleanup(wt.lock_read().unlock)
4497
wt.lock_read()
4498
self.add_cleanup(wt.unlock)
4565
4499
else:
4566
self.add_cleanup(branch.lock_read().unlock)
4500
branch.lock_read()
4501
self.add_cleanup(branch.unlock)
4567
4502
tree = _get_one_revision_tree('annotate', revision, branch=branch)
4568
self.add_cleanup(tree.lock_read().unlock)
4503
tree.lock_read()
4504
self.add_cleanup(tree.unlock)
4569
4505
if wt is not None:
4570
4506
file_id = wt.path2id(relpath)
4571
4507
else:
4584
4520
4585
4521
4586
4522
class cmd_re_sign(Command):
4587
__doc__ = """Create a digital signature for an existing revision."""
4523
"""Create a digital signature for an existing revision."""
4588
4524
# TODO be able to replace existing ones.
4589
4525
4590
4526
hidden = True # is this right ?
4591
4527
takes_args = ['revision_id*']
4592
takes_options = ['directory', 'revision']
4528
takes_options = ['revision']
4593
4529
4594
def run(self, revision_id_list=None, revision=None, directory=u'.'):
4530
def run(self, revision_id_list=None, revision=None):
4595
4531
if revision_id_list is not None and revision is not None:
4596
4532
raise errors.BzrCommandError('You can only supply one of revision_id or --revision')
4597
4533
if revision_id_list is None and revision is None:
4598
4534
raise errors.BzrCommandError('You must supply either --revision or a revision_id')
4599
b = WorkingTree.open_containing(directory)[0].branch
4600
self.add_cleanup(b.lock_write().unlock)
4535
b = WorkingTree.open_containing(u'.')[0].branch
4536
b.lock_write()
4537
self.add_cleanup(b.unlock)
4601
4538
return self._run(b, revision_id_list, revision)
4602
4539
4603
4540
def _run(self, b, revision_id_list, revision):
4649
4586
4650
4587
4651
4588
class cmd_bind(Command):
4652
__doc__ = """Convert the current branch into a checkout of the supplied branch.
4653
If no branch is supplied, rebind to the last bound location.
4589
"""Convert the current branch into a checkout of the supplied branch.
4654
4590
4655
4591
Once converted into a checkout, commits must succeed on the master branch
4656
4592
before they will be applied to the local branch.
4662
4598
4663
4599
_see_also = ['checkouts', 'unbind']
4664
4600
takes_args = ['location?']
4665
takes_options = ['directory']
4601
takes_options = []
4666
4602
4667
def run(self, location=None, directory=u'.'):
4668
b, relpath = Branch.open_containing(directory)
4603
def run(self, location=None):
4604
b, relpath = Branch.open_containing(u'.')
4669
4605
if location is None:
4670
4606
try:
4671
4607
location = b.get_old_bound_location()
4690
4626
4691
4627
4692
4628
class cmd_unbind(Command):
4693
__doc__ = """Convert the current checkout into a regular branch.
4629
"""Convert the current checkout into a regular branch.
4694
4630
4695
4631
After unbinding, the local branch is considered independent and subsequent
4696
4632
commits will be local only.
4698
4634
4699
4635
_see_also = ['checkouts', 'bind']
4700
4636
takes_args = []
4701
takes_options = ['directory']
4637
takes_options = []
4702
4638
4703
def run(self, directory=u'.'):
4704
b, relpath = Branch.open_containing(directory)
4639
def run(self):
4640
b, relpath = Branch.open_containing(u'.')
4705
4641
if not b.unbind():
4706
4642
raise errors.BzrCommandError('Local branch is not bound')
4707
4643
4708
4644
4709
4645
class cmd_uncommit(Command):
4710
__doc__ = """Remove the last committed revision.
4646
"""Remove the last committed revision.
4711
4647
4712
4648
--verbose will print out what is being removed.
4713
4649
--dry-run will go through all the motions, but not actually
4753
4689
b = control.open_branch()
4754
4690
4755
4691
if tree is not None:
4756
self.add_cleanup(tree.lock_write().unlock)
4692
tree.lock_write()
4693
self.add_cleanup(tree.unlock)
4757
4694
else:
4758
self.add_cleanup(b.lock_write().unlock)
4695
b.lock_write()
4696
self.add_cleanup(b.unlock)
4759
4697
return self._run(b, tree, dry_run, verbose, revision, force, local=local)
4760
4698
4761
4699
def _run(self, b, tree, dry_run, verbose, revision, force, local=False):
4779
4717
rev_id = b.get_rev_id(revno)
4780
4718
4781
4719
if rev_id is None or _mod_revision.is_null(rev_id):
4782
self.outf.write('No revisions to uncommit.\n')
4720
ui.ui_factory.note('No revisions to uncommit.')
4783
4721
return 1
4784
4722
4723
log_collector = ui.ui_factory.make_output_stream()
4785
4724
lf = log_formatter('short',
4786
to_file=self.outf,
4725
to_file=log_collector,
4787
4726
show_timezone='original')
4788
4727
4789
4728
show_log(b,
4794
4733
end_revision=last_revno)
4795
4734
4796
4735
if dry_run:
4797
self.outf.write('Dry-run, pretending to remove'
4798
' the above revisions.\n')
4736
ui.ui_factory.note('Dry-run, pretending to remove the above revisions.')
4799
4737
else:
4800
self.outf.write('The above revision(s) will be removed.\n')
4738
ui.ui_factory.note('The above revision(s) will be removed.')
4801
4739
4802
4740
if not force:
4803
if not ui.ui_factory.get_boolean('Are you sure'):
4804
self.outf.write('Canceled')
4741
if not ui.ui_factory.get_boolean('Are you sure [y/N]? '):
4742
ui.ui_factory.note('Canceled')
4805
4743
return 0
4806
4744
4807
4745
mutter('Uncommitting from {%s} to {%s}',
4808
4746
last_rev_id, rev_id)
4809
4747
uncommit(b, tree=tree, dry_run=dry_run, verbose=verbose,
4810
4748
revno=revno, local=local)
4811
self.outf.write('You can restore the old tip by running:\n'
4812
' bzr pull . -r revid:%s\n' % last_rev_id)
4749
ui.ui_factory.note('You can restore the old tip by running:\n'
4750
' bzr pull . -r revid:%s' % last_rev_id)
4813
4751
4814
4752
4815
4753
class cmd_break_lock(Command):
4816
__doc__ = """Break a dead lock on a repository, branch or working directory.
4754
"""Break a dead lock on a repository, branch or working directory.
4817
4755
4818
4756
CAUTION: Locks should only be broken when you are sure that the process
4819
4757
holding the lock has been stopped.
4838
4776
4839
4777
4840
4778
class cmd_wait_until_signalled(Command):
4841
__doc__ = """Test helper for test_start_and_stop_bzr_subprocess_send_signal.
4779
"""Test helper for test_start_and_stop_bzr_subprocess_send_signal.
4842
4780
4843
4781
This just prints a line to signal when it is ready, then blocks on stdin.
4844
4782
"""
4852
4790
4853
4791
4854
4792
class cmd_serve(Command):
4855
__doc__ = """Run the bzr server."""
4793
"""Run the bzr server."""
4856
4794
4857
4795
aliases = ['server']
4858
4796
4869
4807
'result in a dynamically allocated port. The default port '
4870
4808
'depends on the protocol.',
4871
4809
type=str),
4872
custom_help('directory',
4873
help='Serve contents of this directory.'),
4810
Option('directory',
4811
help='Serve contents of this directory.',
4812
type=unicode),
4874
4813
Option('allow-writes',
4875
4814
help='By default the server is a readonly server. Supplying '
4876
4815
'--allow-writes enables write access to the contents of '
4917
4856
4918
4857
4919
4858
class cmd_join(Command):
4920
__doc__ = """Combine a tree into its containing tree.
4859
"""Combine a tree into its containing tree.
4921
4860
4922
4861
This command requires the target tree to be in a rich-root format.
4923
4862
4963
4902
4964
4903
4965
4904
class cmd_split(Command):
4966
__doc__ = """Split a subdirectory of a tree into a separate tree.
4905
"""Split a subdirectory of a tree into a separate tree.
4967
4906
4968
4907
This command will produce a target tree in a format that supports
4969
4908
rich roots, like 'rich-root' or 'rich-root-pack'. These formats cannot be
4989
4928
4990
4929
4991
4930
class cmd_merge_directive(Command):
4992
__doc__ = """Generate a merge directive for auto-merge tools.
4931
"""Generate a merge directive for auto-merge tools.
4993
4932
4994
4933
A directive requests a merge to be performed, and also provides all the
4995
4934
information necessary to do so. This means it must either include a
5088
5027
5089
5028
5090
5029
class cmd_send(Command):
5091
__doc__ = """Mail or create a merge-directive for submitting changes.
5030
"""Mail or create a merge-directive for submitting changes.
5092
5031
5093
5032
A merge directive provides many things needed for requesting merges:
5094
5033
5128
5067
given, in which case it is sent to a file.
5129
5068
5130
5069
Mail is sent using your preferred mail program. This should be transparent
5131
on Windows (it uses MAPI). On Unix, it requires the xdg-email utility.
5070
on Windows (it uses MAPI). On Linux, it requires the xdg-email utility.
5132
5071
If the preferred client can't be found (or used), your editor will be used.
5133
5072
5134
5073
To use a specific mail program, set the mail_client configuration option.
5176
5115
short_name='f',
5177
5116
type=unicode),
5178
5117
Option('output', short_name='o',
5179
help='Write merge directive to this file or directory; '
5118
help='Write merge directive to this file; '
5180
5119
'use - for stdout.',
5181
5120
type=unicode),
5182
5121
Option('strict',
5205
5144
5206
5145
5207
5146
class cmd_bundle_revisions(cmd_send):
5208
__doc__ = """Create a merge-directive for submitting changes.
5147
"""Create a merge-directive for submitting changes.
5209
5148
5210
5149
A merge directive provides many things needed for requesting merges:
5211
5150
5278
5217
5279
5218
5280
5219
class cmd_tag(Command):
5281
__doc__ = """Create, remove or modify a tag naming a revision.
5220
"""Create, remove or modify a tag naming a revision.
5282
5221
5283
5222
Tags give human-meaningful names to revisions. Commands that take a -r
5284
5223
(--revision) option can be given -rtag:X, where X is any previously
5292
5231
5293
5232
To rename a tag (change the name but keep it on the same revsion), run ``bzr
5294
5233
tag new-name -r tag:old-name`` and then ``bzr tag --delete oldname``.
5295
5296
If no tag name is specified it will be determined through the
5297
'automatic_tag_name' hook. This can e.g. be used to automatically tag
5298
upstream releases by reading configure.ac. See ``bzr help hooks`` for
5299
details.
5300
5234
"""
5301
5235
5302
5236
_see_also = ['commit', 'tags']
5303
takes_args = ['tag_name?']
5237
takes_args = ['tag_name']
5304
5238
takes_options = [
5305
5239
Option('delete',
5306
5240
help='Delete this tag rather than placing it.',
5307
5241
),
5308
custom_help('directory',
5309
help='Branch in which to place the tag.'),
5242
Option('directory',
5243
help='Branch in which to place the tag.',
5244
short_name='d',
5245
type=unicode,
5246
),
5310
5247
Option('force',
5311
5248
help='Replace existing tags.',
5312
5249
),
5313
5250
'revision',
5314
5251
]
5315
5252
5316
def run(self, tag_name=None,
5253
def run(self, tag_name,
5317
5254
delete=None,
5318
5255
directory='.',
5319
5256
force=None,
5320
5257
revision=None,
5321
5258
):
5322
5259
branch, relpath = Branch.open_containing(directory)
5323
self.add_cleanup(branch.lock_write().unlock)
5260
branch.lock_write()
5261
self.add_cleanup(branch.unlock)
5324
5262
if delete:
5325
if tag_name is None:
5326
raise errors.BzrCommandError("No tag specified to delete.")
5327
5263
branch.tags.delete_tag(tag_name)
5328
5264
self.outf.write('Deleted tag %s.\n' % tag_name)
5329
5265
else:
5335
5271
revision_id = revision[0].as_revision_id(branch)
5336
5272
else:
5337
5273
revision_id = branch.last_revision()
5338
if tag_name is None:
5339
tag_name = branch.automatic_tag_name(revision_id)
5340
if tag_name is None:
5341
raise errors.BzrCommandError(
5342
"Please specify a tag name.")
5343
5274
if (not force) and branch.tags.has_tag(tag_name):
5344
5275
raise errors.TagAlreadyExists(tag_name)
5345
5276
branch.tags.set_tag(tag_name, revision_id)
5347
5278
5348
5279
5349
5280
class cmd_tags(Command):
5350
__doc__ = """List tags.
5281
"""List tags.
5351
5282
5352
5283
This command shows a table of tag names and the revisions they reference.
5353
5284
"""
5354
5285
5355
5286
_see_also = ['tag']
5356
5287
takes_options = [
5357
custom_help('directory',
5358
help='Branch whose tags should be displayed.'),
5288
Option('directory',
5289
help='Branch whose tags should be displayed.',
5290
short_name='d',
5291
type=unicode,
5292
),
5359
5293
RegistryOption.from_kwargs('sort',
5360
5294
'Sort tags by different criteria.', title='Sorting',
5361
5295
alpha='Sort tags lexicographically (default).',
5378
5312
if not tags:
5379
5313
return
5380
5314
5381
self.add_cleanup(branch.lock_read().unlock)
5315
branch.lock_read()
5316
self.add_cleanup(branch.unlock)
5382
5317
if revision:
5383
5318
graph = branch.repository.get_graph()
5384
5319
rev1, rev2 = _get_revision_range(revision, branch, self.name())
5417
5352
5418
5353
5419
5354
class cmd_reconfigure(Command):
5420
__doc__ = """Reconfigure the type of a bzr directory.
5355
"""Reconfigure the type of a bzr directory.
5421
5356
5422
5357
A target configuration must be specified.
5423
5358
5508
5443
5509
5444
5510
5445
class cmd_switch(Command):
5511
__doc__ = """Set the branch of a checkout and update.
5446
"""Set the branch of a checkout and update.
5512
5447
5513
5448
For lightweight checkouts, this changes the branch being referenced.
5514
5449
For heavyweight checkouts, this checks that there are no local commits
5604
5539
5605
5540
5606
5541
class cmd_view(Command):
5607
__doc__ = """Manage filtered views.
5542
"""Manage filtered views.
5608
5543
5609
5544
Views provide a mask over the tree so that users can focus on
5610
5545
a subset of a tree when doing their work. After creating a view,
5758
5693
5759
5694
5760
5695
class cmd_hooks(Command):
5761
__doc__ = """Show hooks."""
5696
"""Show hooks."""
5762
5697
5763
5698
hidden = True
5764
5699
5777
5712
self.outf.write(" <no hooks installed>\n")
5778
5713
5779
5714
5780
class cmd_remove_branch(Command):
5781
__doc__ = """Remove a branch.
5782
5783
This will remove the branch from the specified location but
5784
will keep any working tree or repository in place.
5785
5786
:Examples:
5787
5788
Remove the branch at repo/trunk::
5789
5790
bzr remove-branch repo/trunk
5791
5792
"""
5793
5794
takes_args = ["location?"]
5795
5796
aliases = ["rmbranch"]
5797
5798
def run(self, location=None):
5799
if location is None:
5800
location = "."
5801
branch = Branch.open_containing(location)[0]
5802
branch.bzrdir.destroy_branch()
5803
5804
5805
5715
class cmd_shelve(Command):
5806
__doc__ = """Temporarily set aside some changes from the current tree.
5716
"""Temporarily set aside some changes from the current tree.
5807
5717
5808
5718
Shelve allows you to temporarily put changes you've made "on the shelf",
5809
5719
ie. out of the way, until a later time when you can bring them back from
5862
5772
5863
5773
def run_for_list(self):
5864
5774
tree = WorkingTree.open_containing('.')[0]
5865
self.add_cleanup(tree.lock_read().unlock)
5775
tree.lock_read()
5776
self.add_cleanup(tree.unlock)
5866
5777
manager = tree.get_shelf_manager()
5867
5778
shelves = manager.active_shelves()
5868
5779
if len(shelves) == 0:
5877
5788
5878
5789
5879
5790
class cmd_unshelve(Command):
5880
__doc__ = """Restore shelved changes.
5791
"""Restore shelved changes.
5881
5792
5882
5793
By default, the most recently shelved changes are restored. However if you
5883
5794
specify a shelf by id those changes will be restored instead. This works
5909
5820
5910
5821
5911
5822
class cmd_clean_tree(Command):
5912
__doc__ = """Remove unwanted files from working tree.
5823
"""Remove unwanted files from working tree.
5913
5824
5914
5825
By default, only unknown files, not ignored files, are deleted. Versioned
5915
5826
files are never deleted.
5923
5834
5924
5835
To check what clean-tree will do, use --dry-run.
5925
5836
"""
5926
takes_options = ['directory',
5927
Option('ignored', help='Delete all ignored files.'),
5837
takes_options = [Option('ignored', help='Delete all ignored files.'),
5928
5838
Option('detritus', help='Delete conflict files, merge'
5929
5839
' backups, and failed selftest dirs.'),
5930
5840
Option('unknown',
5933
5843
' deleting them.'),
5934
5844
Option('force', help='Do not prompt before deleting.')]
5935
5845
def run(self, unknown=False, ignored=False, detritus=False, dry_run=False,
5936
force=False, directory=u'.'):
5846
force=False):
5937
5847
from bzrlib.clean_tree import clean_tree
5938
5848
if not (unknown or ignored or detritus):
5939
5849
unknown = True
5940
5850
if dry_run:
5941
5851
force = True
5942
clean_tree(directory, unknown=unknown, ignored=ignored,
5943
detritus=detritus, dry_run=dry_run, no_prompt=force)
5852
clean_tree('.', unknown=unknown, ignored=ignored, detritus=detritus,
5853
dry_run=dry_run, no_prompt=force)
5944
5854
5945
5855
5946
5856
class cmd_reference(Command):
5947
__doc__ = """list, view and set branch locations for nested trees.
5857
"""list, view and set branch locations for nested trees.
5948
5858
5949
5859
If no arguments are provided, lists the branch locations for nested trees.
5950
5860
If one argument is provided, display the branch location for that tree.
5990
5900
self.outf.write('%s %s\n' % (path, location))
5991
5901
5992
5902
5993
def _register_lazy_builtins():
5994
# register lazy builtins from other modules; called at startup and should
5995
# be only called once.
5996
for (name, aliases, module_name) in [
5997
('cmd_bundle_info', [], 'bzrlib.bundle.commands'),
5998
('cmd_dpush', [], 'bzrlib.foreign'),
5999
('cmd_version_info', [], 'bzrlib.cmd_version_info'),
6000
('cmd_resolve', ['resolved'], 'bzrlib.conflicts'),
6001
('cmd_conflicts', [], 'bzrlib.conflicts'),
6002
('cmd_sign_my_commits', [], 'bzrlib.sign_my_commits'),
6003
]:
6004
builtin_command_registry.register_lazy(name, aliases, module_name)
5903
# these get imported and then picked up by the scan for cmd_*
5904
# TODO: Some more consistent way to split command definitions across files;
5905
# we do need to load at least some information about them to know of
5906
# aliases. ideally we would avoid loading the implementation until the
5907
# details were needed.
5908
from bzrlib.cmd_version_info import cmd_version_info
5909
from bzrlib.conflicts import cmd_resolve, cmd_conflicts, restore
5910
from bzrlib.bundle.commands import (
5911
cmd_bundle_info,
5912
)
5913
from bzrlib.foreign import cmd_dpush
5914
from bzrlib.sign_my_commits import cmd_sign_my_commits
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0