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 5133
- compare with another revision
- download diff
- download tarball
- view history from revision 5133
- Committer: Canonical.com Patch Queue Manager
- Date: 2010-04-06 06:59:03 UTC
- mfrom: (5051.5.1 subunit)
- Revision ID: pqm@pqm.ubuntu.com-20100406065903-y9dxgwmog1pmw7dz
Use subunit when running tests in PQM.
- files removed:
- bzrlib/tests/commands/test_revert.py
- bzrlib/tests/per_bzrdir_colo
- files renamed:
- apport/ => contrib/apport/
- apport/bzr-crashdb.conf => contrib/apport/bzr.conf
- files modified:
- NEWS
added
removed
bzrlib/builtins.py
239
239
# opens the branch?)
240
240
241
241
class cmd_status(Command):
242
__doc__ = """Display status summary.
242
"""Display status summary.
243
243
244
244
This reports on versioned and unknown files, reporting them
245
245
grouped by state. Possible states are:
332
332
333
333
334
334
class cmd_cat_revision(Command):
335
__doc__ = """Write out metadata for a revision.
335
"""Write out metadata for a revision.
336
336
337
337
The revision to print can either be specified by a specific
338
338
revision identifier, or you can use --revision.
390
390
391
391
392
392
class cmd_dump_btree(Command):
393
__doc__ = """Dump the contents of a btree index file to stdout.
393
"""Dump the contents of a btree index file to stdout.
394
394
395
395
PATH is a btree index file, it can be any URL. This includes things like
396
396
.bzr/repository/pack-names, or .bzr/repository/indices/a34b3a...ca4a4.iix
471
471
472
472
473
473
class cmd_remove_tree(Command):
474
__doc__ = """Remove the working tree from a given branch/checkout.
474
"""Remove the working tree from a given branch/checkout.
475
475
476
476
Since a lightweight checkout is little more than a working tree
477
477
this will refuse to run against one.
504
504
if (working.has_changes()):
505
505
raise errors.UncommittedChanges(working)
506
506
507
if working.user_url != working.branch.user_url:
507
working_path = working.bzrdir.root_transport.base
508
branch_path = working.branch.bzrdir.root_transport.base
509
if working_path != branch_path:
508
510
raise errors.BzrCommandError("You cannot remove the working tree"
509
511
" from a lightweight checkout")
510
512
512
514
513
515
514
516
class cmd_revno(Command):
515
__doc__ = """Show current revision number.
517
"""Show current revision number.
516
518
517
519
This is equal to the number of revisions on this branch.
518
520
"""
528
530
if tree:
529
531
try:
530
532
wt = WorkingTree.open_containing(location)[0]
531
self.add_cleanup(wt.lock_read().unlock)
533
wt.lock_read()
532
534
except (errors.NoWorkingTree, errors.NotLocalUrl):
533
535
raise errors.NoWorkingTree(location)
536
self.add_cleanup(wt.unlock)
534
537
revid = wt.last_revision()
535
538
try:
536
539
revno_t = wt.branch.revision_id_to_dotted_revno(revid)
539
542
revno = ".".join(str(n) for n in revno_t)
540
543
else:
541
544
b = Branch.open_containing(location)[0]
542
self.add_cleanup(b.lock_read().unlock)
545
b.lock_read()
546
self.add_cleanup(b.unlock)
543
547
revno = b.revno()
544
548
self.cleanup_now()
545
549
self.outf.write(str(revno) + '\n')
546
550
547
551
548
552
class cmd_revision_info(Command):
549
__doc__ = """Show revision number and revision id for a given revision identifier.
553
"""Show revision number and revision id for a given revision identifier.
550
554
"""
551
555
hidden = True
552
556
takes_args = ['revision_info*']
568
572
try:
569
573
wt = WorkingTree.open_containing(directory)[0]
570
574
b = wt.branch
571
self.add_cleanup(wt.lock_read().unlock)
575
wt.lock_read()
576
self.add_cleanup(wt.unlock)
572
577
except (errors.NoWorkingTree, errors.NotLocalUrl):
573
578
wt = None
574
579
b = Branch.open_containing(directory)[0]
575
self.add_cleanup(b.lock_read().unlock)
580
b.lock_read()
581
self.add_cleanup(b.unlock)
576
582
revision_ids = []
577
583
if revision is not None:
578
584
revision_ids.extend(rev.as_revision_id(b) for rev in revision)
606
612
607
613
608
614
class cmd_add(Command):
609
__doc__ = """Add specified files or directories.
615
"""Add specified files or directories.
610
616
611
617
In non-recursive mode, all the named items are added, regardless
612
618
of whether they were previously ignored. A warning is given if
677
683
should_print=(not is_quiet()))
678
684
679
685
if base_tree:
680
self.add_cleanup(base_tree.lock_read().unlock)
686
base_tree.lock_read()
687
self.add_cleanup(base_tree.unlock)
681
688
tree, file_list = tree_files_for_add(file_list)
682
689
added, ignored = tree.smart_add(file_list, not
683
690
no_recurse, action=action, save=not dry_run)
691
698
692
699
693
700
class cmd_mkdir(Command):
694
__doc__ = """Create a new versioned directory.
701
"""Create a new versioned directory.
695
702
696
703
This is equivalent to creating the directory and then adding it.
697
704
"""
713
720
714
721
715
722
class cmd_relpath(Command):
716
__doc__ = """Show path of a file relative to root"""
723
"""Show path of a file relative to root"""
717
724
718
725
takes_args = ['filename']
719
726
hidden = True
728
735
729
736
730
737
class cmd_inventory(Command):
731
__doc__ = """Show inventory of the current working copy or a revision.
738
"""Show inventory of the current working copy or a revision.
732
739
733
740
It is possible to limit the output to a particular entry
734
741
type using the --kind option. For example: --kind file.
755
762
756
763
revision = _get_one_revision('inventory', revision)
757
764
work_tree, file_list = tree_files(file_list)
758
self.add_cleanup(work_tree.lock_read().unlock)
765
work_tree.lock_read()
766
self.add_cleanup(work_tree.unlock)
759
767
if revision is not None:
760
768
tree = revision.as_tree(work_tree.branch)
761
769
762
770
extra_trees = [work_tree]
763
self.add_cleanup(tree.lock_read().unlock)
771
tree.lock_read()
772
self.add_cleanup(tree.unlock)
764
773
else:
765
774
tree = work_tree
766
775
extra_trees = []
787
796
788
797
789
798
class cmd_mv(Command):
790
__doc__ = """Move or rename a file.
799
"""Move or rename a file.
791
800
792
801
:Usage:
793
802
bzr mv OLDNAME NEWNAME
826
835
if len(names_list) < 2:
827
836
raise errors.BzrCommandError("missing file argument")
828
837
tree, rel_names = tree_files(names_list, canonicalize=False)
829
self.add_cleanup(tree.lock_tree_write().unlock)
838
tree.lock_tree_write()
839
self.add_cleanup(tree.unlock)
830
840
self._run(tree, names_list, rel_names, after)
831
841
832
842
def run_auto(self, names_list, after, dry_run):
837
847
raise errors.BzrCommandError('--after cannot be specified with'
838
848
' --auto.')
839
849
work_tree, file_list = tree_files(names_list, default_branch='.')
840
self.add_cleanup(work_tree.lock_tree_write().unlock)
850
work_tree.lock_tree_write()
851
self.add_cleanup(work_tree.unlock)
841
852
rename_map.RenameMap.guess_renames(work_tree, dry_run)
842
853
843
854
def _run(self, tree, names_list, rel_names, after):
922
933
923
934
924
935
class cmd_pull(Command):
925
__doc__ = """Turn this branch into a mirror of another branch.
936
"""Turn this branch into a mirror of another branch.
926
937
927
938
By default, this command only works on branches that have not diverged.
928
939
Branches are considered diverged if the destination branch's most recent
977
988
try:
978
989
tree_to = WorkingTree.open_containing(directory)[0]
979
990
branch_to = tree_to.branch
980
self.add_cleanup(tree_to.lock_write().unlock)
981
991
except errors.NoWorkingTree:
982
992
tree_to = None
983
993
branch_to = Branch.open_containing(directory)[0]
984
self.add_cleanup(branch_to.lock_write().unlock)
985
994
986
995
if local and not branch_to.get_bound_location():
987
996
raise errors.LocalRequiresBoundBranch()
988
997
1018
1027
else:
1019
1028
branch_from = Branch.open(location,
1020
1029
possible_transports=possible_transports)
1021
self.add_cleanup(branch_from.lock_read().unlock)
1022
1030
1023
1031
if branch_to.get_parent() is None or remember:
1024
1032
branch_to.set_parent(branch_from.base)
1025
1033
1034
if branch_from is not branch_to:
1035
branch_from.lock_read()
1036
self.add_cleanup(branch_from.unlock)
1026
1037
if revision is not None:
1027
1038
revision_id = revision.as_revision_id(branch_from)
1028
1039
1040
branch_to.lock_write()
1041
self.add_cleanup(branch_to.unlock)
1029
1042
if tree_to is not None:
1030
1043
view_info = _get_view_info_for_change_reporter(tree_to)
1031
1044
change_reporter = delta._ChangeReporter(
1046
1059
1047
1060
1048
1061
class cmd_push(Command):
1049
__doc__ = """Update a mirror of this branch.
1062
"""Update a mirror of this branch.
1050
1063
1051
1064
The target branch will not have its working tree populated because this
1052
1065
is both expensive, and is not supported on remote file systems.
1113
1126
# Get the source branch
1114
1127
(tree, br_from,
1115
1128
_unused) = bzrdir.BzrDir.open_containing_tree_or_branch(directory)
1129
if strict is None:
1130
strict = br_from.get_config().get_user_option_as_bool('push_strict')
1131
if strict is None: strict = True # default value
1116
1132
# Get the tip's revision_id
1117
1133
revision = _get_one_revision('push', revision)
1118
1134
if revision is not None:
1119
1135
revision_id = revision.in_history(br_from).rev_id
1120
1136
else:
1121
1137
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.')
1138
if strict and tree is not None and revision_id is None:
1139
if (tree.has_changes()):
1140
raise errors.UncommittedChanges(
1141
tree, more='Use --no-strict to force the push.')
1142
if tree.last_revision() != tree.branch.last_revision():
1143
# The tree has lost sync with its branch, there is little
1144
# chance that the user is aware of it but he can still force
1145
# the push with --no-strict
1146
raise errors.OutOfDateTree(
1147
tree, more='Use --no-strict to force the push.')
1148
1127
1149
# Get the stacked_on branch, if any
1128
1150
if stacked_on is not None:
1129
1151
stacked_on = urlutils.normalize_url(stacked_on)
1161
1183
1162
1184
1163
1185
class cmd_branch(Command):
1164
__doc__ = """Create a new branch that is a copy of an existing branch.
1186
"""Create a new branch that is a copy of an existing branch.
1165
1187
1166
1188
If the TO_LOCATION is omitted, the last component of the FROM_LOCATION will
1167
1189
be used. In other words, "branch ../foo/bar" will attempt to create ./bar.
1207
1229
accelerator_tree, br_from = bzrdir.BzrDir.open_tree_or_branch(
1208
1230
from_location)
1209
1231
revision = _get_one_revision('branch', revision)
1210
self.add_cleanup(br_from.lock_read().unlock)
1232
br_from.lock_read()
1233
self.add_cleanup(br_from.unlock)
1211
1234
if revision is not None:
1212
1235
revision_id = revision.as_revision_id(br_from)
1213
1236
else:
1273
1296
1274
1297
1275
1298
class cmd_checkout(Command):
1276
__doc__ = """Create a new checkout of an existing branch.
1299
"""Create a new checkout of an existing branch.
1277
1300
1278
1301
If BRANCH_LOCATION is omitted, checkout will reconstitute a working tree for
1279
1302
the branch found in '.'. This is useful if you have removed the working tree
1342
1365
1343
1366
1344
1367
class cmd_renames(Command):
1345
__doc__ = """Show list of renamed files.
1368
"""Show list of renamed files.
1346
1369
"""
1347
1370
# TODO: Option to show renames between two historical versions.
1348
1371
1353
1376
@display_command
1354
1377
def run(self, dir=u'.'):
1355
1378
tree = WorkingTree.open_containing(dir)[0]
1356
self.add_cleanup(tree.lock_read().unlock)
1379
tree.lock_read()
1380
self.add_cleanup(tree.unlock)
1357
1381
new_inv = tree.inventory
1358
1382
old_tree = tree.basis_tree()
1359
self.add_cleanup(old_tree.lock_read().unlock)
1383
old_tree.lock_read()
1384
self.add_cleanup(old_tree.unlock)
1360
1385
old_inv = old_tree.inventory
1361
1386
renames = []
1362
1387
iterator = tree.iter_changes(old_tree, include_unchanged=True)
1372
1397
1373
1398
1374
1399
class cmd_update(Command):
1375
__doc__ = """Update a tree to have the latest code committed to its branch.
1400
"""Update a tree to have the latest code committed to its branch.
1376
1401
1377
1402
This will perform a merge into the working tree, and may generate
1378
1403
conflicts. If you have any local changes, you will still
1400
1425
master = branch.get_master_branch(
1401
1426
possible_transports=possible_transports)
1402
1427
if master is not None:
1428
tree.lock_write()
1403
1429
branch_location = master.base
1404
tree.lock_write()
1405
1430
else:
1431
tree.lock_tree_write()
1406
1432
branch_location = tree.branch.base
1407
tree.lock_tree_write()
1408
1433
self.add_cleanup(tree.unlock)
1409
1434
# get rid of the final '/' and be ready for display
1410
1435
branch_location = urlutils.unescape_for_display(
1423
1448
else:
1424
1449
revision_id = branch.last_revision()
1425
1450
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))
1451
revno = branch.revision_id_to_revno(revision_id)
1452
note("Tree is up to date at revision %d of branch %s" %
1453
(revno, branch_location))
1429
1454
return 0
1430
1455
view_info = _get_view_info_for_change_reporter(tree)
1431
1456
change_reporter = delta._ChangeReporter(
1443
1468
"bzr update --revision only works"
1444
1469
" for a revision in the branch history"
1445
1470
% (e.revision))
1446
revno = tree.branch.revision_id_to_dotted_revno(
1471
revno = tree.branch.revision_id_to_revno(
1447
1472
_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:
1473
note('Updated to revision %d of branch %s' %
1474
(revno, branch_location))
1475
if tree.get_parent_ids()[1:] != existing_pending_merges:
1452
1476
note('Your local commits will now show as pending merges with '
1453
1477
"'bzr status', and can be committed with 'bzr commit'.")
1454
1478
if conflicts != 0:
1458
1482
1459
1483
1460
1484
class cmd_info(Command):
1461
__doc__ = """Show information about a working tree, branch or repository.
1485
"""Show information about a working tree, branch or repository.
1462
1486
1463
1487
This command will show all known locations and formats associated to the
1464
1488
tree, branch or repository.
1502
1526
1503
1527
1504
1528
class cmd_remove(Command):
1505
__doc__ = """Remove files or directories.
1529
"""Remove files or directories.
1506
1530
1507
1531
This makes bzr stop tracking changes to the specified files. bzr will delete
1508
1532
them if they can easily be recovered using revert. If no options or
1530
1554
if file_list is not None:
1531
1555
file_list = [f for f in file_list]
1532
1556
1533
self.add_cleanup(tree.lock_write().unlock)
1557
tree.lock_write()
1558
self.add_cleanup(tree.unlock)
1534
1559
# Heuristics should probably all move into tree.remove_smart or
1535
1560
# some such?
1536
1561
if new:
1555
1580
1556
1581
1557
1582
class cmd_file_id(Command):
1558
__doc__ = """Print file_id of a particular file or directory.
1583
"""Print file_id of a particular file or directory.
1559
1584
1560
1585
The file_id is assigned when the file is first added and remains the
1561
1586
same through all revisions where the file exists, even when it is
1577
1602
1578
1603
1579
1604
class cmd_file_path(Command):
1580
__doc__ = """Print path of file_ids to a file or directory.
1605
"""Print path of file_ids to a file or directory.
1581
1606
1582
1607
This prints one line for each directory down to the target,
1583
1608
starting at the branch root.
1599
1624
1600
1625
1601
1626
class cmd_reconcile(Command):
1602
__doc__ = """Reconcile bzr metadata in a branch.
1627
"""Reconcile bzr metadata in a branch.
1603
1628
1604
1629
This can correct data mismatches that may have been caused by
1605
1630
previous ghost operations or bzr upgrades. You should only
1627
1652
1628
1653
1629
1654
class cmd_revision_history(Command):
1630
__doc__ = """Display the list of revision ids on a branch."""
1655
"""Display the list of revision ids on a branch."""
1631
1656
1632
1657
_see_also = ['log']
1633
1658
takes_args = ['location?']
1643
1668
1644
1669
1645
1670
class cmd_ancestry(Command):
1646
__doc__ = """List all revisions merged into this branch."""
1671
"""List all revisions merged into this branch."""
1647
1672
1648
1673
_see_also = ['log', 'revision-history']
1649
1674
takes_args = ['location?']
1668
1693
1669
1694
1670
1695
class cmd_init(Command):
1671
__doc__ = """Make a directory into a versioned branch.
1696
"""Make a directory into a versioned branch.
1672
1697
1673
1698
Use this to create an empty branch, or before importing an
1674
1699
existing project.
1777
1802
1778
1803
1779
1804
class cmd_init_repository(Command):
1780
__doc__ = """Create a shared repository for branches to share storage space.
1805
"""Create a shared repository for branches to share storage space.
1781
1806
1782
1807
New branches created under the repository directory will store their
1783
1808
revisions in the repository, not in the branch directory. For branches
1837
1862
1838
1863
1839
1864
class cmd_diff(Command):
1840
__doc__ = """Show differences in the working tree, between revisions or branches.
1865
"""Show differences in the working tree, between revisions or branches.
1841
1866
1842
1867
If no arguments are given, all changes for the current tree are listed.
1843
1868
If files are given, only the changes in those files are listed.
1940
1965
@display_command
1941
1966
def run(self, revision=None, file_list=None, diff_options=None,
1942
1967
prefix=None, old=None, new=None, using=None, format=None):
1943
from bzrlib.diff import (get_trees_and_branches_to_diff_locked,
1968
from bzrlib.diff import (get_trees_and_branches_to_diff,
1944
1969
show_diff_trees)
1945
1970
1946
1971
if (prefix is None) or (prefix == '0'):
1967
1992
1968
1993
(old_tree, new_tree,
1969
1994
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)
1995
specific_files, extra_trees) = get_trees_and_branches_to_diff(
1996
file_list, revision, old, new, apply_view=True)
1972
1997
return show_diff_trees(old_tree, new_tree, sys.stdout,
1973
1998
specific_files=specific_files,
1974
1999
external_diff_options=diff_options,
1978
2003
1979
2004
1980
2005
class cmd_deleted(Command):
1981
__doc__ = """List files deleted in the working tree.
2006
"""List files deleted in the working tree.
1982
2007
"""
1983
2008
# TODO: Show files deleted since a previous revision, or
1984
2009
# between two revisions.
1992
2017
@display_command
1993
2018
def run(self, show_ids=False):
1994
2019
tree = WorkingTree.open_containing(u'.')[0]
1995
self.add_cleanup(tree.lock_read().unlock)
2020
tree.lock_read()
2021
self.add_cleanup(tree.unlock)
1996
2022
old = tree.basis_tree()
1997
self.add_cleanup(old.lock_read().unlock)
2023
old.lock_read()
2024
self.add_cleanup(old.unlock)
1998
2025
for path, ie in old.inventory.iter_entries():
1999
2026
if not tree.has_id(ie.file_id):
2000
2027
self.outf.write(path)
2005
2032
2006
2033
2007
2034
class cmd_modified(Command):
2008
__doc__ = """List files modified in working tree.
2035
"""List files modified in working tree.
2009
2036
"""
2010
2037
2011
2038
hidden = True
2028
2055
2029
2056
2030
2057
class cmd_added(Command):
2031
__doc__ = """List files added in working tree.
2058
"""List files added in working tree.
2032
2059
"""
2033
2060
2034
2061
hidden = True
2042
2069
@display_command
2043
2070
def run(self, null=False):
2044
2071
wt = WorkingTree.open_containing(u'.')[0]
2045
self.add_cleanup(wt.lock_read().unlock)
2072
wt.lock_read()
2073
self.add_cleanup(wt.unlock)
2046
2074
basis = wt.basis_tree()
2047
self.add_cleanup(basis.lock_read().unlock)
2075
basis.lock_read()
2076
self.add_cleanup(basis.unlock)
2048
2077
basis_inv = basis.inventory
2049
2078
inv = wt.inventory
2050
2079
for file_id in inv:
2062
2091
2063
2092
2064
2093
class cmd_root(Command):
2065
__doc__ = """Show the tree root directory.
2094
"""Show the tree root directory.
2066
2095
2067
2096
The root is the nearest enclosing directory with a .bzr control
2068
2097
directory."""
2092
2121
2093
2122
2094
2123
class cmd_log(Command):
2095
__doc__ = """Show historical log for a branch or subset of a branch.
2124
"""Show historical log for a branch or subset of a branch.
2096
2125
2097
2126
log is bzr's default tool for exploring the history of a branch.
2098
2127
The branch to use is taken from the first parameter. If no parameters
2279
2308
help='Show changes made in each revision as a patch.'),
2280
2309
Option('include-merges',
2281
2310
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
2311
]
2287
2312
encoding_type = 'replace'
2288
2313
2298
2323
message=None,
2299
2324
limit=None,
2300
2325
show_diff=False,
2301
include_merges=False,
2302
exclude_common_ancestry=False,
2303
):
2326
include_merges=False):
2304
2327
from bzrlib.log import (
2305
2328
Logger,
2306
2329
make_log_request_dict,
2307
2330
_get_info_for_log_files,
2308
2331
)
2309
2332
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
2333
if include_merges:
2315
2334
if levels is None:
2316
2335
levels = 0
2332
2351
if file_list:
2333
2352
# find the file ids to log and check for directory filtering
2334
2353
b, file_info_list, rev1, rev2 = _get_info_for_log_files(
2335
revision, file_list, self.add_cleanup)
2354
revision, file_list)
2355
self.add_cleanup(b.unlock)
2336
2356
for relpath, file_id, kind in file_info_list:
2337
2357
if file_id is None:
2338
2358
raise errors.BzrCommandError(
2356
2376
location = '.'
2357
2377
dir, relpath = bzrdir.BzrDir.open_containing(location)
2358
2378
b = dir.open_branch()
2359
self.add_cleanup(b.lock_read().unlock)
2379
b.lock_read()
2380
self.add_cleanup(b.unlock)
2360
2381
rev1, rev2 = _get_revision_range(revision, b, self.name())
2361
2382
2362
2383
# Decide on the type of delta & diff filtering to use
2407
2428
direction=direction, specific_fileids=file_ids,
2408
2429
start_revision=rev1, end_revision=rev2, limit=limit,
2409
2430
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
)
2431
diff_type=diff_type, _match_using_deltas=match_using_deltas)
2413
2432
Logger(b, rqst).show(lf)
2414
2433
2415
2434
2473
2492
2474
2493
2475
2494
class cmd_touching_revisions(Command):
2476
__doc__ = """Return revision-ids which affected a particular file.
2495
"""Return revision-ids which affected a particular file.
2477
2496
2478
2497
A more user-friendly interface is "bzr log FILE".
2479
2498
"""
2486
2505
tree, relpath = WorkingTree.open_containing(filename)
2487
2506
file_id = tree.path2id(relpath)
2488
2507
b = tree.branch
2489
self.add_cleanup(b.lock_read().unlock)
2508
b.lock_read()
2509
self.add_cleanup(b.unlock)
2490
2510
touching_revs = log.find_touching_revisions(b, file_id)
2491
2511
for revno, revision_id, what in touching_revs:
2492
2512
self.outf.write("%6d %s\n" % (revno, what))
2493
2513
2494
2514
2495
2515
class cmd_ls(Command):
2496
__doc__ = """List files in a tree.
2516
"""List files in a tree.
2497
2517
"""
2498
2518
2499
2519
_see_also = ['status', 'cat']
2561
2581
view_str = views.view_display_str(view_files)
2562
2582
note("Ignoring files outside view. View is %s" % view_str)
2563
2583
2564
self.add_cleanup(tree.lock_read().unlock)
2584
tree.lock_read()
2585
self.add_cleanup(tree.unlock)
2565
2586
for fp, fc, fkind, fid, entry in tree.list_files(include_root=False,
2566
2587
from_dir=relpath, recursive=recursive):
2567
2588
# Apply additional masking
2609
2630
2610
2631
2611
2632
class cmd_unknowns(Command):
2612
__doc__ = """List unknown files.
2633
"""List unknown files.
2613
2634
"""
2614
2635
2615
2636
hidden = True
2622
2643
2623
2644
2624
2645
class cmd_ignore(Command):
2625
__doc__ = """Ignore specified files or patterns.
2646
"""Ignore specified files or patterns.
2626
2647
2627
2648
See ``bzr help patterns`` for details on the syntax of patterns.
2628
2649
2637
2658
using this command or directly by using an editor, be sure to commit
2638
2659
it.
2639
2660
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
2661
Patterns prefixed with '!' are exceptions to ignore patterns and take
2647
2662
precedence over regular ignores. Such exceptions are used to specify
2648
2663
files that should be versioned which would otherwise be ignored.
2689
2704
_see_also = ['status', 'ignored', 'patterns']
2690
2705
takes_args = ['name_pattern*']
2691
2706
takes_options = [
2692
Option('default-rules',
2693
help='Display the default ignore rules that bzr uses.')
2707
Option('old-default-rules',
2708
help='Write out the ignore rules bzr < 0.9 always used.')
2694
2709
]
2695
2710
2696
def run(self, name_pattern_list=None, default_rules=None):
2711
def run(self, name_pattern_list=None, old_default_rules=None):
2697
2712
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:
2713
if old_default_rules is not None:
2714
# dump the rules and exit
2715
for pattern in ignores.OLD_DEFAULTS:
2701
2716
self.outf.write("%s\n" % pattern)
2702
2717
return
2703
2718
if not name_pattern_list:
2704
2719
raise errors.BzrCommandError("ignore requires at least one "
2705
"NAME_PATTERN or --default-rules.")
2720
"NAME_PATTERN or --old-default-rules")
2706
2721
name_pattern_list = [globbing.normalize_pattern(p)
2707
2722
for p in name_pattern_list]
2708
2723
for name_pattern in name_pattern_list:
2730
2745
2731
2746
2732
2747
class cmd_ignored(Command):
2733
__doc__ = """List ignored files and the patterns that matched them.
2748
"""List ignored files and the patterns that matched them.
2734
2749
2735
2750
List all the ignored files and the ignore pattern that caused the file to
2736
2751
be ignored.
2746
2761
@display_command
2747
2762
def run(self):
2748
2763
tree = WorkingTree.open_containing(u'.')[0]
2749
self.add_cleanup(tree.lock_read().unlock)
2764
tree.lock_read()
2765
self.add_cleanup(tree.unlock)
2750
2766
for path, file_class, kind, file_id, entry in tree.list_files():
2751
2767
if file_class != 'I':
2752
2768
continue
2756
2772
2757
2773
2758
2774
class cmd_lookup_revision(Command):
2759
__doc__ = """Lookup the revision-id from a revision-number
2775
"""Lookup the revision-id from a revision-number
2760
2776
2761
2777
:Examples:
2762
2778
bzr lookup-revision 33
2776
2792
2777
2793
2778
2794
class cmd_export(Command):
2779
__doc__ = """Export current or past revision to a destination directory or archive.
2795
"""Export current or past revision to a destination directory or archive.
2780
2796
2781
2797
If no revision is specified this exports the last committed revision.
2782
2798
2839
2855
2840
2856
2841
2857
class cmd_cat(Command):
2842
__doc__ = """Write the contents of a file as of a given revision to standard output.
2858
"""Write the contents of a file as of a given revision to standard output.
2843
2859
2844
2860
If no revision is nominated, the last revision is used.
2845
2861
2865
2881
" one revision specifier")
2866
2882
tree, branch, relpath = \
2867
2883
bzrdir.BzrDir.open_containing_tree_or_branch(filename)
2868
self.add_cleanup(branch.lock_read().unlock)
2884
branch.lock_read()
2885
self.add_cleanup(branch.unlock)
2869
2886
return self._run(tree, branch, relpath, filename, revision,
2870
2887
name_from_revision, filters)
2871
2888
2874
2891
if tree is None:
2875
2892
tree = b.basis_tree()
2876
2893
rev_tree = _get_one_revision_tree('cat', revision, branch=b)
2877
self.add_cleanup(rev_tree.lock_read().unlock)
2894
rev_tree.lock_read()
2895
self.add_cleanup(rev_tree.unlock)
2878
2896
2879
2897
old_file_id = rev_tree.path2id(relpath)
2880
2898
2923
2941
2924
2942
2925
2943
class cmd_local_time_offset(Command):
2926
__doc__ = """Show the offset in seconds from GMT to local time."""
2944
"""Show the offset in seconds from GMT to local time."""
2927
2945
hidden = True
2928
2946
@display_command
2929
2947
def run(self):
2932
2950
2933
2951
2934
2952
class cmd_commit(Command):
2935
__doc__ = """Commit changes into a new revision.
2953
"""Commit changes into a new revision.
2936
2954
2937
2955
An explanatory message needs to be given for each commit. This is
2938
2956
often done by using the --message option (getting the message from the
3046
3064
"the master branch until a normal commit "
3047
3065
"is performed."
3048
3066
),
3049
Option('show-diff', short_name='p',
3067
Option('show-diff',
3050
3068
help='When no message is supplied, show the diff along'
3051
3069
' with the status summary in the message editor.'),
3052
3070
]
3132
3150
'(use --file "%(f)s" to take commit message from that file)'
3133
3151
% { 'f': message })
3134
3152
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
3153
3142
3154
def get_message(commit_obj):
3143
3155
"""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,
3156
my_message = message
3157
if my_message is not None and '\r' in my_message:
3158
my_message = my_message.replace('\r\n', '\n')
3159
my_message = my_message.replace('\r', '\n')
3160
if my_message is None and not file:
3161
t = make_commit_message_template_encoded(tree,
3153
3162
selected_list, diff=show_diff,
3154
3163
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
3164
start_message = generate_commit_message_template(commit_obj)
3161
my_message = edit_commit_message_encoded(text,
3165
my_message = edit_commit_message_encoded(t,
3162
3166
start_message=start_message)
3163
3167
if my_message is None:
3164
3168
raise errors.BzrCommandError("please specify a commit"
3165
3169
" message with either --message or --file")
3170
elif my_message and file:
3171
raise errors.BzrCommandError(
3172
"please specify either --message or --file")
3173
if file:
3174
my_message = codecs.open(file, 'rt',
3175
osutils.get_user_encoding()).read()
3166
3176
if my_message == "":
3167
3177
raise errors.BzrCommandError("empty commit message specified")
3168
3178
return my_message
3180
3190
timezone=offset,
3181
3191
exclude=safe_relpath_files(tree, exclude))
3182
3192
except PointlessCommit:
3193
# FIXME: This should really happen before the file is read in;
3194
# perhaps prepare the commit; get the message; then actually commit
3183
3195
raise errors.BzrCommandError("No changes to commit."
3184
3196
" Use --unchanged to commit anyhow.")
3185
3197
except ConflictsInTree:
3198
3210
3199
3211
3200
3212
class cmd_check(Command):
3201
__doc__ = """Validate working tree structure, branch consistency and repository history.
3213
"""Validate working tree structure, branch consistency and repository history.
3202
3214
3203
3215
This command checks various invariants about branch and repository storage
3204
3216
to detect data corruption or bzr bugs.
3268
3280
3269
3281
3270
3282
class cmd_upgrade(Command):
3271
__doc__ = """Upgrade branch storage to current format.
3283
"""Upgrade branch storage to current format.
3272
3284
3273
3285
The check command or bzr developers may sometimes advise you to run
3274
3286
this command. When the default format has changed you may also be warned
3292
3304
3293
3305
3294
3306
class cmd_whoami(Command):
3295
__doc__ = """Show or set bzr user id.
3307
"""Show or set bzr user id.
3296
3308
3297
3309
:Examples:
3298
3310
Show the email of the current user::
3342
3354
3343
3355
3344
3356
class cmd_nick(Command):
3345
__doc__ = """Print or set the branch nickname.
3357
"""Print or set the branch nickname.
3346
3358
3347
3359
If unset, the tree root directory name is used as the nickname.
3348
3360
To print the current nickname, execute with no argument.
3366
3378
3367
3379
3368
3380
class cmd_alias(Command):
3369
__doc__ = """Set/unset and display aliases.
3381
"""Set/unset and display aliases.
3370
3382
3371
3383
:Examples:
3372
3384
Show the current aliases::
3436
3448
3437
3449
3438
3450
class cmd_selftest(Command):
3439
__doc__ = """Run internal test suite.
3451
"""Run internal test suite.
3440
3452
3441
3453
If arguments are given, they are regular expressions that say which tests
3442
3454
should run. Tests matching any expression are run, and other tests are
3583
3595
raise errors.BzrCommandError("subunit not available. subunit "
3584
3596
"needs to be installed to use --subunit.")
3585
3597
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
3598
if parallel:
3592
3599
self.additional_selftest_args.setdefault(
3593
3600
'suite_decorators', []).append(parallel)
3624
3631
3625
3632
3626
3633
class cmd_version(Command):
3627
__doc__ = """Show version of bzr."""
3634
"""Show version of bzr."""
3628
3635
3629
3636
encoding_type = 'replace'
3630
3637
takes_options = [
3641
3648
3642
3649
3643
3650
class cmd_rocks(Command):
3644
__doc__ = """Statement of optimism."""
3651
"""Statement of optimism."""
3645
3652
3646
3653
hidden = True
3647
3654
3651
3658
3652
3659
3653
3660
class cmd_find_merge_base(Command):
3654
__doc__ = """Find and print a base revision for merging two branches."""
3661
"""Find and print a base revision for merging two branches."""
3655
3662
# TODO: Options to specify revisions on either side, as if
3656
3663
# merging only part of the history.
3657
3664
takes_args = ['branch', 'other']
3663
3670
3664
3671
branch1 = Branch.open_containing(branch)[0]
3665
3672
branch2 = Branch.open_containing(other)[0]
3666
self.add_cleanup(branch1.lock_read().unlock)
3667
self.add_cleanup(branch2.lock_read().unlock)
3673
branch1.lock_read()
3674
self.add_cleanup(branch1.unlock)
3675
branch2.lock_read()
3676
self.add_cleanup(branch2.unlock)
3668
3677
last1 = ensure_null(branch1.last_revision())
3669
3678
last2 = ensure_null(branch2.last_revision())
3670
3679
3675
3684
3676
3685
3677
3686
class cmd_merge(Command):
3678
__doc__ = """Perform a three-way merge.
3687
"""Perform a three-way merge.
3679
3688
3680
3689
The source of the merge can be specified either in the form of a branch,
3681
3690
or in the form of a path to a file containing a merge directive generated
3808
3817
unversioned_filter=tree.is_ignored, view_info=view_info)
3809
3818
pb = ui.ui_factory.nested_progress_bar()
3810
3819
self.add_cleanup(pb.finished)
3811
self.add_cleanup(tree.lock_write().unlock)
3820
tree.lock_write()
3821
self.add_cleanup(tree.unlock)
3812
3822
if location is not None:
3813
3823
try:
3814
3824
mergeable = bundle.read_mergeable_from_url(location,
4035
4045
4036
4046
4037
4047
class cmd_remerge(Command):
4038
__doc__ = """Redo a merge.
4048
"""Redo a merge.
4039
4049
4040
4050
Use this if you want to try a different merge technique while resolving
4041
4051
conflicts. Some merge techniques are better than others, and remerge
4070
4080
if merge_type is None:
4071
4081
merge_type = _mod_merge.Merge3Merger
4072
4082
tree, file_list = tree_files(file_list)
4073
self.add_cleanup(tree.lock_write().unlock)
4083
tree.lock_write()
4084
self.add_cleanup(tree.unlock)
4074
4085
parents = tree.get_parent_ids()
4075
4086
if len(parents) != 2:
4076
4087
raise errors.BzrCommandError("Sorry, remerge only works after normal"
4129
4140
4130
4141
4131
4142
class cmd_revert(Command):
4132
__doc__ = """Revert files to a previous revision.
4143
"""Revert files to a previous revision.
4133
4144
4134
4145
Giving a list of files will revert only those files. Otherwise, all files
4135
4146
will be reverted. If the revision is not specified with '--revision', the
4186
4197
def run(self, revision=None, no_backup=False, file_list=None,
4187
4198
forget_merges=None):
4188
4199
tree, file_list = tree_files(file_list)
4189
self.add_cleanup(tree.lock_tree_write().unlock)
4200
tree.lock_write()
4201
self.add_cleanup(tree.unlock)
4190
4202
if forget_merges:
4191
4203
tree.set_parent_ids(tree.get_parent_ids()[:1])
4192
4204
else:
4200
4212
4201
4213
4202
4214
class cmd_assert_fail(Command):
4203
__doc__ = """Test reporting of assertion failures"""
4215
"""Test reporting of assertion failures"""
4204
4216
# intended just for use in testing
4205
4217
4206
4218
hidden = True
4210
4222
4211
4223
4212
4224
class cmd_help(Command):
4213
__doc__ = """Show help on a command or other topic.
4225
"""Show help on a command or other topic.
4214
4226
"""
4215
4227
4216
4228
_see_also = ['topics']
4229
4241
4230
4242
4231
4243
class cmd_shell_complete(Command):
4232
__doc__ = """Show appropriate completions for context.
4244
"""Show appropriate completions for context.
4233
4245
4234
4246
For a list of all available commands, say 'bzr shell-complete'.
4235
4247
"""
4244
4256
4245
4257
4246
4258
class cmd_missing(Command):
4247
__doc__ = """Show unmerged/unpulled revisions between two branches.
4259
"""Show unmerged/unpulled revisions between two branches.
4248
4260
4249
4261
OTHER_BRANCH may be local or remote.
4250
4262
4328
4340
restrict = 'remote'
4329
4341
4330
4342
local_branch = Branch.open_containing(u".")[0]
4331
self.add_cleanup(local_branch.lock_read().unlock)
4332
4333
4343
parent = local_branch.get_parent()
4334
4344
if other_branch is None:
4335
4345
other_branch = parent
4344
4354
remote_branch = Branch.open(other_branch)
4345
4355
if remote_branch.base == local_branch.base:
4346
4356
remote_branch = local_branch
4347
else:
4348
self.add_cleanup(remote_branch.lock_read().unlock)
4349
4357
4358
local_branch.lock_read()
4359
self.add_cleanup(local_branch.unlock)
4350
4360
local_revid_range = _revision_range_to_revid_range(
4351
4361
_get_revision_range(my_revision, local_branch,
4352
4362
self.name()))
4353
4363
4364
remote_branch.lock_read()
4365
self.add_cleanup(remote_branch.unlock)
4354
4366
remote_revid_range = _revision_range_to_revid_range(
4355
4367
_get_revision_range(revision,
4356
4368
remote_branch, self.name()))
4406
4418
message("Branches are up to date.\n")
4407
4419
self.cleanup_now()
4408
4420
if not status_code and parent is None and other_branch is not None:
4409
self.add_cleanup(local_branch.lock_write().unlock)
4421
local_branch.lock_write()
4422
self.add_cleanup(local_branch.unlock)
4410
4423
# handle race conditions - a parent might be set while we run.
4411
4424
if local_branch.get_parent() is None:
4412
4425
local_branch.set_parent(remote_branch.base)
4414
4427
4415
4428
4416
4429
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
"""
4430
"""Compress the data within a repository."""
4434
4431
4435
4432
_see_also = ['repositories']
4436
4433
takes_args = ['branch_or_repo?']
4437
takes_options = [
4438
Option('clean-obsolete-packs', 'Delete obsolete packs to save disk space.'),
4439
]
4440
4434
4441
def run(self, branch_or_repo='.', clean_obsolete_packs=False):
4435
def run(self, branch_or_repo='.'):
4442
4436
dir = bzrdir.BzrDir.open_containing(branch_or_repo)[0]
4443
4437
try:
4444
4438
branch = dir.open_branch()
4445
4439
repository = branch.repository
4446
4440
except errors.NotBranchError:
4447
4441
repository = dir.open_repository()
4448
repository.pack(clean_obsolete_packs=clean_obsolete_packs)
4442
repository.pack()
4449
4443
4450
4444
4451
4445
class cmd_plugins(Command):
4452
__doc__ = """List the installed plugins.
4446
"""List the installed plugins.
4453
4447
4454
4448
This command displays the list of installed plugins including
4455
4449
version of plugin and a short description of each.
4494
4488
4495
4489
4496
4490
class cmd_testament(Command):
4497
__doc__ = """Show testament (signing-form) of a revision."""
4491
"""Show testament (signing-form) of a revision."""
4498
4492
takes_options = [
4499
4493
'revision',
4500
4494
Option('long', help='Produce long-format testament.'),
4512
4506
b = Branch.open_containing(branch)[0]
4513
4507
else:
4514
4508
b = Branch.open(branch)
4515
self.add_cleanup(b.lock_read().unlock)
4509
b.lock_read()
4510
self.add_cleanup(b.unlock)
4516
4511
if revision is None:
4517
4512
rev_id = b.last_revision()
4518
4513
else:
4525
4520
4526
4521
4527
4522
class cmd_annotate(Command):
4528
__doc__ = """Show the origin of each line in a file.
4523
"""Show the origin of each line in a file.
4529
4524
4530
4525
This prints out the given file with an annotation on the left side
4531
4526
indicating which revision, author and date introduced the change.
4552
4547
wt, branch, relpath = \
4553
4548
bzrdir.BzrDir.open_containing_tree_or_branch(filename)
4554
4549
if wt is not None:
4555
self.add_cleanup(wt.lock_read().unlock)
4550
wt.lock_read()
4551
self.add_cleanup(wt.unlock)
4556
4552
else:
4557
self.add_cleanup(branch.lock_read().unlock)
4553
branch.lock_read()
4554
self.add_cleanup(branch.unlock)
4558
4555
tree = _get_one_revision_tree('annotate', revision, branch=branch)
4559
self.add_cleanup(tree.lock_read().unlock)
4556
tree.lock_read()
4557
self.add_cleanup(tree.unlock)
4560
4558
if wt is not None:
4561
4559
file_id = wt.path2id(relpath)
4562
4560
else:
4575
4573
4576
4574
4577
4575
class cmd_re_sign(Command):
4578
__doc__ = """Create a digital signature for an existing revision."""
4576
"""Create a digital signature for an existing revision."""
4579
4577
# TODO be able to replace existing ones.
4580
4578
4581
4579
hidden = True # is this right ?
4588
4586
if revision_id_list is None and revision is None:
4589
4587
raise errors.BzrCommandError('You must supply either --revision or a revision_id')
4590
4588
b = WorkingTree.open_containing(u'.')[0].branch
4591
self.add_cleanup(b.lock_write().unlock)
4589
b.lock_write()
4590
self.add_cleanup(b.unlock)
4592
4591
return self._run(b, revision_id_list, revision)
4593
4592
4594
4593
def _run(self, b, revision_id_list, revision):
4640
4639
4641
4640
4642
4641
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.
4642
"""Convert the current branch into a checkout of the supplied branch.
4645
4643
4646
4644
Once converted into a checkout, commits must succeed on the master branch
4647
4645
before they will be applied to the local branch.
4681
4679
4682
4680
4683
4681
class cmd_unbind(Command):
4684
__doc__ = """Convert the current checkout into a regular branch.
4682
"""Convert the current checkout into a regular branch.
4685
4683
4686
4684
After unbinding, the local branch is considered independent and subsequent
4687
4685
commits will be local only.
4698
4696
4699
4697
4700
4698
class cmd_uncommit(Command):
4701
__doc__ = """Remove the last committed revision.
4699
"""Remove the last committed revision.
4702
4700
4703
4701
--verbose will print out what is being removed.
4704
4702
--dry-run will go through all the motions, but not actually
4744
4742
b = control.open_branch()
4745
4743
4746
4744
if tree is not None:
4747
self.add_cleanup(tree.lock_write().unlock)
4745
tree.lock_write()
4746
self.add_cleanup(tree.unlock)
4748
4747
else:
4749
self.add_cleanup(b.lock_write().unlock)
4748
b.lock_write()
4749
self.add_cleanup(b.unlock)
4750
4750
return self._run(b, tree, dry_run, verbose, revision, force, local=local)
4751
4751
4752
4752
def _run(self, b, tree, dry_run, verbose, revision, force, local=False):
4804
4804
4805
4805
4806
4806
class cmd_break_lock(Command):
4807
__doc__ = """Break a dead lock on a repository, branch or working directory.
4807
"""Break a dead lock on a repository, branch or working directory.
4808
4808
4809
4809
CAUTION: Locks should only be broken when you are sure that the process
4810
4810
holding the lock has been stopped.
4829
4829
4830
4830
4831
4831
class cmd_wait_until_signalled(Command):
4832
__doc__ = """Test helper for test_start_and_stop_bzr_subprocess_send_signal.
4832
"""Test helper for test_start_and_stop_bzr_subprocess_send_signal.
4833
4833
4834
4834
This just prints a line to signal when it is ready, then blocks on stdin.
4835
4835
"""
4843
4843
4844
4844
4845
4845
class cmd_serve(Command):
4846
__doc__ = """Run the bzr server."""
4846
"""Run the bzr server."""
4847
4847
4848
4848
aliases = ['server']
4849
4849
4909
4909
4910
4910
4911
4911
class cmd_join(Command):
4912
__doc__ = """Combine a tree into its containing tree.
4912
"""Combine a tree into its containing tree.
4913
4913
4914
4914
This command requires the target tree to be in a rich-root format.
4915
4915
4955
4955
4956
4956
4957
4957
class cmd_split(Command):
4958
__doc__ = """Split a subdirectory of a tree into a separate tree.
4958
"""Split a subdirectory of a tree into a separate tree.
4959
4959
4960
4960
This command will produce a target tree in a format that supports
4961
4961
rich roots, like 'rich-root' or 'rich-root-pack'. These formats cannot be
4981
4981
4982
4982
4983
4983
class cmd_merge_directive(Command):
4984
__doc__ = """Generate a merge directive for auto-merge tools.
4984
"""Generate a merge directive for auto-merge tools.
4985
4985
4986
4986
A directive requests a merge to be performed, and also provides all the
4987
4987
information necessary to do so. This means it must either include a
5080
5080
5081
5081
5082
5082
class cmd_send(Command):
5083
__doc__ = """Mail or create a merge-directive for submitting changes.
5083
"""Mail or create a merge-directive for submitting changes.
5084
5084
5085
5085
A merge directive provides many things needed for requesting merges:
5086
5086
5197
5197
5198
5198
5199
5199
class cmd_bundle_revisions(cmd_send):
5200
__doc__ = """Create a merge-directive for submitting changes.
5200
"""Create a merge-directive for submitting changes.
5201
5201
5202
5202
A merge directive provides many things needed for requesting merges:
5203
5203
5270
5270
5271
5271
5272
5272
class cmd_tag(Command):
5273
__doc__ = """Create, remove or modify a tag naming a revision.
5273
"""Create, remove or modify a tag naming a revision.
5274
5274
5275
5275
Tags give human-meaningful names to revisions. Commands that take a -r
5276
5276
(--revision) option can be given -rtag:X, where X is any previously
5315
5315
revision=None,
5316
5316
):
5317
5317
branch, relpath = Branch.open_containing(directory)
5318
self.add_cleanup(branch.lock_write().unlock)
5318
branch.lock_write()
5319
self.add_cleanup(branch.unlock)
5319
5320
if delete:
5320
5321
if tag_name is None:
5321
5322
raise errors.BzrCommandError("No tag specified to delete.")
5342
5343
5343
5344
5344
5345
class cmd_tags(Command):
5345
__doc__ = """List tags.
5346
"""List tags.
5346
5347
5347
5348
This command shows a table of tag names and the revisions they reference.
5348
5349
"""
5376
5377
if not tags:
5377
5378
return
5378
5379
5379
self.add_cleanup(branch.lock_read().unlock)
5380
branch.lock_read()
5381
self.add_cleanup(branch.unlock)
5380
5382
if revision:
5381
5383
graph = branch.repository.get_graph()
5382
5384
rev1, rev2 = _get_revision_range(revision, branch, self.name())
5415
5417
5416
5418
5417
5419
class cmd_reconfigure(Command):
5418
__doc__ = """Reconfigure the type of a bzr directory.
5420
"""Reconfigure the type of a bzr directory.
5419
5421
5420
5422
A target configuration must be specified.
5421
5423
5506
5508
5507
5509
5508
5510
class cmd_switch(Command):
5509
__doc__ = """Set the branch of a checkout and update.
5511
"""Set the branch of a checkout and update.
5510
5512
5511
5513
For lightweight checkouts, this changes the branch being referenced.
5512
5514
For heavyweight checkouts, this checks that there are no local commits
5602
5604
5603
5605
5604
5606
class cmd_view(Command):
5605
__doc__ = """Manage filtered views.
5607
"""Manage filtered views.
5606
5608
5607
5609
Views provide a mask over the tree so that users can focus on
5608
5610
a subset of a tree when doing their work. After creating a view,
5756
5758
5757
5759
5758
5760
class cmd_hooks(Command):
5759
__doc__ = """Show hooks."""
5761
"""Show hooks."""
5760
5762
5761
5763
hidden = True
5762
5764
5776
5778
5777
5779
5778
5780
class cmd_remove_branch(Command):
5779
__doc__ = """Remove a branch.
5781
"""Remove a branch.
5780
5782
5781
5783
This will remove the branch from the specified location but
5782
5784
will keep any working tree or repository in place.
5801
5803
5802
5804
5803
5805
class cmd_shelve(Command):
5804
__doc__ = """Temporarily set aside some changes from the current tree.
5806
"""Temporarily set aside some changes from the current tree.
5805
5807
5806
5808
Shelve allows you to temporarily put changes you've made "on the shelf",
5807
5809
ie. out of the way, until a later time when you can bring them back from
5860
5862
5861
5863
def run_for_list(self):
5862
5864
tree = WorkingTree.open_containing('.')[0]
5863
self.add_cleanup(tree.lock_read().unlock)
5865
tree.lock_read()
5866
self.add_cleanup(tree.unlock)
5864
5867
manager = tree.get_shelf_manager()
5865
5868
shelves = manager.active_shelves()
5866
5869
if len(shelves) == 0:
5875
5878
5876
5879
5877
5880
class cmd_unshelve(Command):
5878
__doc__ = """Restore shelved changes.
5881
"""Restore shelved changes.
5879
5882
5880
5883
By default, the most recently shelved changes are restored. However if you
5881
5884
specify a shelf by id those changes will be restored instead. This works
5907
5910
5908
5911
5909
5912
class cmd_clean_tree(Command):
5910
__doc__ = """Remove unwanted files from working tree.
5913
"""Remove unwanted files from working tree.
5911
5914
5912
5915
By default, only unknown files, not ignored files, are deleted. Versioned
5913
5916
files are never deleted.
5941
5944
5942
5945
5943
5946
class cmd_reference(Command):
5944
__doc__ = """list, view and set branch locations for nested trees.
5947
"""list, view and set branch locations for nested trees.
5945
5948
5946
5949
If no arguments are provided, lists the branch locations for nested trees.
5947
5950
If one argument is provided, display the branch location for that tree.
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0