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 5141.2.1
- compare with another revision
- download diff
- download tarball
- view history from revision 5141.2.1
- Committer: Robert Collins
- Date: 2010-04-09 03:58:14 UTC
- mto: This revision was merged to the branch mainline in revision 5146.
- Revision ID: robertc@robertcollins.net-20100409035814-eqayfeknoncyoctr
``bzrlib.commands.Command.run_direct`` is no longer needed - the pre
2.1 method of calling run() to perform testing or direct use via the API
is now possible again. As part of this, the _operation attribute on
Command is now transient and only exists for the duration of ``run()``.
(Robert Collins)
2.1 method of calling run() to perform testing or direct use via the API
is now possible again. As part of this, the _operation attribute on
Command is now transient and only exists for the duration of ``run()``.
(Robert Collins)
- files added:
- bzrlib/benchmarks
- bzrlib/benchmarks/tree_creator
- files removed:
- bzrlib/library_state.py
- bzrlib/plugins/bash_completion
- bzrlib/plugins/bash_completion/tests
- bzrlib/tests/per_bzrdir_colo
- files modified:
- INSTALL
added
removed
bzrlib/builtins.py
180
180
view_str = views.view_display_str(view_files)
181
181
note("Ignoring files outside view. View is %s" % view_str)
182
182
return tree, file_list
183
tree = WorkingTree.open_containing(file_list[0])[0]
183
tree = WorkingTree.open_containing(osutils.realpath(file_list[0]))[0]
184
184
return tree, safe_relpath_files(tree, file_list, canonicalize,
185
185
apply_view=apply_view)
186
186
232
232
return view_info
233
233
234
234
235
def _open_directory_or_containing_tree_or_branch(filename, directory):
236
"""Open the tree or branch containing the specified file, unless
237
the --directory option is used to specify a different branch."""
238
if directory is not None:
239
return (None, Branch.open(directory), filename)
240
return bzrdir.BzrDir.open_containing_tree_or_branch(filename)
241
242
243
235
# TODO: Make sure no commands unconditionally use the working directory as a
244
236
# branch. If a filename argument is used, the first of them should be used to
245
237
# specify the branch. (Perhaps this can be factored out into some kind of
247
239
# opens the branch?)
248
240
249
241
class cmd_status(Command):
250
__doc__ = """Display status summary.
242
"""Display status summary.
251
243
252
244
This reports on versioned and unknown files, reporting them
253
245
grouped by state. Possible states are:
340
332
341
333
342
334
class cmd_cat_revision(Command):
343
__doc__ = """Write out metadata for a revision.
335
"""Write out metadata for a revision.
344
336
345
337
The revision to print can either be specified by a specific
346
338
revision identifier, or you can use --revision.
348
340
349
341
hidden = True
350
342
takes_args = ['revision_id?']
351
takes_options = ['directory', 'revision']
343
takes_options = ['revision']
352
344
# cat-revision is more for frontends so should be exact
353
345
encoding = 'strict'
354
346
361
353
self.outf.write(revtext.decode('utf-8'))
362
354
363
355
@display_command
364
def run(self, revision_id=None, revision=None, directory=u'.'):
356
def run(self, revision_id=None, revision=None):
365
357
if revision_id is not None and revision is not None:
366
358
raise errors.BzrCommandError('You can only supply one of'
367
359
' revision_id or --revision')
368
360
if revision_id is None and revision is None:
369
361
raise errors.BzrCommandError('You must supply either'
370
362
' --revision or a revision_id')
371
b = WorkingTree.open_containing(directory)[0].branch
363
b = WorkingTree.open_containing(u'.')[0].branch
372
364
373
365
revisions = b.repository.revisions
374
366
if revisions is None:
398
390
399
391
400
392
class cmd_dump_btree(Command):
401
__doc__ = """Dump the contents of a btree index file to stdout.
393
"""Dump the contents of a btree index file to stdout.
402
394
403
395
PATH is a btree index file, it can be any URL. This includes things like
404
396
.bzr/repository/pack-names, or .bzr/repository/indices/a34b3a...ca4a4.iix
479
471
480
472
481
473
class cmd_remove_tree(Command):
482
__doc__ = """Remove the working tree from a given branch/checkout.
474
"""Remove the working tree from a given branch/checkout.
483
475
484
476
Since a lightweight checkout is little more than a working tree
485
477
this will refuse to run against one.
491
483
takes_options = [
492
484
Option('force',
493
485
help='Remove the working tree even if it has '
494
'uncommitted or shelved changes.'),
486
'uncommitted changes.'),
495
487
]
496
488
497
489
def run(self, location_list, force=False):
511
503
if not force:
512
504
if (working.has_changes()):
513
505
raise errors.UncommittedChanges(working)
514
if working.get_shelf_manager().last_shelf() is not None:
515
raise errors.ShelvedChanges(working)
516
506
517
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:
518
510
raise errors.BzrCommandError("You cannot remove the working tree"
519
511
" from a lightweight checkout")
520
512
522
514
523
515
524
516
class cmd_revno(Command):
525
__doc__ = """Show current revision number.
517
"""Show current revision number.
526
518
527
519
This is equal to the number of revisions on this branch.
528
520
"""
538
530
if tree:
539
531
try:
540
532
wt = WorkingTree.open_containing(location)[0]
541
self.add_cleanup(wt.lock_read().unlock)
533
wt.lock_read()
542
534
except (errors.NoWorkingTree, errors.NotLocalUrl):
543
535
raise errors.NoWorkingTree(location)
536
self.add_cleanup(wt.unlock)
544
537
revid = wt.last_revision()
545
538
try:
546
539
revno_t = wt.branch.revision_id_to_dotted_revno(revid)
549
542
revno = ".".join(str(n) for n in revno_t)
550
543
else:
551
544
b = Branch.open_containing(location)[0]
552
self.add_cleanup(b.lock_read().unlock)
545
b.lock_read()
546
self.add_cleanup(b.unlock)
553
547
revno = b.revno()
554
548
self.cleanup_now()
555
549
self.outf.write(str(revno) + '\n')
556
550
557
551
558
552
class cmd_revision_info(Command):
559
__doc__ = """Show revision number and revision id for a given revision identifier.
553
"""Show revision number and revision id for a given revision identifier.
560
554
"""
561
555
hidden = True
562
556
takes_args = ['revision_info*']
563
557
takes_options = [
564
558
'revision',
565
custom_help('directory',
559
Option('directory',
566
560
help='Branch to examine, '
567
'rather than the one containing the working directory.'),
561
'rather than the one containing the working directory.',
562
short_name='d',
563
type=unicode,
564
),
568
565
Option('tree', help='Show revno of working tree'),
569
566
]
570
567
575
572
try:
576
573
wt = WorkingTree.open_containing(directory)[0]
577
574
b = wt.branch
578
self.add_cleanup(wt.lock_read().unlock)
575
wt.lock_read()
576
self.add_cleanup(wt.unlock)
579
577
except (errors.NoWorkingTree, errors.NotLocalUrl):
580
578
wt = None
581
579
b = Branch.open_containing(directory)[0]
582
self.add_cleanup(b.lock_read().unlock)
580
b.lock_read()
581
self.add_cleanup(b.unlock)
583
582
revision_ids = []
584
583
if revision is not None:
585
584
revision_ids.extend(rev.as_revision_id(b) for rev in revision)
613
612
614
613
615
614
class cmd_add(Command):
616
__doc__ = """Add specified files or directories.
615
"""Add specified files or directories.
617
616
618
617
In non-recursive mode, all the named items are added, regardless
619
618
of whether they were previously ignored. A warning is given if
684
683
should_print=(not is_quiet()))
685
684
686
685
if base_tree:
687
self.add_cleanup(base_tree.lock_read().unlock)
686
base_tree.lock_read()
687
self.add_cleanup(base_tree.unlock)
688
688
tree, file_list = tree_files_for_add(file_list)
689
689
added, ignored = tree.smart_add(file_list, not
690
690
no_recurse, action=action, save=not dry_run)
698
698
699
699
700
700
class cmd_mkdir(Command):
701
__doc__ = """Create a new versioned directory.
701
"""Create a new versioned directory.
702
702
703
703
This is equivalent to creating the directory and then adding it.
704
704
"""
720
720
721
721
722
722
class cmd_relpath(Command):
723
__doc__ = """Show path of a file relative to root"""
723
"""Show path of a file relative to root"""
724
724
725
725
takes_args = ['filename']
726
726
hidden = True
735
735
736
736
737
737
class cmd_inventory(Command):
738
__doc__ = """Show inventory of the current working copy or a revision.
738
"""Show inventory of the current working copy or a revision.
739
739
740
740
It is possible to limit the output to a particular entry
741
741
type using the --kind option. For example: --kind file.
762
762
763
763
revision = _get_one_revision('inventory', revision)
764
764
work_tree, file_list = tree_files(file_list)
765
self.add_cleanup(work_tree.lock_read().unlock)
765
work_tree.lock_read()
766
self.add_cleanup(work_tree.unlock)
766
767
if revision is not None:
767
768
tree = revision.as_tree(work_tree.branch)
768
769
769
770
extra_trees = [work_tree]
770
self.add_cleanup(tree.lock_read().unlock)
771
tree.lock_read()
772
self.add_cleanup(tree.unlock)
771
773
else:
772
774
tree = work_tree
773
775
extra_trees = []
794
796
795
797
796
798
class cmd_mv(Command):
797
__doc__ = """Move or rename a file.
799
"""Move or rename a file.
798
800
799
801
:Usage:
800
802
bzr mv OLDNAME NEWNAME
833
835
if len(names_list) < 2:
834
836
raise errors.BzrCommandError("missing file argument")
835
837
tree, rel_names = tree_files(names_list, canonicalize=False)
836
self.add_cleanup(tree.lock_tree_write().unlock)
838
tree.lock_tree_write()
839
self.add_cleanup(tree.unlock)
837
840
self._run(tree, names_list, rel_names, after)
838
841
839
842
def run_auto(self, names_list, after, dry_run):
844
847
raise errors.BzrCommandError('--after cannot be specified with'
845
848
' --auto.')
846
849
work_tree, file_list = tree_files(names_list, default_branch='.')
847
self.add_cleanup(work_tree.lock_tree_write().unlock)
850
work_tree.lock_tree_write()
851
self.add_cleanup(work_tree.unlock)
848
852
rename_map.RenameMap.guess_renames(work_tree, dry_run)
849
853
850
854
def _run(self, tree, names_list, rel_names, after):
929
933
930
934
931
935
class cmd_pull(Command):
932
__doc__ = """Turn this branch into a mirror of another branch.
936
"""Turn this branch into a mirror of another branch.
933
937
934
938
By default, this command only works on branches that have not diverged.
935
939
Branches are considered diverged if the destination branch's most recent
958
962
takes_options = ['remember', 'overwrite', 'revision',
959
963
custom_help('verbose',
960
964
help='Show logs of pulled revisions.'),
961
custom_help('directory',
965
Option('directory',
962
966
help='Branch to pull into, '
963
'rather than the one containing the working directory.'),
967
'rather than the one containing the working directory.',
968
short_name='d',
969
type=unicode,
970
),
964
971
Option('local',
965
972
help="Perform a local pull in a bound "
966
973
"branch. Local pulls are not applied to "
981
988
try:
982
989
tree_to = WorkingTree.open_containing(directory)[0]
983
990
branch_to = tree_to.branch
984
self.add_cleanup(tree_to.lock_write().unlock)
985
991
except errors.NoWorkingTree:
986
992
tree_to = None
987
993
branch_to = Branch.open_containing(directory)[0]
988
self.add_cleanup(branch_to.lock_write().unlock)
989
994
990
995
if local and not branch_to.get_bound_location():
991
996
raise errors.LocalRequiresBoundBranch()
992
997
1022
1027
else:
1023
1028
branch_from = Branch.open(location,
1024
1029
possible_transports=possible_transports)
1025
self.add_cleanup(branch_from.lock_read().unlock)
1026
1030
1027
1031
if branch_to.get_parent() is None or remember:
1028
1032
branch_to.set_parent(branch_from.base)
1029
1033
1034
if branch_from is not branch_to:
1035
branch_from.lock_read()
1036
self.add_cleanup(branch_from.unlock)
1030
1037
if revision is not None:
1031
1038
revision_id = revision.as_revision_id(branch_from)
1032
1039
1040
branch_to.lock_write()
1041
self.add_cleanup(branch_to.unlock)
1033
1042
if tree_to is not None:
1034
1043
view_info = _get_view_info_for_change_reporter(tree_to)
1035
1044
change_reporter = delta._ChangeReporter(
1050
1059
1051
1060
1052
1061
class cmd_push(Command):
1053
__doc__ = """Update a mirror of this branch.
1062
"""Update a mirror of this branch.
1054
1063
1055
1064
The target branch will not have its working tree populated because this
1056
1065
is both expensive, and is not supported on remote file systems.
1080
1089
Option('create-prefix',
1081
1090
help='Create the path leading up to the branch '
1082
1091
'if it does not already exist.'),
1083
custom_help('directory',
1092
Option('directory',
1084
1093
help='Branch to push from, '
1085
'rather than the one containing the working directory.'),
1094
'rather than the one containing the working directory.',
1095
short_name='d',
1096
type=unicode,
1097
),
1086
1098
Option('use-existing-dir',
1087
1099
help='By default push will fail if the target'
1088
1100
' directory exists, but does not already'
1114
1126
# Get the source branch
1115
1127
(tree, br_from,
1116
1128
_unused) = bzrdir.BzrDir.open_containing_tree_or_branch(directory)
1129
if strict is None:
1130
strict = br_from.get_config().get_user_option_as_bool('push_strict')
1131
if strict is None: strict = True # default value
1117
1132
# Get the tip's revision_id
1118
1133
revision = _get_one_revision('push', revision)
1119
1134
if revision is not None:
1120
1135
revision_id = revision.in_history(br_from).rev_id
1121
1136
else:
1122
1137
revision_id = None
1123
if tree is not None and revision_id is None:
1124
tree.check_changed_or_out_of_date(
1125
strict, 'push_strict',
1126
more_error='Use --no-strict to force the push.',
1127
more_warning='Uncommitted changes will not be pushed.')
1138
if strict and tree is not None and revision_id is None:
1139
if (tree.has_changes()):
1140
raise errors.UncommittedChanges(
1141
tree, more='Use --no-strict to force the push.')
1142
if tree.last_revision() != tree.branch.last_revision():
1143
# The tree has lost sync with its branch, there is little
1144
# chance that the user is aware of it but he can still force
1145
# the push with --no-strict
1146
raise errors.OutOfDateTree(
1147
tree, more='Use --no-strict to force the push.')
1148
1128
1149
# Get the stacked_on branch, if any
1129
1150
if stacked_on is not None:
1130
1151
stacked_on = urlutils.normalize_url(stacked_on)
1162
1183
1163
1184
1164
1185
class cmd_branch(Command):
1165
__doc__ = """Create a new branch that is a copy of an existing branch.
1186
"""Create a new branch that is a copy of an existing branch.
1166
1187
1167
1188
If the TO_LOCATION is omitted, the last component of the FROM_LOCATION will
1168
1189
be used. In other words, "branch ../foo/bar" will attempt to create ./bar.
1208
1229
accelerator_tree, br_from = bzrdir.BzrDir.open_tree_or_branch(
1209
1230
from_location)
1210
1231
revision = _get_one_revision('branch', revision)
1211
self.add_cleanup(br_from.lock_read().unlock)
1232
br_from.lock_read()
1233
self.add_cleanup(br_from.unlock)
1212
1234
if revision is not None:
1213
1235
revision_id = revision.as_revision_id(br_from)
1214
1236
else:
1274
1296
1275
1297
1276
1298
class cmd_checkout(Command):
1277
__doc__ = """Create a new checkout of an existing branch.
1299
"""Create a new checkout of an existing branch.
1278
1300
1279
1301
If BRANCH_LOCATION is omitted, checkout will reconstitute a working tree for
1280
1302
the branch found in '.'. This is useful if you have removed the working tree
1343
1365
1344
1366
1345
1367
class cmd_renames(Command):
1346
__doc__ = """Show list of renamed files.
1368
"""Show list of renamed files.
1347
1369
"""
1348
1370
# TODO: Option to show renames between two historical versions.
1349
1371
1354
1376
@display_command
1355
1377
def run(self, dir=u'.'):
1356
1378
tree = WorkingTree.open_containing(dir)[0]
1357
self.add_cleanup(tree.lock_read().unlock)
1379
tree.lock_read()
1380
self.add_cleanup(tree.unlock)
1358
1381
new_inv = tree.inventory
1359
1382
old_tree = tree.basis_tree()
1360
self.add_cleanup(old_tree.lock_read().unlock)
1383
old_tree.lock_read()
1384
self.add_cleanup(old_tree.unlock)
1361
1385
old_inv = old_tree.inventory
1362
1386
renames = []
1363
1387
iterator = tree.iter_changes(old_tree, include_unchanged=True)
1373
1397
1374
1398
1375
1399
class cmd_update(Command):
1376
__doc__ = """Update a tree to have the latest code committed to its branch.
1400
"""Update a tree to have the latest code committed to its branch.
1377
1401
1378
1402
This will perform a merge into the working tree, and may generate
1379
1403
conflicts. If you have any local changes, you will still
1401
1425
master = branch.get_master_branch(
1402
1426
possible_transports=possible_transports)
1403
1427
if master is not None:
1428
tree.lock_write()
1404
1429
branch_location = master.base
1405
tree.lock_write()
1406
1430
else:
1431
tree.lock_tree_write()
1407
1432
branch_location = tree.branch.base
1408
tree.lock_tree_write()
1409
1433
self.add_cleanup(tree.unlock)
1410
1434
# get rid of the final '/' and be ready for display
1411
1435
branch_location = urlutils.unescape_for_display(
1448
1472
_mod_revision.ensure_null(tree.last_revision()))
1449
1473
note('Updated to revision %s of branch %s' %
1450
1474
('.'.join(map(str, revno)), branch_location))
1451
parent_ids = tree.get_parent_ids()
1452
if parent_ids[1:] and parent_ids[1:] != existing_pending_merges:
1475
if tree.get_parent_ids()[1:] != existing_pending_merges:
1453
1476
note('Your local commits will now show as pending merges with '
1454
1477
"'bzr status', and can be committed with 'bzr commit'.")
1455
1478
if conflicts != 0:
1459
1482
1460
1483
1461
1484
class cmd_info(Command):
1462
__doc__ = """Show information about a working tree, branch or repository.
1485
"""Show information about a working tree, branch or repository.
1463
1486
1464
1487
This command will show all known locations and formats associated to the
1465
1488
tree, branch or repository.
1503
1526
1504
1527
1505
1528
class cmd_remove(Command):
1506
__doc__ = """Remove files or directories.
1529
"""Remove files or directories.
1507
1530
1508
1531
This makes bzr stop tracking changes to the specified files. bzr will delete
1509
1532
them if they can easily be recovered using revert. If no options or
1531
1554
if file_list is not None:
1532
1555
file_list = [f for f in file_list]
1533
1556
1534
self.add_cleanup(tree.lock_write().unlock)
1557
tree.lock_write()
1558
self.add_cleanup(tree.unlock)
1535
1559
# Heuristics should probably all move into tree.remove_smart or
1536
1560
# some such?
1537
1561
if new:
1556
1580
1557
1581
1558
1582
class cmd_file_id(Command):
1559
__doc__ = """Print file_id of a particular file or directory.
1583
"""Print file_id of a particular file or directory.
1560
1584
1561
1585
The file_id is assigned when the file is first added and remains the
1562
1586
same through all revisions where the file exists, even when it is
1578
1602
1579
1603
1580
1604
class cmd_file_path(Command):
1581
__doc__ = """Print path of file_ids to a file or directory.
1605
"""Print path of file_ids to a file or directory.
1582
1606
1583
1607
This prints one line for each directory down to the target,
1584
1608
starting at the branch root.
1600
1624
1601
1625
1602
1626
class cmd_reconcile(Command):
1603
__doc__ = """Reconcile bzr metadata in a branch.
1627
"""Reconcile bzr metadata in a branch.
1604
1628
1605
1629
This can correct data mismatches that may have been caused by
1606
1630
previous ghost operations or bzr upgrades. You should only
1628
1652
1629
1653
1630
1654
class cmd_revision_history(Command):
1631
__doc__ = """Display the list of revision ids on a branch."""
1655
"""Display the list of revision ids on a branch."""
1632
1656
1633
1657
_see_also = ['log']
1634
1658
takes_args = ['location?']
1644
1668
1645
1669
1646
1670
class cmd_ancestry(Command):
1647
__doc__ = """List all revisions merged into this branch."""
1671
"""List all revisions merged into this branch."""
1648
1672
1649
1673
_see_also = ['log', 'revision-history']
1650
1674
takes_args = ['location?']
1669
1693
1670
1694
1671
1695
class cmd_init(Command):
1672
__doc__ = """Make a directory into a versioned branch.
1696
"""Make a directory into a versioned branch.
1673
1697
1674
1698
Use this to create an empty branch, or before importing an
1675
1699
existing project.
1778
1802
1779
1803
1780
1804
class cmd_init_repository(Command):
1781
__doc__ = """Create a shared repository for branches to share storage space.
1805
"""Create a shared repository for branches to share storage space.
1782
1806
1783
1807
New branches created under the repository directory will store their
1784
1808
revisions in the repository, not in the branch directory. For branches
1838
1862
1839
1863
1840
1864
class cmd_diff(Command):
1841
__doc__ = """Show differences in the working tree, between revisions or branches.
1865
"""Show differences in the working tree, between revisions or branches.
1842
1866
1843
1867
If no arguments are given, all changes for the current tree are listed.
1844
1868
If files are given, only the changes in those files are listed.
1941
1965
@display_command
1942
1966
def run(self, revision=None, file_list=None, diff_options=None,
1943
1967
prefix=None, old=None, new=None, using=None, format=None):
1944
from bzrlib.diff import (get_trees_and_branches_to_diff_locked,
1968
from bzrlib.diff import (get_trees_and_branches_to_diff,
1945
1969
show_diff_trees)
1946
1970
1947
1971
if (prefix is None) or (prefix == '0'):
1968
1992
1969
1993
(old_tree, new_tree,
1970
1994
old_branch, new_branch,
1971
specific_files, extra_trees) = get_trees_and_branches_to_diff_locked(
1972
file_list, revision, old, new, self.add_cleanup, apply_view=True)
1973
# GNU diff on Windows uses ANSI encoding for filenames
1974
path_encoding = osutils.get_diff_header_encoding()
1995
specific_files, extra_trees) = get_trees_and_branches_to_diff(
1996
file_list, revision, old, new, apply_view=True)
1975
1997
return show_diff_trees(old_tree, new_tree, sys.stdout,
1976
1998
specific_files=specific_files,
1977
1999
external_diff_options=diff_options,
1978
2000
old_label=old_label, new_label=new_label,
1979
extra_trees=extra_trees,
1980
path_encoding=path_encoding,
1981
using=using,
2001
extra_trees=extra_trees, using=using,
1982
2002
format_cls=format)
1983
2003
1984
2004
1985
2005
class cmd_deleted(Command):
1986
__doc__ = """List files deleted in the working tree.
2006
"""List files deleted in the working tree.
1987
2007
"""
1988
2008
# TODO: Show files deleted since a previous revision, or
1989
2009
# between two revisions.
1992
2012
# level of effort but possibly much less IO. (Or possibly not,
1993
2013
# if the directories are very large...)
1994
2014
_see_also = ['status', 'ls']
1995
takes_options = ['directory', 'show-ids']
2015
takes_options = ['show-ids']
1996
2016
1997
2017
@display_command
1998
def run(self, show_ids=False, directory=u'.'):
1999
tree = WorkingTree.open_containing(directory)[0]
2000
self.add_cleanup(tree.lock_read().unlock)
2018
def run(self, show_ids=False):
2019
tree = WorkingTree.open_containing(u'.')[0]
2020
tree.lock_read()
2021
self.add_cleanup(tree.unlock)
2001
2022
old = tree.basis_tree()
2002
self.add_cleanup(old.lock_read().unlock)
2023
old.lock_read()
2024
self.add_cleanup(old.unlock)
2003
2025
for path, ie in old.inventory.iter_entries():
2004
2026
if not tree.has_id(ie.file_id):
2005
2027
self.outf.write(path)
2010
2032
2011
2033
2012
2034
class cmd_modified(Command):
2013
__doc__ = """List files modified in working tree.
2035
"""List files modified in working tree.
2014
2036
"""
2015
2037
2016
2038
hidden = True
2017
2039
_see_also = ['status', 'ls']
2018
takes_options = ['directory', 'null']
2040
takes_options = [
2041
Option('null',
2042
help='Write an ascii NUL (\\0) separator '
2043
'between files rather than a newline.')
2044
]
2019
2045
2020
2046
@display_command
2021
def run(self, null=False, directory=u'.'):
2022
tree = WorkingTree.open_containing(directory)[0]
2047
def run(self, null=False):
2048
tree = WorkingTree.open_containing(u'.')[0]
2023
2049
td = tree.changes_from(tree.basis_tree())
2024
2050
for path, id, kind, text_modified, meta_modified in td.modified:
2025
2051
if null:
2029
2055
2030
2056
2031
2057
class cmd_added(Command):
2032
__doc__ = """List files added in working tree.
2058
"""List files added in working tree.
2033
2059
"""
2034
2060
2035
2061
hidden = True
2036
2062
_see_also = ['status', 'ls']
2037
takes_options = ['directory', 'null']
2063
takes_options = [
2064
Option('null',
2065
help='Write an ascii NUL (\\0) separator '
2066
'between files rather than a newline.')
2067
]
2038
2068
2039
2069
@display_command
2040
def run(self, null=False, directory=u'.'):
2041
wt = WorkingTree.open_containing(directory)[0]
2042
self.add_cleanup(wt.lock_read().unlock)
2070
def run(self, null=False):
2071
wt = WorkingTree.open_containing(u'.')[0]
2072
wt.lock_read()
2073
self.add_cleanup(wt.unlock)
2043
2074
basis = wt.basis_tree()
2044
self.add_cleanup(basis.lock_read().unlock)
2075
basis.lock_read()
2076
self.add_cleanup(basis.unlock)
2045
2077
basis_inv = basis.inventory
2046
2078
inv = wt.inventory
2047
2079
for file_id in inv:
2050
2082
if inv.is_root(file_id) and len(basis_inv) == 0:
2051
2083
continue
2052
2084
path = inv.id2path(file_id)
2053
if not os.access(osutils.pathjoin(wt.basedir, path), os.F_OK):
2085
if not os.access(osutils.abspath(path), os.F_OK):
2054
2086
continue
2055
2087
if null:
2056
2088
self.outf.write(path + '\0')
2059
2091
2060
2092
2061
2093
class cmd_root(Command):
2062
__doc__ = """Show the tree root directory.
2094
"""Show the tree root directory.
2063
2095
2064
2096
The root is the nearest enclosing directory with a .bzr control
2065
2097
directory."""
2089
2121
2090
2122
2091
2123
class cmd_log(Command):
2092
__doc__ = """Show historical log for a branch or subset of a branch.
2124
"""Show historical log for a branch or subset of a branch.
2093
2125
2094
2126
log is bzr's default tool for exploring the history of a branch.
2095
2127
The branch to use is taken from the first parameter. If no parameters
2256
2288
help='Show just the specified revision.'
2257
2289
' See also "help revisionspec".'),
2258
2290
'log-format',
2259
RegistryOption('authors',
2260
'What names to list as authors - first, all or committer.',
2261
title='Authors',
2262
lazy_registry=('bzrlib.log', 'author_list_registry'),
2263
),
2264
2291
Option('levels',
2265
2292
short_name='n',
2266
2293
help='Number of levels to display - 0 for all, 1 for flat.',
2281
2308
help='Show changes made in each revision as a patch.'),
2282
2309
Option('include-merges',
2283
2310
help='Show merged revisions like --levels 0 does.'),
2284
Option('exclude-common-ancestry',
2285
help='Display only the revisions that are not part'
2286
' of both ancestries (require -rX..Y)'
2287
)
2288
2311
]
2289
2312
encoding_type = 'replace'
2290
2313
2300
2323
message=None,
2301
2324
limit=None,
2302
2325
show_diff=False,
2303
include_merges=False,
2304
authors=None,
2305
exclude_common_ancestry=False,
2306
):
2326
include_merges=False):
2307
2327
from bzrlib.log import (
2308
2328
Logger,
2309
2329
make_log_request_dict,
2310
2330
_get_info_for_log_files,
2311
2331
)
2312
2332
direction = (forward and 'forward') or 'reverse'
2313
if (exclude_common_ancestry
2314
and (revision is None or len(revision) != 2)):
2315
raise errors.BzrCommandError(
2316
'--exclude-common-ancestry requires -r with two revisions')
2317
2333
if include_merges:
2318
2334
if levels is None:
2319
2335
levels = 0
2335
2351
if file_list:
2336
2352
# find the file ids to log and check for directory filtering
2337
2353
b, file_info_list, rev1, rev2 = _get_info_for_log_files(
2338
revision, file_list, self.add_cleanup)
2354
revision, file_list)
2355
self.add_cleanup(b.unlock)
2339
2356
for relpath, file_id, kind in file_info_list:
2340
2357
if file_id is None:
2341
2358
raise errors.BzrCommandError(
2359
2376
location = '.'
2360
2377
dir, relpath = bzrdir.BzrDir.open_containing(location)
2361
2378
b = dir.open_branch()
2362
self.add_cleanup(b.lock_read().unlock)
2379
b.lock_read()
2380
self.add_cleanup(b.unlock)
2363
2381
rev1, rev2 = _get_revision_range(revision, b, self.name())
2364
2382
2365
2383
# Decide on the type of delta & diff filtering to use
2385
2403
show_timezone=timezone,
2386
2404
delta_format=get_verbosity_level(),
2387
2405
levels=levels,
2388
show_advice=levels is None,
2389
author_list_handler=authors)
2406
show_advice=levels is None)
2390
2407
2391
2408
# Choose the algorithm for doing the logging. It's annoying
2392
2409
# having multiple code paths like this but necessary until
2411
2428
direction=direction, specific_fileids=file_ids,
2412
2429
start_revision=rev1, end_revision=rev2, limit=limit,
2413
2430
message_search=message, delta_type=delta_type,
2414
diff_type=diff_type, _match_using_deltas=match_using_deltas,
2415
exclude_common_ancestry=exclude_common_ancestry,
2416
)
2431
diff_type=diff_type, _match_using_deltas=match_using_deltas)
2417
2432
Logger(b, rqst).show(lf)
2418
2433
2419
2434
2477
2492
2478
2493
2479
2494
class cmd_touching_revisions(Command):
2480
__doc__ = """Return revision-ids which affected a particular file.
2495
"""Return revision-ids which affected a particular file.
2481
2496
2482
2497
A more user-friendly interface is "bzr log FILE".
2483
2498
"""
2490
2505
tree, relpath = WorkingTree.open_containing(filename)
2491
2506
file_id = tree.path2id(relpath)
2492
2507
b = tree.branch
2493
self.add_cleanup(b.lock_read().unlock)
2508
b.lock_read()
2509
self.add_cleanup(b.unlock)
2494
2510
touching_revs = log.find_touching_revisions(b, file_id)
2495
2511
for revno, revision_id, what in touching_revs:
2496
2512
self.outf.write("%6d %s\n" % (revno, what))
2497
2513
2498
2514
2499
2515
class cmd_ls(Command):
2500
__doc__ = """List files in a tree.
2516
"""List files in a tree.
2501
2517
"""
2502
2518
2503
2519
_see_also = ['status', 'cat']
2509
2525
help='Recurse into subdirectories.'),
2510
2526
Option('from-root',
2511
2527
help='Print paths relative to the root of the branch.'),
2512
Option('unknown', short_name='u',
2513
help='Print unknown files.'),
2528
Option('unknown', help='Print unknown files.'),
2514
2529
Option('versioned', help='Print versioned files.',
2515
2530
short_name='V'),
2516
Option('ignored', short_name='i',
2517
help='Print ignored files.'),
2518
Option('kind', short_name='k',
2531
Option('ignored', help='Print ignored files.'),
2532
Option('null',
2533
help='Write an ascii NUL (\\0) separator '
2534
'between files rather than a newline.'),
2535
Option('kind',
2519
2536
help='List entries of a particular kind: file, directory, symlink.',
2520
2537
type=unicode),
2521
'null',
2522
2538
'show-ids',
2523
'directory',
2524
2539
]
2525
2540
@display_command
2526
2541
def run(self, revision=None, verbose=False,
2527
2542
recursive=False, from_root=False,
2528
2543
unknown=False, versioned=False, ignored=False,
2529
null=False, kind=None, show_ids=False, path=None, directory=None):
2544
null=False, kind=None, show_ids=False, path=None):
2530
2545
2531
2546
if kind and kind not in ('file', 'directory', 'symlink'):
2532
2547
raise errors.BzrCommandError('invalid kind specified')
2544
2559
raise errors.BzrCommandError('cannot specify both --from-root'
2545
2560
' and PATH')
2546
2561
fs_path = path
2547
tree, branch, relpath = \
2548
_open_directory_or_containing_tree_or_branch(fs_path, directory)
2562
tree, branch, relpath = bzrdir.BzrDir.open_containing_tree_or_branch(
2563
fs_path)
2549
2564
2550
2565
# Calculate the prefix to use
2551
2566
prefix = None
2566
2581
view_str = views.view_display_str(view_files)
2567
2582
note("Ignoring files outside view. View is %s" % view_str)
2568
2583
2569
self.add_cleanup(tree.lock_read().unlock)
2584
tree.lock_read()
2585
self.add_cleanup(tree.unlock)
2570
2586
for fp, fc, fkind, fid, entry in tree.list_files(include_root=False,
2571
2587
from_dir=relpath, recursive=recursive):
2572
2588
# Apply additional masking
2614
2630
2615
2631
2616
2632
class cmd_unknowns(Command):
2617
__doc__ = """List unknown files.
2633
"""List unknown files.
2618
2634
"""
2619
2635
2620
2636
hidden = True
2621
2637
_see_also = ['ls']
2622
takes_options = ['directory']
2623
2638
2624
2639
@display_command
2625
def run(self, directory=u'.'):
2626
for f in WorkingTree.open_containing(directory)[0].unknowns():
2640
def run(self):
2641
for f in WorkingTree.open_containing(u'.')[0].unknowns():
2627
2642
self.outf.write(osutils.quotefn(f) + '\n')
2628
2643
2629
2644
2630
2645
class cmd_ignore(Command):
2631
__doc__ = """Ignore specified files or patterns.
2646
"""Ignore specified files or patterns.
2632
2647
2633
2648
See ``bzr help patterns`` for details on the syntax of patterns.
2634
2649
2643
2658
using this command or directly by using an editor, be sure to commit
2644
2659
it.
2645
2660
2646
Bazaar also supports a global ignore file ~/.bazaar/ignore. On Windows
2647
the global ignore file can be found in the application data directory as
2648
C:\\Documents and Settings\\<user>\\Application Data\\Bazaar\\2.0\\ignore.
2649
Global ignores are not touched by this command. The global ignore file
2650
can be edited directly using an editor.
2651
2652
2661
Patterns prefixed with '!' are exceptions to ignore patterns and take
2653
2662
precedence over regular ignores. Such exceptions are used to specify
2654
2663
files that should be versioned which would otherwise be ignored.
2694
2703
2695
2704
_see_also = ['status', 'ignored', 'patterns']
2696
2705
takes_args = ['name_pattern*']
2697
takes_options = ['directory',
2698
Option('default-rules',
2699
help='Display the default ignore rules that bzr uses.')
2706
takes_options = [
2707
Option('old-default-rules',
2708
help='Write out the ignore rules bzr < 0.9 always used.')
2700
2709
]
2701
2710
2702
def run(self, name_pattern_list=None, default_rules=None,
2703
directory=u'.'):
2711
def run(self, name_pattern_list=None, old_default_rules=None):
2704
2712
from bzrlib import ignores
2705
if default_rules is not None:
2706
# dump the default rules and exit
2707
for pattern in ignores.USER_DEFAULTS:
2713
if old_default_rules is not None:
2714
# dump the rules and exit
2715
for pattern in ignores.OLD_DEFAULTS:
2708
2716
self.outf.write("%s\n" % pattern)
2709
2717
return
2710
2718
if not name_pattern_list:
2711
2719
raise errors.BzrCommandError("ignore requires at least one "
2712
"NAME_PATTERN or --default-rules.")
2720
"NAME_PATTERN or --old-default-rules")
2713
2721
name_pattern_list = [globbing.normalize_pattern(p)
2714
2722
for p in name_pattern_list]
2715
bad_patterns = ''
2716
for p in name_pattern_list:
2717
if not globbing.Globster.is_pattern_valid(p):
2718
bad_patterns += ('\n %s' % p)
2719
if bad_patterns:
2720
msg = ('Invalid ignore pattern(s) found. %s' % bad_patterns)
2721
ui.ui_factory.show_error(msg)
2722
raise errors.InvalidPattern('')
2723
2723
for name_pattern in name_pattern_list:
2724
2724
if (name_pattern[0] == '/' or
2725
2725
(len(name_pattern) > 1 and name_pattern[1] == ':')):
2726
2726
raise errors.BzrCommandError(
2727
2727
"NAME_PATTERN should not be an absolute path")
2728
tree, relpath = WorkingTree.open_containing(directory)
2728
tree, relpath = WorkingTree.open_containing(u'.')
2729
2729
ignores.tree_ignores_add_patterns(tree, name_pattern_list)
2730
2730
ignored = globbing.Globster(name_pattern_list)
2731
2731
matches = []
2732
self.add_cleanup(tree.lock_read().unlock)
2732
tree.lock_read()
2733
2733
for entry in tree.list_files():
2734
2734
id = entry[3]
2735
2735
if id is not None:
2736
2736
filename = entry[0]
2737
2737
if ignored.match(filename):
2738
2738
matches.append(filename)
2739
tree.unlock()
2739
2740
if len(matches) > 0:
2740
2741
self.outf.write("Warning: the following files are version controlled and"
2741
2742
" match your ignore pattern:\n%s"
2744
2745
2745
2746
2746
2747
class cmd_ignored(Command):
2747
__doc__ = """List ignored files and the patterns that matched them.
2748
"""List ignored files and the patterns that matched them.
2748
2749
2749
2750
List all the ignored files and the ignore pattern that caused the file to
2750
2751
be ignored.
2756
2757
2757
2758
encoding_type = 'replace'
2758
2759
_see_also = ['ignore', 'ls']
2759
takes_options = ['directory']
2760
2760
2761
2761
@display_command
2762
def run(self, directory=u'.'):
2763
tree = WorkingTree.open_containing(directory)[0]
2764
self.add_cleanup(tree.lock_read().unlock)
2762
def run(self):
2763
tree = WorkingTree.open_containing(u'.')[0]
2764
tree.lock_read()
2765
self.add_cleanup(tree.unlock)
2765
2766
for path, file_class, kind, file_id, entry in tree.list_files():
2766
2767
if file_class != 'I':
2767
2768
continue
2771
2772
2772
2773
2773
2774
class cmd_lookup_revision(Command):
2774
__doc__ = """Lookup the revision-id from a revision-number
2775
"""Lookup the revision-id from a revision-number
2775
2776
2776
2777
:Examples:
2777
2778
bzr lookup-revision 33
2778
2779
"""
2779
2780
hidden = True
2780
2781
takes_args = ['revno']
2781
takes_options = ['directory']
2782
2782
2783
2783
@display_command
2784
def run(self, revno, directory=u'.'):
2784
def run(self, revno):
2785
2785
try:
2786
2786
revno = int(revno)
2787
2787
except ValueError:
2788
2788
raise errors.BzrCommandError("not a valid revision-number: %r"
2789
2789
% revno)
2790
revid = WorkingTree.open_containing(directory)[0].branch.get_rev_id(revno)
2790
revid = WorkingTree.open_containing(u'.')[0].branch.get_rev_id(revno)
2791
2791
self.outf.write("%s\n" % revid)
2792
2792
2793
2793
2794
2794
class cmd_export(Command):
2795
__doc__ = """Export current or past revision to a destination directory or archive.
2795
"""Export current or past revision to a destination directory or archive.
2796
2796
2797
2797
If no revision is specified this exports the last committed revision.
2798
2798
2820
2820
================= =========================
2821
2821
"""
2822
2822
takes_args = ['dest', 'branch_or_subdir?']
2823
takes_options = ['directory',
2823
takes_options = [
2824
2824
Option('format',
2825
2825
help="Type of file to export to.",
2826
2826
type=unicode),
2835
2835
'revision in which it was changed.'),
2836
2836
]
2837
2837
def run(self, dest, branch_or_subdir=None, revision=None, format=None,
2838
root=None, filters=False, per_file_timestamps=False, directory=u'.'):
2838
root=None, filters=False, per_file_timestamps=False):
2839
2839
from bzrlib.export import export
2840
2840
2841
2841
if branch_or_subdir is None:
2842
tree = WorkingTree.open_containing(directory)[0]
2842
tree = WorkingTree.open_containing(u'.')[0]
2843
2843
b = tree.branch
2844
2844
subdir = None
2845
2845
else:
2855
2855
2856
2856
2857
2857
class cmd_cat(Command):
2858
__doc__ = """Write the contents of a file as of a given revision to standard output.
2858
"""Write the contents of a file as of a given revision to standard output.
2859
2859
2860
2860
If no revision is nominated, the last revision is used.
2861
2861
2864
2864
"""
2865
2865
2866
2866
_see_also = ['ls']
2867
takes_options = ['directory',
2867
takes_options = [
2868
2868
Option('name-from-revision', help='The path name in the old tree.'),
2869
2869
Option('filters', help='Apply content filters to display the '
2870
2870
'convenience form.'),
2875
2875
2876
2876
@display_command
2877
2877
def run(self, filename, revision=None, name_from_revision=False,
2878
filters=False, directory=None):
2878
filters=False):
2879
2879
if revision is not None and len(revision) != 1:
2880
2880
raise errors.BzrCommandError("bzr cat --revision takes exactly"
2881
2881
" one revision specifier")
2882
2882
tree, branch, relpath = \
2883
_open_directory_or_containing_tree_or_branch(filename, directory)
2884
self.add_cleanup(branch.lock_read().unlock)
2883
bzrdir.BzrDir.open_containing_tree_or_branch(filename)
2884
branch.lock_read()
2885
self.add_cleanup(branch.unlock)
2885
2886
return self._run(tree, branch, relpath, filename, revision,
2886
2887
name_from_revision, filters)
2887
2888
2890
2891
if tree is None:
2891
2892
tree = b.basis_tree()
2892
2893
rev_tree = _get_one_revision_tree('cat', revision, branch=b)
2893
self.add_cleanup(rev_tree.lock_read().unlock)
2894
rev_tree.lock_read()
2895
self.add_cleanup(rev_tree.unlock)
2894
2896
2895
2897
old_file_id = rev_tree.path2id(relpath)
2896
2898
2939
2941
2940
2942
2941
2943
class cmd_local_time_offset(Command):
2942
__doc__ = """Show the offset in seconds from GMT to local time."""
2944
"""Show the offset in seconds from GMT to local time."""
2943
2945
hidden = True
2944
2946
@display_command
2945
2947
def run(self):
2948
2950
2949
2951
2950
2952
class cmd_commit(Command):
2951
__doc__ = """Commit changes into a new revision.
2953
"""Commit changes into a new revision.
2952
2954
2953
2955
An explanatory message needs to be given for each commit. This is
2954
2956
often done by using the --message option (getting the message from the
3062
3064
"the master branch until a normal commit "
3063
3065
"is performed."
3064
3066
),
3065
Option('show-diff', short_name='p',
3067
Option('show-diff',
3066
3068
help='When no message is supplied, show the diff along'
3067
3069
' with the status summary in the message editor.'),
3068
3070
]
3158
3160
def get_message(commit_obj):
3159
3161
"""Callback to get commit message"""
3160
3162
if file:
3161
f = codecs.open(file, 'rt', osutils.get_user_encoding())
3162
try:
3163
my_message = f.read()
3164
finally:
3165
f.close()
3163
my_message = codecs.open(
3164
file, 'rt', osutils.get_user_encoding()).read()
3166
3165
elif message is not None:
3167
3166
my_message = message
3168
3167
else:
3217
3216
3218
3217
3219
3218
class cmd_check(Command):
3220
__doc__ = """Validate working tree structure, branch consistency and repository history.
3219
"""Validate working tree structure, branch consistency and repository history.
3221
3220
3222
3221
This command checks various invariants about branch and repository storage
3223
3222
to detect data corruption or bzr bugs.
3287
3286
3288
3287
3289
3288
class cmd_upgrade(Command):
3290
__doc__ = """Upgrade branch storage to current format.
3289
"""Upgrade branch storage to current format.
3291
3290
3292
3291
The check command or bzr developers may sometimes advise you to run
3293
3292
this command. When the default format has changed you may also be warned
3311
3310
3312
3311
3313
3312
class cmd_whoami(Command):
3314
__doc__ = """Show or set bzr user id.
3313
"""Show or set bzr user id.
3315
3314
3316
3315
:Examples:
3317
3316
Show the email of the current user::
3322
3321
3323
3322
bzr whoami "Frank Chu <fchu@example.com>"
3324
3323
"""
3325
takes_options = [ 'directory',
3326
Option('email',
3324
takes_options = [ Option('email',
3327
3325
help='Display email address only.'),
3328
3326
Option('branch',
3329
3327
help='Set identity for the current branch instead of '
3333
3331
encoding_type = 'replace'
3334
3332
3335
3333
@display_command
3336
def run(self, email=False, branch=False, name=None, directory=None):
3334
def run(self, email=False, branch=False, name=None):
3337
3335
if name is None:
3338
if directory is None:
3339
# use branch if we're inside one; otherwise global config
3340
try:
3341
c = Branch.open_containing(u'.')[0].get_config()
3342
except errors.NotBranchError:
3343
c = config.GlobalConfig()
3344
else:
3345
c = Branch.open(directory).get_config()
3336
# use branch if we're inside one; otherwise global config
3337
try:
3338
c = Branch.open_containing('.')[0].get_config()
3339
except errors.NotBranchError:
3340
c = config.GlobalConfig()
3346
3341
if email:
3347
3342
self.outf.write(c.user_email() + '\n')
3348
3343
else:
3358
3353
3359
3354
# use global config unless --branch given
3360
3355
if branch:
3361
if directory is None:
3362
c = Branch.open_containing(u'.')[0].get_config()
3363
else:
3364
c = Branch.open(directory).get_config()
3356
c = Branch.open_containing('.')[0].get_config()
3365
3357
else:
3366
3358
c = config.GlobalConfig()
3367
3359
c.set_user_option('email', name)
3368
3360
3369
3361
3370
3362
class cmd_nick(Command):
3371
__doc__ = """Print or set the branch nickname.
3363
"""Print or set the branch nickname.
3372
3364
3373
3365
If unset, the tree root directory name is used as the nickname.
3374
3366
To print the current nickname, execute with no argument.
3379
3371
3380
3372
_see_also = ['info']
3381
3373
takes_args = ['nickname?']
3382
takes_options = ['directory']
3383
def run(self, nickname=None, directory=u'.'):
3384
branch = Branch.open_containing(directory)[0]
3374
def run(self, nickname=None):
3375
branch = Branch.open_containing(u'.')[0]
3385
3376
if nickname is None:
3386
3377
self.printme(branch)
3387
3378
else:
3393
3384
3394
3385
3395
3386
class cmd_alias(Command):
3396
__doc__ = """Set/unset and display aliases.
3387
"""Set/unset and display aliases.
3397
3388
3398
3389
:Examples:
3399
3390
Show the current aliases::
3463
3454
3464
3455
3465
3456
class cmd_selftest(Command):
3466
__doc__ = """Run internal test suite.
3457
"""Run internal test suite.
3467
3458
3468
3459
If arguments are given, they are regular expressions that say which tests
3469
3460
should run. Tests matching any expression are run, and other tests are
3537
3528
'throughout the test suite.',
3538
3529
type=get_transport_type),
3539
3530
Option('benchmark',
3540
help='Run the benchmarks rather than selftests.',
3541
hidden=True),
3531
help='Run the benchmarks rather than selftests.'),
3542
3532
Option('lsprof-timed',
3543
3533
help='Generate lsprof output for benchmarked'
3544
3534
' sections of code.'),
3545
3535
Option('lsprof-tests',
3546
3536
help='Generate lsprof output for each test.'),
3537
Option('cache-dir', type=str,
3538
help='Cache intermediate benchmark output in this '
3539
'directory.'),
3547
3540
Option('first',
3548
3541
help='Run all tests, but run specified tests first.',
3549
3542
short_name='f',
3583
3576
3584
3577
def run(self, testspecs_list=None, verbose=False, one=False,
3585
3578
transport=None, benchmark=None,
3586
lsprof_timed=None,
3579
lsprof_timed=None, cache_dir=None,
3587
3580
first=False, list_only=False,
3588
3581
randomize=None, exclude=None, strict=False,
3589
3582
load_list=None, debugflag=None, starting_with=None, subunit=False,
3590
3583
parallel=None, lsprof_tests=False):
3591
3584
from bzrlib.tests import selftest
3585
import bzrlib.benchmarks as benchmarks
3586
from bzrlib.benchmarks import tree_creator
3592
3587
3593
3588
# Make deprecation warnings visible, unless -Werror is set
3594
3589
symbol_versioning.activate_deprecation_warnings(override=False)
3595
3590
3591
if cache_dir is not None:
3592
tree_creator.TreeCreator.CACHE_ROOT = osutils.abspath(cache_dir)
3596
3593
if testspecs_list is not None:
3597
3594
pattern = '|'.join(testspecs_list)
3598
3595
else:
3604
3601
raise errors.BzrCommandError("subunit not available. subunit "
3605
3602
"needs to be installed to use --subunit.")
3606
3603
self.additional_selftest_args['runner_class'] = SubUnitBzrRunner
3607
# On Windows, disable automatic conversion of '\n' to '\r\n' in
3608
# stdout, which would corrupt the subunit stream.
3609
# FIXME: This has been fixed in subunit trunk (>0.0.5) so the
3610
# following code can be deleted when it's sufficiently deployed
3611
# -- vila/mgz 20100514
3612
if (sys.platform == "win32"
3613
and getattr(sys.stdout, 'fileno', None) is not None):
3614
import msvcrt
3615
msvcrt.setmode(sys.stdout.fileno(), os.O_BINARY)
3616
3604
if parallel:
3617
3605
self.additional_selftest_args.setdefault(
3618
3606
'suite_decorators', []).append(parallel)
3619
3607
if benchmark:
3620
raise errors.BzrCommandError(
3621
"--benchmark is no longer supported from bzr 2.2; "
3622
"use bzr-usertest instead")
3623
test_suite_factory = None
3608
test_suite_factory = benchmarks.test_suite
3609
# Unless user explicitly asks for quiet, be verbose in benchmarks
3610
verbose = not is_quiet()
3611
# TODO: should possibly lock the history file...
3612
benchfile = open(".perf_history", "at", buffering=1)
3613
self.add_cleanup(benchfile.close)
3614
else:
3615
test_suite_factory = None
3616
benchfile = None
3624
3617
selftest_kwargs = {"verbose": verbose,
3625
3618
"pattern": pattern,
3626
3619
"stop_on_failure": one,
3628
3621
"test_suite_factory": test_suite_factory,
3629
3622
"lsprof_timed": lsprof_timed,
3630
3623
"lsprof_tests": lsprof_tests,
3624
"bench_history": benchfile,
3631
3625
"matching_tests_first": first,
3632
3626
"list_only": list_only,
3633
3627
"random_seed": randomize,
3643
3637
3644
3638
3645
3639
class cmd_version(Command):
3646
__doc__ = """Show version of bzr."""
3640
"""Show version of bzr."""
3647
3641
3648
3642
encoding_type = 'replace'
3649
3643
takes_options = [
3660
3654
3661
3655
3662
3656
class cmd_rocks(Command):
3663
__doc__ = """Statement of optimism."""
3657
"""Statement of optimism."""
3664
3658
3665
3659
hidden = True
3666
3660
3670
3664
3671
3665
3672
3666
class cmd_find_merge_base(Command):
3673
__doc__ = """Find and print a base revision for merging two branches."""
3667
"""Find and print a base revision for merging two branches."""
3674
3668
# TODO: Options to specify revisions on either side, as if
3675
3669
# merging only part of the history.
3676
3670
takes_args = ['branch', 'other']
3682
3676
3683
3677
branch1 = Branch.open_containing(branch)[0]
3684
3678
branch2 = Branch.open_containing(other)[0]
3685
self.add_cleanup(branch1.lock_read().unlock)
3686
self.add_cleanup(branch2.lock_read().unlock)
3679
branch1.lock_read()
3680
self.add_cleanup(branch1.unlock)
3681
branch2.lock_read()
3682
self.add_cleanup(branch2.unlock)
3687
3683
last1 = ensure_null(branch1.last_revision())
3688
3684
last2 = ensure_null(branch2.last_revision())
3689
3685
3694
3690
3695
3691
3696
3692
class cmd_merge(Command):
3697
__doc__ = """Perform a three-way merge.
3693
"""Perform a three-way merge.
3698
3694
3699
3695
The source of the merge can be specified either in the form of a branch,
3700
3696
or in the form of a path to a file containing a merge directive generated
3783
3779
' completely merged into the source, pull from the'
3784
3780
' source rather than merging. When this happens,'
3785
3781
' you do not need to commit the result.'),
3786
custom_help('directory',
3782
Option('directory',
3787
3783
help='Branch to merge into, '
3788
'rather than the one containing the working directory.'),
3784
'rather than the one containing the working directory.',
3785
short_name='d',
3786
type=unicode,
3787
),
3789
3788
Option('preview', help='Instead of merging, show a diff of the'
3790
3789
' merge.'),
3791
3790
Option('interactive', help='Select changes interactively.',
3824
3823
unversioned_filter=tree.is_ignored, view_info=view_info)
3825
3824
pb = ui.ui_factory.nested_progress_bar()
3826
3825
self.add_cleanup(pb.finished)
3827
self.add_cleanup(tree.lock_write().unlock)
3826
tree.lock_write()
3827
self.add_cleanup(tree.unlock)
3828
3828
if location is not None:
3829
3829
try:
3830
3830
mergeable = bundle.read_mergeable_from_url(location,
3891
3891
def _do_preview(self, merger):
3892
3892
from bzrlib.diff import show_diff_trees
3893
3893
result_tree = self._get_preview(merger)
3894
path_encoding = osutils.get_diff_header_encoding()
3895
3894
show_diff_trees(merger.this_tree, result_tree, self.outf,
3896
old_label='', new_label='',
3897
path_encoding=path_encoding)
3895
old_label='', new_label='')
3898
3896
3899
3897
def _do_merge(self, merger, change_reporter, allow_pending, verified):
3900
3898
merger.change_reporter = change_reporter
4053
4051
4054
4052
4055
4053
class cmd_remerge(Command):
4056
__doc__ = """Redo a merge.
4054
"""Redo a merge.
4057
4055
4058
4056
Use this if you want to try a different merge technique while resolving
4059
4057
conflicts. Some merge techniques are better than others, and remerge
4088
4086
if merge_type is None:
4089
4087
merge_type = _mod_merge.Merge3Merger
4090
4088
tree, file_list = tree_files(file_list)
4091
self.add_cleanup(tree.lock_write().unlock)
4089
tree.lock_write()
4090
self.add_cleanup(tree.unlock)
4092
4091
parents = tree.get_parent_ids()
4093
4092
if len(parents) != 2:
4094
4093
raise errors.BzrCommandError("Sorry, remerge only works after normal"
4147
4146
4148
4147
4149
4148
class cmd_revert(Command):
4150
__doc__ = """Revert files to a previous revision.
4149
"""Revert files to a previous revision.
4151
4150
4152
4151
Giving a list of files will revert only those files. Otherwise, all files
4153
4152
will be reverted. If the revision is not specified with '--revision', the
4204
4203
def run(self, revision=None, no_backup=False, file_list=None,
4205
4204
forget_merges=None):
4206
4205
tree, file_list = tree_files(file_list)
4207
self.add_cleanup(tree.lock_tree_write().unlock)
4206
tree.lock_write()
4207
self.add_cleanup(tree.unlock)
4208
4208
if forget_merges:
4209
4209
tree.set_parent_ids(tree.get_parent_ids()[:1])
4210
4210
else:
4218
4218
4219
4219
4220
4220
class cmd_assert_fail(Command):
4221
__doc__ = """Test reporting of assertion failures"""
4221
"""Test reporting of assertion failures"""
4222
4222
# intended just for use in testing
4223
4223
4224
4224
hidden = True
4228
4228
4229
4229
4230
4230
class cmd_help(Command):
4231
__doc__ = """Show help on a command or other topic.
4231
"""Show help on a command or other topic.
4232
4232
"""
4233
4233
4234
4234
_see_also = ['topics']
4247
4247
4248
4248
4249
4249
class cmd_shell_complete(Command):
4250
__doc__ = """Show appropriate completions for context.
4250
"""Show appropriate completions for context.
4251
4251
4252
4252
For a list of all available commands, say 'bzr shell-complete'.
4253
4253
"""
4262
4262
4263
4263
4264
4264
class cmd_missing(Command):
4265
__doc__ = """Show unmerged/unpulled revisions between two branches.
4265
"""Show unmerged/unpulled revisions between two branches.
4266
4266
4267
4267
OTHER_BRANCH may be local or remote.
4268
4268
4299
4299
_see_also = ['merge', 'pull']
4300
4300
takes_args = ['other_branch?']
4301
4301
takes_options = [
4302
'directory',
4303
4302
Option('reverse', 'Reverse the order of revisions.'),
4304
4303
Option('mine-only',
4305
4304
'Display changes in the local branch only.'),
4327
4326
theirs_only=False,
4328
4327
log_format=None, long=False, short=False, line=False,
4329
4328
show_ids=False, verbose=False, this=False, other=False,
4330
include_merges=False, revision=None, my_revision=None,
4331
directory=u'.'):
4329
include_merges=False, revision=None, my_revision=None):
4332
4330
from bzrlib.missing import find_unmerged, iter_log_revisions
4333
4331
def message(s):
4334
4332
if not is_quiet():
4347
4345
elif theirs_only:
4348
4346
restrict = 'remote'
4349
4347
4350
local_branch = Branch.open_containing(directory)[0]
4351
self.add_cleanup(local_branch.lock_read().unlock)
4352
4348
local_branch = Branch.open_containing(u".")[0]
4353
4349
parent = local_branch.get_parent()
4354
4350
if other_branch is None:
4355
4351
other_branch = parent
4364
4360
remote_branch = Branch.open(other_branch)
4365
4361
if remote_branch.base == local_branch.base:
4366
4362
remote_branch = local_branch
4367
else:
4368
self.add_cleanup(remote_branch.lock_read().unlock)
4369
4363
4364
local_branch.lock_read()
4365
self.add_cleanup(local_branch.unlock)
4370
4366
local_revid_range = _revision_range_to_revid_range(
4371
4367
_get_revision_range(my_revision, local_branch,
4372
4368
self.name()))
4373
4369
4370
remote_branch.lock_read()
4371
self.add_cleanup(remote_branch.unlock)
4374
4372
remote_revid_range = _revision_range_to_revid_range(
4375
4373
_get_revision_range(revision,
4376
4374
remote_branch, self.name()))
4426
4424
message("Branches are up to date.\n")
4427
4425
self.cleanup_now()
4428
4426
if not status_code and parent is None and other_branch is not None:
4429
self.add_cleanup(local_branch.lock_write().unlock)
4427
local_branch.lock_write()
4428
self.add_cleanup(local_branch.unlock)
4430
4429
# handle race conditions - a parent might be set while we run.
4431
4430
if local_branch.get_parent() is None:
4432
4431
local_branch.set_parent(remote_branch.base)
4434
4433
4435
4434
4436
4435
class cmd_pack(Command):
4437
__doc__ = """Compress the data within a repository.
4438
4439
This operation compresses the data within a bazaar repository. As
4440
bazaar supports automatic packing of repository, this operation is
4441
normally not required to be done manually.
4442
4443
During the pack operation, bazaar takes a backup of existing repository
4444
data, i.e. pack files. This backup is eventually removed by bazaar
4445
automatically when it is safe to do so. To save disk space by removing
4446
the backed up pack files, the --clean-obsolete-packs option may be
4447
used.
4448
4449
Warning: If you use --clean-obsolete-packs and your machine crashes
4450
during or immediately after repacking, you may be left with a state
4451
where the deletion has been written to disk but the new packs have not
4452
been. In this case the repository may be unusable.
4453
"""
4436
"""Compress the data within a repository."""
4454
4437
4455
4438
_see_also = ['repositories']
4456
4439
takes_args = ['branch_or_repo?']
4457
takes_options = [
4458
Option('clean-obsolete-packs', 'Delete obsolete packs to save disk space.'),
4459
]
4460
4440
4461
def run(self, branch_or_repo='.', clean_obsolete_packs=False):
4441
def run(self, branch_or_repo='.'):
4462
4442
dir = bzrdir.BzrDir.open_containing(branch_or_repo)[0]
4463
4443
try:
4464
4444
branch = dir.open_branch()
4465
4445
repository = branch.repository
4466
4446
except errors.NotBranchError:
4467
4447
repository = dir.open_repository()
4468
repository.pack(clean_obsolete_packs=clean_obsolete_packs)
4448
repository.pack()
4469
4449
4470
4450
4471
4451
class cmd_plugins(Command):
4472
__doc__ = """List the installed plugins.
4452
"""List the installed plugins.
4473
4453
4474
4454
This command displays the list of installed plugins including
4475
4455
version of plugin and a short description of each.
4514
4494
4515
4495
4516
4496
class cmd_testament(Command):
4517
__doc__ = """Show testament (signing-form) of a revision."""
4497
"""Show testament (signing-form) of a revision."""
4518
4498
takes_options = [
4519
4499
'revision',
4520
4500
Option('long', help='Produce long-format testament.'),
4532
4512
b = Branch.open_containing(branch)[0]
4533
4513
else:
4534
4514
b = Branch.open(branch)
4535
self.add_cleanup(b.lock_read().unlock)
4515
b.lock_read()
4516
self.add_cleanup(b.unlock)
4536
4517
if revision is None:
4537
4518
rev_id = b.last_revision()
4538
4519
else:
4545
4526
4546
4527
4547
4528
class cmd_annotate(Command):
4548
__doc__ = """Show the origin of each line in a file.
4529
"""Show the origin of each line in a file.
4549
4530
4550
4531
This prints out the given file with an annotation on the left side
4551
4532
indicating which revision, author and date introduced the change.
4562
4543
Option('long', help='Show commit date in annotations.'),
4563
4544
'revision',
4564
4545
'show-ids',
4565
'directory',
4566
4546
]
4567
4547
encoding_type = 'exact'
4568
4548
4569
4549
@display_command
4570
4550
def run(self, filename, all=False, long=False, revision=None,
4571
show_ids=False, directory=None):
4551
show_ids=False):
4572
4552
from bzrlib.annotate import annotate_file, annotate_file_tree
4573
4553
wt, branch, relpath = \
4574
_open_directory_or_containing_tree_or_branch(filename, directory)
4554
bzrdir.BzrDir.open_containing_tree_or_branch(filename)
4575
4555
if wt is not None:
4576
self.add_cleanup(wt.lock_read().unlock)
4556
wt.lock_read()
4557
self.add_cleanup(wt.unlock)
4577
4558
else:
4578
self.add_cleanup(branch.lock_read().unlock)
4559
branch.lock_read()
4560
self.add_cleanup(branch.unlock)
4579
4561
tree = _get_one_revision_tree('annotate', revision, branch=branch)
4580
self.add_cleanup(tree.lock_read().unlock)
4562
tree.lock_read()
4563
self.add_cleanup(tree.unlock)
4581
4564
if wt is not None:
4582
4565
file_id = wt.path2id(relpath)
4583
4566
else:
4596
4579
4597
4580
4598
4581
class cmd_re_sign(Command):
4599
__doc__ = """Create a digital signature for an existing revision."""
4582
"""Create a digital signature for an existing revision."""
4600
4583
# TODO be able to replace existing ones.
4601
4584
4602
4585
hidden = True # is this right ?
4603
4586
takes_args = ['revision_id*']
4604
takes_options = ['directory', 'revision']
4587
takes_options = ['revision']
4605
4588
4606
def run(self, revision_id_list=None, revision=None, directory=u'.'):
4589
def run(self, revision_id_list=None, revision=None):
4607
4590
if revision_id_list is not None and revision is not None:
4608
4591
raise errors.BzrCommandError('You can only supply one of revision_id or --revision')
4609
4592
if revision_id_list is None and revision is None:
4610
4593
raise errors.BzrCommandError('You must supply either --revision or a revision_id')
4611
b = WorkingTree.open_containing(directory)[0].branch
4612
self.add_cleanup(b.lock_write().unlock)
4594
b = WorkingTree.open_containing(u'.')[0].branch
4595
b.lock_write()
4596
self.add_cleanup(b.unlock)
4613
4597
return self._run(b, revision_id_list, revision)
4614
4598
4615
4599
def _run(self, b, revision_id_list, revision):
4661
4645
4662
4646
4663
4647
class cmd_bind(Command):
4664
__doc__ = """Convert the current branch into a checkout of the supplied branch.
4665
If no branch is supplied, rebind to the last bound location.
4648
"""Convert the current branch into a checkout of the supplied branch.
4666
4649
4667
4650
Once converted into a checkout, commits must succeed on the master branch
4668
4651
before they will be applied to the local branch.
4674
4657
4675
4658
_see_also = ['checkouts', 'unbind']
4676
4659
takes_args = ['location?']
4677
takes_options = ['directory']
4660
takes_options = []
4678
4661
4679
def run(self, location=None, directory=u'.'):
4680
b, relpath = Branch.open_containing(directory)
4662
def run(self, location=None):
4663
b, relpath = Branch.open_containing(u'.')
4681
4664
if location is None:
4682
4665
try:
4683
4666
location = b.get_old_bound_location()
4702
4685
4703
4686
4704
4687
class cmd_unbind(Command):
4705
__doc__ = """Convert the current checkout into a regular branch.
4688
"""Convert the current checkout into a regular branch.
4706
4689
4707
4690
After unbinding, the local branch is considered independent and subsequent
4708
4691
commits will be local only.
4710
4693
4711
4694
_see_also = ['checkouts', 'bind']
4712
4695
takes_args = []
4713
takes_options = ['directory']
4696
takes_options = []
4714
4697
4715
def run(self, directory=u'.'):
4716
b, relpath = Branch.open_containing(directory)
4698
def run(self):
4699
b, relpath = Branch.open_containing(u'.')
4717
4700
if not b.unbind():
4718
4701
raise errors.BzrCommandError('Local branch is not bound')
4719
4702
4720
4703
4721
4704
class cmd_uncommit(Command):
4722
__doc__ = """Remove the last committed revision.
4705
"""Remove the last committed revision.
4723
4706
4724
4707
--verbose will print out what is being removed.
4725
4708
--dry-run will go through all the motions, but not actually
4765
4748
b = control.open_branch()
4766
4749
4767
4750
if tree is not None:
4768
self.add_cleanup(tree.lock_write().unlock)
4751
tree.lock_write()
4752
self.add_cleanup(tree.unlock)
4769
4753
else:
4770
self.add_cleanup(b.lock_write().unlock)
4754
b.lock_write()
4755
self.add_cleanup(b.unlock)
4771
4756
return self._run(b, tree, dry_run, verbose, revision, force, local=local)
4772
4757
4773
4758
def _run(self, b, tree, dry_run, verbose, revision, force, local=False):
4825
4810
4826
4811
4827
4812
class cmd_break_lock(Command):
4828
__doc__ = """Break a dead lock on a repository, branch or working directory.
4813
"""Break a dead lock on a repository, branch or working directory.
4829
4814
4830
4815
CAUTION: Locks should only be broken when you are sure that the process
4831
4816
holding the lock has been stopped.
4850
4835
4851
4836
4852
4837
class cmd_wait_until_signalled(Command):
4853
__doc__ = """Test helper for test_start_and_stop_bzr_subprocess_send_signal.
4838
"""Test helper for test_start_and_stop_bzr_subprocess_send_signal.
4854
4839
4855
4840
This just prints a line to signal when it is ready, then blocks on stdin.
4856
4841
"""
4864
4849
4865
4850
4866
4851
class cmd_serve(Command):
4867
__doc__ = """Run the bzr server."""
4852
"""Run the bzr server."""
4868
4853
4869
4854
aliases = ['server']
4870
4855
4881
4866
'result in a dynamically allocated port. The default port '
4882
4867
'depends on the protocol.',
4883
4868
type=str),
4884
custom_help('directory',
4885
help='Serve contents of this directory.'),
4869
Option('directory',
4870
help='Serve contents of this directory.',
4871
type=unicode),
4886
4872
Option('allow-writes',
4887
4873
help='By default the server is a readonly server. Supplying '
4888
4874
'--allow-writes enables write access to the contents of '
4915
4901
4916
4902
def run(self, port=None, inet=False, directory=None, allow_writes=False,
4917
4903
protocol=None):
4918
from bzrlib import transport
4904
from bzrlib.transport import get_transport, transport_server_registry
4919
4905
if directory is None:
4920
4906
directory = os.getcwd()
4921
4907
if protocol is None:
4922
protocol = transport.transport_server_registry.get()
4908
protocol = transport_server_registry.get()
4923
4909
host, port = self.get_host_and_port(port)
4924
4910
url = urlutils.local_path_to_url(directory)
4925
4911
if not allow_writes:
4926
4912
url = 'readonly+' + url
4927
t = transport.get_transport(url)
4928
protocol(t, host, port, inet)
4913
transport = get_transport(url)
4914
protocol(transport, host, port, inet)
4929
4915
4930
4916
4931
4917
class cmd_join(Command):
4932
__doc__ = """Combine a tree into its containing tree.
4918
"""Combine a tree into its containing tree.
4933
4919
4934
4920
This command requires the target tree to be in a rich-root format.
4935
4921
4975
4961
4976
4962
4977
4963
class cmd_split(Command):
4978
__doc__ = """Split a subdirectory of a tree into a separate tree.
4964
"""Split a subdirectory of a tree into a separate tree.
4979
4965
4980
4966
This command will produce a target tree in a format that supports
4981
4967
rich roots, like 'rich-root' or 'rich-root-pack'. These formats cannot be
5001
4987
5002
4988
5003
4989
class cmd_merge_directive(Command):
5004
__doc__ = """Generate a merge directive for auto-merge tools.
4990
"""Generate a merge directive for auto-merge tools.
5005
4991
5006
4992
A directive requests a merge to be performed, and also provides all the
5007
4993
information necessary to do so. This means it must either include a
5024
5010
_see_also = ['send']
5025
5011
5026
5012
takes_options = [
5027
'directory',
5028
5013
RegistryOption.from_kwargs('patch-type',
5029
5014
'The type of patch to include in the directive.',
5030
5015
title='Patch type',
5043
5028
encoding_type = 'exact'
5044
5029
5045
5030
def run(self, submit_branch=None, public_branch=None, patch_type='bundle',
5046
sign=False, revision=None, mail_to=None, message=None,
5047
directory=u'.'):
5031
sign=False, revision=None, mail_to=None, message=None):
5048
5032
from bzrlib.revision import ensure_null, NULL_REVISION
5049
5033
include_patch, include_bundle = {
5050
5034
'plain': (False, False),
5051
5035
'diff': (True, False),
5052
5036
'bundle': (True, True),
5053
5037
}[patch_type]
5054
branch = Branch.open(directory)
5038
branch = Branch.open('.')
5055
5039
stored_submit_branch = branch.get_submit_branch()
5056
5040
if submit_branch is None:
5057
5041
submit_branch = stored_submit_branch
5102
5086
5103
5087
5104
5088
class cmd_send(Command):
5105
__doc__ = """Mail or create a merge-directive for submitting changes.
5089
"""Mail or create a merge-directive for submitting changes.
5106
5090
5107
5091
A merge directive provides many things needed for requesting merges:
5108
5092
5142
5126
given, in which case it is sent to a file.
5143
5127
5144
5128
Mail is sent using your preferred mail program. This should be transparent
5145
on Windows (it uses MAPI). On Unix, it requires the xdg-email utility.
5129
on Windows (it uses MAPI). On Linux, it requires the xdg-email utility.
5146
5130
If the preferred client can't be found (or used), your editor will be used.
5147
5131
5148
5132
To use a specific mail program, set the mail_client configuration option.
5219
5203
5220
5204
5221
5205
class cmd_bundle_revisions(cmd_send):
5222
__doc__ = """Create a merge-directive for submitting changes.
5206
"""Create a merge-directive for submitting changes.
5223
5207
5224
5208
A merge directive provides many things needed for requesting merges:
5225
5209
5292
5276
5293
5277
5294
5278
class cmd_tag(Command):
5295
__doc__ = """Create, remove or modify a tag naming a revision.
5279
"""Create, remove or modify a tag naming a revision.
5296
5280
5297
5281
Tags give human-meaningful names to revisions. Commands that take a -r
5298
5282
(--revision) option can be given -rtag:X, where X is any previously
5319
5303
Option('delete',
5320
5304
help='Delete this tag rather than placing it.',
5321
5305
),
5322
custom_help('directory',
5323
help='Branch in which to place the tag.'),
5306
Option('directory',
5307
help='Branch in which to place the tag.',
5308
short_name='d',
5309
type=unicode,
5310
),
5324
5311
Option('force',
5325
5312
help='Replace existing tags.',
5326
5313
),
5334
5321
revision=None,
5335
5322
):
5336
5323
branch, relpath = Branch.open_containing(directory)
5337
self.add_cleanup(branch.lock_write().unlock)
5324
branch.lock_write()
5325
self.add_cleanup(branch.unlock)
5338
5326
if delete:
5339
5327
if tag_name is None:
5340
5328
raise errors.BzrCommandError("No tag specified to delete.")
5361
5349
5362
5350
5363
5351
class cmd_tags(Command):
5364
__doc__ = """List tags.
5352
"""List tags.
5365
5353
5366
5354
This command shows a table of tag names and the revisions they reference.
5367
5355
"""
5368
5356
5369
5357
_see_also = ['tag']
5370
5358
takes_options = [
5371
custom_help('directory',
5372
help='Branch whose tags should be displayed.'),
5359
Option('directory',
5360
help='Branch whose tags should be displayed.',
5361
short_name='d',
5362
type=unicode,
5363
),
5373
5364
RegistryOption.from_kwargs('sort',
5374
5365
'Sort tags by different criteria.', title='Sorting',
5375
5366
alpha='Sort tags lexicographically (default).',
5392
5383
if not tags:
5393
5384
return
5394
5385
5395
self.add_cleanup(branch.lock_read().unlock)
5386
branch.lock_read()
5387
self.add_cleanup(branch.unlock)
5396
5388
if revision:
5397
5389
graph = branch.repository.get_graph()
5398
5390
rev1, rev2 = _get_revision_range(revision, branch, self.name())
5431
5423
5432
5424
5433
5425
class cmd_reconfigure(Command):
5434
__doc__ = """Reconfigure the type of a bzr directory.
5426
"""Reconfigure the type of a bzr directory.
5435
5427
5436
5428
A target configuration must be specified.
5437
5429
5522
5514
5523
5515
5524
5516
class cmd_switch(Command):
5525
__doc__ = """Set the branch of a checkout and update.
5517
"""Set the branch of a checkout and update.
5526
5518
5527
5519
For lightweight checkouts, this changes the branch being referenced.
5528
5520
For heavyweight checkouts, this checks that there are no local commits
5545
5537
"""
5546
5538
5547
5539
takes_args = ['to_location?']
5548
takes_options = ['directory',
5549
Option('force',
5540
takes_options = [Option('force',
5550
5541
help='Switch even if local commits will be lost.'),
5551
5542
'revision',
5552
5543
Option('create-branch', short_name='b',
5555
5546
]
5556
5547
5557
5548
def run(self, to_location=None, force=False, create_branch=False,
5558
revision=None, directory=u'.'):
5549
revision=None):
5559
5550
from bzrlib import switch
5560
tree_location = directory
5551
tree_location = '.'
5561
5552
revision = _get_one_revision('switch', revision)
5562
5553
control_dir = bzrdir.BzrDir.open_containing(tree_location)[0]
5563
5554
if to_location is None:
5564
5555
if revision is None:
5565
5556
raise errors.BzrCommandError('You must supply either a'
5566
5557
' revision or a location')
5567
to_location = tree_location
5558
to_location = '.'
5568
5559
try:
5569
5560
branch = control_dir.open_branch()
5570
5561
had_explicit_nick = branch.get_config().has_explicit_nickname()
5619
5610
5620
5611
5621
5612
class cmd_view(Command):
5622
__doc__ = """Manage filtered views.
5613
"""Manage filtered views.
5623
5614
5624
5615
Views provide a mask over the tree so that users can focus on
5625
5616
a subset of a tree when doing their work. After creating a view,
5773
5764
5774
5765
5775
5766
class cmd_hooks(Command):
5776
__doc__ = """Show hooks."""
5767
"""Show hooks."""
5777
5768
5778
5769
hidden = True
5779
5770
5793
5784
5794
5785
5795
5786
class cmd_remove_branch(Command):
5796
__doc__ = """Remove a branch.
5787
"""Remove a branch.
5797
5788
5798
5789
This will remove the branch from the specified location but
5799
5790
will keep any working tree or repository in place.
5818
5809
5819
5810
5820
5811
class cmd_shelve(Command):
5821
__doc__ = """Temporarily set aside some changes from the current tree.
5812
"""Temporarily set aside some changes from the current tree.
5822
5813
5823
5814
Shelve allows you to temporarily put changes you've made "on the shelf",
5824
5815
ie. out of the way, until a later time when you can bring them back from
5845
5836
takes_args = ['file*']
5846
5837
5847
5838
takes_options = [
5848
'directory',
5849
5839
'revision',
5850
5840
Option('all', help='Shelve all changes.'),
5851
5841
'message',
5860
5850
_see_also = ['unshelve']
5861
5851
5862
5852
def run(self, revision=None, all=False, file_list=None, message=None,
5863
writer=None, list=False, destroy=False, directory=u'.'):
5853
writer=None, list=False, destroy=False):
5864
5854
if list:
5865
5855
return self.run_for_list()
5866
5856
from bzrlib.shelf_ui import Shelver
5868
5858
writer = bzrlib.option.diff_writer_registry.get()
5869
5859
try:
5870
5860
shelver = Shelver.from_args(writer(sys.stdout), revision, all,
5871
file_list, message, destroy=destroy, directory=directory)
5861
file_list, message, destroy=destroy)
5872
5862
try:
5873
5863
shelver.run()
5874
5864
finally:
5878
5868
5879
5869
def run_for_list(self):
5880
5870
tree = WorkingTree.open_containing('.')[0]
5881
self.add_cleanup(tree.lock_read().unlock)
5871
tree.lock_read()
5872
self.add_cleanup(tree.unlock)
5882
5873
manager = tree.get_shelf_manager()
5883
5874
shelves = manager.active_shelves()
5884
5875
if len(shelves) == 0:
5893
5884
5894
5885
5895
5886
class cmd_unshelve(Command):
5896
__doc__ = """Restore shelved changes.
5887
"""Restore shelved changes.
5897
5888
5898
5889
By default, the most recently shelved changes are restored. However if you
5899
5890
specify a shelf by id those changes will be restored instead. This works
5902
5893
5903
5894
takes_args = ['shelf_id?']
5904
5895
takes_options = [
5905
'directory',
5906
5896
RegistryOption.from_kwargs(
5907
5897
'action', help="The action to perform.",
5908
5898
enum_switch=False, value_switches=True,
5916
5906
]
5917
5907
_see_also = ['shelve']
5918
5908
5919
def run(self, shelf_id=None, action='apply', directory=u'.'):
5909
def run(self, shelf_id=None, action='apply'):
5920
5910
from bzrlib.shelf_ui import Unshelver
5921
unshelver = Unshelver.from_args(shelf_id, action, directory=directory)
5911
unshelver = Unshelver.from_args(shelf_id, action)
5922
5912
try:
5923
5913
unshelver.run()
5924
5914
finally:
5926
5916
5927
5917
5928
5918
class cmd_clean_tree(Command):
5929
__doc__ = """Remove unwanted files from working tree.
5919
"""Remove unwanted files from working tree.
5930
5920
5931
5921
By default, only unknown files, not ignored files, are deleted. Versioned
5932
5922
files are never deleted.
5940
5930
5941
5931
To check what clean-tree will do, use --dry-run.
5942
5932
"""
5943
takes_options = ['directory',
5944
Option('ignored', help='Delete all ignored files.'),
5933
takes_options = [Option('ignored', help='Delete all ignored files.'),
5945
5934
Option('detritus', help='Delete conflict files, merge'
5946
5935
' backups, and failed selftest dirs.'),
5947
5936
Option('unknown',
5950
5939
' deleting them.'),
5951
5940
Option('force', help='Do not prompt before deleting.')]
5952
5941
def run(self, unknown=False, ignored=False, detritus=False, dry_run=False,
5953
force=False, directory=u'.'):
5942
force=False):
5954
5943
from bzrlib.clean_tree import clean_tree
5955
5944
if not (unknown or ignored or detritus):
5956
5945
unknown = True
5957
5946
if dry_run:
5958
5947
force = True
5959
clean_tree(directory, unknown=unknown, ignored=ignored,
5960
detritus=detritus, dry_run=dry_run, no_prompt=force)
5948
clean_tree('.', unknown=unknown, ignored=ignored, detritus=detritus,
5949
dry_run=dry_run, no_prompt=force)
5961
5950
5962
5951
5963
5952
class cmd_reference(Command):
5964
__doc__ = """list, view and set branch locations for nested trees.
5953
"""list, view and set branch locations for nested trees.
5965
5954
5966
5955
If no arguments are provided, lists the branch locations for nested trees.
5967
5956
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