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 5074.3.1
- compare with another revision
- download diff
- download tarball
- view history from revision 5074.3.1
- Committer: Ian Clatworthy
- Date: 2010-03-04 04:15:18 UTC
- mto: (5094.1.1 integration)
- mto: This revision was merged to the branch mainline in revision 5096.
- Revision ID: ian.clatworthy@canonical.com-20100304041518-vf8v1ivn8jrh9fs5
Initial cut at a What's New in 2.2 document
- 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 renamed:
- apport/ => contrib/apport/
- apport/bzr-crashdb.conf => contrib/apport/bzr.conf
- files modified:
- .bzrignore
added
removed
bzrlib/builtins.py
60
60
from bzrlib.workingtree import WorkingTree
61
61
""")
62
62
63
from bzrlib.commands import (
64
Command,
65
builtin_command_registry,
66
display_command,
67
)
63
from bzrlib.commands import Command, display_command
68
64
from bzrlib.option import (
69
65
ListOption,
70
66
Option,
180
176
view_str = views.view_display_str(view_files)
181
177
note("Ignoring files outside view. View is %s" % view_str)
182
178
return tree, file_list
183
tree = WorkingTree.open_containing(file_list[0])[0]
179
tree = WorkingTree.open_containing(osutils.realpath(file_list[0]))[0]
184
180
return tree, safe_relpath_files(tree, file_list, canonicalize,
185
181
apply_view=apply_view)
186
182
232
228
return view_info
233
229
234
230
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
231
# TODO: Make sure no commands unconditionally use the working directory as a
244
232
# branch. If a filename argument is used, the first of them should be used to
245
233
# specify the branch. (Perhaps this can be factored out into some kind of
247
235
# opens the branch?)
248
236
249
237
class cmd_status(Command):
250
__doc__ = """Display status summary.
238
"""Display status summary.
251
239
252
240
This reports on versioned and unknown files, reporting them
253
241
grouped by state. Possible states are:
340
328
341
329
342
330
class cmd_cat_revision(Command):
343
__doc__ = """Write out metadata for a revision.
331
"""Write out metadata for a revision.
344
332
345
333
The revision to print can either be specified by a specific
346
334
revision identifier, or you can use --revision.
348
336
349
337
hidden = True
350
338
takes_args = ['revision_id?']
351
takes_options = ['directory', 'revision']
339
takes_options = ['revision']
352
340
# cat-revision is more for frontends so should be exact
353
341
encoding = 'strict'
354
342
361
349
self.outf.write(revtext.decode('utf-8'))
362
350
363
351
@display_command
364
def run(self, revision_id=None, revision=None, directory=u'.'):
352
def run(self, revision_id=None, revision=None):
365
353
if revision_id is not None and revision is not None:
366
354
raise errors.BzrCommandError('You can only supply one of'
367
355
' revision_id or --revision')
368
356
if revision_id is None and revision is None:
369
357
raise errors.BzrCommandError('You must supply either'
370
358
' --revision or a revision_id')
371
b = WorkingTree.open_containing(directory)[0].branch
359
b = WorkingTree.open_containing(u'.')[0].branch
372
360
373
361
revisions = b.repository.revisions
374
362
if revisions is None:
398
386
399
387
400
388
class cmd_dump_btree(Command):
401
__doc__ = """Dump the contents of a btree index file to stdout.
389
"""Dump the contents of a btree index file to stdout.
402
390
403
391
PATH is a btree index file, it can be any URL. This includes things like
404
392
.bzr/repository/pack-names, or .bzr/repository/indices/a34b3a...ca4a4.iix
468
456
for node in bt.iter_all_entries():
469
457
# Node is made up of:
470
458
# (index, key, value, [references])
471
try:
472
refs = node[3]
473
except IndexError:
474
refs_as_tuples = None
475
else:
476
refs_as_tuples = static_tuple.as_tuples(refs)
459
refs_as_tuples = static_tuple.as_tuples(node[3])
477
460
as_tuple = (tuple(node[1]), node[2], refs_as_tuples)
478
461
self.outf.write('%s\n' % (as_tuple,))
479
462
480
463
481
464
class cmd_remove_tree(Command):
482
__doc__ = """Remove the working tree from a given branch/checkout.
465
"""Remove the working tree from a given branch/checkout.
483
466
484
467
Since a lightweight checkout is little more than a working tree
485
468
this will refuse to run against one.
491
474
takes_options = [
492
475
Option('force',
493
476
help='Remove the working tree even if it has '
494
'uncommitted or shelved changes.'),
477
'uncommitted changes.'),
495
478
]
496
479
497
480
def run(self, location_list, force=False):
511
494
if not force:
512
495
if (working.has_changes()):
513
496
raise errors.UncommittedChanges(working)
514
if working.get_shelf_manager().last_shelf() is not None:
515
raise errors.ShelvedChanges(working)
516
497
517
if working.user_url != working.branch.user_url:
498
working_path = working.bzrdir.root_transport.base
499
branch_path = working.branch.bzrdir.root_transport.base
500
if working_path != branch_path:
518
501
raise errors.BzrCommandError("You cannot remove the working tree"
519
502
" from a lightweight checkout")
520
503
522
505
523
506
524
507
class cmd_revno(Command):
525
__doc__ = """Show current revision number.
508
"""Show current revision number.
526
509
527
510
This is equal to the number of revisions on this branch.
528
511
"""
538
521
if tree:
539
522
try:
540
523
wt = WorkingTree.open_containing(location)[0]
541
self.add_cleanup(wt.lock_read().unlock)
524
wt.lock_read()
542
525
except (errors.NoWorkingTree, errors.NotLocalUrl):
543
526
raise errors.NoWorkingTree(location)
527
self.add_cleanup(wt.unlock)
544
528
revid = wt.last_revision()
545
529
try:
546
530
revno_t = wt.branch.revision_id_to_dotted_revno(revid)
549
533
revno = ".".join(str(n) for n in revno_t)
550
534
else:
551
535
b = Branch.open_containing(location)[0]
552
self.add_cleanup(b.lock_read().unlock)
536
b.lock_read()
537
self.add_cleanup(b.unlock)
553
538
revno = b.revno()
554
539
self.cleanup_now()
555
540
self.outf.write(str(revno) + '\n')
556
541
557
542
558
543
class cmd_revision_info(Command):
559
__doc__ = """Show revision number and revision id for a given revision identifier.
544
"""Show revision number and revision id for a given revision identifier.
560
545
"""
561
546
hidden = True
562
547
takes_args = ['revision_info*']
563
548
takes_options = [
564
549
'revision',
565
custom_help('directory',
550
Option('directory',
566
551
help='Branch to examine, '
567
'rather than the one containing the working directory.'),
552
'rather than the one containing the working directory.',
553
short_name='d',
554
type=unicode,
555
),
568
556
Option('tree', help='Show revno of working tree'),
569
557
]
570
558
575
563
try:
576
564
wt = WorkingTree.open_containing(directory)[0]
577
565
b = wt.branch
578
self.add_cleanup(wt.lock_read().unlock)
566
wt.lock_read()
567
self.add_cleanup(wt.unlock)
579
568
except (errors.NoWorkingTree, errors.NotLocalUrl):
580
569
wt = None
581
570
b = Branch.open_containing(directory)[0]
582
self.add_cleanup(b.lock_read().unlock)
571
b.lock_read()
572
self.add_cleanup(b.unlock)
583
573
revision_ids = []
584
574
if revision is not None:
585
575
revision_ids.extend(rev.as_revision_id(b) for rev in revision)
613
603
614
604
615
605
class cmd_add(Command):
616
__doc__ = """Add specified files or directories.
606
"""Add specified files or directories.
617
607
618
608
In non-recursive mode, all the named items are added, regardless
619
609
of whether they were previously ignored. A warning is given if
684
674
should_print=(not is_quiet()))
685
675
686
676
if base_tree:
687
self.add_cleanup(base_tree.lock_read().unlock)
677
base_tree.lock_read()
678
self.add_cleanup(base_tree.unlock)
688
679
tree, file_list = tree_files_for_add(file_list)
689
680
added, ignored = tree.smart_add(file_list, not
690
681
no_recurse, action=action, save=not dry_run)
698
689
699
690
700
691
class cmd_mkdir(Command):
701
__doc__ = """Create a new versioned directory.
692
"""Create a new versioned directory.
702
693
703
694
This is equivalent to creating the directory and then adding it.
704
695
"""
720
711
721
712
722
713
class cmd_relpath(Command):
723
__doc__ = """Show path of a file relative to root"""
714
"""Show path of a file relative to root"""
724
715
725
716
takes_args = ['filename']
726
717
hidden = True
735
726
736
727
737
728
class cmd_inventory(Command):
738
__doc__ = """Show inventory of the current working copy or a revision.
729
"""Show inventory of the current working copy or a revision.
739
730
740
731
It is possible to limit the output to a particular entry
741
732
type using the --kind option. For example: --kind file.
762
753
763
754
revision = _get_one_revision('inventory', revision)
764
755
work_tree, file_list = tree_files(file_list)
765
self.add_cleanup(work_tree.lock_read().unlock)
756
work_tree.lock_read()
757
self.add_cleanup(work_tree.unlock)
766
758
if revision is not None:
767
759
tree = revision.as_tree(work_tree.branch)
768
760
769
761
extra_trees = [work_tree]
770
self.add_cleanup(tree.lock_read().unlock)
762
tree.lock_read()
763
self.add_cleanup(tree.unlock)
771
764
else:
772
765
tree = work_tree
773
766
extra_trees = []
794
787
795
788
796
789
class cmd_mv(Command):
797
__doc__ = """Move or rename a file.
790
"""Move or rename a file.
798
791
799
792
:Usage:
800
793
bzr mv OLDNAME NEWNAME
833
826
if len(names_list) < 2:
834
827
raise errors.BzrCommandError("missing file argument")
835
828
tree, rel_names = tree_files(names_list, canonicalize=False)
836
self.add_cleanup(tree.lock_tree_write().unlock)
829
tree.lock_tree_write()
830
self.add_cleanup(tree.unlock)
837
831
self._run(tree, names_list, rel_names, after)
838
832
839
833
def run_auto(self, names_list, after, dry_run):
844
838
raise errors.BzrCommandError('--after cannot be specified with'
845
839
' --auto.')
846
840
work_tree, file_list = tree_files(names_list, default_branch='.')
847
self.add_cleanup(work_tree.lock_tree_write().unlock)
841
work_tree.lock_tree_write()
842
self.add_cleanup(work_tree.unlock)
848
843
rename_map.RenameMap.guess_renames(work_tree, dry_run)
849
844
850
845
def _run(self, tree, names_list, rel_names, after):
929
924
930
925
931
926
class cmd_pull(Command):
932
__doc__ = """Turn this branch into a mirror of another branch.
927
"""Turn this branch into a mirror of another branch.
933
928
934
929
By default, this command only works on branches that have not diverged.
935
930
Branches are considered diverged if the destination branch's most recent
958
953
takes_options = ['remember', 'overwrite', 'revision',
959
954
custom_help('verbose',
960
955
help='Show logs of pulled revisions.'),
961
custom_help('directory',
956
Option('directory',
962
957
help='Branch to pull into, '
963
'rather than the one containing the working directory.'),
958
'rather than the one containing the working directory.',
959
short_name='d',
960
type=unicode,
961
),
964
962
Option('local',
965
963
help="Perform a local pull in a bound "
966
964
"branch. Local pulls are not applied to "
981
979
try:
982
980
tree_to = WorkingTree.open_containing(directory)[0]
983
981
branch_to = tree_to.branch
984
self.add_cleanup(tree_to.lock_write().unlock)
985
982
except errors.NoWorkingTree:
986
983
tree_to = None
987
984
branch_to = Branch.open_containing(directory)[0]
988
self.add_cleanup(branch_to.lock_write().unlock)
989
985
990
986
if local and not branch_to.get_bound_location():
991
987
raise errors.LocalRequiresBoundBranch()
992
988
1022
1018
else:
1023
1019
branch_from = Branch.open(location,
1024
1020
possible_transports=possible_transports)
1025
self.add_cleanup(branch_from.lock_read().unlock)
1026
1021
1027
1022
if branch_to.get_parent() is None or remember:
1028
1023
branch_to.set_parent(branch_from.base)
1029
1024
1025
if branch_from is not branch_to:
1026
branch_from.lock_read()
1027
self.add_cleanup(branch_from.unlock)
1030
1028
if revision is not None:
1031
1029
revision_id = revision.as_revision_id(branch_from)
1032
1030
1031
branch_to.lock_write()
1032
self.add_cleanup(branch_to.unlock)
1033
1033
if tree_to is not None:
1034
1034
view_info = _get_view_info_for_change_reporter(tree_to)
1035
1035
change_reporter = delta._ChangeReporter(
1050
1050
1051
1051
1052
1052
class cmd_push(Command):
1053
__doc__ = """Update a mirror of this branch.
1053
"""Update a mirror of this branch.
1054
1054
1055
1055
The target branch will not have its working tree populated because this
1056
1056
is both expensive, and is not supported on remote file systems.
1080
1080
Option('create-prefix',
1081
1081
help='Create the path leading up to the branch '
1082
1082
'if it does not already exist.'),
1083
custom_help('directory',
1083
Option('directory',
1084
1084
help='Branch to push from, '
1085
'rather than the one containing the working directory.'),
1085
'rather than the one containing the working directory.',
1086
short_name='d',
1087
type=unicode,
1088
),
1086
1089
Option('use-existing-dir',
1087
1090
help='By default push will fail if the target'
1088
1091
' directory exists, but does not already'
1114
1117
# Get the source branch
1115
1118
(tree, br_from,
1116
1119
_unused) = bzrdir.BzrDir.open_containing_tree_or_branch(directory)
1120
if strict is None:
1121
strict = br_from.get_config().get_user_option_as_bool('push_strict')
1122
if strict is None: strict = True # default value
1117
1123
# Get the tip's revision_id
1118
1124
revision = _get_one_revision('push', revision)
1119
1125
if revision is not None:
1120
1126
revision_id = revision.in_history(br_from).rev_id
1121
1127
else:
1122
1128
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.')
1129
if strict and tree is not None and revision_id is None:
1130
if (tree.has_changes()):
1131
raise errors.UncommittedChanges(
1132
tree, more='Use --no-strict to force the push.')
1133
if tree.last_revision() != tree.branch.last_revision():
1134
# The tree has lost sync with its branch, there is little
1135
# chance that the user is aware of it but he can still force
1136
# the push with --no-strict
1137
raise errors.OutOfDateTree(
1138
tree, more='Use --no-strict to force the push.')
1139
1128
1140
# Get the stacked_on branch, if any
1129
1141
if stacked_on is not None:
1130
1142
stacked_on = urlutils.normalize_url(stacked_on)
1162
1174
1163
1175
1164
1176
class cmd_branch(Command):
1165
__doc__ = """Create a new branch that is a copy of an existing branch.
1177
"""Create a new branch that is a copy of an existing branch.
1166
1178
1167
1179
If the TO_LOCATION is omitted, the last component of the FROM_LOCATION will
1168
1180
be used. In other words, "branch ../foo/bar" will attempt to create ./bar.
1208
1220
accelerator_tree, br_from = bzrdir.BzrDir.open_tree_or_branch(
1209
1221
from_location)
1210
1222
revision = _get_one_revision('branch', revision)
1211
self.add_cleanup(br_from.lock_read().unlock)
1223
br_from.lock_read()
1224
self.add_cleanup(br_from.unlock)
1212
1225
if revision is not None:
1213
1226
revision_id = revision.as_revision_id(br_from)
1214
1227
else:
1274
1287
1275
1288
1276
1289
class cmd_checkout(Command):
1277
__doc__ = """Create a new checkout of an existing branch.
1290
"""Create a new checkout of an existing branch.
1278
1291
1279
1292
If BRANCH_LOCATION is omitted, checkout will reconstitute a working tree for
1280
1293
the branch found in '.'. This is useful if you have removed the working tree
1343
1356
1344
1357
1345
1358
class cmd_renames(Command):
1346
__doc__ = """Show list of renamed files.
1359
"""Show list of renamed files.
1347
1360
"""
1348
1361
# TODO: Option to show renames between two historical versions.
1349
1362
1354
1367
@display_command
1355
1368
def run(self, dir=u'.'):
1356
1369
tree = WorkingTree.open_containing(dir)[0]
1357
self.add_cleanup(tree.lock_read().unlock)
1370
tree.lock_read()
1371
self.add_cleanup(tree.unlock)
1358
1372
new_inv = tree.inventory
1359
1373
old_tree = tree.basis_tree()
1360
self.add_cleanup(old_tree.lock_read().unlock)
1374
old_tree.lock_read()
1375
self.add_cleanup(old_tree.unlock)
1361
1376
old_inv = old_tree.inventory
1362
1377
renames = []
1363
1378
iterator = tree.iter_changes(old_tree, include_unchanged=True)
1373
1388
1374
1389
1375
1390
class cmd_update(Command):
1376
__doc__ = """Update a tree to have the latest code committed to its branch.
1391
"""Update a tree to have the latest code committed to its branch.
1377
1392
1378
1393
This will perform a merge into the working tree, and may generate
1379
1394
conflicts. If you have any local changes, you will still
1401
1416
master = branch.get_master_branch(
1402
1417
possible_transports=possible_transports)
1403
1418
if master is not None:
1419
tree.lock_write()
1404
1420
branch_location = master.base
1405
tree.lock_write()
1406
1421
else:
1422
tree.lock_tree_write()
1407
1423
branch_location = tree.branch.base
1408
tree.lock_tree_write()
1409
1424
self.add_cleanup(tree.unlock)
1410
1425
# get rid of the final '/' and be ready for display
1411
branch_location = urlutils.unescape_for_display(
1412
branch_location.rstrip('/'),
1413
self.outf.encoding)
1426
branch_location = urlutils.unescape_for_display(branch_location[:-1],
1427
self.outf.encoding)
1414
1428
existing_pending_merges = tree.get_parent_ids()[1:]
1415
1429
if master is None:
1416
1430
old_tip = None
1424
1438
else:
1425
1439
revision_id = branch.last_revision()
1426
1440
if revision_id == _mod_revision.ensure_null(tree.last_revision()):
1427
revno = branch.revision_id_to_dotted_revno(revision_id)
1428
note("Tree is up to date at revision %s of branch %s" %
1429
('.'.join(map(str, revno)), branch_location))
1441
revno = branch.revision_id_to_revno(revision_id)
1442
note("Tree is up to date at revision %d of branch %s" %
1443
(revno, branch_location))
1430
1444
return 0
1431
1445
view_info = _get_view_info_for_change_reporter(tree)
1432
1446
change_reporter = delta._ChangeReporter(
1444
1458
"bzr update --revision only works"
1445
1459
" for a revision in the branch history"
1446
1460
% (e.revision))
1447
revno = tree.branch.revision_id_to_dotted_revno(
1461
revno = tree.branch.revision_id_to_revno(
1448
1462
_mod_revision.ensure_null(tree.last_revision()))
1449
note('Updated to revision %s of branch %s' %
1450
('.'.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:
1463
note('Updated to revision %d of branch %s' %
1464
(revno, branch_location))
1465
if tree.get_parent_ids()[1:] != existing_pending_merges:
1453
1466
note('Your local commits will now show as pending merges with '
1454
1467
"'bzr status', and can be committed with 'bzr commit'.")
1455
1468
if conflicts != 0:
1459
1472
1460
1473
1461
1474
class cmd_info(Command):
1462
__doc__ = """Show information about a working tree, branch or repository.
1475
"""Show information about a working tree, branch or repository.
1463
1476
1464
1477
This command will show all known locations and formats associated to the
1465
1478
tree, branch or repository.
1503
1516
1504
1517
1505
1518
class cmd_remove(Command):
1506
__doc__ = """Remove files or directories.
1519
"""Remove files or directories.
1507
1520
1508
1521
This makes bzr stop tracking changes to the specified files. bzr will delete
1509
1522
them if they can easily be recovered using revert. If no options or
1531
1544
if file_list is not None:
1532
1545
file_list = [f for f in file_list]
1533
1546
1534
self.add_cleanup(tree.lock_write().unlock)
1547
tree.lock_write()
1548
self.add_cleanup(tree.unlock)
1535
1549
# Heuristics should probably all move into tree.remove_smart or
1536
1550
# some such?
1537
1551
if new:
1556
1570
1557
1571
1558
1572
class cmd_file_id(Command):
1559
__doc__ = """Print file_id of a particular file or directory.
1573
"""Print file_id of a particular file or directory.
1560
1574
1561
1575
The file_id is assigned when the file is first added and remains the
1562
1576
same through all revisions where the file exists, even when it is
1578
1592
1579
1593
1580
1594
class cmd_file_path(Command):
1581
__doc__ = """Print path of file_ids to a file or directory.
1595
"""Print path of file_ids to a file or directory.
1582
1596
1583
1597
This prints one line for each directory down to the target,
1584
1598
starting at the branch root.
1600
1614
1601
1615
1602
1616
class cmd_reconcile(Command):
1603
__doc__ = """Reconcile bzr metadata in a branch.
1617
"""Reconcile bzr metadata in a branch.
1604
1618
1605
1619
This can correct data mismatches that may have been caused by
1606
1620
previous ghost operations or bzr upgrades. You should only
1628
1642
1629
1643
1630
1644
class cmd_revision_history(Command):
1631
__doc__ = """Display the list of revision ids on a branch."""
1645
"""Display the list of revision ids on a branch."""
1632
1646
1633
1647
_see_also = ['log']
1634
1648
takes_args = ['location?']
1644
1658
1645
1659
1646
1660
class cmd_ancestry(Command):
1647
__doc__ = """List all revisions merged into this branch."""
1661
"""List all revisions merged into this branch."""
1648
1662
1649
1663
_see_also = ['log', 'revision-history']
1650
1664
takes_args = ['location?']
1669
1683
1670
1684
1671
1685
class cmd_init(Command):
1672
__doc__ = """Make a directory into a versioned branch.
1686
"""Make a directory into a versioned branch.
1673
1687
1674
1688
Use this to create an empty branch, or before importing an
1675
1689
existing project.
1778
1792
1779
1793
1780
1794
class cmd_init_repository(Command):
1781
__doc__ = """Create a shared repository for branches to share storage space.
1795
"""Create a shared repository for branches to share storage space.
1782
1796
1783
1797
New branches created under the repository directory will store their
1784
1798
revisions in the repository, not in the branch directory. For branches
1838
1852
1839
1853
1840
1854
class cmd_diff(Command):
1841
__doc__ = """Show differences in the working tree, between revisions or branches.
1855
"""Show differences in the working tree, between revisions or branches.
1842
1856
1843
1857
If no arguments are given, all changes for the current tree are listed.
1844
1858
If files are given, only the changes in those files are listed.
1930
1944
help='Use this command to compare files.',
1931
1945
type=unicode,
1932
1946
),
1933
RegistryOption('format',
1934
help='Diff format to use.',
1935
lazy_registry=('bzrlib.diff', 'format_registry'),
1936
value_switches=False, title='Diff format'),
1937
1947
]
1938
1948
aliases = ['di', 'dif']
1939
1949
encoding_type = 'exact'
1940
1950
1941
1951
@display_command
1942
1952
def run(self, revision=None, file_list=None, diff_options=None,
1943
prefix=None, old=None, new=None, using=None, format=None):
1944
from bzrlib.diff import (get_trees_and_branches_to_diff_locked,
1945
show_diff_trees)
1953
prefix=None, old=None, new=None, using=None):
1954
from bzrlib.diff import get_trees_and_branches_to_diff, show_diff_trees
1946
1955
1947
1956
if (prefix is None) or (prefix == '0'):
1948
1957
# diff -p0 format
1962
1971
raise errors.BzrCommandError('bzr diff --revision takes exactly'
1963
1972
' one or two revision specifiers')
1964
1973
1965
if using is not None and format is not None:
1966
raise errors.BzrCommandError('--using and --format are mutually '
1967
'exclusive.')
1968
1969
1974
(old_tree, new_tree,
1970
1975
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()
1976
specific_files, extra_trees) = get_trees_and_branches_to_diff(
1977
file_list, revision, old, new, apply_view=True)
1975
1978
return show_diff_trees(old_tree, new_tree, sys.stdout,
1976
1979
specific_files=specific_files,
1977
1980
external_diff_options=diff_options,
1978
1981
old_label=old_label, new_label=new_label,
1979
extra_trees=extra_trees,
1980
path_encoding=path_encoding,
1981
using=using,
1982
format_cls=format)
1982
extra_trees=extra_trees, using=using)
1983
1983
1984
1984
1985
1985
class cmd_deleted(Command):
1986
__doc__ = """List files deleted in the working tree.
1986
"""List files deleted in the working tree.
1987
1987
"""
1988
1988
# TODO: Show files deleted since a previous revision, or
1989
1989
# between two revisions.
1992
1992
# level of effort but possibly much less IO. (Or possibly not,
1993
1993
# if the directories are very large...)
1994
1994
_see_also = ['status', 'ls']
1995
takes_options = ['directory', 'show-ids']
1995
takes_options = ['show-ids']
1996
1996
1997
1997
@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)
1998
def run(self, show_ids=False):
1999
tree = WorkingTree.open_containing(u'.')[0]
2000
tree.lock_read()
2001
self.add_cleanup(tree.unlock)
2001
2002
old = tree.basis_tree()
2002
self.add_cleanup(old.lock_read().unlock)
2003
old.lock_read()
2004
self.add_cleanup(old.unlock)
2003
2005
for path, ie in old.inventory.iter_entries():
2004
2006
if not tree.has_id(ie.file_id):
2005
2007
self.outf.write(path)
2010
2012
2011
2013
2012
2014
class cmd_modified(Command):
2013
__doc__ = """List files modified in working tree.
2015
"""List files modified in working tree.
2014
2016
"""
2015
2017
2016
2018
hidden = True
2017
2019
_see_also = ['status', 'ls']
2018
takes_options = ['directory', 'null']
2020
takes_options = [
2021
Option('null',
2022
help='Write an ascii NUL (\\0) separator '
2023
'between files rather than a newline.')
2024
]
2019
2025
2020
2026
@display_command
2021
def run(self, null=False, directory=u'.'):
2022
tree = WorkingTree.open_containing(directory)[0]
2027
def run(self, null=False):
2028
tree = WorkingTree.open_containing(u'.')[0]
2023
2029
td = tree.changes_from(tree.basis_tree())
2024
2030
for path, id, kind, text_modified, meta_modified in td.modified:
2025
2031
if null:
2029
2035
2030
2036
2031
2037
class cmd_added(Command):
2032
__doc__ = """List files added in working tree.
2038
"""List files added in working tree.
2033
2039
"""
2034
2040
2035
2041
hidden = True
2036
2042
_see_also = ['status', 'ls']
2037
takes_options = ['directory', 'null']
2043
takes_options = [
2044
Option('null',
2045
help='Write an ascii NUL (\\0) separator '
2046
'between files rather than a newline.')
2047
]
2038
2048
2039
2049
@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)
2050
def run(self, null=False):
2051
wt = WorkingTree.open_containing(u'.')[0]
2052
wt.lock_read()
2053
self.add_cleanup(wt.unlock)
2043
2054
basis = wt.basis_tree()
2044
self.add_cleanup(basis.lock_read().unlock)
2055
basis.lock_read()
2056
self.add_cleanup(basis.unlock)
2045
2057
basis_inv = basis.inventory
2046
2058
inv = wt.inventory
2047
2059
for file_id in inv:
2050
2062
if inv.is_root(file_id) and len(basis_inv) == 0:
2051
2063
continue
2052
2064
path = inv.id2path(file_id)
2053
if not os.access(osutils.pathjoin(wt.basedir, path), os.F_OK):
2065
if not os.access(osutils.abspath(path), os.F_OK):
2054
2066
continue
2055
2067
if null:
2056
2068
self.outf.write(path + '\0')
2059
2071
2060
2072
2061
2073
class cmd_root(Command):
2062
__doc__ = """Show the tree root directory.
2074
"""Show the tree root directory.
2063
2075
2064
2076
The root is the nearest enclosing directory with a .bzr control
2065
2077
directory."""
2089
2101
2090
2102
2091
2103
class cmd_log(Command):
2092
__doc__ = """Show historical log for a branch or subset of a branch.
2104
"""Show historical log for a branch or subset of a branch.
2093
2105
2094
2106
log is bzr's default tool for exploring the history of a branch.
2095
2107
The branch to use is taken from the first parameter. If no parameters
2256
2268
help='Show just the specified revision.'
2257
2269
' See also "help revisionspec".'),
2258
2270
'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
2271
Option('levels',
2265
2272
short_name='n',
2266
2273
help='Number of levels to display - 0 for all, 1 for flat.',
2281
2288
help='Show changes made in each revision as a patch.'),
2282
2289
Option('include-merges',
2283
2290
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
2291
]
2289
2292
encoding_type = 'replace'
2290
2293
2300
2303
message=None,
2301
2304
limit=None,
2302
2305
show_diff=False,
2303
include_merges=False,
2304
authors=None,
2305
exclude_common_ancestry=False,
2306
):
2306
include_merges=False):
2307
2307
from bzrlib.log import (
2308
2308
Logger,
2309
2309
make_log_request_dict,
2310
2310
_get_info_for_log_files,
2311
2311
)
2312
2312
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
2313
if include_merges:
2318
2314
if levels is None:
2319
2315
levels = 0
2335
2331
if file_list:
2336
2332
# find the file ids to log and check for directory filtering
2337
2333
b, file_info_list, rev1, rev2 = _get_info_for_log_files(
2338
revision, file_list, self.add_cleanup)
2334
revision, file_list)
2335
self.add_cleanup(b.unlock)
2339
2336
for relpath, file_id, kind in file_info_list:
2340
2337
if file_id is None:
2341
2338
raise errors.BzrCommandError(
2359
2356
location = '.'
2360
2357
dir, relpath = bzrdir.BzrDir.open_containing(location)
2361
2358
b = dir.open_branch()
2362
self.add_cleanup(b.lock_read().unlock)
2359
b.lock_read()
2360
self.add_cleanup(b.unlock)
2363
2361
rev1, rev2 = _get_revision_range(revision, b, self.name())
2364
2362
2365
2363
# Decide on the type of delta & diff filtering to use
2385
2383
show_timezone=timezone,
2386
2384
delta_format=get_verbosity_level(),
2387
2385
levels=levels,
2388
show_advice=levels is None,
2389
author_list_handler=authors)
2386
show_advice=levels is None)
2390
2387
2391
2388
# Choose the algorithm for doing the logging. It's annoying
2392
2389
# having multiple code paths like this but necessary until
2411
2408
direction=direction, specific_fileids=file_ids,
2412
2409
start_revision=rev1, end_revision=rev2, limit=limit,
2413
2410
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
)
2411
diff_type=diff_type, _match_using_deltas=match_using_deltas)
2417
2412
Logger(b, rqst).show(lf)
2418
2413
2419
2414
2438
2433
raise errors.BzrCommandError(
2439
2434
"bzr %s doesn't accept two revisions in different"
2440
2435
" branches." % command_name)
2441
if start_spec.spec is None:
2442
# Avoid loading all the history.
2443
rev1 = RevisionInfo(branch, None, None)
2444
else:
2445
rev1 = start_spec.in_history(branch)
2436
rev1 = start_spec.in_history(branch)
2446
2437
# Avoid loading all of history when we know a missing
2447
2438
# end of range means the last revision ...
2448
2439
if end_spec.spec is None:
2477
2468
2478
2469
2479
2470
class cmd_touching_revisions(Command):
2480
__doc__ = """Return revision-ids which affected a particular file.
2471
"""Return revision-ids which affected a particular file.
2481
2472
2482
2473
A more user-friendly interface is "bzr log FILE".
2483
2474
"""
2490
2481
tree, relpath = WorkingTree.open_containing(filename)
2491
2482
file_id = tree.path2id(relpath)
2492
2483
b = tree.branch
2493
self.add_cleanup(b.lock_read().unlock)
2484
b.lock_read()
2485
self.add_cleanup(b.unlock)
2494
2486
touching_revs = log.find_touching_revisions(b, file_id)
2495
2487
for revno, revision_id, what in touching_revs:
2496
2488
self.outf.write("%6d %s\n" % (revno, what))
2497
2489
2498
2490
2499
2491
class cmd_ls(Command):
2500
__doc__ = """List files in a tree.
2492
"""List files in a tree.
2501
2493
"""
2502
2494
2503
2495
_see_also = ['status', 'cat']
2509
2501
help='Recurse into subdirectories.'),
2510
2502
Option('from-root',
2511
2503
help='Print paths relative to the root of the branch.'),
2512
Option('unknown', short_name='u',
2513
help='Print unknown files.'),
2504
Option('unknown', help='Print unknown files.'),
2514
2505
Option('versioned', help='Print versioned files.',
2515
2506
short_name='V'),
2516
Option('ignored', short_name='i',
2517
help='Print ignored files.'),
2518
Option('kind', short_name='k',
2507
Option('ignored', help='Print ignored files.'),
2508
Option('null',
2509
help='Write an ascii NUL (\\0) separator '
2510
'between files rather than a newline.'),
2511
Option('kind',
2519
2512
help='List entries of a particular kind: file, directory, symlink.',
2520
2513
type=unicode),
2521
'null',
2522
2514
'show-ids',
2523
'directory',
2524
2515
]
2525
2516
@display_command
2526
2517
def run(self, revision=None, verbose=False,
2527
2518
recursive=False, from_root=False,
2528
2519
unknown=False, versioned=False, ignored=False,
2529
null=False, kind=None, show_ids=False, path=None, directory=None):
2520
null=False, kind=None, show_ids=False, path=None):
2530
2521
2531
2522
if kind and kind not in ('file', 'directory', 'symlink'):
2532
2523
raise errors.BzrCommandError('invalid kind specified')
2544
2535
raise errors.BzrCommandError('cannot specify both --from-root'
2545
2536
' and PATH')
2546
2537
fs_path = path
2547
tree, branch, relpath = \
2548
_open_directory_or_containing_tree_or_branch(fs_path, directory)
2538
tree, branch, relpath = bzrdir.BzrDir.open_containing_tree_or_branch(
2539
fs_path)
2549
2540
2550
2541
# Calculate the prefix to use
2551
2542
prefix = None
2566
2557
view_str = views.view_display_str(view_files)
2567
2558
note("Ignoring files outside view. View is %s" % view_str)
2568
2559
2569
self.add_cleanup(tree.lock_read().unlock)
2560
tree.lock_read()
2561
self.add_cleanup(tree.unlock)
2570
2562
for fp, fc, fkind, fid, entry in tree.list_files(include_root=False,
2571
2563
from_dir=relpath, recursive=recursive):
2572
2564
# Apply additional masking
2614
2606
2615
2607
2616
2608
class cmd_unknowns(Command):
2617
__doc__ = """List unknown files.
2609
"""List unknown files.
2618
2610
"""
2619
2611
2620
2612
hidden = True
2621
2613
_see_also = ['ls']
2622
takes_options = ['directory']
2623
2614
2624
2615
@display_command
2625
def run(self, directory=u'.'):
2626
for f in WorkingTree.open_containing(directory)[0].unknowns():
2616
def run(self):
2617
for f in WorkingTree.open_containing(u'.')[0].unknowns():
2627
2618
self.outf.write(osutils.quotefn(f) + '\n')
2628
2619
2629
2620
2630
2621
class cmd_ignore(Command):
2631
__doc__ = """Ignore specified files or patterns.
2622
"""Ignore specified files or patterns.
2632
2623
2633
2624
See ``bzr help patterns`` for details on the syntax of patterns.
2634
2625
2643
2634
using this command or directly by using an editor, be sure to commit
2644
2635
it.
2645
2636
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
2637
Patterns prefixed with '!' are exceptions to ignore patterns and take
2653
2638
precedence over regular ignores. Such exceptions are used to specify
2654
2639
files that should be versioned which would otherwise be ignored.
2694
2679
2695
2680
_see_also = ['status', 'ignored', 'patterns']
2696
2681
takes_args = ['name_pattern*']
2697
takes_options = ['directory',
2698
Option('default-rules',
2699
help='Display the default ignore rules that bzr uses.')
2682
takes_options = [
2683
Option('old-default-rules',
2684
help='Write out the ignore rules bzr < 0.9 always used.')
2700
2685
]
2701
2686
2702
def run(self, name_pattern_list=None, default_rules=None,
2703
directory=u'.'):
2687
def run(self, name_pattern_list=None, old_default_rules=None):
2704
2688
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:
2689
if old_default_rules is not None:
2690
# dump the rules and exit
2691
for pattern in ignores.OLD_DEFAULTS:
2708
2692
self.outf.write("%s\n" % pattern)
2709
2693
return
2710
2694
if not name_pattern_list:
2711
2695
raise errors.BzrCommandError("ignore requires at least one "
2712
"NAME_PATTERN or --default-rules.")
2696
"NAME_PATTERN or --old-default-rules")
2713
2697
name_pattern_list = [globbing.normalize_pattern(p)
2714
2698
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
2699
for name_pattern in name_pattern_list:
2724
2700
if (name_pattern[0] == '/' or
2725
2701
(len(name_pattern) > 1 and name_pattern[1] == ':')):
2726
2702
raise errors.BzrCommandError(
2727
2703
"NAME_PATTERN should not be an absolute path")
2728
tree, relpath = WorkingTree.open_containing(directory)
2704
tree, relpath = WorkingTree.open_containing(u'.')
2729
2705
ignores.tree_ignores_add_patterns(tree, name_pattern_list)
2730
2706
ignored = globbing.Globster(name_pattern_list)
2731
2707
matches = []
2732
self.add_cleanup(tree.lock_read().unlock)
2708
tree.lock_read()
2733
2709
for entry in tree.list_files():
2734
2710
id = entry[3]
2735
2711
if id is not None:
2736
2712
filename = entry[0]
2737
2713
if ignored.match(filename):
2738
2714
matches.append(filename)
2715
tree.unlock()
2739
2716
if len(matches) > 0:
2740
2717
self.outf.write("Warning: the following files are version controlled and"
2741
2718
" match your ignore pattern:\n%s"
2744
2721
2745
2722
2746
2723
class cmd_ignored(Command):
2747
__doc__ = """List ignored files and the patterns that matched them.
2724
"""List ignored files and the patterns that matched them.
2748
2725
2749
2726
List all the ignored files and the ignore pattern that caused the file to
2750
2727
be ignored.
2756
2733
2757
2734
encoding_type = 'replace'
2758
2735
_see_also = ['ignore', 'ls']
2759
takes_options = ['directory']
2760
2736
2761
2737
@display_command
2762
def run(self, directory=u'.'):
2763
tree = WorkingTree.open_containing(directory)[0]
2764
self.add_cleanup(tree.lock_read().unlock)
2738
def run(self):
2739
tree = WorkingTree.open_containing(u'.')[0]
2740
tree.lock_read()
2741
self.add_cleanup(tree.unlock)
2765
2742
for path, file_class, kind, file_id, entry in tree.list_files():
2766
2743
if file_class != 'I':
2767
2744
continue
2771
2748
2772
2749
2773
2750
class cmd_lookup_revision(Command):
2774
__doc__ = """Lookup the revision-id from a revision-number
2751
"""Lookup the revision-id from a revision-number
2775
2752
2776
2753
:Examples:
2777
2754
bzr lookup-revision 33
2778
2755
"""
2779
2756
hidden = True
2780
2757
takes_args = ['revno']
2781
takes_options = ['directory']
2782
2758
2783
2759
@display_command
2784
def run(self, revno, directory=u'.'):
2760
def run(self, revno):
2785
2761
try:
2786
2762
revno = int(revno)
2787
2763
except ValueError:
2788
2764
raise errors.BzrCommandError("not a valid revision-number: %r"
2789
2765
% revno)
2790
revid = WorkingTree.open_containing(directory)[0].branch.get_rev_id(revno)
2766
revid = WorkingTree.open_containing(u'.')[0].branch.get_rev_id(revno)
2791
2767
self.outf.write("%s\n" % revid)
2792
2768
2793
2769
2794
2770
class cmd_export(Command):
2795
__doc__ = """Export current or past revision to a destination directory or archive.
2771
"""Export current or past revision to a destination directory or archive.
2796
2772
2797
2773
If no revision is specified this exports the last committed revision.
2798
2774
2820
2796
================= =========================
2821
2797
"""
2822
2798
takes_args = ['dest', 'branch_or_subdir?']
2823
takes_options = ['directory',
2799
takes_options = [
2824
2800
Option('format',
2825
2801
help="Type of file to export to.",
2826
2802
type=unicode),
2830
2806
Option('root',
2831
2807
type=str,
2832
2808
help="Name of the root directory inside the exported file."),
2833
Option('per-file-timestamps',
2834
help='Set modification time of files to that of the last '
2835
'revision in which it was changed.'),
2836
2809
]
2837
2810
def run(self, dest, branch_or_subdir=None, revision=None, format=None,
2838
root=None, filters=False, per_file_timestamps=False, directory=u'.'):
2811
root=None, filters=False):
2839
2812
from bzrlib.export import export
2840
2813
2841
2814
if branch_or_subdir is None:
2842
tree = WorkingTree.open_containing(directory)[0]
2815
tree = WorkingTree.open_containing(u'.')[0]
2843
2816
b = tree.branch
2844
2817
subdir = None
2845
2818
else:
2848
2821
2849
2822
rev_tree = _get_one_revision_tree('export', revision, branch=b, tree=tree)
2850
2823
try:
2851
export(rev_tree, dest, format, root, subdir, filtered=filters,
2852
per_file_timestamps=per_file_timestamps)
2824
export(rev_tree, dest, format, root, subdir, filtered=filters)
2853
2825
except errors.NoSuchExportFormat, e:
2854
2826
raise errors.BzrCommandError('Unsupported export format: %s' % e.format)
2855
2827
2856
2828
2857
2829
class cmd_cat(Command):
2858
__doc__ = """Write the contents of a file as of a given revision to standard output.
2830
"""Write the contents of a file as of a given revision to standard output.
2859
2831
2860
2832
If no revision is nominated, the last revision is used.
2861
2833
2864
2836
"""
2865
2837
2866
2838
_see_also = ['ls']
2867
takes_options = ['directory',
2839
takes_options = [
2868
2840
Option('name-from-revision', help='The path name in the old tree.'),
2869
2841
Option('filters', help='Apply content filters to display the '
2870
2842
'convenience form.'),
2875
2847
2876
2848
@display_command
2877
2849
def run(self, filename, revision=None, name_from_revision=False,
2878
filters=False, directory=None):
2850
filters=False):
2879
2851
if revision is not None and len(revision) != 1:
2880
2852
raise errors.BzrCommandError("bzr cat --revision takes exactly"
2881
2853
" one revision specifier")
2882
2854
tree, branch, relpath = \
2883
_open_directory_or_containing_tree_or_branch(filename, directory)
2884
self.add_cleanup(branch.lock_read().unlock)
2855
bzrdir.BzrDir.open_containing_tree_or_branch(filename)
2856
branch.lock_read()
2857
self.add_cleanup(branch.unlock)
2885
2858
return self._run(tree, branch, relpath, filename, revision,
2886
2859
name_from_revision, filters)
2887
2860
2890
2863
if tree is None:
2891
2864
tree = b.basis_tree()
2892
2865
rev_tree = _get_one_revision_tree('cat', revision, branch=b)
2893
self.add_cleanup(rev_tree.lock_read().unlock)
2866
rev_tree.lock_read()
2867
self.add_cleanup(rev_tree.unlock)
2894
2868
2895
2869
old_file_id = rev_tree.path2id(relpath)
2896
2870
2939
2913
2940
2914
2941
2915
class cmd_local_time_offset(Command):
2942
__doc__ = """Show the offset in seconds from GMT to local time."""
2916
"""Show the offset in seconds from GMT to local time."""
2943
2917
hidden = True
2944
2918
@display_command
2945
2919
def run(self):
2948
2922
2949
2923
2950
2924
class cmd_commit(Command):
2951
__doc__ = """Commit changes into a new revision.
2925
"""Commit changes into a new revision.
2952
2926
2953
2927
An explanatory message needs to be given for each commit. This is
2954
2928
often done by using the --message option (getting the message from the
3062
3036
"the master branch until a normal commit "
3063
3037
"is performed."
3064
3038
),
3065
Option('show-diff', short_name='p',
3039
Option('show-diff',
3066
3040
help='When no message is supplied, show the diff along'
3067
3041
' with the status summary in the message editor.'),
3068
3042
]
3148
3122
'(use --file "%(f)s" to take commit message from that file)'
3149
3123
% { 'f': message })
3150
3124
ui.ui_factory.show_warning(warning_msg)
3151
if '\r' in message:
3152
message = message.replace('\r\n', '\n')
3153
message = message.replace('\r', '\n')
3154
if file:
3155
raise errors.BzrCommandError(
3156
"please specify either --message or --file")
3157
3125
3158
3126
def get_message(commit_obj):
3159
3127
"""Callback to get commit message"""
3160
if file:
3161
f = codecs.open(file, 'rt', osutils.get_user_encoding())
3162
try:
3163
my_message = f.read()
3164
finally:
3165
f.close()
3166
elif message is not None:
3167
my_message = message
3168
else:
3169
# No message supplied: make one up.
3170
# text is the status of the tree
3171
text = make_commit_message_template_encoded(tree,
3128
my_message = message
3129
if my_message is not None and '\r' in my_message:
3130
my_message = my_message.replace('\r\n', '\n')
3131
my_message = my_message.replace('\r', '\n')
3132
if my_message is None and not file:
3133
t = make_commit_message_template_encoded(tree,
3172
3134
selected_list, diff=show_diff,
3173
3135
output_encoding=osutils.get_user_encoding())
3174
# start_message is the template generated from hooks
3175
# XXX: Warning - looks like hooks return unicode,
3176
# make_commit_message_template_encoded returns user encoding.
3177
# We probably want to be using edit_commit_message instead to
3178
# avoid this.
3179
3136
start_message = generate_commit_message_template(commit_obj)
3180
my_message = edit_commit_message_encoded(text,
3137
my_message = edit_commit_message_encoded(t,
3181
3138
start_message=start_message)
3182
3139
if my_message is None:
3183
3140
raise errors.BzrCommandError("please specify a commit"
3184
3141
" message with either --message or --file")
3142
elif my_message and file:
3143
raise errors.BzrCommandError(
3144
"please specify either --message or --file")
3145
if file:
3146
my_message = codecs.open(file, 'rt',
3147
osutils.get_user_encoding()).read()
3185
3148
if my_message == "":
3186
3149
raise errors.BzrCommandError("empty commit message specified")
3187
3150
return my_message
3199
3162
timezone=offset,
3200
3163
exclude=safe_relpath_files(tree, exclude))
3201
3164
except PointlessCommit:
3165
# FIXME: This should really happen before the file is read in;
3166
# perhaps prepare the commit; get the message; then actually commit
3202
3167
raise errors.BzrCommandError("No changes to commit."
3203
3168
" Use --unchanged to commit anyhow.")
3204
3169
except ConflictsInTree:
3217
3182
3218
3183
3219
3184
class cmd_check(Command):
3220
__doc__ = """Validate working tree structure, branch consistency and repository history.
3185
"""Validate working tree structure, branch consistency and repository history.
3221
3186
3222
3187
This command checks various invariants about branch and repository storage
3223
3188
to detect data corruption or bzr bugs.
3287
3252
3288
3253
3289
3254
class cmd_upgrade(Command):
3290
__doc__ = """Upgrade branch storage to current format.
3255
"""Upgrade branch storage to current format.
3291
3256
3292
3257
The check command or bzr developers may sometimes advise you to run
3293
3258
this command. When the default format has changed you may also be warned
3311
3276
3312
3277
3313
3278
class cmd_whoami(Command):
3314
__doc__ = """Show or set bzr user id.
3279
"""Show or set bzr user id.
3315
3280
3316
3281
:Examples:
3317
3282
Show the email of the current user::
3322
3287
3323
3288
bzr whoami "Frank Chu <fchu@example.com>"
3324
3289
"""
3325
takes_options = [ 'directory',
3326
Option('email',
3290
takes_options = [ Option('email',
3327
3291
help='Display email address only.'),
3328
3292
Option('branch',
3329
3293
help='Set identity for the current branch instead of '
3333
3297
encoding_type = 'replace'
3334
3298
3335
3299
@display_command
3336
def run(self, email=False, branch=False, name=None, directory=None):
3300
def run(self, email=False, branch=False, name=None):
3337
3301
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()
3302
# use branch if we're inside one; otherwise global config
3303
try:
3304
c = Branch.open_containing('.')[0].get_config()
3305
except errors.NotBranchError:
3306
c = config.GlobalConfig()
3346
3307
if email:
3347
3308
self.outf.write(c.user_email() + '\n')
3348
3309
else:
3358
3319
3359
3320
# use global config unless --branch given
3360
3321
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()
3322
c = Branch.open_containing('.')[0].get_config()
3365
3323
else:
3366
3324
c = config.GlobalConfig()
3367
3325
c.set_user_option('email', name)
3368
3326
3369
3327
3370
3328
class cmd_nick(Command):
3371
__doc__ = """Print or set the branch nickname.
3329
"""Print or set the branch nickname.
3372
3330
3373
3331
If unset, the tree root directory name is used as the nickname.
3374
3332
To print the current nickname, execute with no argument.
3379
3337
3380
3338
_see_also = ['info']
3381
3339
takes_args = ['nickname?']
3382
takes_options = ['directory']
3383
def run(self, nickname=None, directory=u'.'):
3384
branch = Branch.open_containing(directory)[0]
3340
def run(self, nickname=None):
3341
branch = Branch.open_containing(u'.')[0]
3385
3342
if nickname is None:
3386
3343
self.printme(branch)
3387
3344
else:
3393
3350
3394
3351
3395
3352
class cmd_alias(Command):
3396
__doc__ = """Set/unset and display aliases.
3353
"""Set/unset and display aliases.
3397
3354
3398
3355
:Examples:
3399
3356
Show the current aliases::
3463
3420
3464
3421
3465
3422
class cmd_selftest(Command):
3466
__doc__ = """Run internal test suite.
3423
"""Run internal test suite.
3467
3424
3468
3425
If arguments are given, they are regular expressions that say which tests
3469
3426
should run. Tests matching any expression are run, and other tests are
3537
3494
'throughout the test suite.',
3538
3495
type=get_transport_type),
3539
3496
Option('benchmark',
3540
help='Run the benchmarks rather than selftests.',
3541
hidden=True),
3497
help='Run the benchmarks rather than selftests.'),
3542
3498
Option('lsprof-timed',
3543
3499
help='Generate lsprof output for benchmarked'
3544
3500
' sections of code.'),
3545
3501
Option('lsprof-tests',
3546
3502
help='Generate lsprof output for each test.'),
3503
Option('cache-dir', type=str,
3504
help='Cache intermediate benchmark output in this '
3505
'directory.'),
3547
3506
Option('first',
3548
3507
help='Run all tests, but run specified tests first.',
3549
3508
short_name='f',
3583
3542
3584
3543
def run(self, testspecs_list=None, verbose=False, one=False,
3585
3544
transport=None, benchmark=None,
3586
lsprof_timed=None,
3545
lsprof_timed=None, cache_dir=None,
3587
3546
first=False, list_only=False,
3588
3547
randomize=None, exclude=None, strict=False,
3589
3548
load_list=None, debugflag=None, starting_with=None, subunit=False,
3590
3549
parallel=None, lsprof_tests=False):
3591
3550
from bzrlib.tests import selftest
3551
import bzrlib.benchmarks as benchmarks
3552
from bzrlib.benchmarks import tree_creator
3592
3553
3593
3554
# Make deprecation warnings visible, unless -Werror is set
3594
3555
symbol_versioning.activate_deprecation_warnings(override=False)
3595
3556
3557
if cache_dir is not None:
3558
tree_creator.TreeCreator.CACHE_ROOT = osutils.abspath(cache_dir)
3596
3559
if testspecs_list is not None:
3597
3560
pattern = '|'.join(testspecs_list)
3598
3561
else:
3604
3567
raise errors.BzrCommandError("subunit not available. subunit "
3605
3568
"needs to be installed to use --subunit.")
3606
3569
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
3570
if parallel:
3617
3571
self.additional_selftest_args.setdefault(
3618
3572
'suite_decorators', []).append(parallel)
3619
3573
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
3574
test_suite_factory = benchmarks.test_suite
3575
# Unless user explicitly asks for quiet, be verbose in benchmarks
3576
verbose = not is_quiet()
3577
# TODO: should possibly lock the history file...
3578
benchfile = open(".perf_history", "at", buffering=1)
3579
self.add_cleanup(benchfile.close)
3580
else:
3581
test_suite_factory = None
3582
benchfile = None
3624
3583
selftest_kwargs = {"verbose": verbose,
3625
3584
"pattern": pattern,
3626
3585
"stop_on_failure": one,
3628
3587
"test_suite_factory": test_suite_factory,
3629
3588
"lsprof_timed": lsprof_timed,
3630
3589
"lsprof_tests": lsprof_tests,
3590
"bench_history": benchfile,
3631
3591
"matching_tests_first": first,
3632
3592
"list_only": list_only,
3633
3593
"random_seed": randomize,
3643
3603
3644
3604
3645
3605
class cmd_version(Command):
3646
__doc__ = """Show version of bzr."""
3606
"""Show version of bzr."""
3647
3607
3648
3608
encoding_type = 'replace'
3649
3609
takes_options = [
3660
3620
3661
3621
3662
3622
class cmd_rocks(Command):
3663
__doc__ = """Statement of optimism."""
3623
"""Statement of optimism."""
3664
3624
3665
3625
hidden = True
3666
3626
3670
3630
3671
3631
3672
3632
class cmd_find_merge_base(Command):
3673
__doc__ = """Find and print a base revision for merging two branches."""
3633
"""Find and print a base revision for merging two branches."""
3674
3634
# TODO: Options to specify revisions on either side, as if
3675
3635
# merging only part of the history.
3676
3636
takes_args = ['branch', 'other']
3682
3642
3683
3643
branch1 = Branch.open_containing(branch)[0]
3684
3644
branch2 = Branch.open_containing(other)[0]
3685
self.add_cleanup(branch1.lock_read().unlock)
3686
self.add_cleanup(branch2.lock_read().unlock)
3645
branch1.lock_read()
3646
self.add_cleanup(branch1.unlock)
3647
branch2.lock_read()
3648
self.add_cleanup(branch2.unlock)
3687
3649
last1 = ensure_null(branch1.last_revision())
3688
3650
last2 = ensure_null(branch2.last_revision())
3689
3651
3694
3656
3695
3657
3696
3658
class cmd_merge(Command):
3697
__doc__ = """Perform a three-way merge.
3659
"""Perform a three-way merge.
3698
3660
3699
3661
The source of the merge can be specified either in the form of a branch,
3700
3662
or in the form of a path to a file containing a merge directive generated
3783
3745
' completely merged into the source, pull from the'
3784
3746
' source rather than merging. When this happens,'
3785
3747
' you do not need to commit the result.'),
3786
custom_help('directory',
3748
Option('directory',
3787
3749
help='Branch to merge into, '
3788
'rather than the one containing the working directory.'),
3750
'rather than the one containing the working directory.',
3751
short_name='d',
3752
type=unicode,
3753
),
3789
3754
Option('preview', help='Instead of merging, show a diff of the'
3790
3755
' merge.'),
3791
3756
Option('interactive', help='Select changes interactively.',
3824
3789
unversioned_filter=tree.is_ignored, view_info=view_info)
3825
3790
pb = ui.ui_factory.nested_progress_bar()
3826
3791
self.add_cleanup(pb.finished)
3827
self.add_cleanup(tree.lock_write().unlock)
3792
tree.lock_write()
3793
self.add_cleanup(tree.unlock)
3828
3794
if location is not None:
3829
3795
try:
3830
3796
mergeable = bundle.read_mergeable_from_url(location,
3891
3857
def _do_preview(self, merger):
3892
3858
from bzrlib.diff import show_diff_trees
3893
3859
result_tree = self._get_preview(merger)
3894
path_encoding = osutils.get_diff_header_encoding()
3895
3860
show_diff_trees(merger.this_tree, result_tree, self.outf,
3896
old_label='', new_label='',
3897
path_encoding=path_encoding)
3861
old_label='', new_label='')
3898
3862
3899
3863
def _do_merge(self, merger, change_reporter, allow_pending, verified):
3900
3864
merger.change_reporter = change_reporter
4053
4017
4054
4018
4055
4019
class cmd_remerge(Command):
4056
__doc__ = """Redo a merge.
4020
"""Redo a merge.
4057
4021
4058
4022
Use this if you want to try a different merge technique while resolving
4059
4023
conflicts. Some merge techniques are better than others, and remerge
4084
4048
4085
4049
def run(self, file_list=None, merge_type=None, show_base=False,
4086
4050
reprocess=False):
4087
from bzrlib.conflicts import restore
4088
4051
if merge_type is None:
4089
4052
merge_type = _mod_merge.Merge3Merger
4090
4053
tree, file_list = tree_files(file_list)
4091
self.add_cleanup(tree.lock_write().unlock)
4054
tree.lock_write()
4055
self.add_cleanup(tree.unlock)
4092
4056
parents = tree.get_parent_ids()
4093
4057
if len(parents) != 2:
4094
4058
raise errors.BzrCommandError("Sorry, remerge only works after normal"
4147
4111
4148
4112
4149
4113
class cmd_revert(Command):
4150
__doc__ = """Revert files to a previous revision.
4114
"""Revert files to a previous revision.
4151
4115
4152
4116
Giving a list of files will revert only those files. Otherwise, all files
4153
4117
will be reverted. If the revision is not specified with '--revision', the
4204
4168
def run(self, revision=None, no_backup=False, file_list=None,
4205
4169
forget_merges=None):
4206
4170
tree, file_list = tree_files(file_list)
4207
self.add_cleanup(tree.lock_tree_write().unlock)
4171
tree.lock_write()
4172
self.add_cleanup(tree.unlock)
4208
4173
if forget_merges:
4209
4174
tree.set_parent_ids(tree.get_parent_ids()[:1])
4210
4175
else:
4218
4183
4219
4184
4220
4185
class cmd_assert_fail(Command):
4221
__doc__ = """Test reporting of assertion failures"""
4186
"""Test reporting of assertion failures"""
4222
4187
# intended just for use in testing
4223
4188
4224
4189
hidden = True
4228
4193
4229
4194
4230
4195
class cmd_help(Command):
4231
__doc__ = """Show help on a command or other topic.
4196
"""Show help on a command or other topic.
4232
4197
"""
4233
4198
4234
4199
_see_also = ['topics']
4247
4212
4248
4213
4249
4214
class cmd_shell_complete(Command):
4250
__doc__ = """Show appropriate completions for context.
4215
"""Show appropriate completions for context.
4251
4216
4252
4217
For a list of all available commands, say 'bzr shell-complete'.
4253
4218
"""
4262
4227
4263
4228
4264
4229
class cmd_missing(Command):
4265
__doc__ = """Show unmerged/unpulled revisions between two branches.
4230
"""Show unmerged/unpulled revisions between two branches.
4266
4231
4267
4232
OTHER_BRANCH may be local or remote.
4268
4233
4299
4264
_see_also = ['merge', 'pull']
4300
4265
takes_args = ['other_branch?']
4301
4266
takes_options = [
4302
'directory',
4303
4267
Option('reverse', 'Reverse the order of revisions.'),
4304
4268
Option('mine-only',
4305
4269
'Display changes in the local branch only.'),
4327
4291
theirs_only=False,
4328
4292
log_format=None, long=False, short=False, line=False,
4329
4293
show_ids=False, verbose=False, this=False, other=False,
4330
include_merges=False, revision=None, my_revision=None,
4331
directory=u'.'):
4294
include_merges=False, revision=None, my_revision=None):
4332
4295
from bzrlib.missing import find_unmerged, iter_log_revisions
4333
4296
def message(s):
4334
4297
if not is_quiet():
4347
4310
elif theirs_only:
4348
4311
restrict = 'remote'
4349
4312
4350
local_branch = Branch.open_containing(directory)[0]
4351
self.add_cleanup(local_branch.lock_read().unlock)
4352
4313
local_branch = Branch.open_containing(u".")[0]
4353
4314
parent = local_branch.get_parent()
4354
4315
if other_branch is None:
4355
4316
other_branch = parent
4364
4325
remote_branch = Branch.open(other_branch)
4365
4326
if remote_branch.base == local_branch.base:
4366
4327
remote_branch = local_branch
4367
else:
4368
self.add_cleanup(remote_branch.lock_read().unlock)
4369
4328
4329
local_branch.lock_read()
4330
self.add_cleanup(local_branch.unlock)
4370
4331
local_revid_range = _revision_range_to_revid_range(
4371
4332
_get_revision_range(my_revision, local_branch,
4372
4333
self.name()))
4373
4334
4335
remote_branch.lock_read()
4336
self.add_cleanup(remote_branch.unlock)
4374
4337
remote_revid_range = _revision_range_to_revid_range(
4375
4338
_get_revision_range(revision,
4376
4339
remote_branch, self.name()))
4426
4389
message("Branches are up to date.\n")
4427
4390
self.cleanup_now()
4428
4391
if not status_code and parent is None and other_branch is not None:
4429
self.add_cleanup(local_branch.lock_write().unlock)
4392
local_branch.lock_write()
4393
self.add_cleanup(local_branch.unlock)
4430
4394
# handle race conditions - a parent might be set while we run.
4431
4395
if local_branch.get_parent() is None:
4432
4396
local_branch.set_parent(remote_branch.base)
4434
4398
4435
4399
4436
4400
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
"""
4401
"""Compress the data within a repository."""
4454
4402
4455
4403
_see_also = ['repositories']
4456
4404
takes_args = ['branch_or_repo?']
4457
takes_options = [
4458
Option('clean-obsolete-packs', 'Delete obsolete packs to save disk space.'),
4459
]
4460
4405
4461
def run(self, branch_or_repo='.', clean_obsolete_packs=False):
4406
def run(self, branch_or_repo='.'):
4462
4407
dir = bzrdir.BzrDir.open_containing(branch_or_repo)[0]
4463
4408
try:
4464
4409
branch = dir.open_branch()
4465
4410
repository = branch.repository
4466
4411
except errors.NotBranchError:
4467
4412
repository = dir.open_repository()
4468
repository.pack(clean_obsolete_packs=clean_obsolete_packs)
4413
repository.pack()
4469
4414
4470
4415
4471
4416
class cmd_plugins(Command):
4472
__doc__ = """List the installed plugins.
4417
"""List the installed plugins.
4473
4418
4474
4419
This command displays the list of installed plugins including
4475
4420
version of plugin and a short description of each.
4514
4459
4515
4460
4516
4461
class cmd_testament(Command):
4517
__doc__ = """Show testament (signing-form) of a revision."""
4462
"""Show testament (signing-form) of a revision."""
4518
4463
takes_options = [
4519
4464
'revision',
4520
4465
Option('long', help='Produce long-format testament.'),
4532
4477
b = Branch.open_containing(branch)[0]
4533
4478
else:
4534
4479
b = Branch.open(branch)
4535
self.add_cleanup(b.lock_read().unlock)
4480
b.lock_read()
4481
self.add_cleanup(b.unlock)
4536
4482
if revision is None:
4537
4483
rev_id = b.last_revision()
4538
4484
else:
4545
4491
4546
4492
4547
4493
class cmd_annotate(Command):
4548
__doc__ = """Show the origin of each line in a file.
4494
"""Show the origin of each line in a file.
4549
4495
4550
4496
This prints out the given file with an annotation on the left side
4551
4497
indicating which revision, author and date introduced the change.
4562
4508
Option('long', help='Show commit date in annotations.'),
4563
4509
'revision',
4564
4510
'show-ids',
4565
'directory',
4566
4511
]
4567
4512
encoding_type = 'exact'
4568
4513
4569
4514
@display_command
4570
4515
def run(self, filename, all=False, long=False, revision=None,
4571
show_ids=False, directory=None):
4516
show_ids=False):
4572
4517
from bzrlib.annotate import annotate_file, annotate_file_tree
4573
4518
wt, branch, relpath = \
4574
_open_directory_or_containing_tree_or_branch(filename, directory)
4519
bzrdir.BzrDir.open_containing_tree_or_branch(filename)
4575
4520
if wt is not None:
4576
self.add_cleanup(wt.lock_read().unlock)
4521
wt.lock_read()
4522
self.add_cleanup(wt.unlock)
4577
4523
else:
4578
self.add_cleanup(branch.lock_read().unlock)
4524
branch.lock_read()
4525
self.add_cleanup(branch.unlock)
4579
4526
tree = _get_one_revision_tree('annotate', revision, branch=branch)
4580
self.add_cleanup(tree.lock_read().unlock)
4527
tree.lock_read()
4528
self.add_cleanup(tree.unlock)
4581
4529
if wt is not None:
4582
4530
file_id = wt.path2id(relpath)
4583
4531
else:
4596
4544
4597
4545
4598
4546
class cmd_re_sign(Command):
4599
__doc__ = """Create a digital signature for an existing revision."""
4547
"""Create a digital signature for an existing revision."""
4600
4548
# TODO be able to replace existing ones.
4601
4549
4602
4550
hidden = True # is this right ?
4603
4551
takes_args = ['revision_id*']
4604
takes_options = ['directory', 'revision']
4552
takes_options = ['revision']
4605
4553
4606
def run(self, revision_id_list=None, revision=None, directory=u'.'):
4554
def run(self, revision_id_list=None, revision=None):
4607
4555
if revision_id_list is not None and revision is not None:
4608
4556
raise errors.BzrCommandError('You can only supply one of revision_id or --revision')
4609
4557
if revision_id_list is None and revision is None:
4610
4558
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)
4559
b = WorkingTree.open_containing(u'.')[0].branch
4560
b.lock_write()
4561
self.add_cleanup(b.unlock)
4613
4562
return self._run(b, revision_id_list, revision)
4614
4563
4615
4564
def _run(self, b, revision_id_list, revision):
4661
4610
4662
4611
4663
4612
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.
4613
"""Convert the current branch into a checkout of the supplied branch.
4666
4614
4667
4615
Once converted into a checkout, commits must succeed on the master branch
4668
4616
before they will be applied to the local branch.
4674
4622
4675
4623
_see_also = ['checkouts', 'unbind']
4676
4624
takes_args = ['location?']
4677
takes_options = ['directory']
4625
takes_options = []
4678
4626
4679
def run(self, location=None, directory=u'.'):
4680
b, relpath = Branch.open_containing(directory)
4627
def run(self, location=None):
4628
b, relpath = Branch.open_containing(u'.')
4681
4629
if location is None:
4682
4630
try:
4683
4631
location = b.get_old_bound_location()
4702
4650
4703
4651
4704
4652
class cmd_unbind(Command):
4705
__doc__ = """Convert the current checkout into a regular branch.
4653
"""Convert the current checkout into a regular branch.
4706
4654
4707
4655
After unbinding, the local branch is considered independent and subsequent
4708
4656
commits will be local only.
4710
4658
4711
4659
_see_also = ['checkouts', 'bind']
4712
4660
takes_args = []
4713
takes_options = ['directory']
4661
takes_options = []
4714
4662
4715
def run(self, directory=u'.'):
4716
b, relpath = Branch.open_containing(directory)
4663
def run(self):
4664
b, relpath = Branch.open_containing(u'.')
4717
4665
if not b.unbind():
4718
4666
raise errors.BzrCommandError('Local branch is not bound')
4719
4667
4720
4668
4721
4669
class cmd_uncommit(Command):
4722
__doc__ = """Remove the last committed revision.
4670
"""Remove the last committed revision.
4723
4671
4724
4672
--verbose will print out what is being removed.
4725
4673
--dry-run will go through all the motions, but not actually
4765
4713
b = control.open_branch()
4766
4714
4767
4715
if tree is not None:
4768
self.add_cleanup(tree.lock_write().unlock)
4716
tree.lock_write()
4717
self.add_cleanup(tree.unlock)
4769
4718
else:
4770
self.add_cleanup(b.lock_write().unlock)
4719
b.lock_write()
4720
self.add_cleanup(b.unlock)
4771
4721
return self._run(b, tree, dry_run, verbose, revision, force, local=local)
4772
4722
4773
4723
def _run(self, b, tree, dry_run, verbose, revision, force, local=False):
4825
4775
4826
4776
4827
4777
class cmd_break_lock(Command):
4828
__doc__ = """Break a dead lock on a repository, branch or working directory.
4778
"""Break a dead lock on a repository, branch or working directory.
4829
4779
4830
4780
CAUTION: Locks should only be broken when you are sure that the process
4831
4781
holding the lock has been stopped.
4850
4800
4851
4801
4852
4802
class cmd_wait_until_signalled(Command):
4853
__doc__ = """Test helper for test_start_and_stop_bzr_subprocess_send_signal.
4803
"""Test helper for test_start_and_stop_bzr_subprocess_send_signal.
4854
4804
4855
4805
This just prints a line to signal when it is ready, then blocks on stdin.
4856
4806
"""
4864
4814
4865
4815
4866
4816
class cmd_serve(Command):
4867
__doc__ = """Run the bzr server."""
4817
"""Run the bzr server."""
4868
4818
4869
4819
aliases = ['server']
4870
4820
4881
4831
'result in a dynamically allocated port. The default port '
4882
4832
'depends on the protocol.',
4883
4833
type=str),
4884
custom_help('directory',
4885
help='Serve contents of this directory.'),
4834
Option('directory',
4835
help='Serve contents of this directory.',
4836
type=unicode),
4886
4837
Option('allow-writes',
4887
4838
help='By default the server is a readonly server. Supplying '
4888
4839
'--allow-writes enables write access to the contents of '
4915
4866
4916
4867
def run(self, port=None, inet=False, directory=None, allow_writes=False,
4917
4868
protocol=None):
4918
from bzrlib import transport
4869
from bzrlib.transport import get_transport, transport_server_registry
4919
4870
if directory is None:
4920
4871
directory = os.getcwd()
4921
4872
if protocol is None:
4922
protocol = transport.transport_server_registry.get()
4873
protocol = transport_server_registry.get()
4923
4874
host, port = self.get_host_and_port(port)
4924
4875
url = urlutils.local_path_to_url(directory)
4925
4876
if not allow_writes:
4926
4877
url = 'readonly+' + url
4927
t = transport.get_transport(url)
4928
protocol(t, host, port, inet)
4878
transport = get_transport(url)
4879
protocol(transport, host, port, inet)
4929
4880
4930
4881
4931
4882
class cmd_join(Command):
4932
__doc__ = """Combine a tree into its containing tree.
4883
"""Combine a tree into its containing tree.
4933
4884
4934
4885
This command requires the target tree to be in a rich-root format.
4935
4886
4975
4926
4976
4927
4977
4928
class cmd_split(Command):
4978
__doc__ = """Split a subdirectory of a tree into a separate tree.
4929
"""Split a subdirectory of a tree into a separate tree.
4979
4930
4980
4931
This command will produce a target tree in a format that supports
4981
4932
rich roots, like 'rich-root' or 'rich-root-pack'. These formats cannot be
5001
4952
5002
4953
5003
4954
class cmd_merge_directive(Command):
5004
__doc__ = """Generate a merge directive for auto-merge tools.
4955
"""Generate a merge directive for auto-merge tools.
5005
4956
5006
4957
A directive requests a merge to be performed, and also provides all the
5007
4958
information necessary to do so. This means it must either include a
5024
4975
_see_also = ['send']
5025
4976
5026
4977
takes_options = [
5027
'directory',
5028
4978
RegistryOption.from_kwargs('patch-type',
5029
4979
'The type of patch to include in the directive.',
5030
4980
title='Patch type',
5043
4993
encoding_type = 'exact'
5044
4994
5045
4995
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'.'):
4996
sign=False, revision=None, mail_to=None, message=None):
5048
4997
from bzrlib.revision import ensure_null, NULL_REVISION
5049
4998
include_patch, include_bundle = {
5050
4999
'plain': (False, False),
5051
5000
'diff': (True, False),
5052
5001
'bundle': (True, True),
5053
5002
}[patch_type]
5054
branch = Branch.open(directory)
5003
branch = Branch.open('.')
5055
5004
stored_submit_branch = branch.get_submit_branch()
5056
5005
if submit_branch is None:
5057
5006
submit_branch = stored_submit_branch
5102
5051
5103
5052
5104
5053
class cmd_send(Command):
5105
__doc__ = """Mail or create a merge-directive for submitting changes.
5054
"""Mail or create a merge-directive for submitting changes.
5106
5055
5107
5056
A merge directive provides many things needed for requesting merges:
5108
5057
5142
5091
given, in which case it is sent to a file.
5143
5092
5144
5093
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.
5094
on Windows (it uses MAPI). On Linux, it requires the xdg-email utility.
5146
5095
If the preferred client can't be found (or used), your editor will be used.
5147
5096
5148
5097
To use a specific mail program, set the mail_client configuration option.
5190
5139
short_name='f',
5191
5140
type=unicode),
5192
5141
Option('output', short_name='o',
5193
help='Write merge directive to this file or directory; '
5142
help='Write merge directive to this file; '
5194
5143
'use - for stdout.',
5195
5144
type=unicode),
5196
5145
Option('strict',
5219
5168
5220
5169
5221
5170
class cmd_bundle_revisions(cmd_send):
5222
__doc__ = """Create a merge-directive for submitting changes.
5171
"""Create a merge-directive for submitting changes.
5223
5172
5224
5173
A merge directive provides many things needed for requesting merges:
5225
5174
5292
5241
5293
5242
5294
5243
class cmd_tag(Command):
5295
__doc__ = """Create, remove or modify a tag naming a revision.
5244
"""Create, remove or modify a tag naming a revision.
5296
5245
5297
5246
Tags give human-meaningful names to revisions. Commands that take a -r
5298
5247
(--revision) option can be given -rtag:X, where X is any previously
5306
5255
5307
5256
To rename a tag (change the name but keep it on the same revsion), run ``bzr
5308
5257
tag new-name -r tag:old-name`` and then ``bzr tag --delete oldname``.
5309
5310
If no tag name is specified it will be determined through the
5311
'automatic_tag_name' hook. This can e.g. be used to automatically tag
5312
upstream releases by reading configure.ac. See ``bzr help hooks`` for
5313
details.
5314
5258
"""
5315
5259
5316
5260
_see_also = ['commit', 'tags']
5317
takes_args = ['tag_name?']
5261
takes_args = ['tag_name']
5318
5262
takes_options = [
5319
5263
Option('delete',
5320
5264
help='Delete this tag rather than placing it.',
5321
5265
),
5322
custom_help('directory',
5323
help='Branch in which to place the tag.'),
5266
Option('directory',
5267
help='Branch in which to place the tag.',
5268
short_name='d',
5269
type=unicode,
5270
),
5324
5271
Option('force',
5325
5272
help='Replace existing tags.',
5326
5273
),
5327
5274
'revision',
5328
5275
]
5329
5276
5330
def run(self, tag_name=None,
5277
def run(self, tag_name,
5331
5278
delete=None,
5332
5279
directory='.',
5333
5280
force=None,
5334
5281
revision=None,
5335
5282
):
5336
5283
branch, relpath = Branch.open_containing(directory)
5337
self.add_cleanup(branch.lock_write().unlock)
5284
branch.lock_write()
5285
self.add_cleanup(branch.unlock)
5338
5286
if delete:
5339
if tag_name is None:
5340
raise errors.BzrCommandError("No tag specified to delete.")
5341
5287
branch.tags.delete_tag(tag_name)
5342
5288
self.outf.write('Deleted tag %s.\n' % tag_name)
5343
5289
else:
5349
5295
revision_id = revision[0].as_revision_id(branch)
5350
5296
else:
5351
5297
revision_id = branch.last_revision()
5352
if tag_name is None:
5353
tag_name = branch.automatic_tag_name(revision_id)
5354
if tag_name is None:
5355
raise errors.BzrCommandError(
5356
"Please specify a tag name.")
5357
5298
if (not force) and branch.tags.has_tag(tag_name):
5358
5299
raise errors.TagAlreadyExists(tag_name)
5359
5300
branch.tags.set_tag(tag_name, revision_id)
5361
5302
5362
5303
5363
5304
class cmd_tags(Command):
5364
__doc__ = """List tags.
5305
"""List tags.
5365
5306
5366
5307
This command shows a table of tag names and the revisions they reference.
5367
5308
"""
5368
5309
5369
5310
_see_also = ['tag']
5370
5311
takes_options = [
5371
custom_help('directory',
5372
help='Branch whose tags should be displayed.'),
5312
Option('directory',
5313
help='Branch whose tags should be displayed.',
5314
short_name='d',
5315
type=unicode,
5316
),
5373
5317
RegistryOption.from_kwargs('sort',
5374
5318
'Sort tags by different criteria.', title='Sorting',
5375
5319
alpha='Sort tags lexicographically (default).',
5392
5336
if not tags:
5393
5337
return
5394
5338
5395
self.add_cleanup(branch.lock_read().unlock)
5339
branch.lock_read()
5340
self.add_cleanup(branch.unlock)
5396
5341
if revision:
5397
5342
graph = branch.repository.get_graph()
5398
5343
rev1, rev2 = _get_revision_range(revision, branch, self.name())
5431
5376
5432
5377
5433
5378
class cmd_reconfigure(Command):
5434
__doc__ = """Reconfigure the type of a bzr directory.
5379
"""Reconfigure the type of a bzr directory.
5435
5380
5436
5381
A target configuration must be specified.
5437
5382
5522
5467
5523
5468
5524
5469
class cmd_switch(Command):
5525
__doc__ = """Set the branch of a checkout and update.
5470
"""Set the branch of a checkout and update.
5526
5471
5527
5472
For lightweight checkouts, this changes the branch being referenced.
5528
5473
For heavyweight checkouts, this checks that there are no local commits
5545
5490
"""
5546
5491
5547
5492
takes_args = ['to_location?']
5548
takes_options = ['directory',
5549
Option('force',
5493
takes_options = [Option('force',
5550
5494
help='Switch even if local commits will be lost.'),
5551
5495
'revision',
5552
5496
Option('create-branch', short_name='b',
5555
5499
]
5556
5500
5557
5501
def run(self, to_location=None, force=False, create_branch=False,
5558
revision=None, directory=u'.'):
5502
revision=None):
5559
5503
from bzrlib import switch
5560
tree_location = directory
5504
tree_location = '.'
5561
5505
revision = _get_one_revision('switch', revision)
5562
5506
control_dir = bzrdir.BzrDir.open_containing(tree_location)[0]
5563
5507
if to_location is None:
5564
5508
if revision is None:
5565
5509
raise errors.BzrCommandError('You must supply either a'
5566
5510
' revision or a location')
5567
to_location = tree_location
5511
to_location = '.'
5568
5512
try:
5569
5513
branch = control_dir.open_branch()
5570
5514
had_explicit_nick = branch.get_config().has_explicit_nickname()
5619
5563
5620
5564
5621
5565
class cmd_view(Command):
5622
__doc__ = """Manage filtered views.
5566
"""Manage filtered views.
5623
5567
5624
5568
Views provide a mask over the tree so that users can focus on
5625
5569
a subset of a tree when doing their work. After creating a view,
5773
5717
5774
5718
5775
5719
class cmd_hooks(Command):
5776
__doc__ = """Show hooks."""
5720
"""Show hooks."""
5777
5721
5778
5722
hidden = True
5779
5723
5792
5736
self.outf.write(" <no hooks installed>\n")
5793
5737
5794
5738
5795
class cmd_remove_branch(Command):
5796
__doc__ = """Remove a branch.
5797
5798
This will remove the branch from the specified location but
5799
will keep any working tree or repository in place.
5800
5801
:Examples:
5802
5803
Remove the branch at repo/trunk::
5804
5805
bzr remove-branch repo/trunk
5806
5807
"""
5808
5809
takes_args = ["location?"]
5810
5811
aliases = ["rmbranch"]
5812
5813
def run(self, location=None):
5814
if location is None:
5815
location = "."
5816
branch = Branch.open_containing(location)[0]
5817
branch.bzrdir.destroy_branch()
5818
5819
5820
5739
class cmd_shelve(Command):
5821
__doc__ = """Temporarily set aside some changes from the current tree.
5740
"""Temporarily set aside some changes from the current tree.
5822
5741
5823
5742
Shelve allows you to temporarily put changes you've made "on the shelf",
5824
5743
ie. out of the way, until a later time when you can bring them back from
5845
5764
takes_args = ['file*']
5846
5765
5847
5766
takes_options = [
5848
'directory',
5849
5767
'revision',
5850
5768
Option('all', help='Shelve all changes.'),
5851
5769
'message',
5860
5778
_see_also = ['unshelve']
5861
5779
5862
5780
def run(self, revision=None, all=False, file_list=None, message=None,
5863
writer=None, list=False, destroy=False, directory=u'.'):
5781
writer=None, list=False, destroy=False):
5864
5782
if list:
5865
5783
return self.run_for_list()
5866
5784
from bzrlib.shelf_ui import Shelver
5868
5786
writer = bzrlib.option.diff_writer_registry.get()
5869
5787
try:
5870
5788
shelver = Shelver.from_args(writer(sys.stdout), revision, all,
5871
file_list, message, destroy=destroy, directory=directory)
5789
file_list, message, destroy=destroy)
5872
5790
try:
5873
5791
shelver.run()
5874
5792
finally:
5878
5796
5879
5797
def run_for_list(self):
5880
5798
tree = WorkingTree.open_containing('.')[0]
5881
self.add_cleanup(tree.lock_read().unlock)
5799
tree.lock_read()
5800
self.add_cleanup(tree.unlock)
5882
5801
manager = tree.get_shelf_manager()
5883
5802
shelves = manager.active_shelves()
5884
5803
if len(shelves) == 0:
5893
5812
5894
5813
5895
5814
class cmd_unshelve(Command):
5896
__doc__ = """Restore shelved changes.
5815
"""Restore shelved changes.
5897
5816
5898
5817
By default, the most recently shelved changes are restored. However if you
5899
5818
specify a shelf by id those changes will be restored instead. This works
5902
5821
5903
5822
takes_args = ['shelf_id?']
5904
5823
takes_options = [
5905
'directory',
5906
5824
RegistryOption.from_kwargs(
5907
5825
'action', help="The action to perform.",
5908
5826
enum_switch=False, value_switches=True,
5916
5834
]
5917
5835
_see_also = ['shelve']
5918
5836
5919
def run(self, shelf_id=None, action='apply', directory=u'.'):
5837
def run(self, shelf_id=None, action='apply'):
5920
5838
from bzrlib.shelf_ui import Unshelver
5921
unshelver = Unshelver.from_args(shelf_id, action, directory=directory)
5839
unshelver = Unshelver.from_args(shelf_id, action)
5922
5840
try:
5923
5841
unshelver.run()
5924
5842
finally:
5926
5844
5927
5845
5928
5846
class cmd_clean_tree(Command):
5929
__doc__ = """Remove unwanted files from working tree.
5847
"""Remove unwanted files from working tree.
5930
5848
5931
5849
By default, only unknown files, not ignored files, are deleted. Versioned
5932
5850
files are never deleted.
5940
5858
5941
5859
To check what clean-tree will do, use --dry-run.
5942
5860
"""
5943
takes_options = ['directory',
5944
Option('ignored', help='Delete all ignored files.'),
5861
takes_options = [Option('ignored', help='Delete all ignored files.'),
5945
5862
Option('detritus', help='Delete conflict files, merge'
5946
5863
' backups, and failed selftest dirs.'),
5947
5864
Option('unknown',
5950
5867
' deleting them.'),
5951
5868
Option('force', help='Do not prompt before deleting.')]
5952
5869
def run(self, unknown=False, ignored=False, detritus=False, dry_run=False,
5953
force=False, directory=u'.'):
5870
force=False):
5954
5871
from bzrlib.clean_tree import clean_tree
5955
5872
if not (unknown or ignored or detritus):
5956
5873
unknown = True
5957
5874
if dry_run:
5958
5875
force = True
5959
clean_tree(directory, unknown=unknown, ignored=ignored,
5960
detritus=detritus, dry_run=dry_run, no_prompt=force)
5876
clean_tree('.', unknown=unknown, ignored=ignored, detritus=detritus,
5877
dry_run=dry_run, no_prompt=force)
5961
5878
5962
5879
5963
5880
class cmd_reference(Command):
5964
__doc__ = """list, view and set branch locations for nested trees.
5881
"""list, view and set branch locations for nested trees.
5965
5882
5966
5883
If no arguments are provided, lists the branch locations for nested trees.
5967
5884
If one argument is provided, display the branch location for that tree.
6007
5924
self.outf.write('%s %s\n' % (path, location))
6008
5925
6009
5926
6010
def _register_lazy_builtins():
6011
# register lazy builtins from other modules; called at startup and should
6012
# be only called once.
6013
for (name, aliases, module_name) in [
6014
('cmd_bundle_info', [], 'bzrlib.bundle.commands'),
6015
('cmd_dpush', [], 'bzrlib.foreign'),
6016
('cmd_version_info', [], 'bzrlib.cmd_version_info'),
6017
('cmd_resolve', ['resolved'], 'bzrlib.conflicts'),
6018
('cmd_conflicts', [], 'bzrlib.conflicts'),
6019
('cmd_sign_my_commits', [], 'bzrlib.sign_my_commits'),
6020
]:
6021
builtin_command_registry.register_lazy(name, aliases, module_name)
5927
# these get imported and then picked up by the scan for cmd_*
5928
# TODO: Some more consistent way to split command definitions across files;
5929
# we do need to load at least some information about them to know of
5930
# aliases. ideally we would avoid loading the implementation until the
5931
# details were needed.
5932
from bzrlib.cmd_version_info import cmd_version_info
5933
from bzrlib.conflicts import cmd_resolve, cmd_conflicts, restore
5934
from bzrlib.bundle.commands import (
5935
cmd_bundle_info,
5936
)
5937
from bzrlib.foreign import cmd_dpush
5938
from bzrlib.sign_my_commits import cmd_sign_my_commits
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0