« back to all changes in this revision
Viewing changes to bzrlib/builtins.py
- browse files at revision 5141.3.3
- compare with another revision
- download diff
- download tarball
- view history from revision 5141.3.3
- Committer: Jelmer Vernooij
- Date: 2010-04-12 15:28:32 UTC
- mto: (5147.4.2 more-colo)
- mto: This revision was merged to the branch mainline in revision 5148.
- Revision ID: jelmer@samba.org-20100412152832-nm7rf8o5p9v1wggk
Clarify segment/subsegment handling.
- files removed:
- bzrlib/tests/commands/test_revert.py
- bzrlib/tests/per_bzrdir_colo
- 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(
1447
1472
_mod_revision.ensure_null(tree.last_revision()))
1448
1473
note('Updated to revision %s of branch %s' %
1449
1474
('.'.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:
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
]
3198
3216
3199
3217
3200
3218
class cmd_check(Command):
3201
__doc__ = """Validate working tree structure, branch consistency and repository history.
3219
"""Validate working tree structure, branch consistency and repository history.
3202
3220
3203
3221
This command checks various invariants about branch and repository storage
3204
3222
to detect data corruption or bzr bugs.
3268
3286
3269
3287
3270
3288
class cmd_upgrade(Command):
3271
__doc__ = """Upgrade branch storage to current format.
3289
"""Upgrade branch storage to current format.
3272
3290
3273
3291
The check command or bzr developers may sometimes advise you to run
3274
3292
this command. When the default format has changed you may also be warned
3292
3310
3293
3311
3294
3312
class cmd_whoami(Command):
3295
__doc__ = """Show or set bzr user id.
3313
"""Show or set bzr user id.
3296
3314
3297
3315
:Examples:
3298
3316
Show the email of the current user::
3342
3360
3343
3361
3344
3362
class cmd_nick(Command):
3345
__doc__ = """Print or set the branch nickname.
3363
"""Print or set the branch nickname.
3346
3364
3347
3365
If unset, the tree root directory name is used as the nickname.
3348
3366
To print the current nickname, execute with no argument.
3366
3384
3367
3385
3368
3386
class cmd_alias(Command):
3369
__doc__ = """Set/unset and display aliases.
3387
"""Set/unset and display aliases.
3370
3388
3371
3389
:Examples:
3372
3390
Show the current aliases::
3436
3454
3437
3455
3438
3456
class cmd_selftest(Command):
3439
__doc__ = """Run internal test suite.
3457
"""Run internal test suite.
3440
3458
3441
3459
If arguments are given, they are regular expressions that say which tests
3442
3460
should run. Tests matching any expression are run, and other tests are
3583
3601
raise errors.BzrCommandError("subunit not available. subunit "
3584
3602
"needs to be installed to use --subunit.")
3585
3603
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
3604
if parallel:
3592
3605
self.additional_selftest_args.setdefault(
3593
3606
'suite_decorators', []).append(parallel)
3624
3637
3625
3638
3626
3639
class cmd_version(Command):
3627
__doc__ = """Show version of bzr."""
3640
"""Show version of bzr."""
3628
3641
3629
3642
encoding_type = 'replace'
3630
3643
takes_options = [
3641
3654
3642
3655
3643
3656
class cmd_rocks(Command):
3644
__doc__ = """Statement of optimism."""
3657
"""Statement of optimism."""
3645
3658
3646
3659
hidden = True
3647
3660
3651
3664
3652
3665
3653
3666
class cmd_find_merge_base(Command):
3654
__doc__ = """Find and print a base revision for merging two branches."""
3667
"""Find and print a base revision for merging two branches."""
3655
3668
# TODO: Options to specify revisions on either side, as if
3656
3669
# merging only part of the history.
3657
3670
takes_args = ['branch', 'other']
3663
3676
3664
3677
branch1 = Branch.open_containing(branch)[0]
3665
3678
branch2 = Branch.open_containing(other)[0]
3666
self.add_cleanup(branch1.lock_read().unlock)
3667
self.add_cleanup(branch2.lock_read().unlock)
3679
branch1.lock_read()
3680
self.add_cleanup(branch1.unlock)
3681
branch2.lock_read()
3682
self.add_cleanup(branch2.unlock)
3668
3683
last1 = ensure_null(branch1.last_revision())
3669
3684
last2 = ensure_null(branch2.last_revision())
3670
3685
3675
3690
3676
3691
3677
3692
class cmd_merge(Command):
3678
__doc__ = """Perform a three-way merge.
3693
"""Perform a three-way merge.
3679
3694
3680
3695
The source of the merge can be specified either in the form of a branch,
3681
3696
or in the form of a path to a file containing a merge directive generated
3808
3823
unversioned_filter=tree.is_ignored, view_info=view_info)
3809
3824
pb = ui.ui_factory.nested_progress_bar()
3810
3825
self.add_cleanup(pb.finished)
3811
self.add_cleanup(tree.lock_write().unlock)
3826
tree.lock_write()
3827
self.add_cleanup(tree.unlock)
3812
3828
if location is not None:
3813
3829
try:
3814
3830
mergeable = bundle.read_mergeable_from_url(location,
4035
4051
4036
4052
4037
4053
class cmd_remerge(Command):
4038
__doc__ = """Redo a merge.
4054
"""Redo a merge.
4039
4055
4040
4056
Use this if you want to try a different merge technique while resolving
4041
4057
conflicts. Some merge techniques are better than others, and remerge
4070
4086
if merge_type is None:
4071
4087
merge_type = _mod_merge.Merge3Merger
4072
4088
tree, file_list = tree_files(file_list)
4073
self.add_cleanup(tree.lock_write().unlock)
4089
tree.lock_write()
4090
self.add_cleanup(tree.unlock)
4074
4091
parents = tree.get_parent_ids()
4075
4092
if len(parents) != 2:
4076
4093
raise errors.BzrCommandError("Sorry, remerge only works after normal"
4129
4146
4130
4147
4131
4148
class cmd_revert(Command):
4132
__doc__ = """Revert files to a previous revision.
4149
"""Revert files to a previous revision.
4133
4150
4134
4151
Giving a list of files will revert only those files. Otherwise, all files
4135
4152
will be reverted. If the revision is not specified with '--revision', the
4186
4203
def run(self, revision=None, no_backup=False, file_list=None,
4187
4204
forget_merges=None):
4188
4205
tree, file_list = tree_files(file_list)
4189
self.add_cleanup(tree.lock_tree_write().unlock)
4206
tree.lock_write()
4207
self.add_cleanup(tree.unlock)
4190
4208
if forget_merges:
4191
4209
tree.set_parent_ids(tree.get_parent_ids()[:1])
4192
4210
else:
4200
4218
4201
4219
4202
4220
class cmd_assert_fail(Command):
4203
__doc__ = """Test reporting of assertion failures"""
4221
"""Test reporting of assertion failures"""
4204
4222
# intended just for use in testing
4205
4223
4206
4224
hidden = True
4210
4228
4211
4229
4212
4230
class cmd_help(Command):
4213
__doc__ = """Show help on a command or other topic.
4231
"""Show help on a command or other topic.
4214
4232
"""
4215
4233
4216
4234
_see_also = ['topics']
4229
4247
4230
4248
4231
4249
class cmd_shell_complete(Command):
4232
__doc__ = """Show appropriate completions for context.
4250
"""Show appropriate completions for context.
4233
4251
4234
4252
For a list of all available commands, say 'bzr shell-complete'.
4235
4253
"""
4244
4262
4245
4263
4246
4264
class cmd_missing(Command):
4247
__doc__ = """Show unmerged/unpulled revisions between two branches.
4265
"""Show unmerged/unpulled revisions between two branches.
4248
4266
4249
4267
OTHER_BRANCH may be local or remote.
4250
4268
4328
4346
restrict = 'remote'
4329
4347
4330
4348
local_branch = Branch.open_containing(u".")[0]
4331
self.add_cleanup(local_branch.lock_read().unlock)
4332
4333
4349
parent = local_branch.get_parent()
4334
4350
if other_branch is None:
4335
4351
other_branch = parent
4344
4360
remote_branch = Branch.open(other_branch)
4345
4361
if remote_branch.base == local_branch.base:
4346
4362
remote_branch = local_branch
4347
else:
4348
self.add_cleanup(remote_branch.lock_read().unlock)
4349
4363
4364
local_branch.lock_read()
4365
self.add_cleanup(local_branch.unlock)
4350
4366
local_revid_range = _revision_range_to_revid_range(
4351
4367
_get_revision_range(my_revision, local_branch,
4352
4368
self.name()))
4353
4369
4370
remote_branch.lock_read()
4371
self.add_cleanup(remote_branch.unlock)
4354
4372
remote_revid_range = _revision_range_to_revid_range(
4355
4373
_get_revision_range(revision,
4356
4374
remote_branch, self.name()))
4406
4424
message("Branches are up to date.\n")
4407
4425
self.cleanup_now()
4408
4426
if not status_code and parent is None and other_branch is not None:
4409
self.add_cleanup(local_branch.lock_write().unlock)
4427
local_branch.lock_write()
4428
self.add_cleanup(local_branch.unlock)
4410
4429
# handle race conditions - a parent might be set while we run.
4411
4430
if local_branch.get_parent() is None:
4412
4431
local_branch.set_parent(remote_branch.base)
4414
4433
4415
4434
4416
4435
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
"""
4436
"""Compress the data within a repository."""
4434
4437
4435
4438
_see_also = ['repositories']
4436
4439
takes_args = ['branch_or_repo?']
4437
takes_options = [
4438
Option('clean-obsolete-packs', 'Delete obsolete packs to save disk space.'),
4439
]
4440
4440
4441
def run(self, branch_or_repo='.', clean_obsolete_packs=False):
4441
def run(self, branch_or_repo='.'):
4442
4442
dir = bzrdir.BzrDir.open_containing(branch_or_repo)[0]
4443
4443
try:
4444
4444
branch = dir.open_branch()
4445
4445
repository = branch.repository
4446
4446
except errors.NotBranchError:
4447
4447
repository = dir.open_repository()
4448
repository.pack(clean_obsolete_packs=clean_obsolete_packs)
4448
repository.pack()
4449
4449
4450
4450
4451
4451
class cmd_plugins(Command):
4452
__doc__ = """List the installed plugins.
4452
"""List the installed plugins.
4453
4453
4454
4454
This command displays the list of installed plugins including
4455
4455
version of plugin and a short description of each.
4494
4494
4495
4495
4496
4496
class cmd_testament(Command):
4497
__doc__ = """Show testament (signing-form) of a revision."""
4497
"""Show testament (signing-form) of a revision."""
4498
4498
takes_options = [
4499
4499
'revision',
4500
4500
Option('long', help='Produce long-format testament.'),
4512
4512
b = Branch.open_containing(branch)[0]
4513
4513
else:
4514
4514
b = Branch.open(branch)
4515
self.add_cleanup(b.lock_read().unlock)
4515
b.lock_read()
4516
self.add_cleanup(b.unlock)
4516
4517
if revision is None:
4517
4518
rev_id = b.last_revision()
4518
4519
else:
4525
4526
4526
4527
4527
4528
class cmd_annotate(Command):
4528
__doc__ = """Show the origin of each line in a file.
4529
"""Show the origin of each line in a file.
4529
4530
4530
4531
This prints out the given file with an annotation on the left side
4531
4532
indicating which revision, author and date introduced the change.
4552
4553
wt, branch, relpath = \
4553
4554
bzrdir.BzrDir.open_containing_tree_or_branch(filename)
4554
4555
if wt is not None:
4555
self.add_cleanup(wt.lock_read().unlock)
4556
wt.lock_read()
4557
self.add_cleanup(wt.unlock)
4556
4558
else:
4557
self.add_cleanup(branch.lock_read().unlock)
4559
branch.lock_read()
4560
self.add_cleanup(branch.unlock)
4558
4561
tree = _get_one_revision_tree('annotate', revision, branch=branch)
4559
self.add_cleanup(tree.lock_read().unlock)
4562
tree.lock_read()
4563
self.add_cleanup(tree.unlock)
4560
4564
if wt is not None:
4561
4565
file_id = wt.path2id(relpath)
4562
4566
else:
4575
4579
4576
4580
4577
4581
class cmd_re_sign(Command):
4578
__doc__ = """Create a digital signature for an existing revision."""
4582
"""Create a digital signature for an existing revision."""
4579
4583
# TODO be able to replace existing ones.
4580
4584
4581
4585
hidden = True # is this right ?
4588
4592
if revision_id_list is None and revision is None:
4589
4593
raise errors.BzrCommandError('You must supply either --revision or a revision_id')
4590
4594
b = WorkingTree.open_containing(u'.')[0].branch
4591
self.add_cleanup(b.lock_write().unlock)
4595
b.lock_write()
4596
self.add_cleanup(b.unlock)
4592
4597
return self._run(b, revision_id_list, revision)
4593
4598
4594
4599
def _run(self, b, revision_id_list, revision):
4640
4645
4641
4646
4642
4647
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.
4648
"""Convert the current branch into a checkout of the supplied branch.
4645
4649
4646
4650
Once converted into a checkout, commits must succeed on the master branch
4647
4651
before they will be applied to the local branch.
4681
4685
4682
4686
4683
4687
class cmd_unbind(Command):
4684
__doc__ = """Convert the current checkout into a regular branch.
4688
"""Convert the current checkout into a regular branch.
4685
4689
4686
4690
After unbinding, the local branch is considered independent and subsequent
4687
4691
commits will be local only.
4698
4702
4699
4703
4700
4704
class cmd_uncommit(Command):
4701
__doc__ = """Remove the last committed revision.
4705
"""Remove the last committed revision.
4702
4706
4703
4707
--verbose will print out what is being removed.
4704
4708
--dry-run will go through all the motions, but not actually
4744
4748
b = control.open_branch()
4745
4749
4746
4750
if tree is not None:
4747
self.add_cleanup(tree.lock_write().unlock)
4751
tree.lock_write()
4752
self.add_cleanup(tree.unlock)
4748
4753
else:
4749
self.add_cleanup(b.lock_write().unlock)
4754
b.lock_write()
4755
self.add_cleanup(b.unlock)
4750
4756
return self._run(b, tree, dry_run, verbose, revision, force, local=local)
4751
4757
4752
4758
def _run(self, b, tree, dry_run, verbose, revision, force, local=False):
4804
4810
4805
4811
4806
4812
class cmd_break_lock(Command):
4807
__doc__ = """Break a dead lock on a repository, branch or working directory.
4813
"""Break a dead lock on a repository, branch or working directory.
4808
4814
4809
4815
CAUTION: Locks should only be broken when you are sure that the process
4810
4816
holding the lock has been stopped.
4829
4835
4830
4836
4831
4837
class cmd_wait_until_signalled(Command):
4832
__doc__ = """Test helper for test_start_and_stop_bzr_subprocess_send_signal.
4838
"""Test helper for test_start_and_stop_bzr_subprocess_send_signal.
4833
4839
4834
4840
This just prints a line to signal when it is ready, then blocks on stdin.
4835
4841
"""
4843
4849
4844
4850
4845
4851
class cmd_serve(Command):
4846
__doc__ = """Run the bzr server."""
4852
"""Run the bzr server."""
4847
4853
4848
4854
aliases = ['server']
4849
4855
4909
4915
4910
4916
4911
4917
class cmd_join(Command):
4912
__doc__ = """Combine a tree into its containing tree.
4918
"""Combine a tree into its containing tree.
4913
4919
4914
4920
This command requires the target tree to be in a rich-root format.
4915
4921
4955
4961
4956
4962
4957
4963
class cmd_split(Command):
4958
__doc__ = """Split a subdirectory of a tree into a separate tree.
4964
"""Split a subdirectory of a tree into a separate tree.
4959
4965
4960
4966
This command will produce a target tree in a format that supports
4961
4967
rich roots, like 'rich-root' or 'rich-root-pack'. These formats cannot be
4981
4987
4982
4988
4983
4989
class cmd_merge_directive(Command):
4984
__doc__ = """Generate a merge directive for auto-merge tools.
4990
"""Generate a merge directive for auto-merge tools.
4985
4991
4986
4992
A directive requests a merge to be performed, and also provides all the
4987
4993
information necessary to do so. This means it must either include a
5080
5086
5081
5087
5082
5088
class cmd_send(Command):
5083
__doc__ = """Mail or create a merge-directive for submitting changes.
5089
"""Mail or create a merge-directive for submitting changes.
5084
5090
5085
5091
A merge directive provides many things needed for requesting merges:
5086
5092
5197
5203
5198
5204
5199
5205
class cmd_bundle_revisions(cmd_send):
5200
__doc__ = """Create a merge-directive for submitting changes.
5206
"""Create a merge-directive for submitting changes.
5201
5207
5202
5208
A merge directive provides many things needed for requesting merges:
5203
5209
5270
5276
5271
5277
5272
5278
class cmd_tag(Command):
5273
__doc__ = """Create, remove or modify a tag naming a revision.
5279
"""Create, remove or modify a tag naming a revision.
5274
5280
5275
5281
Tags give human-meaningful names to revisions. Commands that take a -r
5276
5282
(--revision) option can be given -rtag:X, where X is any previously
5315
5321
revision=None,
5316
5322
):
5317
5323
branch, relpath = Branch.open_containing(directory)
5318
self.add_cleanup(branch.lock_write().unlock)
5324
branch.lock_write()
5325
self.add_cleanup(branch.unlock)
5319
5326
if delete:
5320
5327
if tag_name is None:
5321
5328
raise errors.BzrCommandError("No tag specified to delete.")
5342
5349
5343
5350
5344
5351
class cmd_tags(Command):
5345
__doc__ = """List tags.
5352
"""List tags.
5346
5353
5347
5354
This command shows a table of tag names and the revisions they reference.
5348
5355
"""
5376
5383
if not tags:
5377
5384
return
5378
5385
5379
self.add_cleanup(branch.lock_read().unlock)
5386
branch.lock_read()
5387
self.add_cleanup(branch.unlock)
5380
5388
if revision:
5381
5389
graph = branch.repository.get_graph()
5382
5390
rev1, rev2 = _get_revision_range(revision, branch, self.name())
5415
5423
5416
5424
5417
5425
class cmd_reconfigure(Command):
5418
__doc__ = """Reconfigure the type of a bzr directory.
5426
"""Reconfigure the type of a bzr directory.
5419
5427
5420
5428
A target configuration must be specified.
5421
5429
5506
5514
5507
5515
5508
5516
class cmd_switch(Command):
5509
__doc__ = """Set the branch of a checkout and update.
5517
"""Set the branch of a checkout and update.
5510
5518
5511
5519
For lightweight checkouts, this changes the branch being referenced.
5512
5520
For heavyweight checkouts, this checks that there are no local commits
5602
5610
5603
5611
5604
5612
class cmd_view(Command):
5605
__doc__ = """Manage filtered views.
5613
"""Manage filtered views.
5606
5614
5607
5615
Views provide a mask over the tree so that users can focus on
5608
5616
a subset of a tree when doing their work. After creating a view,
5756
5764
5757
5765
5758
5766
class cmd_hooks(Command):
5759
__doc__ = """Show hooks."""
5767
"""Show hooks."""
5760
5768
5761
5769
hidden = True
5762
5770
5776
5784
5777
5785
5778
5786
class cmd_remove_branch(Command):
5779
__doc__ = """Remove a branch.
5787
"""Remove a branch.
5780
5788
5781
5789
This will remove the branch from the specified location but
5782
5790
will keep any working tree or repository in place.
5801
5809
5802
5810
5803
5811
class cmd_shelve(Command):
5804
__doc__ = """Temporarily set aside some changes from the current tree.
5812
"""Temporarily set aside some changes from the current tree.
5805
5813
5806
5814
Shelve allows you to temporarily put changes you've made "on the shelf",
5807
5815
ie. out of the way, until a later time when you can bring them back from
5860
5868
5861
5869
def run_for_list(self):
5862
5870
tree = WorkingTree.open_containing('.')[0]
5863
self.add_cleanup(tree.lock_read().unlock)
5871
tree.lock_read()
5872
self.add_cleanup(tree.unlock)
5864
5873
manager = tree.get_shelf_manager()
5865
5874
shelves = manager.active_shelves()
5866
5875
if len(shelves) == 0:
5875
5884
5876
5885
5877
5886
class cmd_unshelve(Command):
5878
__doc__ = """Restore shelved changes.
5887
"""Restore shelved changes.
5879
5888
5880
5889
By default, the most recently shelved changes are restored. However if you
5881
5890
specify a shelf by id those changes will be restored instead. This works
5907
5916
5908
5917
5909
5918
class cmd_clean_tree(Command):
5910
__doc__ = """Remove unwanted files from working tree.
5919
"""Remove unwanted files from working tree.
5911
5920
5912
5921
By default, only unknown files, not ignored files, are deleted. Versioned
5913
5922
files are never deleted.
5941
5950
5942
5951
5943
5952
class cmd_reference(Command):
5944
__doc__ = """list, view and set branch locations for nested trees.
5953
"""list, view and set branch locations for nested trees.
5945
5954
5946
5955
If no arguments are provided, lists the branch locations for nested trees.
5947
5956
If one argument is provided, display the branch location for that tree.
Loggerhead is a web-based interface for Breezy
Version: 2.0.1