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