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 5151.2.4
- compare with another revision
- download diff
- download tarball
- view history from revision 5151.2.4
- Committer: John Arbash Meinel
- Date: 2010-04-14 05:06:53 UTC
- mto: (5050.3.2 2.2)
- mto: This revision was merged to the branch mainline in revision 5157.
- Revision ID: john@arbash-meinel.com-20100414050653-5l0z0hn2pk2y2uf5
Minor tweak
- files removed:
- bzrlib/tests/commands/test_revert.py
- 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)
991
tree_to.lock_write()
992
self.add_cleanup(tree_to.unlock)
981
993
except errors.NoWorkingTree:
982
994
tree_to = None
983
995
branch_to = Branch.open_containing(directory)[0]
984
self.add_cleanup(branch_to.lock_write().unlock)
996
branch_to.lock_write()
997
self.add_cleanup(branch_to.unlock)
985
998
986
999
if local and not branch_to.get_bound_location():
987
1000
raise errors.LocalRequiresBoundBranch()
1018
1031
else:
1019
1032
branch_from = Branch.open(location,
1020
1033
possible_transports=possible_transports)
1021
self.add_cleanup(branch_from.lock_read().unlock)
1034
branch_from.lock_read()
1035
self.add_cleanup(branch_from.unlock)
1022
1036
1023
1037
if branch_to.get_parent() is None or remember:
1024
1038
branch_to.set_parent(branch_from.base)
1046
1060
1047
1061
1048
1062
class cmd_push(Command):
1049
__doc__ = """Update a mirror of this branch.
1063
"""Update a mirror of this branch.
1050
1064
1051
1065
The target branch will not have its working tree populated because this
1052
1066
is both expensive, and is not supported on remote file systems.
1120
1134
else:
1121
1135
revision_id = None
1122
1136
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.')
1137
tree.warn_if_changed_or_out_of_date(
1138
strict, 'push_strict', 'Use --no-strict to force the push.')
1127
1139
# Get the stacked_on branch, if any
1128
1140
if stacked_on is not None:
1129
1141
stacked_on = urlutils.normalize_url(stacked_on)
1161
1173
1162
1174
1163
1175
class cmd_branch(Command):
1164
__doc__ = """Create a new branch that is a copy of an existing branch.
1176
"""Create a new branch that is a copy of an existing branch.
1165
1177
1166
1178
If the TO_LOCATION is omitted, the last component of the FROM_LOCATION will
1167
1179
be used. In other words, "branch ../foo/bar" will attempt to create ./bar.
1207
1219
accelerator_tree, br_from = bzrdir.BzrDir.open_tree_or_branch(
1208
1220
from_location)
1209
1221
revision = _get_one_revision('branch', revision)
1210
self.add_cleanup(br_from.lock_read().unlock)
1222
br_from.lock_read()
1223
self.add_cleanup(br_from.unlock)
1211
1224
if revision is not None:
1212
1225
revision_id = revision.as_revision_id(br_from)
1213
1226
else:
1273
1286
1274
1287
1275
1288
class cmd_checkout(Command):
1276
__doc__ = """Create a new checkout of an existing branch.
1289
"""Create a new checkout of an existing branch.
1277
1290
1278
1291
If BRANCH_LOCATION is omitted, checkout will reconstitute a working tree for
1279
1292
the branch found in '.'. This is useful if you have removed the working tree
1342
1355
1343
1356
1344
1357
class cmd_renames(Command):
1345
__doc__ = """Show list of renamed files.
1358
"""Show list of renamed files.
1346
1359
"""
1347
1360
# TODO: Option to show renames between two historical versions.
1348
1361
1353
1366
@display_command
1354
1367
def run(self, dir=u'.'):
1355
1368
tree = WorkingTree.open_containing(dir)[0]
1356
self.add_cleanup(tree.lock_read().unlock)
1369
tree.lock_read()
1370
self.add_cleanup(tree.unlock)
1357
1371
new_inv = tree.inventory
1358
1372
old_tree = tree.basis_tree()
1359
self.add_cleanup(old_tree.lock_read().unlock)
1373
old_tree.lock_read()
1374
self.add_cleanup(old_tree.unlock)
1360
1375
old_inv = old_tree.inventory
1361
1376
renames = []
1362
1377
iterator = tree.iter_changes(old_tree, include_unchanged=True)
1372
1387
1373
1388
1374
1389
class cmd_update(Command):
1375
__doc__ = """Update a tree to have the latest code committed to its branch.
1390
"""Update a tree to have the latest code committed to its branch.
1376
1391
1377
1392
This will perform a merge into the working tree, and may generate
1378
1393
conflicts. If you have any local changes, you will still
1400
1415
master = branch.get_master_branch(
1401
1416
possible_transports=possible_transports)
1402
1417
if master is not None:
1418
tree.lock_write()
1403
1419
branch_location = master.base
1404
tree.lock_write()
1405
1420
else:
1421
tree.lock_tree_write()
1406
1422
branch_location = tree.branch.base
1407
tree.lock_tree_write()
1408
1423
self.add_cleanup(tree.unlock)
1409
1424
# get rid of the final '/' and be ready for display
1410
1425
branch_location = urlutils.unescape_for_display(
1447
1462
_mod_revision.ensure_null(tree.last_revision()))
1448
1463
note('Updated to revision %s of branch %s' %
1449
1464
('.'.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:
1465
if tree.get_parent_ids()[1:] != existing_pending_merges:
1452
1466
note('Your local commits will now show as pending merges with '
1453
1467
"'bzr status', and can be committed with 'bzr commit'.")
1454
1468
if conflicts != 0:
1458
1472
1459
1473
1460
1474
class cmd_info(Command):
1461
__doc__ = """Show information about a working tree, branch or repository.
1475
"""Show information about a working tree, branch or repository.
1462
1476
1463
1477
This command will show all known locations and formats associated to the
1464
1478
tree, branch or repository.
1502
1516
1503
1517
1504
1518
class cmd_remove(Command):
1505
__doc__ = """Remove files or directories.
1519
"""Remove files or directories.
1506
1520
1507
1521
This makes bzr stop tracking changes to the specified files. bzr will delete
1508
1522
them if they can easily be recovered using revert. If no options or
1530
1544
if file_list is not None:
1531
1545
file_list = [f for f in file_list]
1532
1546
1533
self.add_cleanup(tree.lock_write().unlock)
1547
tree.lock_write()
1548
self.add_cleanup(tree.unlock)
1534
1549
# Heuristics should probably all move into tree.remove_smart or
1535
1550
# some such?
1536
1551
if new:
1555
1570
1556
1571
1557
1572
class cmd_file_id(Command):
1558
__doc__ = """Print file_id of a particular file or directory.
1573
"""Print file_id of a particular file or directory.
1559
1574
1560
1575
The file_id is assigned when the file is first added and remains the
1561
1576
same through all revisions where the file exists, even when it is
1577
1592
1578
1593
1579
1594
class cmd_file_path(Command):
1580
__doc__ = """Print path of file_ids to a file or directory.
1595
"""Print path of file_ids to a file or directory.
1581
1596
1582
1597
This prints one line for each directory down to the target,
1583
1598
starting at the branch root.
1599
1614
1600
1615
1601
1616
class cmd_reconcile(Command):
1602
__doc__ = """Reconcile bzr metadata in a branch.
1617
"""Reconcile bzr metadata in a branch.
1603
1618
1604
1619
This can correct data mismatches that may have been caused by
1605
1620
previous ghost operations or bzr upgrades. You should only
1627
1642
1628
1643
1629
1644
class cmd_revision_history(Command):
1630
__doc__ = """Display the list of revision ids on a branch."""
1645
"""Display the list of revision ids on a branch."""
1631
1646
1632
1647
_see_also = ['log']
1633
1648
takes_args = ['location?']
1643
1658
1644
1659
1645
1660
class cmd_ancestry(Command):
1646
__doc__ = """List all revisions merged into this branch."""
1661
"""List all revisions merged into this branch."""
1647
1662
1648
1663
_see_also = ['log', 'revision-history']
1649
1664
takes_args = ['location?']
1668
1683
1669
1684
1670
1685
class cmd_init(Command):
1671
__doc__ = """Make a directory into a versioned branch.
1686
"""Make a directory into a versioned branch.
1672
1687
1673
1688
Use this to create an empty branch, or before importing an
1674
1689
existing project.
1777
1792
1778
1793
1779
1794
class cmd_init_repository(Command):
1780
__doc__ = """Create a shared repository for branches to share storage space.
1795
"""Create a shared repository for branches to share storage space.
1781
1796
1782
1797
New branches created under the repository directory will store their
1783
1798
revisions in the repository, not in the branch directory. For branches
1837
1852
1838
1853
1839
1854
class cmd_diff(Command):
1840
__doc__ = """Show differences in the working tree, between revisions or branches.
1855
"""Show differences in the working tree, between revisions or branches.
1841
1856
1842
1857
If no arguments are given, all changes for the current tree are listed.
1843
1858
If files are given, only the changes in those files are listed.
1940
1955
@display_command
1941
1956
def run(self, revision=None, file_list=None, diff_options=None,
1942
1957
prefix=None, old=None, new=None, using=None, format=None):
1943
from bzrlib.diff import (get_trees_and_branches_to_diff_locked,
1958
from bzrlib.diff import (get_trees_and_branches_to_diff,
1944
1959
show_diff_trees)
1945
1960
1946
1961
if (prefix is None) or (prefix == '0'):
1967
1982
1968
1983
(old_tree, new_tree,
1969
1984
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)
1985
specific_files, extra_trees) = get_trees_and_branches_to_diff(
1986
file_list, revision, old, new, apply_view=True)
1972
1987
return show_diff_trees(old_tree, new_tree, sys.stdout,
1973
1988
specific_files=specific_files,
1974
1989
external_diff_options=diff_options,
1978
1993
1979
1994
1980
1995
class cmd_deleted(Command):
1981
__doc__ = """List files deleted in the working tree.
1996
"""List files deleted in the working tree.
1982
1997
"""
1983
1998
# TODO: Show files deleted since a previous revision, or
1984
1999
# between two revisions.
1992
2007
@display_command
1993
2008
def run(self, show_ids=False):
1994
2009
tree = WorkingTree.open_containing(u'.')[0]
1995
self.add_cleanup(tree.lock_read().unlock)
2010
tree.lock_read()
2011
self.add_cleanup(tree.unlock)
1996
2012
old = tree.basis_tree()
1997
self.add_cleanup(old.lock_read().unlock)
2013
old.lock_read()
2014
self.add_cleanup(old.unlock)
1998
2015
for path, ie in old.inventory.iter_entries():
1999
2016
if not tree.has_id(ie.file_id):
2000
2017
self.outf.write(path)
2005
2022
2006
2023
2007
2024
class cmd_modified(Command):
2008
__doc__ = """List files modified in working tree.
2025
"""List files modified in working tree.
2009
2026
"""
2010
2027
2011
2028
hidden = True
2028
2045
2029
2046
2030
2047
class cmd_added(Command):
2031
__doc__ = """List files added in working tree.
2048
"""List files added in working tree.
2032
2049
"""
2033
2050
2034
2051
hidden = True
2042
2059
@display_command
2043
2060
def run(self, null=False):
2044
2061
wt = WorkingTree.open_containing(u'.')[0]
2045
self.add_cleanup(wt.lock_read().unlock)
2062
wt.lock_read()
2063
self.add_cleanup(wt.unlock)
2046
2064
basis = wt.basis_tree()
2047
self.add_cleanup(basis.lock_read().unlock)
2065
basis.lock_read()
2066
self.add_cleanup(basis.unlock)
2048
2067
basis_inv = basis.inventory
2049
2068
inv = wt.inventory
2050
2069
for file_id in inv:
2062
2081
2063
2082
2064
2083
class cmd_root(Command):
2065
__doc__ = """Show the tree root directory.
2084
"""Show the tree root directory.
2066
2085
2067
2086
The root is the nearest enclosing directory with a .bzr control
2068
2087
directory."""
2092
2111
2093
2112
2094
2113
class cmd_log(Command):
2095
__doc__ = """Show historical log for a branch or subset of a branch.
2114
"""Show historical log for a branch or subset of a branch.
2096
2115
2097
2116
log is bzr's default tool for exploring the history of a branch.
2098
2117
The branch to use is taken from the first parameter. If no parameters
2279
2298
help='Show changes made in each revision as a patch.'),
2280
2299
Option('include-merges',
2281
2300
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
2301
]
2287
2302
encoding_type = 'replace'
2288
2303
2298
2313
message=None,
2299
2314
limit=None,
2300
2315
show_diff=False,
2301
include_merges=False,
2302
exclude_common_ancestry=False,
2303
):
2316
include_merges=False):
2304
2317
from bzrlib.log import (
2305
2318
Logger,
2306
2319
make_log_request_dict,
2307
2320
_get_info_for_log_files,
2308
2321
)
2309
2322
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
2323
if include_merges:
2315
2324
if levels is None:
2316
2325
levels = 0
2332
2341
if file_list:
2333
2342
# find the file ids to log and check for directory filtering
2334
2343
b, file_info_list, rev1, rev2 = _get_info_for_log_files(
2335
revision, file_list, self.add_cleanup)
2344
revision, file_list)
2345
self.add_cleanup(b.unlock)
2336
2346
for relpath, file_id, kind in file_info_list:
2337
2347
if file_id is None:
2338
2348
raise errors.BzrCommandError(
2356
2366
location = '.'
2357
2367
dir, relpath = bzrdir.BzrDir.open_containing(location)
2358
2368
b = dir.open_branch()
2359
self.add_cleanup(b.lock_read().unlock)
2369
b.lock_read()
2370
self.add_cleanup(b.unlock)
2360
2371
rev1, rev2 = _get_revision_range(revision, b, self.name())
2361
2372
2362
2373
# Decide on the type of delta & diff filtering to use
2407
2418
direction=direction, specific_fileids=file_ids,
2408
2419
start_revision=rev1, end_revision=rev2, limit=limit,
2409
2420
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
)
2421
diff_type=diff_type, _match_using_deltas=match_using_deltas)
2413
2422
Logger(b, rqst).show(lf)
2414
2423
2415
2424
2473
2482
2474
2483
2475
2484
class cmd_touching_revisions(Command):
2476
__doc__ = """Return revision-ids which affected a particular file.
2485
"""Return revision-ids which affected a particular file.
2477
2486
2478
2487
A more user-friendly interface is "bzr log FILE".
2479
2488
"""
2486
2495
tree, relpath = WorkingTree.open_containing(filename)
2487
2496
file_id = tree.path2id(relpath)
2488
2497
b = tree.branch
2489
self.add_cleanup(b.lock_read().unlock)
2498
b.lock_read()
2499
self.add_cleanup(b.unlock)
2490
2500
touching_revs = log.find_touching_revisions(b, file_id)
2491
2501
for revno, revision_id, what in touching_revs:
2492
2502
self.outf.write("%6d %s\n" % (revno, what))
2493
2503
2494
2504
2495
2505
class cmd_ls(Command):
2496
__doc__ = """List files in a tree.
2506
"""List files in a tree.
2497
2507
"""
2498
2508
2499
2509
_see_also = ['status', 'cat']
2561
2571
view_str = views.view_display_str(view_files)
2562
2572
note("Ignoring files outside view. View is %s" % view_str)
2563
2573
2564
self.add_cleanup(tree.lock_read().unlock)
2574
tree.lock_read()
2575
self.add_cleanup(tree.unlock)
2565
2576
for fp, fc, fkind, fid, entry in tree.list_files(include_root=False,
2566
2577
from_dir=relpath, recursive=recursive):
2567
2578
# Apply additional masking
2609
2620
2610
2621
2611
2622
class cmd_unknowns(Command):
2612
__doc__ = """List unknown files.
2623
"""List unknown files.
2613
2624
"""
2614
2625
2615
2626
hidden = True
2622
2633
2623
2634
2624
2635
class cmd_ignore(Command):
2625
__doc__ = """Ignore specified files or patterns.
2636
"""Ignore specified files or patterns.
2626
2637
2627
2638
See ``bzr help patterns`` for details on the syntax of patterns.
2628
2639
2637
2648
using this command or directly by using an editor, be sure to commit
2638
2649
it.
2639
2650
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
2651
Patterns prefixed with '!' are exceptions to ignore patterns and take
2647
2652
precedence over regular ignores. Such exceptions are used to specify
2648
2653
files that should be versioned which would otherwise be ignored.
2689
2694
_see_also = ['status', 'ignored', 'patterns']
2690
2695
takes_args = ['name_pattern*']
2691
2696
takes_options = [
2692
Option('default-rules',
2693
help='Display the default ignore rules that bzr uses.')
2697
Option('old-default-rules',
2698
help='Write out the ignore rules bzr < 0.9 always used.')
2694
2699
]
2695
2700
2696
def run(self, name_pattern_list=None, default_rules=None):
2701
def run(self, name_pattern_list=None, old_default_rules=None):
2697
2702
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:
2703
if old_default_rules is not None:
2704
# dump the rules and exit
2705
for pattern in ignores.OLD_DEFAULTS:
2701
2706
self.outf.write("%s\n" % pattern)
2702
2707
return
2703
2708
if not name_pattern_list:
2704
2709
raise errors.BzrCommandError("ignore requires at least one "
2705
"NAME_PATTERN or --default-rules.")
2710
"NAME_PATTERN or --old-default-rules")
2706
2711
name_pattern_list = [globbing.normalize_pattern(p)
2707
2712
for p in name_pattern_list]
2708
2713
for name_pattern in name_pattern_list:
2730
2735
2731
2736
2732
2737
class cmd_ignored(Command):
2733
__doc__ = """List ignored files and the patterns that matched them.
2738
"""List ignored files and the patterns that matched them.
2734
2739
2735
2740
List all the ignored files and the ignore pattern that caused the file to
2736
2741
be ignored.
2746
2751
@display_command
2747
2752
def run(self):
2748
2753
tree = WorkingTree.open_containing(u'.')[0]
2749
self.add_cleanup(tree.lock_read().unlock)
2754
tree.lock_read()
2755
self.add_cleanup(tree.unlock)
2750
2756
for path, file_class, kind, file_id, entry in tree.list_files():
2751
2757
if file_class != 'I':
2752
2758
continue
2756
2762
2757
2763
2758
2764
class cmd_lookup_revision(Command):
2759
__doc__ = """Lookup the revision-id from a revision-number
2765
"""Lookup the revision-id from a revision-number
2760
2766
2761
2767
:Examples:
2762
2768
bzr lookup-revision 33
2776
2782
2777
2783
2778
2784
class cmd_export(Command):
2779
__doc__ = """Export current or past revision to a destination directory or archive.
2785
"""Export current or past revision to a destination directory or archive.
2780
2786
2781
2787
If no revision is specified this exports the last committed revision.
2782
2788
2839
2845
2840
2846
2841
2847
class cmd_cat(Command):
2842
__doc__ = """Write the contents of a file as of a given revision to standard output.
2848
"""Write the contents of a file as of a given revision to standard output.
2843
2849
2844
2850
If no revision is nominated, the last revision is used.
2845
2851
2865
2871
" one revision specifier")
2866
2872
tree, branch, relpath = \
2867
2873
bzrdir.BzrDir.open_containing_tree_or_branch(filename)
2868
self.add_cleanup(branch.lock_read().unlock)
2874
branch.lock_read()
2875
self.add_cleanup(branch.unlock)
2869
2876
return self._run(tree, branch, relpath, filename, revision,
2870
2877
name_from_revision, filters)
2871
2878
2874
2881
if tree is None:
2875
2882
tree = b.basis_tree()
2876
2883
rev_tree = _get_one_revision_tree('cat', revision, branch=b)
2877
self.add_cleanup(rev_tree.lock_read().unlock)
2884
rev_tree.lock_read()
2885
self.add_cleanup(rev_tree.unlock)
2878
2886
2879
2887
old_file_id = rev_tree.path2id(relpath)
2880
2888
2923
2931
2924
2932
2925
2933
class cmd_local_time_offset(Command):
2926
__doc__ = """Show the offset in seconds from GMT to local time."""
2934
"""Show the offset in seconds from GMT to local time."""
2927
2935
hidden = True
2928
2936
@display_command
2929
2937
def run(self):
2932
2940
2933
2941
2934
2942
class cmd_commit(Command):
2935
__doc__ = """Commit changes into a new revision.
2943
"""Commit changes into a new revision.
2936
2944
2937
2945
An explanatory message needs to be given for each commit. This is
2938
2946
often done by using the --message option (getting the message from the
3046
3054
"the master branch until a normal commit "
3047
3055
"is performed."
3048
3056
),
3049
Option('show-diff', short_name='p',
3057
Option('show-diff',
3050
3058
help='When no message is supplied, show the diff along'
3051
3059
' with the status summary in the message editor.'),
3052
3060
]
3198
3206
3199
3207
3200
3208
class cmd_check(Command):
3201
__doc__ = """Validate working tree structure, branch consistency and repository history.
3209
"""Validate working tree structure, branch consistency and repository history.
3202
3210
3203
3211
This command checks various invariants about branch and repository storage
3204
3212
to detect data corruption or bzr bugs.
3268
3276
3269
3277
3270
3278
class cmd_upgrade(Command):
3271
__doc__ = """Upgrade branch storage to current format.
3279
"""Upgrade branch storage to current format.
3272
3280
3273
3281
The check command or bzr developers may sometimes advise you to run
3274
3282
this command. When the default format has changed you may also be warned
3292
3300
3293
3301
3294
3302
class cmd_whoami(Command):
3295
__doc__ = """Show or set bzr user id.
3303
"""Show or set bzr user id.
3296
3304
3297
3305
:Examples:
3298
3306
Show the email of the current user::
3342
3350
3343
3351
3344
3352
class cmd_nick(Command):
3345
__doc__ = """Print or set the branch nickname.
3353
"""Print or set the branch nickname.
3346
3354
3347
3355
If unset, the tree root directory name is used as the nickname.
3348
3356
To print the current nickname, execute with no argument.
3366
3374
3367
3375
3368
3376
class cmd_alias(Command):
3369
__doc__ = """Set/unset and display aliases.
3377
"""Set/unset and display aliases.
3370
3378
3371
3379
:Examples:
3372
3380
Show the current aliases::
3436
3444
3437
3445
3438
3446
class cmd_selftest(Command):
3439
__doc__ = """Run internal test suite.
3447
"""Run internal test suite.
3440
3448
3441
3449
If arguments are given, they are regular expressions that say which tests
3442
3450
should run. Tests matching any expression are run, and other tests are
3583
3591
raise errors.BzrCommandError("subunit not available. subunit "
3584
3592
"needs to be installed to use --subunit.")
3585
3593
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
3594
if parallel:
3592
3595
self.additional_selftest_args.setdefault(
3593
3596
'suite_decorators', []).append(parallel)
3624
3627
3625
3628
3626
3629
class cmd_version(Command):
3627
__doc__ = """Show version of bzr."""
3630
"""Show version of bzr."""
3628
3631
3629
3632
encoding_type = 'replace'
3630
3633
takes_options = [
3641
3644
3642
3645
3643
3646
class cmd_rocks(Command):
3644
__doc__ = """Statement of optimism."""
3647
"""Statement of optimism."""
3645
3648
3646
3649
hidden = True
3647
3650
3651
3654
3652
3655
3653
3656
class cmd_find_merge_base(Command):
3654
__doc__ = """Find and print a base revision for merging two branches."""
3657
"""Find and print a base revision for merging two branches."""
3655
3658
# TODO: Options to specify revisions on either side, as if
3656
3659
# merging only part of the history.
3657
3660
takes_args = ['branch', 'other']
3663
3666
3664
3667
branch1 = Branch.open_containing(branch)[0]
3665
3668
branch2 = Branch.open_containing(other)[0]
3666
self.add_cleanup(branch1.lock_read().unlock)
3667
self.add_cleanup(branch2.lock_read().unlock)
3669
branch1.lock_read()
3670
self.add_cleanup(branch1.unlock)
3671
branch2.lock_read()
3672
self.add_cleanup(branch2.unlock)
3668
3673
last1 = ensure_null(branch1.last_revision())
3669
3674
last2 = ensure_null(branch2.last_revision())
3670
3675
3675
3680
3676
3681
3677
3682
class cmd_merge(Command):
3678
__doc__ = """Perform a three-way merge.
3683
"""Perform a three-way merge.
3679
3684
3680
3685
The source of the merge can be specified either in the form of a branch,
3681
3686
or in the form of a path to a file containing a merge directive generated
3808
3813
unversioned_filter=tree.is_ignored, view_info=view_info)
3809
3814
pb = ui.ui_factory.nested_progress_bar()
3810
3815
self.add_cleanup(pb.finished)
3811
self.add_cleanup(tree.lock_write().unlock)
3816
tree.lock_write()
3817
self.add_cleanup(tree.unlock)
3812
3818
if location is not None:
3813
3819
try:
3814
3820
mergeable = bundle.read_mergeable_from_url(location,
4035
4041
4036
4042
4037
4043
class cmd_remerge(Command):
4038
__doc__ = """Redo a merge.
4044
"""Redo a merge.
4039
4045
4040
4046
Use this if you want to try a different merge technique while resolving
4041
4047
conflicts. Some merge techniques are better than others, and remerge
4070
4076
if merge_type is None:
4071
4077
merge_type = _mod_merge.Merge3Merger
4072
4078
tree, file_list = tree_files(file_list)
4073
self.add_cleanup(tree.lock_write().unlock)
4079
tree.lock_write()
4080
self.add_cleanup(tree.unlock)
4074
4081
parents = tree.get_parent_ids()
4075
4082
if len(parents) != 2:
4076
4083
raise errors.BzrCommandError("Sorry, remerge only works after normal"
4129
4136
4130
4137
4131
4138
class cmd_revert(Command):
4132
__doc__ = """Revert files to a previous revision.
4139
"""Revert files to a previous revision.
4133
4140
4134
4141
Giving a list of files will revert only those files. Otherwise, all files
4135
4142
will be reverted. If the revision is not specified with '--revision', the
4186
4193
def run(self, revision=None, no_backup=False, file_list=None,
4187
4194
forget_merges=None):
4188
4195
tree, file_list = tree_files(file_list)
4189
self.add_cleanup(tree.lock_tree_write().unlock)
4196
tree.lock_write()
4197
self.add_cleanup(tree.unlock)
4190
4198
if forget_merges:
4191
4199
tree.set_parent_ids(tree.get_parent_ids()[:1])
4192
4200
else:
4200
4208
4201
4209
4202
4210
class cmd_assert_fail(Command):
4203
__doc__ = """Test reporting of assertion failures"""
4211
"""Test reporting of assertion failures"""
4204
4212
# intended just for use in testing
4205
4213
4206
4214
hidden = True
4210
4218
4211
4219
4212
4220
class cmd_help(Command):
4213
__doc__ = """Show help on a command or other topic.
4221
"""Show help on a command or other topic.
4214
4222
"""
4215
4223
4216
4224
_see_also = ['topics']
4229
4237
4230
4238
4231
4239
class cmd_shell_complete(Command):
4232
__doc__ = """Show appropriate completions for context.
4240
"""Show appropriate completions for context.
4233
4241
4234
4242
For a list of all available commands, say 'bzr shell-complete'.
4235
4243
"""
4244
4252
4245
4253
4246
4254
class cmd_missing(Command):
4247
__doc__ = """Show unmerged/unpulled revisions between two branches.
4255
"""Show unmerged/unpulled revisions between two branches.
4248
4256
4249
4257
OTHER_BRANCH may be local or remote.
4250
4258
4328
4336
restrict = 'remote'
4329
4337
4330
4338
local_branch = Branch.open_containing(u".")[0]
4331
self.add_cleanup(local_branch.lock_read().unlock)
4339
local_branch.lock_read()
4340
self.add_cleanup(local_branch.unlock)
4332
4341
4333
4342
parent = local_branch.get_parent()
4334
4343
if other_branch is None:
4345
4354
if remote_branch.base == local_branch.base:
4346
4355
remote_branch = local_branch
4347
4356
else:
4348
self.add_cleanup(remote_branch.lock_read().unlock)
4357
remote_branch.lock_read()
4358
self.add_cleanup(remote_branch.unlock)
4349
4359
4350
4360
local_revid_range = _revision_range_to_revid_range(
4351
4361
_get_revision_range(my_revision, local_branch,
4406
4416
message("Branches are up to date.\n")
4407
4417
self.cleanup_now()
4408
4418
if not status_code and parent is None and other_branch is not None:
4409
self.add_cleanup(local_branch.lock_write().unlock)
4419
local_branch.lock_write()
4420
self.add_cleanup(local_branch.unlock)
4410
4421
# handle race conditions - a parent might be set while we run.
4411
4422
if local_branch.get_parent() is None:
4412
4423
local_branch.set_parent(remote_branch.base)
4414
4425
4415
4426
4416
4427
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
"""
4428
"""Compress the data within a repository."""
4434
4429
4435
4430
_see_also = ['repositories']
4436
4431
takes_args = ['branch_or_repo?']
4437
takes_options = [
4438
Option('clean-obsolete-packs', 'Delete obsolete packs to save disk space.'),
4439
]
4440
4432
4441
def run(self, branch_or_repo='.', clean_obsolete_packs=False):
4433
def run(self, branch_or_repo='.'):
4442
4434
dir = bzrdir.BzrDir.open_containing(branch_or_repo)[0]
4443
4435
try:
4444
4436
branch = dir.open_branch()
4445
4437
repository = branch.repository
4446
4438
except errors.NotBranchError:
4447
4439
repository = dir.open_repository()
4448
repository.pack(clean_obsolete_packs=clean_obsolete_packs)
4440
repository.pack()
4449
4441
4450
4442
4451
4443
class cmd_plugins(Command):
4452
__doc__ = """List the installed plugins.
4444
"""List the installed plugins.
4453
4445
4454
4446
This command displays the list of installed plugins including
4455
4447
version of plugin and a short description of each.
4494
4486
4495
4487
4496
4488
class cmd_testament(Command):
4497
__doc__ = """Show testament (signing-form) of a revision."""
4489
"""Show testament (signing-form) of a revision."""
4498
4490
takes_options = [
4499
4491
'revision',
4500
4492
Option('long', help='Produce long-format testament.'),
4512
4504
b = Branch.open_containing(branch)[0]
4513
4505
else:
4514
4506
b = Branch.open(branch)
4515
self.add_cleanup(b.lock_read().unlock)
4507
b.lock_read()
4508
self.add_cleanup(b.unlock)
4516
4509
if revision is None:
4517
4510
rev_id = b.last_revision()
4518
4511
else:
4525
4518
4526
4519
4527
4520
class cmd_annotate(Command):
4528
__doc__ = """Show the origin of each line in a file.
4521
"""Show the origin of each line in a file.
4529
4522
4530
4523
This prints out the given file with an annotation on the left side
4531
4524
indicating which revision, author and date introduced the change.
4552
4545
wt, branch, relpath = \
4553
4546
bzrdir.BzrDir.open_containing_tree_or_branch(filename)
4554
4547
if wt is not None:
4555
self.add_cleanup(wt.lock_read().unlock)
4548
wt.lock_read()
4549
self.add_cleanup(wt.unlock)
4556
4550
else:
4557
self.add_cleanup(branch.lock_read().unlock)
4551
branch.lock_read()
4552
self.add_cleanup(branch.unlock)
4558
4553
tree = _get_one_revision_tree('annotate', revision, branch=branch)
4559
self.add_cleanup(tree.lock_read().unlock)
4554
tree.lock_read()
4555
self.add_cleanup(tree.unlock)
4560
4556
if wt is not None:
4561
4557
file_id = wt.path2id(relpath)
4562
4558
else:
4575
4571
4576
4572
4577
4573
class cmd_re_sign(Command):
4578
__doc__ = """Create a digital signature for an existing revision."""
4574
"""Create a digital signature for an existing revision."""
4579
4575
# TODO be able to replace existing ones.
4580
4576
4581
4577
hidden = True # is this right ?
4588
4584
if revision_id_list is None and revision is None:
4589
4585
raise errors.BzrCommandError('You must supply either --revision or a revision_id')
4590
4586
b = WorkingTree.open_containing(u'.')[0].branch
4591
self.add_cleanup(b.lock_write().unlock)
4587
b.lock_write()
4588
self.add_cleanup(b.unlock)
4592
4589
return self._run(b, revision_id_list, revision)
4593
4590
4594
4591
def _run(self, b, revision_id_list, revision):
4640
4637
4641
4638
4642
4639
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.
4640
"""Convert the current branch into a checkout of the supplied branch.
4645
4641
4646
4642
Once converted into a checkout, commits must succeed on the master branch
4647
4643
before they will be applied to the local branch.
4681
4677
4682
4678
4683
4679
class cmd_unbind(Command):
4684
__doc__ = """Convert the current checkout into a regular branch.
4680
"""Convert the current checkout into a regular branch.
4685
4681
4686
4682
After unbinding, the local branch is considered independent and subsequent
4687
4683
commits will be local only.
4698
4694
4699
4695
4700
4696
class cmd_uncommit(Command):
4701
__doc__ = """Remove the last committed revision.
4697
"""Remove the last committed revision.
4702
4698
4703
4699
--verbose will print out what is being removed.
4704
4700
--dry-run will go through all the motions, but not actually
4744
4740
b = control.open_branch()
4745
4741
4746
4742
if tree is not None:
4747
self.add_cleanup(tree.lock_write().unlock)
4743
tree.lock_write()
4744
self.add_cleanup(tree.unlock)
4748
4745
else:
4749
self.add_cleanup(b.lock_write().unlock)
4746
b.lock_write()
4747
self.add_cleanup(b.unlock)
4750
4748
return self._run(b, tree, dry_run, verbose, revision, force, local=local)
4751
4749
4752
4750
def _run(self, b, tree, dry_run, verbose, revision, force, local=False):
4804
4802
4805
4803
4806
4804
class cmd_break_lock(Command):
4807
__doc__ = """Break a dead lock on a repository, branch or working directory.
4805
"""Break a dead lock on a repository, branch or working directory.
4808
4806
4809
4807
CAUTION: Locks should only be broken when you are sure that the process
4810
4808
holding the lock has been stopped.
4829
4827
4830
4828
4831
4829
class cmd_wait_until_signalled(Command):
4832
__doc__ = """Test helper for test_start_and_stop_bzr_subprocess_send_signal.
4830
"""Test helper for test_start_and_stop_bzr_subprocess_send_signal.
4833
4831
4834
4832
This just prints a line to signal when it is ready, then blocks on stdin.
4835
4833
"""
4843
4841
4844
4842
4845
4843
class cmd_serve(Command):
4846
__doc__ = """Run the bzr server."""
4844
"""Run the bzr server."""
4847
4845
4848
4846
aliases = ['server']
4849
4847
4909
4907
4910
4908
4911
4909
class cmd_join(Command):
4912
__doc__ = """Combine a tree into its containing tree.
4910
"""Combine a tree into its containing tree.
4913
4911
4914
4912
This command requires the target tree to be in a rich-root format.
4915
4913
4955
4953
4956
4954
4957
4955
class cmd_split(Command):
4958
__doc__ = """Split a subdirectory of a tree into a separate tree.
4956
"""Split a subdirectory of a tree into a separate tree.
4959
4957
4960
4958
This command will produce a target tree in a format that supports
4961
4959
rich roots, like 'rich-root' or 'rich-root-pack'. These formats cannot be
4981
4979
4982
4980
4983
4981
class cmd_merge_directive(Command):
4984
__doc__ = """Generate a merge directive for auto-merge tools.
4982
"""Generate a merge directive for auto-merge tools.
4985
4983
4986
4984
A directive requests a merge to be performed, and also provides all the
4987
4985
information necessary to do so. This means it must either include a
5080
5078
5081
5079
5082
5080
class cmd_send(Command):
5083
__doc__ = """Mail or create a merge-directive for submitting changes.
5081
"""Mail or create a merge-directive for submitting changes.
5084
5082
5085
5083
A merge directive provides many things needed for requesting merges:
5086
5084
5197
5195
5198
5196
5199
5197
class cmd_bundle_revisions(cmd_send):
5200
__doc__ = """Create a merge-directive for submitting changes.
5198
"""Create a merge-directive for submitting changes.
5201
5199
5202
5200
A merge directive provides many things needed for requesting merges:
5203
5201
5270
5268
5271
5269
5272
5270
class cmd_tag(Command):
5273
__doc__ = """Create, remove or modify a tag naming a revision.
5271
"""Create, remove or modify a tag naming a revision.
5274
5272
5275
5273
Tags give human-meaningful names to revisions. Commands that take a -r
5276
5274
(--revision) option can be given -rtag:X, where X is any previously
5315
5313
revision=None,
5316
5314
):
5317
5315
branch, relpath = Branch.open_containing(directory)
5318
self.add_cleanup(branch.lock_write().unlock)
5316
branch.lock_write()
5317
self.add_cleanup(branch.unlock)
5319
5318
if delete:
5320
5319
if tag_name is None:
5321
5320
raise errors.BzrCommandError("No tag specified to delete.")
5342
5341
5343
5342
5344
5343
class cmd_tags(Command):
5345
__doc__ = """List tags.
5344
"""List tags.
5346
5345
5347
5346
This command shows a table of tag names and the revisions they reference.
5348
5347
"""
5376
5375
if not tags:
5377
5376
return
5378
5377
5379
self.add_cleanup(branch.lock_read().unlock)
5378
branch.lock_read()
5379
self.add_cleanup(branch.unlock)
5380
5380
if revision:
5381
5381
graph = branch.repository.get_graph()
5382
5382
rev1, rev2 = _get_revision_range(revision, branch, self.name())
5415
5415
5416
5416
5417
5417
class cmd_reconfigure(Command):
5418
__doc__ = """Reconfigure the type of a bzr directory.
5418
"""Reconfigure the type of a bzr directory.
5419
5419
5420
5420
A target configuration must be specified.
5421
5421
5506
5506
5507
5507
5508
5508
class cmd_switch(Command):
5509
__doc__ = """Set the branch of a checkout and update.
5509
"""Set the branch of a checkout and update.
5510
5510
5511
5511
For lightweight checkouts, this changes the branch being referenced.
5512
5512
For heavyweight checkouts, this checks that there are no local commits
5602
5602
5603
5603
5604
5604
class cmd_view(Command):
5605
__doc__ = """Manage filtered views.
5605
"""Manage filtered views.
5606
5606
5607
5607
Views provide a mask over the tree so that users can focus on
5608
5608
a subset of a tree when doing their work. After creating a view,
5756
5756
5757
5757
5758
5758
class cmd_hooks(Command):
5759
__doc__ = """Show hooks."""
5759
"""Show hooks."""
5760
5760
5761
5761
hidden = True
5762
5762
5776
5776
5777
5777
5778
5778
class cmd_remove_branch(Command):
5779
__doc__ = """Remove a branch.
5779
"""Remove a branch.
5780
5780
5781
5781
This will remove the branch from the specified location but
5782
5782
will keep any working tree or repository in place.
5801
5801
5802
5802
5803
5803
class cmd_shelve(Command):
5804
__doc__ = """Temporarily set aside some changes from the current tree.
5804
"""Temporarily set aside some changes from the current tree.
5805
5805
5806
5806
Shelve allows you to temporarily put changes you've made "on the shelf",
5807
5807
ie. out of the way, until a later time when you can bring them back from
5860
5860
5861
5861
def run_for_list(self):
5862
5862
tree = WorkingTree.open_containing('.')[0]
5863
self.add_cleanup(tree.lock_read().unlock)
5863
tree.lock_read()
5864
self.add_cleanup(tree.unlock)
5864
5865
manager = tree.get_shelf_manager()
5865
5866
shelves = manager.active_shelves()
5866
5867
if len(shelves) == 0:
5875
5876
5876
5877
5877
5878
class cmd_unshelve(Command):
5878
__doc__ = """Restore shelved changes.
5879
"""Restore shelved changes.
5879
5880
5880
5881
By default, the most recently shelved changes are restored. However if you
5881
5882
specify a shelf by id those changes will be restored instead. This works
5907
5908
5908
5909
5909
5910
class cmd_clean_tree(Command):
5910
__doc__ = """Remove unwanted files from working tree.
5911
"""Remove unwanted files from working tree.
5911
5912
5912
5913
By default, only unknown files, not ignored files, are deleted. Versioned
5913
5914
files are never deleted.
5941
5942
5942
5943
5943
5944
class cmd_reference(Command):
5944
__doc__ = """list, view and set branch locations for nested trees.
5945
"""list, view and set branch locations for nested trees.
5945
5946
5946
5947
If no arguments are provided, lists the branch locations for nested trees.
5947
5948
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