« back to all changes in this revision
Viewing changes to bzrlib/builtins.py
- browse files at revision 5089.1.1
- compare with another revision
- download diff
- download tarball
- view history from revision 5089.1.1
- Committer: Martin Pool
- Date: 2010-03-15 06:54:44 UTC
- mto: This revision was merged to the branch mainline in revision 5095.
- Revision ID: mbp@canonical.com-20100315065444-gfs7vp8te4ez5rc9
Fix typo in ReadVFile.readline (thanks mnordhoff)
- files removed:
- bzrlib/tests/blackbox/test_rmbranch.py
- bzrlib/tests/per_bzrdir_colo
- 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,
239
235
# opens the branch?)
240
236
241
237
class cmd_status(Command):
242
__doc__ = """Display status summary.
238
"""Display status summary.
243
239
244
240
This reports on versioned and unknown files, reporting them
245
241
grouped by state. Possible states are:
332
328
333
329
334
330
class cmd_cat_revision(Command):
335
__doc__ = """Write out metadata for a revision.
331
"""Write out metadata for a revision.
336
332
337
333
The revision to print can either be specified by a specific
338
334
revision identifier, or you can use --revision.
390
386
391
387
392
388
class cmd_dump_btree(Command):
393
__doc__ = """Dump the contents of a btree index file to stdout.
389
"""Dump the contents of a btree index file to stdout.
394
390
395
391
PATH is a btree index file, it can be any URL. This includes things like
396
392
.bzr/repository/pack-names, or .bzr/repository/indices/a34b3a...ca4a4.iix
460
456
for node in bt.iter_all_entries():
461
457
# Node is made up of:
462
458
# (index, key, value, [references])
463
try:
464
refs = node[3]
465
except IndexError:
466
refs_as_tuples = None
467
else:
468
refs_as_tuples = static_tuple.as_tuples(refs)
459
refs_as_tuples = static_tuple.as_tuples(node[3])
469
460
as_tuple = (tuple(node[1]), node[2], refs_as_tuples)
470
461
self.outf.write('%s\n' % (as_tuple,))
471
462
472
463
473
464
class cmd_remove_tree(Command):
474
__doc__ = """Remove the working tree from a given branch/checkout.
465
"""Remove the working tree from a given branch/checkout.
475
466
476
467
Since a lightweight checkout is little more than a working tree
477
468
this will refuse to run against one.
504
495
if (working.has_changes()):
505
496
raise errors.UncommittedChanges(working)
506
497
507
if working.user_url != working.branch.user_url:
498
working_path = working.bzrdir.root_transport.base
499
branch_path = working.branch.bzrdir.root_transport.base
500
if working_path != branch_path:
508
501
raise errors.BzrCommandError("You cannot remove the working tree"
509
502
" from a lightweight checkout")
510
503
512
505
513
506
514
507
class cmd_revno(Command):
515
__doc__ = """Show current revision number.
508
"""Show current revision number.
516
509
517
510
This is equal to the number of revisions on this branch.
518
511
"""
528
521
if tree:
529
522
try:
530
523
wt = WorkingTree.open_containing(location)[0]
531
self.add_cleanup(wt.lock_read().unlock)
524
wt.lock_read()
532
525
except (errors.NoWorkingTree, errors.NotLocalUrl):
533
526
raise errors.NoWorkingTree(location)
527
self.add_cleanup(wt.unlock)
534
528
revid = wt.last_revision()
535
529
try:
536
530
revno_t = wt.branch.revision_id_to_dotted_revno(revid)
539
533
revno = ".".join(str(n) for n in revno_t)
540
534
else:
541
535
b = Branch.open_containing(location)[0]
542
self.add_cleanup(b.lock_read().unlock)
536
b.lock_read()
537
self.add_cleanup(b.unlock)
543
538
revno = b.revno()
544
539
self.cleanup_now()
545
540
self.outf.write(str(revno) + '\n')
546
541
547
542
548
543
class cmd_revision_info(Command):
549
__doc__ = """Show revision number and revision id for a given revision identifier.
544
"""Show revision number and revision id for a given revision identifier.
550
545
"""
551
546
hidden = True
552
547
takes_args = ['revision_info*']
568
563
try:
569
564
wt = WorkingTree.open_containing(directory)[0]
570
565
b = wt.branch
571
self.add_cleanup(wt.lock_read().unlock)
566
wt.lock_read()
567
self.add_cleanup(wt.unlock)
572
568
except (errors.NoWorkingTree, errors.NotLocalUrl):
573
569
wt = None
574
570
b = Branch.open_containing(directory)[0]
575
self.add_cleanup(b.lock_read().unlock)
571
b.lock_read()
572
self.add_cleanup(b.unlock)
576
573
revision_ids = []
577
574
if revision is not None:
578
575
revision_ids.extend(rev.as_revision_id(b) for rev in revision)
606
603
607
604
608
605
class cmd_add(Command):
609
__doc__ = """Add specified files or directories.
606
"""Add specified files or directories.
610
607
611
608
In non-recursive mode, all the named items are added, regardless
612
609
of whether they were previously ignored. A warning is given if
677
674
should_print=(not is_quiet()))
678
675
679
676
if base_tree:
680
self.add_cleanup(base_tree.lock_read().unlock)
677
base_tree.lock_read()
678
self.add_cleanup(base_tree.unlock)
681
679
tree, file_list = tree_files_for_add(file_list)
682
680
added, ignored = tree.smart_add(file_list, not
683
681
no_recurse, action=action, save=not dry_run)
691
689
692
690
693
691
class cmd_mkdir(Command):
694
__doc__ = """Create a new versioned directory.
692
"""Create a new versioned directory.
695
693
696
694
This is equivalent to creating the directory and then adding it.
697
695
"""
713
711
714
712
715
713
class cmd_relpath(Command):
716
__doc__ = """Show path of a file relative to root"""
714
"""Show path of a file relative to root"""
717
715
718
716
takes_args = ['filename']
719
717
hidden = True
728
726
729
727
730
728
class cmd_inventory(Command):
731
__doc__ = """Show inventory of the current working copy or a revision.
729
"""Show inventory of the current working copy or a revision.
732
730
733
731
It is possible to limit the output to a particular entry
734
732
type using the --kind option. For example: --kind file.
755
753
756
754
revision = _get_one_revision('inventory', revision)
757
755
work_tree, file_list = tree_files(file_list)
758
self.add_cleanup(work_tree.lock_read().unlock)
756
work_tree.lock_read()
757
self.add_cleanup(work_tree.unlock)
759
758
if revision is not None:
760
759
tree = revision.as_tree(work_tree.branch)
761
760
762
761
extra_trees = [work_tree]
763
self.add_cleanup(tree.lock_read().unlock)
762
tree.lock_read()
763
self.add_cleanup(tree.unlock)
764
764
else:
765
765
tree = work_tree
766
766
extra_trees = []
787
787
788
788
789
789
class cmd_mv(Command):
790
__doc__ = """Move or rename a file.
790
"""Move or rename a file.
791
791
792
792
:Usage:
793
793
bzr mv OLDNAME NEWNAME
826
826
if len(names_list) < 2:
827
827
raise errors.BzrCommandError("missing file argument")
828
828
tree, rel_names = tree_files(names_list, canonicalize=False)
829
self.add_cleanup(tree.lock_tree_write().unlock)
829
tree.lock_tree_write()
830
self.add_cleanup(tree.unlock)
830
831
self._run(tree, names_list, rel_names, after)
831
832
832
833
def run_auto(self, names_list, after, dry_run):
837
838
raise errors.BzrCommandError('--after cannot be specified with'
838
839
' --auto.')
839
840
work_tree, file_list = tree_files(names_list, default_branch='.')
840
self.add_cleanup(work_tree.lock_tree_write().unlock)
841
work_tree.lock_tree_write()
842
self.add_cleanup(work_tree.unlock)
841
843
rename_map.RenameMap.guess_renames(work_tree, dry_run)
842
844
843
845
def _run(self, tree, names_list, rel_names, after):
922
924
923
925
924
926
class cmd_pull(Command):
925
__doc__ = """Turn this branch into a mirror of another branch.
927
"""Turn this branch into a mirror of another branch.
926
928
927
929
By default, this command only works on branches that have not diverged.
928
930
Branches are considered diverged if the destination branch's most recent
977
979
try:
978
980
tree_to = WorkingTree.open_containing(directory)[0]
979
981
branch_to = tree_to.branch
980
self.add_cleanup(tree_to.lock_write().unlock)
981
982
except errors.NoWorkingTree:
982
983
tree_to = None
983
984
branch_to = Branch.open_containing(directory)[0]
984
self.add_cleanup(branch_to.lock_write().unlock)
985
985
986
986
if local and not branch_to.get_bound_location():
987
987
raise errors.LocalRequiresBoundBranch()
988
988
1018
1018
else:
1019
1019
branch_from = Branch.open(location,
1020
1020
possible_transports=possible_transports)
1021
self.add_cleanup(branch_from.lock_read().unlock)
1022
1021
1023
1022
if branch_to.get_parent() is None or remember:
1024
1023
branch_to.set_parent(branch_from.base)
1025
1024
1025
if branch_from is not branch_to:
1026
branch_from.lock_read()
1027
self.add_cleanup(branch_from.unlock)
1026
1028
if revision is not None:
1027
1029
revision_id = revision.as_revision_id(branch_from)
1028
1030
1031
branch_to.lock_write()
1032
self.add_cleanup(branch_to.unlock)
1029
1033
if tree_to is not None:
1030
1034
view_info = _get_view_info_for_change_reporter(tree_to)
1031
1035
change_reporter = delta._ChangeReporter(
1046
1050
1047
1051
1048
1052
class cmd_push(Command):
1049
__doc__ = """Update a mirror of this branch.
1053
"""Update a mirror of this branch.
1050
1054
1051
1055
The target branch will not have its working tree populated because this
1052
1056
is both expensive, and is not supported on remote file systems.
1113
1117
# Get the source branch
1114
1118
(tree, br_from,
1115
1119
_unused) = bzrdir.BzrDir.open_containing_tree_or_branch(directory)
1120
if strict is None:
1121
strict = br_from.get_config().get_user_option_as_bool('push_strict')
1122
if strict is None: strict = True # default value
1116
1123
# Get the tip's revision_id
1117
1124
revision = _get_one_revision('push', revision)
1118
1125
if revision is not None:
1119
1126
revision_id = revision.in_history(br_from).rev_id
1120
1127
else:
1121
1128
revision_id = None
1122
if tree is not None and revision_id is None:
1123
tree.check_changed_or_out_of_date(
1124
strict, 'push_strict',
1125
more_error='Use --no-strict to force the push.',
1126
more_warning='Uncommitted changes will not be pushed.')
1129
if strict and tree is not None and revision_id is None:
1130
if (tree.has_changes()):
1131
raise errors.UncommittedChanges(
1132
tree, more='Use --no-strict to force the push.')
1133
if tree.last_revision() != tree.branch.last_revision():
1134
# The tree has lost sync with its branch, there is little
1135
# chance that the user is aware of it but he can still force
1136
# the push with --no-strict
1137
raise errors.OutOfDateTree(
1138
tree, more='Use --no-strict to force the push.')
1139
1127
1140
# Get the stacked_on branch, if any
1128
1141
if stacked_on is not None:
1129
1142
stacked_on = urlutils.normalize_url(stacked_on)
1161
1174
1162
1175
1163
1176
class cmd_branch(Command):
1164
__doc__ = """Create a new branch that is a copy of an existing branch.
1177
"""Create a new branch that is a copy of an existing branch.
1165
1178
1166
1179
If the TO_LOCATION is omitted, the last component of the FROM_LOCATION will
1167
1180
be used. In other words, "branch ../foo/bar" will attempt to create ./bar.
1207
1220
accelerator_tree, br_from = bzrdir.BzrDir.open_tree_or_branch(
1208
1221
from_location)
1209
1222
revision = _get_one_revision('branch', revision)
1210
self.add_cleanup(br_from.lock_read().unlock)
1223
br_from.lock_read()
1224
self.add_cleanup(br_from.unlock)
1211
1225
if revision is not None:
1212
1226
revision_id = revision.as_revision_id(br_from)
1213
1227
else:
1273
1287
1274
1288
1275
1289
class cmd_checkout(Command):
1276
__doc__ = """Create a new checkout of an existing branch.
1290
"""Create a new checkout of an existing branch.
1277
1291
1278
1292
If BRANCH_LOCATION is omitted, checkout will reconstitute a working tree for
1279
1293
the branch found in '.'. This is useful if you have removed the working tree
1342
1356
1343
1357
1344
1358
class cmd_renames(Command):
1345
__doc__ = """Show list of renamed files.
1359
"""Show list of renamed files.
1346
1360
"""
1347
1361
# TODO: Option to show renames between two historical versions.
1348
1362
1353
1367
@display_command
1354
1368
def run(self, dir=u'.'):
1355
1369
tree = WorkingTree.open_containing(dir)[0]
1356
self.add_cleanup(tree.lock_read().unlock)
1370
tree.lock_read()
1371
self.add_cleanup(tree.unlock)
1357
1372
new_inv = tree.inventory
1358
1373
old_tree = tree.basis_tree()
1359
self.add_cleanup(old_tree.lock_read().unlock)
1374
old_tree.lock_read()
1375
self.add_cleanup(old_tree.unlock)
1360
1376
old_inv = old_tree.inventory
1361
1377
renames = []
1362
1378
iterator = tree.iter_changes(old_tree, include_unchanged=True)
1372
1388
1373
1389
1374
1390
class cmd_update(Command):
1375
__doc__ = """Update a tree to have the latest code committed to its branch.
1391
"""Update a tree to have the latest code committed to its branch.
1376
1392
1377
1393
This will perform a merge into the working tree, and may generate
1378
1394
conflicts. If you have any local changes, you will still
1400
1416
master = branch.get_master_branch(
1401
1417
possible_transports=possible_transports)
1402
1418
if master is not None:
1419
tree.lock_write()
1403
1420
branch_location = master.base
1404
tree.lock_write()
1405
1421
else:
1422
tree.lock_tree_write()
1406
1423
branch_location = tree.branch.base
1407
tree.lock_tree_write()
1408
1424
self.add_cleanup(tree.unlock)
1409
1425
# get rid of the final '/' and be ready for display
1410
branch_location = urlutils.unescape_for_display(
1411
branch_location.rstrip('/'),
1412
self.outf.encoding)
1426
branch_location = urlutils.unescape_for_display(branch_location[:-1],
1427
self.outf.encoding)
1413
1428
existing_pending_merges = tree.get_parent_ids()[1:]
1414
1429
if master is None:
1415
1430
old_tip = None
1423
1438
else:
1424
1439
revision_id = branch.last_revision()
1425
1440
if revision_id == _mod_revision.ensure_null(tree.last_revision()):
1426
revno = branch.revision_id_to_dotted_revno(revision_id)
1427
note("Tree is up to date at revision %s of branch %s" %
1428
('.'.join(map(str, revno)), branch_location))
1441
revno = branch.revision_id_to_revno(revision_id)
1442
note("Tree is up to date at revision %d of branch %s" %
1443
(revno, branch_location))
1429
1444
return 0
1430
1445
view_info = _get_view_info_for_change_reporter(tree)
1431
1446
change_reporter = delta._ChangeReporter(
1443
1458
"bzr update --revision only works"
1444
1459
" for a revision in the branch history"
1445
1460
% (e.revision))
1446
revno = tree.branch.revision_id_to_dotted_revno(
1461
revno = tree.branch.revision_id_to_revno(
1447
1462
_mod_revision.ensure_null(tree.last_revision()))
1448
note('Updated to revision %s of branch %s' %
1449
('.'.join(map(str, revno)), branch_location))
1450
parent_ids = tree.get_parent_ids()
1451
if parent_ids[1:] and parent_ids[1:] != existing_pending_merges:
1463
note('Updated to revision %d of branch %s' %
1464
(revno, branch_location))
1465
if tree.get_parent_ids()[1:] != existing_pending_merges:
1452
1466
note('Your local commits will now show as pending merges with '
1453
1467
"'bzr status', and can be committed with 'bzr commit'.")
1454
1468
if conflicts != 0:
1458
1472
1459
1473
1460
1474
class cmd_info(Command):
1461
__doc__ = """Show information about a working tree, branch or repository.
1475
"""Show information about a working tree, branch or repository.
1462
1476
1463
1477
This command will show all known locations and formats associated to the
1464
1478
tree, branch or repository.
1502
1516
1503
1517
1504
1518
class cmd_remove(Command):
1505
__doc__ = """Remove files or directories.
1519
"""Remove files or directories.
1506
1520
1507
1521
This makes bzr stop tracking changes to the specified files. bzr will delete
1508
1522
them if they can easily be recovered using revert. If no options or
1530
1544
if file_list is not None:
1531
1545
file_list = [f for f in file_list]
1532
1546
1533
self.add_cleanup(tree.lock_write().unlock)
1547
tree.lock_write()
1548
self.add_cleanup(tree.unlock)
1534
1549
# Heuristics should probably all move into tree.remove_smart or
1535
1550
# some such?
1536
1551
if new:
1555
1570
1556
1571
1557
1572
class cmd_file_id(Command):
1558
__doc__ = """Print file_id of a particular file or directory.
1573
"""Print file_id of a particular file or directory.
1559
1574
1560
1575
The file_id is assigned when the file is first added and remains the
1561
1576
same through all revisions where the file exists, even when it is
1577
1592
1578
1593
1579
1594
class cmd_file_path(Command):
1580
__doc__ = """Print path of file_ids to a file or directory.
1595
"""Print path of file_ids to a file or directory.
1581
1596
1582
1597
This prints one line for each directory down to the target,
1583
1598
starting at the branch root.
1599
1614
1600
1615
1601
1616
class cmd_reconcile(Command):
1602
__doc__ = """Reconcile bzr metadata in a branch.
1617
"""Reconcile bzr metadata in a branch.
1603
1618
1604
1619
This can correct data mismatches that may have been caused by
1605
1620
previous ghost operations or bzr upgrades. You should only
1627
1642
1628
1643
1629
1644
class cmd_revision_history(Command):
1630
__doc__ = """Display the list of revision ids on a branch."""
1645
"""Display the list of revision ids on a branch."""
1631
1646
1632
1647
_see_also = ['log']
1633
1648
takes_args = ['location?']
1643
1658
1644
1659
1645
1660
class cmd_ancestry(Command):
1646
__doc__ = """List all revisions merged into this branch."""
1661
"""List all revisions merged into this branch."""
1647
1662
1648
1663
_see_also = ['log', 'revision-history']
1649
1664
takes_args = ['location?']
1668
1683
1669
1684
1670
1685
class cmd_init(Command):
1671
__doc__ = """Make a directory into a versioned branch.
1686
"""Make a directory into a versioned branch.
1672
1687
1673
1688
Use this to create an empty branch, or before importing an
1674
1689
existing project.
1777
1792
1778
1793
1779
1794
class cmd_init_repository(Command):
1780
__doc__ = """Create a shared repository for branches to share storage space.
1795
"""Create a shared repository for branches to share storage space.
1781
1796
1782
1797
New branches created under the repository directory will store their
1783
1798
revisions in the repository, not in the branch directory. For branches
1837
1852
1838
1853
1839
1854
class cmd_diff(Command):
1840
__doc__ = """Show differences in the working tree, between revisions or branches.
1855
"""Show differences in the working tree, between revisions or branches.
1841
1856
1842
1857
If no arguments are given, all changes for the current tree are listed.
1843
1858
If files are given, only the changes in those files are listed.
1929
1944
help='Use this command to compare files.',
1930
1945
type=unicode,
1931
1946
),
1932
RegistryOption('format',
1933
help='Diff format to use.',
1934
lazy_registry=('bzrlib.diff', 'format_registry'),
1935
value_switches=False, title='Diff format'),
1936
1947
]
1937
1948
aliases = ['di', 'dif']
1938
1949
encoding_type = 'exact'
1939
1950
1940
1951
@display_command
1941
1952
def run(self, revision=None, file_list=None, diff_options=None,
1942
prefix=None, old=None, new=None, using=None, format=None):
1943
from bzrlib.diff import (get_trees_and_branches_to_diff_locked,
1944
show_diff_trees)
1953
prefix=None, old=None, new=None, using=None):
1954
from bzrlib.diff import get_trees_and_branches_to_diff, show_diff_trees
1945
1955
1946
1956
if (prefix is None) or (prefix == '0'):
1947
1957
# diff -p0 format
1961
1971
raise errors.BzrCommandError('bzr diff --revision takes exactly'
1962
1972
' one or two revision specifiers')
1963
1973
1964
if using is not None and format is not None:
1965
raise errors.BzrCommandError('--using and --format are mutually '
1966
'exclusive.')
1967
1968
1974
(old_tree, new_tree,
1969
1975
old_branch, new_branch,
1970
specific_files, extra_trees) = get_trees_and_branches_to_diff_locked(
1971
file_list, revision, old, new, self.add_cleanup, apply_view=True)
1976
specific_files, extra_trees) = get_trees_and_branches_to_diff(
1977
file_list, revision, old, new, apply_view=True)
1972
1978
return show_diff_trees(old_tree, new_tree, sys.stdout,
1973
1979
specific_files=specific_files,
1974
1980
external_diff_options=diff_options,
1975
1981
old_label=old_label, new_label=new_label,
1976
extra_trees=extra_trees, using=using,
1977
format_cls=format)
1982
extra_trees=extra_trees, using=using)
1978
1983
1979
1984
1980
1985
class cmd_deleted(Command):
1981
__doc__ = """List files deleted in the working tree.
1986
"""List files deleted in the working tree.
1982
1987
"""
1983
1988
# TODO: Show files deleted since a previous revision, or
1984
1989
# between two revisions.
1992
1997
@display_command
1993
1998
def run(self, show_ids=False):
1994
1999
tree = WorkingTree.open_containing(u'.')[0]
1995
self.add_cleanup(tree.lock_read().unlock)
2000
tree.lock_read()
2001
self.add_cleanup(tree.unlock)
1996
2002
old = tree.basis_tree()
1997
self.add_cleanup(old.lock_read().unlock)
2003
old.lock_read()
2004
self.add_cleanup(old.unlock)
1998
2005
for path, ie in old.inventory.iter_entries():
1999
2006
if not tree.has_id(ie.file_id):
2000
2007
self.outf.write(path)
2005
2012
2006
2013
2007
2014
class cmd_modified(Command):
2008
__doc__ = """List files modified in working tree.
2015
"""List files modified in working tree.
2009
2016
"""
2010
2017
2011
2018
hidden = True
2028
2035
2029
2036
2030
2037
class cmd_added(Command):
2031
__doc__ = """List files added in working tree.
2038
"""List files added in working tree.
2032
2039
"""
2033
2040
2034
2041
hidden = True
2042
2049
@display_command
2043
2050
def run(self, null=False):
2044
2051
wt = WorkingTree.open_containing(u'.')[0]
2045
self.add_cleanup(wt.lock_read().unlock)
2052
wt.lock_read()
2053
self.add_cleanup(wt.unlock)
2046
2054
basis = wt.basis_tree()
2047
self.add_cleanup(basis.lock_read().unlock)
2055
basis.lock_read()
2056
self.add_cleanup(basis.unlock)
2048
2057
basis_inv = basis.inventory
2049
2058
inv = wt.inventory
2050
2059
for file_id in inv:
2062
2071
2063
2072
2064
2073
class cmd_root(Command):
2065
__doc__ = """Show the tree root directory.
2074
"""Show the tree root directory.
2066
2075
2067
2076
The root is the nearest enclosing directory with a .bzr control
2068
2077
directory."""
2092
2101
2093
2102
2094
2103
class cmd_log(Command):
2095
__doc__ = """Show historical log for a branch or subset of a branch.
2104
"""Show historical log for a branch or subset of a branch.
2096
2105
2097
2106
log is bzr's default tool for exploring the history of a branch.
2098
2107
The branch to use is taken from the first parameter. If no parameters
2279
2288
help='Show changes made in each revision as a patch.'),
2280
2289
Option('include-merges',
2281
2290
help='Show merged revisions like --levels 0 does.'),
2282
Option('exclude-common-ancestry',
2283
help='Display only the revisions that are not part'
2284
' of both ancestries (require -rX..Y)'
2285
)
2286
2291
]
2287
2292
encoding_type = 'replace'
2288
2293
2298
2303
message=None,
2299
2304
limit=None,
2300
2305
show_diff=False,
2301
include_merges=False,
2302
exclude_common_ancestry=False,
2303
):
2306
include_merges=False):
2304
2307
from bzrlib.log import (
2305
2308
Logger,
2306
2309
make_log_request_dict,
2307
2310
_get_info_for_log_files,
2308
2311
)
2309
2312
direction = (forward and 'forward') or 'reverse'
2310
if (exclude_common_ancestry
2311
and (revision is None or len(revision) != 2)):
2312
raise errors.BzrCommandError(
2313
'--exclude-common-ancestry requires -r with two revisions')
2314
2313
if include_merges:
2315
2314
if levels is None:
2316
2315
levels = 0
2332
2331
if file_list:
2333
2332
# find the file ids to log and check for directory filtering
2334
2333
b, file_info_list, rev1, rev2 = _get_info_for_log_files(
2335
revision, file_list, self.add_cleanup)
2334
revision, file_list)
2335
self.add_cleanup(b.unlock)
2336
2336
for relpath, file_id, kind in file_info_list:
2337
2337
if file_id is None:
2338
2338
raise errors.BzrCommandError(
2356
2356
location = '.'
2357
2357
dir, relpath = bzrdir.BzrDir.open_containing(location)
2358
2358
b = dir.open_branch()
2359
self.add_cleanup(b.lock_read().unlock)
2359
b.lock_read()
2360
self.add_cleanup(b.unlock)
2360
2361
rev1, rev2 = _get_revision_range(revision, b, self.name())
2361
2362
2362
2363
# Decide on the type of delta & diff filtering to use
2407
2408
direction=direction, specific_fileids=file_ids,
2408
2409
start_revision=rev1, end_revision=rev2, limit=limit,
2409
2410
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
)
2411
diff_type=diff_type, _match_using_deltas=match_using_deltas)
2413
2412
Logger(b, rqst).show(lf)
2414
2413
2415
2414
2434
2433
raise errors.BzrCommandError(
2435
2434
"bzr %s doesn't accept two revisions in different"
2436
2435
" branches." % command_name)
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)
2436
rev1 = start_spec.in_history(branch)
2442
2437
# Avoid loading all of history when we know a missing
2443
2438
# end of range means the last revision ...
2444
2439
if end_spec.spec is None:
2473
2468
2474
2469
2475
2470
class cmd_touching_revisions(Command):
2476
__doc__ = """Return revision-ids which affected a particular file.
2471
"""Return revision-ids which affected a particular file.
2477
2472
2478
2473
A more user-friendly interface is "bzr log FILE".
2479
2474
"""
2486
2481
tree, relpath = WorkingTree.open_containing(filename)
2487
2482
file_id = tree.path2id(relpath)
2488
2483
b = tree.branch
2489
self.add_cleanup(b.lock_read().unlock)
2484
b.lock_read()
2485
self.add_cleanup(b.unlock)
2490
2486
touching_revs = log.find_touching_revisions(b, file_id)
2491
2487
for revno, revision_id, what in touching_revs:
2492
2488
self.outf.write("%6d %s\n" % (revno, what))
2493
2489
2494
2490
2495
2491
class cmd_ls(Command):
2496
__doc__ = """List files in a tree.
2492
"""List files in a tree.
2497
2493
"""
2498
2494
2499
2495
_see_also = ['status', 'cat']
2561
2557
view_str = views.view_display_str(view_files)
2562
2558
note("Ignoring files outside view. View is %s" % view_str)
2563
2559
2564
self.add_cleanup(tree.lock_read().unlock)
2560
tree.lock_read()
2561
self.add_cleanup(tree.unlock)
2565
2562
for fp, fc, fkind, fid, entry in tree.list_files(include_root=False,
2566
2563
from_dir=relpath, recursive=recursive):
2567
2564
# Apply additional masking
2609
2606
2610
2607
2611
2608
class cmd_unknowns(Command):
2612
__doc__ = """List unknown files.
2609
"""List unknown files.
2613
2610
"""
2614
2611
2615
2612
hidden = True
2622
2619
2623
2620
2624
2621
class cmd_ignore(Command):
2625
__doc__ = """Ignore specified files or patterns.
2622
"""Ignore specified files or patterns.
2626
2623
2627
2624
See ``bzr help patterns`` for details on the syntax of patterns.
2628
2625
2637
2634
using this command or directly by using an editor, be sure to commit
2638
2635
it.
2639
2636
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
2637
Patterns prefixed with '!' are exceptions to ignore patterns and take
2647
2638
precedence over regular ignores. Such exceptions are used to specify
2648
2639
files that should be versioned which would otherwise be ignored.
2689
2680
_see_also = ['status', 'ignored', 'patterns']
2690
2681
takes_args = ['name_pattern*']
2691
2682
takes_options = [
2692
Option('default-rules',
2693
help='Display the default ignore rules that bzr uses.')
2683
Option('old-default-rules',
2684
help='Write out the ignore rules bzr < 0.9 always used.')
2694
2685
]
2695
2686
2696
def run(self, name_pattern_list=None, default_rules=None):
2687
def run(self, name_pattern_list=None, old_default_rules=None):
2697
2688
from bzrlib import ignores
2698
if default_rules is not None:
2699
# dump the default rules and exit
2700
for pattern in ignores.USER_DEFAULTS:
2689
if old_default_rules is not None:
2690
# dump the rules and exit
2691
for pattern in ignores.OLD_DEFAULTS:
2701
2692
self.outf.write("%s\n" % pattern)
2702
2693
return
2703
2694
if not name_pattern_list:
2704
2695
raise errors.BzrCommandError("ignore requires at least one "
2705
"NAME_PATTERN or --default-rules.")
2696
"NAME_PATTERN or --old-default-rules")
2706
2697
name_pattern_list = [globbing.normalize_pattern(p)
2707
2698
for p in name_pattern_list]
2708
2699
for name_pattern in name_pattern_list:
2730
2721
2731
2722
2732
2723
class cmd_ignored(Command):
2733
__doc__ = """List ignored files and the patterns that matched them.
2724
"""List ignored files and the patterns that matched them.
2734
2725
2735
2726
List all the ignored files and the ignore pattern that caused the file to
2736
2727
be ignored.
2746
2737
@display_command
2747
2738
def run(self):
2748
2739
tree = WorkingTree.open_containing(u'.')[0]
2749
self.add_cleanup(tree.lock_read().unlock)
2740
tree.lock_read()
2741
self.add_cleanup(tree.unlock)
2750
2742
for path, file_class, kind, file_id, entry in tree.list_files():
2751
2743
if file_class != 'I':
2752
2744
continue
2756
2748
2757
2749
2758
2750
class cmd_lookup_revision(Command):
2759
__doc__ = """Lookup the revision-id from a revision-number
2751
"""Lookup the revision-id from a revision-number
2760
2752
2761
2753
:Examples:
2762
2754
bzr lookup-revision 33
2776
2768
2777
2769
2778
2770
class cmd_export(Command):
2779
__doc__ = """Export current or past revision to a destination directory or archive.
2771
"""Export current or past revision to a destination directory or archive.
2780
2772
2781
2773
If no revision is specified this exports the last committed revision.
2782
2774
2839
2831
2840
2832
2841
2833
class cmd_cat(Command):
2842
__doc__ = """Write the contents of a file as of a given revision to standard output.
2834
"""Write the contents of a file as of a given revision to standard output.
2843
2835
2844
2836
If no revision is nominated, the last revision is used.
2845
2837
2865
2857
" one revision specifier")
2866
2858
tree, branch, relpath = \
2867
2859
bzrdir.BzrDir.open_containing_tree_or_branch(filename)
2868
self.add_cleanup(branch.lock_read().unlock)
2860
branch.lock_read()
2861
self.add_cleanup(branch.unlock)
2869
2862
return self._run(tree, branch, relpath, filename, revision,
2870
2863
name_from_revision, filters)
2871
2864
2874
2867
if tree is None:
2875
2868
tree = b.basis_tree()
2876
2869
rev_tree = _get_one_revision_tree('cat', revision, branch=b)
2877
self.add_cleanup(rev_tree.lock_read().unlock)
2870
rev_tree.lock_read()
2871
self.add_cleanup(rev_tree.unlock)
2878
2872
2879
2873
old_file_id = rev_tree.path2id(relpath)
2880
2874
2923
2917
2924
2918
2925
2919
class cmd_local_time_offset(Command):
2926
__doc__ = """Show the offset in seconds from GMT to local time."""
2920
"""Show the offset in seconds from GMT to local time."""
2927
2921
hidden = True
2928
2922
@display_command
2929
2923
def run(self):
2932
2926
2933
2927
2934
2928
class cmd_commit(Command):
2935
__doc__ = """Commit changes into a new revision.
2929
"""Commit changes into a new revision.
2936
2930
2937
2931
An explanatory message needs to be given for each commit. This is
2938
2932
often done by using the --message option (getting the message from the
3046
3040
"the master branch until a normal commit "
3047
3041
"is performed."
3048
3042
),
3049
Option('show-diff', short_name='p',
3043
Option('show-diff',
3050
3044
help='When no message is supplied, show the diff along'
3051
3045
' with the status summary in the message editor.'),
3052
3046
]
3132
3126
'(use --file "%(f)s" to take commit message from that file)'
3133
3127
% { 'f': message })
3134
3128
ui.ui_factory.show_warning(warning_msg)
3135
if '\r' in message:
3136
message = message.replace('\r\n', '\n')
3137
message = message.replace('\r', '\n')
3138
if file:
3139
raise errors.BzrCommandError(
3140
"please specify either --message or --file")
3141
3129
3142
3130
def get_message(commit_obj):
3143
3131
"""Callback to get commit message"""
3144
if file:
3145
my_message = codecs.open(
3146
file, 'rt', osutils.get_user_encoding()).read()
3147
elif message is not None:
3148
my_message = message
3149
else:
3150
# No message supplied: make one up.
3151
# text is the status of the tree
3152
text = make_commit_message_template_encoded(tree,
3132
my_message = message
3133
if my_message is not None and '\r' in my_message:
3134
my_message = my_message.replace('\r\n', '\n')
3135
my_message = my_message.replace('\r', '\n')
3136
if my_message is None and not file:
3137
t = make_commit_message_template_encoded(tree,
3153
3138
selected_list, diff=show_diff,
3154
3139
output_encoding=osutils.get_user_encoding())
3155
# start_message is the template generated from hooks
3156
# XXX: Warning - looks like hooks return unicode,
3157
# make_commit_message_template_encoded returns user encoding.
3158
# We probably want to be using edit_commit_message instead to
3159
# avoid this.
3160
3140
start_message = generate_commit_message_template(commit_obj)
3161
my_message = edit_commit_message_encoded(text,
3141
my_message = edit_commit_message_encoded(t,
3162
3142
start_message=start_message)
3163
3143
if my_message is None:
3164
3144
raise errors.BzrCommandError("please specify a commit"
3165
3145
" message with either --message or --file")
3146
elif my_message and file:
3147
raise errors.BzrCommandError(
3148
"please specify either --message or --file")
3149
if file:
3150
my_message = codecs.open(file, 'rt',
3151
osutils.get_user_encoding()).read()
3166
3152
if my_message == "":
3167
3153
raise errors.BzrCommandError("empty commit message specified")
3168
3154
return my_message
3180
3166
timezone=offset,
3181
3167
exclude=safe_relpath_files(tree, exclude))
3182
3168
except PointlessCommit:
3169
# FIXME: This should really happen before the file is read in;
3170
# perhaps prepare the commit; get the message; then actually commit
3183
3171
raise errors.BzrCommandError("No changes to commit."
3184
3172
" Use --unchanged to commit anyhow.")
3185
3173
except ConflictsInTree:
3198
3186
3199
3187
3200
3188
class cmd_check(Command):
3201
__doc__ = """Validate working tree structure, branch consistency and repository history.
3189
"""Validate working tree structure, branch consistency and repository history.
3202
3190
3203
3191
This command checks various invariants about branch and repository storage
3204
3192
to detect data corruption or bzr bugs.
3268
3256
3269
3257
3270
3258
class cmd_upgrade(Command):
3271
__doc__ = """Upgrade branch storage to current format.
3259
"""Upgrade branch storage to current format.
3272
3260
3273
3261
The check command or bzr developers may sometimes advise you to run
3274
3262
this command. When the default format has changed you may also be warned
3292
3280
3293
3281
3294
3282
class cmd_whoami(Command):
3295
__doc__ = """Show or set bzr user id.
3283
"""Show or set bzr user id.
3296
3284
3297
3285
:Examples:
3298
3286
Show the email of the current user::
3342
3330
3343
3331
3344
3332
class cmd_nick(Command):
3345
__doc__ = """Print or set the branch nickname.
3333
"""Print or set the branch nickname.
3346
3334
3347
3335
If unset, the tree root directory name is used as the nickname.
3348
3336
To print the current nickname, execute with no argument.
3366
3354
3367
3355
3368
3356
class cmd_alias(Command):
3369
__doc__ = """Set/unset and display aliases.
3357
"""Set/unset and display aliases.
3370
3358
3371
3359
:Examples:
3372
3360
Show the current aliases::
3436
3424
3437
3425
3438
3426
class cmd_selftest(Command):
3439
__doc__ = """Run internal test suite.
3427
"""Run internal test suite.
3440
3428
3441
3429
If arguments are given, they are regular expressions that say which tests
3442
3430
should run. Tests matching any expression are run, and other tests are
3583
3571
raise errors.BzrCommandError("subunit not available. subunit "
3584
3572
"needs to be installed to use --subunit.")
3585
3573
self.additional_selftest_args['runner_class'] = SubUnitBzrRunner
3586
# On Windows, disable automatic conversion of '\n' to '\r\n' in
3587
# stdout, which would corrupt the subunit stream.
3588
if sys.platform == "win32" and sys.stdout.fileno() >= 0:
3589
import msvcrt
3590
msvcrt.setmode(sys.stdout.fileno(), os.O_BINARY)
3591
3574
if parallel:
3592
3575
self.additional_selftest_args.setdefault(
3593
3576
'suite_decorators', []).append(parallel)
3624
3607
3625
3608
3626
3609
class cmd_version(Command):
3627
__doc__ = """Show version of bzr."""
3610
"""Show version of bzr."""
3628
3611
3629
3612
encoding_type = 'replace'
3630
3613
takes_options = [
3641
3624
3642
3625
3643
3626
class cmd_rocks(Command):
3644
__doc__ = """Statement of optimism."""
3627
"""Statement of optimism."""
3645
3628
3646
3629
hidden = True
3647
3630
3651
3634
3652
3635
3653
3636
class cmd_find_merge_base(Command):
3654
__doc__ = """Find and print a base revision for merging two branches."""
3637
"""Find and print a base revision for merging two branches."""
3655
3638
# TODO: Options to specify revisions on either side, as if
3656
3639
# merging only part of the history.
3657
3640
takes_args = ['branch', 'other']
3663
3646
3664
3647
branch1 = Branch.open_containing(branch)[0]
3665
3648
branch2 = Branch.open_containing(other)[0]
3666
self.add_cleanup(branch1.lock_read().unlock)
3667
self.add_cleanup(branch2.lock_read().unlock)
3649
branch1.lock_read()
3650
self.add_cleanup(branch1.unlock)
3651
branch2.lock_read()
3652
self.add_cleanup(branch2.unlock)
3668
3653
last1 = ensure_null(branch1.last_revision())
3669
3654
last2 = ensure_null(branch2.last_revision())
3670
3655
3675
3660
3676
3661
3677
3662
class cmd_merge(Command):
3678
__doc__ = """Perform a three-way merge.
3663
"""Perform a three-way merge.
3679
3664
3680
3665
The source of the merge can be specified either in the form of a branch,
3681
3666
or in the form of a path to a file containing a merge directive generated
3808
3793
unversioned_filter=tree.is_ignored, view_info=view_info)
3809
3794
pb = ui.ui_factory.nested_progress_bar()
3810
3795
self.add_cleanup(pb.finished)
3811
self.add_cleanup(tree.lock_write().unlock)
3796
tree.lock_write()
3797
self.add_cleanup(tree.unlock)
3812
3798
if location is not None:
3813
3799
try:
3814
3800
mergeable = bundle.read_mergeable_from_url(location,
4035
4021
4036
4022
4037
4023
class cmd_remerge(Command):
4038
__doc__ = """Redo a merge.
4024
"""Redo a merge.
4039
4025
4040
4026
Use this if you want to try a different merge technique while resolving
4041
4027
conflicts. Some merge techniques are better than others, and remerge
4066
4052
4067
4053
def run(self, file_list=None, merge_type=None, show_base=False,
4068
4054
reprocess=False):
4069
from bzrlib.conflicts import restore
4070
4055
if merge_type is None:
4071
4056
merge_type = _mod_merge.Merge3Merger
4072
4057
tree, file_list = tree_files(file_list)
4073
self.add_cleanup(tree.lock_write().unlock)
4058
tree.lock_write()
4059
self.add_cleanup(tree.unlock)
4074
4060
parents = tree.get_parent_ids()
4075
4061
if len(parents) != 2:
4076
4062
raise errors.BzrCommandError("Sorry, remerge only works after normal"
4129
4115
4130
4116
4131
4117
class cmd_revert(Command):
4132
__doc__ = """Revert files to a previous revision.
4118
"""Revert files to a previous revision.
4133
4119
4134
4120
Giving a list of files will revert only those files. Otherwise, all files
4135
4121
will be reverted. If the revision is not specified with '--revision', the
4186
4172
def run(self, revision=None, no_backup=False, file_list=None,
4187
4173
forget_merges=None):
4188
4174
tree, file_list = tree_files(file_list)
4189
self.add_cleanup(tree.lock_tree_write().unlock)
4175
tree.lock_write()
4176
self.add_cleanup(tree.unlock)
4190
4177
if forget_merges:
4191
4178
tree.set_parent_ids(tree.get_parent_ids()[:1])
4192
4179
else:
4200
4187
4201
4188
4202
4189
class cmd_assert_fail(Command):
4203
__doc__ = """Test reporting of assertion failures"""
4190
"""Test reporting of assertion failures"""
4204
4191
# intended just for use in testing
4205
4192
4206
4193
hidden = True
4210
4197
4211
4198
4212
4199
class cmd_help(Command):
4213
__doc__ = """Show help on a command or other topic.
4200
"""Show help on a command or other topic.
4214
4201
"""
4215
4202
4216
4203
_see_also = ['topics']
4229
4216
4230
4217
4231
4218
class cmd_shell_complete(Command):
4232
__doc__ = """Show appropriate completions for context.
4219
"""Show appropriate completions for context.
4233
4220
4234
4221
For a list of all available commands, say 'bzr shell-complete'.
4235
4222
"""
4244
4231
4245
4232
4246
4233
class cmd_missing(Command):
4247
__doc__ = """Show unmerged/unpulled revisions between two branches.
4234
"""Show unmerged/unpulled revisions between two branches.
4248
4235
4249
4236
OTHER_BRANCH may be local or remote.
4250
4237
4328
4315
restrict = 'remote'
4329
4316
4330
4317
local_branch = Branch.open_containing(u".")[0]
4331
self.add_cleanup(local_branch.lock_read().unlock)
4332
4333
4318
parent = local_branch.get_parent()
4334
4319
if other_branch is None:
4335
4320
other_branch = parent
4344
4329
remote_branch = Branch.open(other_branch)
4345
4330
if remote_branch.base == local_branch.base:
4346
4331
remote_branch = local_branch
4347
else:
4348
self.add_cleanup(remote_branch.lock_read().unlock)
4349
4332
4333
local_branch.lock_read()
4334
self.add_cleanup(local_branch.unlock)
4350
4335
local_revid_range = _revision_range_to_revid_range(
4351
4336
_get_revision_range(my_revision, local_branch,
4352
4337
self.name()))
4353
4338
4339
remote_branch.lock_read()
4340
self.add_cleanup(remote_branch.unlock)
4354
4341
remote_revid_range = _revision_range_to_revid_range(
4355
4342
_get_revision_range(revision,
4356
4343
remote_branch, self.name()))
4406
4393
message("Branches are up to date.\n")
4407
4394
self.cleanup_now()
4408
4395
if not status_code and parent is None and other_branch is not None:
4409
self.add_cleanup(local_branch.lock_write().unlock)
4396
local_branch.lock_write()
4397
self.add_cleanup(local_branch.unlock)
4410
4398
# handle race conditions - a parent might be set while we run.
4411
4399
if local_branch.get_parent() is None:
4412
4400
local_branch.set_parent(remote_branch.base)
4414
4402
4415
4403
4416
4404
class cmd_pack(Command):
4417
__doc__ = """Compress the data within a repository.
4418
4419
This operation compresses the data within a bazaar repository. As
4420
bazaar supports automatic packing of repository, this operation is
4421
normally not required to be done manually.
4422
4423
During the pack operation, bazaar takes a backup of existing repository
4424
data, i.e. pack files. This backup is eventually removed by bazaar
4425
automatically when it is safe to do so. To save disk space by removing
4426
the backed up pack files, the --clean-obsolete-packs option may be
4427
used.
4428
4429
Warning: If you use --clean-obsolete-packs and your machine crashes
4430
during or immediately after repacking, you may be left with a state
4431
where the deletion has been written to disk but the new packs have not
4432
been. In this case the repository may be unusable.
4433
"""
4405
"""Compress the data within a repository."""
4434
4406
4435
4407
_see_also = ['repositories']
4436
4408
takes_args = ['branch_or_repo?']
4437
takes_options = [
4438
Option('clean-obsolete-packs', 'Delete obsolete packs to save disk space.'),
4439
]
4440
4409
4441
def run(self, branch_or_repo='.', clean_obsolete_packs=False):
4410
def run(self, branch_or_repo='.'):
4442
4411
dir = bzrdir.BzrDir.open_containing(branch_or_repo)[0]
4443
4412
try:
4444
4413
branch = dir.open_branch()
4445
4414
repository = branch.repository
4446
4415
except errors.NotBranchError:
4447
4416
repository = dir.open_repository()
4448
repository.pack(clean_obsolete_packs=clean_obsolete_packs)
4417
repository.pack()
4449
4418
4450
4419
4451
4420
class cmd_plugins(Command):
4452
__doc__ = """List the installed plugins.
4421
"""List the installed plugins.
4453
4422
4454
4423
This command displays the list of installed plugins including
4455
4424
version of plugin and a short description of each.
4494
4463
4495
4464
4496
4465
class cmd_testament(Command):
4497
__doc__ = """Show testament (signing-form) of a revision."""
4466
"""Show testament (signing-form) of a revision."""
4498
4467
takes_options = [
4499
4468
'revision',
4500
4469
Option('long', help='Produce long-format testament.'),
4512
4481
b = Branch.open_containing(branch)[0]
4513
4482
else:
4514
4483
b = Branch.open(branch)
4515
self.add_cleanup(b.lock_read().unlock)
4484
b.lock_read()
4485
self.add_cleanup(b.unlock)
4516
4486
if revision is None:
4517
4487
rev_id = b.last_revision()
4518
4488
else:
4525
4495
4526
4496
4527
4497
class cmd_annotate(Command):
4528
__doc__ = """Show the origin of each line in a file.
4498
"""Show the origin of each line in a file.
4529
4499
4530
4500
This prints out the given file with an annotation on the left side
4531
4501
indicating which revision, author and date introduced the change.
4552
4522
wt, branch, relpath = \
4553
4523
bzrdir.BzrDir.open_containing_tree_or_branch(filename)
4554
4524
if wt is not None:
4555
self.add_cleanup(wt.lock_read().unlock)
4525
wt.lock_read()
4526
self.add_cleanup(wt.unlock)
4556
4527
else:
4557
self.add_cleanup(branch.lock_read().unlock)
4528
branch.lock_read()
4529
self.add_cleanup(branch.unlock)
4558
4530
tree = _get_one_revision_tree('annotate', revision, branch=branch)
4559
self.add_cleanup(tree.lock_read().unlock)
4531
tree.lock_read()
4532
self.add_cleanup(tree.unlock)
4560
4533
if wt is not None:
4561
4534
file_id = wt.path2id(relpath)
4562
4535
else:
4575
4548
4576
4549
4577
4550
class cmd_re_sign(Command):
4578
__doc__ = """Create a digital signature for an existing revision."""
4551
"""Create a digital signature for an existing revision."""
4579
4552
# TODO be able to replace existing ones.
4580
4553
4581
4554
hidden = True # is this right ?
4588
4561
if revision_id_list is None and revision is None:
4589
4562
raise errors.BzrCommandError('You must supply either --revision or a revision_id')
4590
4563
b = WorkingTree.open_containing(u'.')[0].branch
4591
self.add_cleanup(b.lock_write().unlock)
4564
b.lock_write()
4565
self.add_cleanup(b.unlock)
4592
4566
return self._run(b, revision_id_list, revision)
4593
4567
4594
4568
def _run(self, b, revision_id_list, revision):
4640
4614
4641
4615
4642
4616
class cmd_bind(Command):
4643
__doc__ = """Convert the current branch into a checkout of the supplied branch.
4644
If no branch is supplied, rebind to the last bound location.
4617
"""Convert the current branch into a checkout of the supplied branch.
4645
4618
4646
4619
Once converted into a checkout, commits must succeed on the master branch
4647
4620
before they will be applied to the local branch.
4681
4654
4682
4655
4683
4656
class cmd_unbind(Command):
4684
__doc__ = """Convert the current checkout into a regular branch.
4657
"""Convert the current checkout into a regular branch.
4685
4658
4686
4659
After unbinding, the local branch is considered independent and subsequent
4687
4660
commits will be local only.
4698
4671
4699
4672
4700
4673
class cmd_uncommit(Command):
4701
__doc__ = """Remove the last committed revision.
4674
"""Remove the last committed revision.
4702
4675
4703
4676
--verbose will print out what is being removed.
4704
4677
--dry-run will go through all the motions, but not actually
4744
4717
b = control.open_branch()
4745
4718
4746
4719
if tree is not None:
4747
self.add_cleanup(tree.lock_write().unlock)
4720
tree.lock_write()
4721
self.add_cleanup(tree.unlock)
4748
4722
else:
4749
self.add_cleanup(b.lock_write().unlock)
4723
b.lock_write()
4724
self.add_cleanup(b.unlock)
4750
4725
return self._run(b, tree, dry_run, verbose, revision, force, local=local)
4751
4726
4752
4727
def _run(self, b, tree, dry_run, verbose, revision, force, local=False):
4804
4779
4805
4780
4806
4781
class cmd_break_lock(Command):
4807
__doc__ = """Break a dead lock on a repository, branch or working directory.
4782
"""Break a dead lock on a repository, branch or working directory.
4808
4783
4809
4784
CAUTION: Locks should only be broken when you are sure that the process
4810
4785
holding the lock has been stopped.
4829
4804
4830
4805
4831
4806
class cmd_wait_until_signalled(Command):
4832
__doc__ = """Test helper for test_start_and_stop_bzr_subprocess_send_signal.
4807
"""Test helper for test_start_and_stop_bzr_subprocess_send_signal.
4833
4808
4834
4809
This just prints a line to signal when it is ready, then blocks on stdin.
4835
4810
"""
4843
4818
4844
4819
4845
4820
class cmd_serve(Command):
4846
__doc__ = """Run the bzr server."""
4821
"""Run the bzr server."""
4847
4822
4848
4823
aliases = ['server']
4849
4824
4909
4884
4910
4885
4911
4886
class cmd_join(Command):
4912
__doc__ = """Combine a tree into its containing tree.
4887
"""Combine a tree into its containing tree.
4913
4888
4914
4889
This command requires the target tree to be in a rich-root format.
4915
4890
4955
4930
4956
4931
4957
4932
class cmd_split(Command):
4958
__doc__ = """Split a subdirectory of a tree into a separate tree.
4933
"""Split a subdirectory of a tree into a separate tree.
4959
4934
4960
4935
This command will produce a target tree in a format that supports
4961
4936
rich roots, like 'rich-root' or 'rich-root-pack'. These formats cannot be
4981
4956
4982
4957
4983
4958
class cmd_merge_directive(Command):
4984
__doc__ = """Generate a merge directive for auto-merge tools.
4959
"""Generate a merge directive for auto-merge tools.
4985
4960
4986
4961
A directive requests a merge to be performed, and also provides all the
4987
4962
information necessary to do so. This means it must either include a
5080
5055
5081
5056
5082
5057
class cmd_send(Command):
5083
__doc__ = """Mail or create a merge-directive for submitting changes.
5058
"""Mail or create a merge-directive for submitting changes.
5084
5059
5085
5060
A merge directive provides many things needed for requesting merges:
5086
5061
5197
5172
5198
5173
5199
5174
class cmd_bundle_revisions(cmd_send):
5200
__doc__ = """Create a merge-directive for submitting changes.
5175
"""Create a merge-directive for submitting changes.
5201
5176
5202
5177
A merge directive provides many things needed for requesting merges:
5203
5178
5270
5245
5271
5246
5272
5247
class cmd_tag(Command):
5273
__doc__ = """Create, remove or modify a tag naming a revision.
5248
"""Create, remove or modify a tag naming a revision.
5274
5249
5275
5250
Tags give human-meaningful names to revisions. Commands that take a -r
5276
5251
(--revision) option can be given -rtag:X, where X is any previously
5284
5259
5285
5260
To rename a tag (change the name but keep it on the same revsion), run ``bzr
5286
5261
tag new-name -r tag:old-name`` and then ``bzr tag --delete oldname``.
5287
5288
If no tag name is specified it will be determined through the
5289
'automatic_tag_name' hook. This can e.g. be used to automatically tag
5290
upstream releases by reading configure.ac. See ``bzr help hooks`` for
5291
details.
5292
5262
"""
5293
5263
5294
5264
_see_also = ['commit', 'tags']
5295
takes_args = ['tag_name?']
5265
takes_args = ['tag_name']
5296
5266
takes_options = [
5297
5267
Option('delete',
5298
5268
help='Delete this tag rather than placing it.',
5308
5278
'revision',
5309
5279
]
5310
5280
5311
def run(self, tag_name=None,
5281
def run(self, tag_name,
5312
5282
delete=None,
5313
5283
directory='.',
5314
5284
force=None,
5315
5285
revision=None,
5316
5286
):
5317
5287
branch, relpath = Branch.open_containing(directory)
5318
self.add_cleanup(branch.lock_write().unlock)
5288
branch.lock_write()
5289
self.add_cleanup(branch.unlock)
5319
5290
if delete:
5320
if tag_name is None:
5321
raise errors.BzrCommandError("No tag specified to delete.")
5322
5291
branch.tags.delete_tag(tag_name)
5323
5292
self.outf.write('Deleted tag %s.\n' % tag_name)
5324
5293
else:
5330
5299
revision_id = revision[0].as_revision_id(branch)
5331
5300
else:
5332
5301
revision_id = branch.last_revision()
5333
if tag_name is None:
5334
tag_name = branch.automatic_tag_name(revision_id)
5335
if tag_name is None:
5336
raise errors.BzrCommandError(
5337
"Please specify a tag name.")
5338
5302
if (not force) and branch.tags.has_tag(tag_name):
5339
5303
raise errors.TagAlreadyExists(tag_name)
5340
5304
branch.tags.set_tag(tag_name, revision_id)
5342
5306
5343
5307
5344
5308
class cmd_tags(Command):
5345
__doc__ = """List tags.
5309
"""List tags.
5346
5310
5347
5311
This command shows a table of tag names and the revisions they reference.
5348
5312
"""
5376
5340
if not tags:
5377
5341
return
5378
5342
5379
self.add_cleanup(branch.lock_read().unlock)
5343
branch.lock_read()
5344
self.add_cleanup(branch.unlock)
5380
5345
if revision:
5381
5346
graph = branch.repository.get_graph()
5382
5347
rev1, rev2 = _get_revision_range(revision, branch, self.name())
5415
5380
5416
5381
5417
5382
class cmd_reconfigure(Command):
5418
__doc__ = """Reconfigure the type of a bzr directory.
5383
"""Reconfigure the type of a bzr directory.
5419
5384
5420
5385
A target configuration must be specified.
5421
5386
5506
5471
5507
5472
5508
5473
class cmd_switch(Command):
5509
__doc__ = """Set the branch of a checkout and update.
5474
"""Set the branch of a checkout and update.
5510
5475
5511
5476
For lightweight checkouts, this changes the branch being referenced.
5512
5477
For heavyweight checkouts, this checks that there are no local commits
5602
5567
5603
5568
5604
5569
class cmd_view(Command):
5605
__doc__ = """Manage filtered views.
5570
"""Manage filtered views.
5606
5571
5607
5572
Views provide a mask over the tree so that users can focus on
5608
5573
a subset of a tree when doing their work. After creating a view,
5756
5721
5757
5722
5758
5723
class cmd_hooks(Command):
5759
__doc__ = """Show hooks."""
5724
"""Show hooks."""
5760
5725
5761
5726
hidden = True
5762
5727
5775
5740
self.outf.write(" <no hooks installed>\n")
5776
5741
5777
5742
5778
class cmd_remove_branch(Command):
5779
__doc__ = """Remove a branch.
5780
5781
This will remove the branch from the specified location but
5782
will keep any working tree or repository in place.
5783
5784
:Examples:
5785
5786
Remove the branch at repo/trunk::
5787
5788
bzr remove-branch repo/trunk
5789
5790
"""
5791
5792
takes_args = ["location?"]
5793
5794
aliases = ["rmbranch"]
5795
5796
def run(self, location=None):
5797
if location is None:
5798
location = "."
5799
branch = Branch.open_containing(location)[0]
5800
branch.bzrdir.destroy_branch()
5801
5802
5803
5743
class cmd_shelve(Command):
5804
__doc__ = """Temporarily set aside some changes from the current tree.
5744
"""Temporarily set aside some changes from the current tree.
5805
5745
5806
5746
Shelve allows you to temporarily put changes you've made "on the shelf",
5807
5747
ie. out of the way, until a later time when you can bring them back from
5860
5800
5861
5801
def run_for_list(self):
5862
5802
tree = WorkingTree.open_containing('.')[0]
5863
self.add_cleanup(tree.lock_read().unlock)
5803
tree.lock_read()
5804
self.add_cleanup(tree.unlock)
5864
5805
manager = tree.get_shelf_manager()
5865
5806
shelves = manager.active_shelves()
5866
5807
if len(shelves) == 0:
5875
5816
5876
5817
5877
5818
class cmd_unshelve(Command):
5878
__doc__ = """Restore shelved changes.
5819
"""Restore shelved changes.
5879
5820
5880
5821
By default, the most recently shelved changes are restored. However if you
5881
5822
specify a shelf by id those changes will be restored instead. This works
5907
5848
5908
5849
5909
5850
class cmd_clean_tree(Command):
5910
__doc__ = """Remove unwanted files from working tree.
5851
"""Remove unwanted files from working tree.
5911
5852
5912
5853
By default, only unknown files, not ignored files, are deleted. Versioned
5913
5854
files are never deleted.
5941
5882
5942
5883
5943
5884
class cmd_reference(Command):
5944
__doc__ = """list, view and set branch locations for nested trees.
5885
"""list, view and set branch locations for nested trees.
5945
5886
5946
5887
If no arguments are provided, lists the branch locations for nested trees.
5947
5888
If one argument is provided, display the branch location for that tree.
5987
5928
self.outf.write('%s %s\n' % (path, location))
5988
5929
5989
5930
5990
def _register_lazy_builtins():
5991
# register lazy builtins from other modules; called at startup and should
5992
# be only called once.
5993
for (name, aliases, module_name) in [
5994
('cmd_bundle_info', [], 'bzrlib.bundle.commands'),
5995
('cmd_dpush', [], 'bzrlib.foreign'),
5996
('cmd_version_info', [], 'bzrlib.cmd_version_info'),
5997
('cmd_resolve', ['resolved'], 'bzrlib.conflicts'),
5998
('cmd_conflicts', [], 'bzrlib.conflicts'),
5999
('cmd_sign_my_commits', [], 'bzrlib.sign_my_commits'),
6000
]:
6001
builtin_command_registry.register_lazy(name, aliases, module_name)
5931
# these get imported and then picked up by the scan for cmd_*
5932
# TODO: Some more consistent way to split command definitions across files;
5933
# we do need to load at least some information about them to know of
5934
# aliases. ideally we would avoid loading the implementation until the
5935
# details were needed.
5936
from bzrlib.cmd_version_info import cmd_version_info
5937
from bzrlib.conflicts import cmd_resolve, cmd_conflicts, restore
5938
from bzrlib.bundle.commands import (
5939
cmd_bundle_info,
5940
)
5941
from bzrlib.foreign import cmd_dpush
5942
from bzrlib.sign_my_commits import cmd_sign_my_commits
Loggerhead is a web-based interface for Breezy
Version: 2.0.1