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