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 4763.2.4
- compare with another revision
- download diff
- download tarball
- view history from revision 4763.2.4
- Committer: John Arbash Meinel
- Date: 2010-02-17 17:11:16 UTC
- mfrom: (4797.2.17 2.1)
- mto: (4797.2.18 2.1)
- mto: This revision was merged to the branch mainline in revision 5055.
- Revision ID: john@arbash-meinel.com-20100217171116-h7t9223ystbnx5h8
merge bzr.2.1 in preparation for NEWS entry.
- files added:
- bzrlib/help_topics/es
- files removed:
- .testr.conf
- apport
- bzrlib/help_topics/es
- bzrlib/tests/per_bzrdir_colo
- doc/en/whats-new
- files renamed:
- bzrlib/help_topics/es/conflict-types.txt => bzrlib/help_topics/es/conflicts.txt
- files modified:
- .bzrignore
added
removed
bzrlib/builtins.py
54
54
)
55
55
from bzrlib.branch import Branch
56
56
from bzrlib.conflicts import ConflictList
57
from bzrlib.transport import memory
58
57
from bzrlib.revisionspec import RevisionSpec, RevisionInfo
59
58
from bzrlib.smtp_connection import SMTPConnection
60
59
from bzrlib.workingtree import WorkingTree
61
60
""")
62
61
63
from bzrlib.commands import (
64
Command,
65
builtin_command_registry,
66
display_command,
67
)
62
from bzrlib.commands import Command, display_command
68
63
from bzrlib.option import (
69
64
ListOption,
70
65
Option,
239
234
# opens the branch?)
240
235
241
236
class cmd_status(Command):
242
__doc__ = """Display status summary.
237
"""Display status summary.
243
238
244
239
This reports on versioned and unknown files, reporting them
245
240
grouped by state. Possible states are:
332
327
333
328
334
329
class cmd_cat_revision(Command):
335
__doc__ = """Write out metadata for a revision.
330
"""Write out metadata for a revision.
336
331
337
332
The revision to print can either be specified by a specific
338
333
revision identifier, or you can use --revision.
344
339
# cat-revision is more for frontends so should be exact
345
340
encoding = 'strict'
346
341
347
def print_revision(self, revisions, revid):
348
stream = revisions.get_record_stream([(revid,)], 'unordered', True)
349
record = stream.next()
350
if record.storage_kind == 'absent':
351
raise errors.NoSuchRevision(revisions, revid)
352
revtext = record.get_bytes_as('fulltext')
353
self.outf.write(revtext.decode('utf-8'))
354
355
342
@display_command
356
343
def run(self, revision_id=None, revision=None):
357
344
if revision_id is not None and revision is not None:
362
349
' --revision or a revision_id')
363
350
b = WorkingTree.open_containing(u'.')[0].branch
364
351
365
revisions = b.repository.revisions
366
if revisions is None:
367
raise errors.BzrCommandError('Repository %r does not support '
368
'access to raw revision texts')
352
# TODO: jam 20060112 should cat-revision always output utf-8?
353
if revision_id is not None:
354
revision_id = osutils.safe_revision_id(revision_id, warn=False)
355
try:
356
self.outf.write(b.repository.get_revision_xml(revision_id).decode('utf-8'))
357
except errors.NoSuchRevision:
358
msg = "The repository %s contains no revision %s." % (b.repository.base,
359
revision_id)
360
raise errors.BzrCommandError(msg)
361
elif revision is not None:
362
for rev in revision:
363
if rev is None:
364
raise errors.BzrCommandError('You cannot specify a NULL'
365
' revision.')
366
rev_id = rev.as_revision_id(b)
367
self.outf.write(b.repository.get_revision_xml(rev_id).decode('utf-8'))
369
368
370
b.repository.lock_read()
371
try:
372
# TODO: jam 20060112 should cat-revision always output utf-8?
373
if revision_id is not None:
374
revision_id = osutils.safe_revision_id(revision_id, warn=False)
375
try:
376
self.print_revision(revisions, revision_id)
377
except errors.NoSuchRevision:
378
msg = "The repository %s contains no revision %s." % (
379
b.repository.base, revision_id)
380
raise errors.BzrCommandError(msg)
381
elif revision is not None:
382
for rev in revision:
383
if rev is None:
384
raise errors.BzrCommandError(
385
'You cannot specify a NULL revision.')
386
rev_id = rev.as_revision_id(b)
387
self.print_revision(revisions, rev_id)
388
finally:
389
b.repository.unlock()
390
391
369
392
370
class cmd_dump_btree(Command):
393
__doc__ = """Dump the contents of a btree index file to stdout.
371
"""Dump the contents of a btree index file to stdout.
394
372
395
373
PATH is a btree index file, it can be any URL. This includes things like
396
374
.bzr/repository/pack-names, or .bzr/repository/indices/a34b3a...ca4a4.iix
460
438
for node in bt.iter_all_entries():
461
439
# Node is made up of:
462
440
# (index, key, value, [references])
463
try:
464
refs = node[3]
465
except IndexError:
466
refs_as_tuples = None
467
else:
468
refs_as_tuples = static_tuple.as_tuples(refs)
441
refs_as_tuples = static_tuple.as_tuples(node[3])
469
442
as_tuple = (tuple(node[1]), node[2], refs_as_tuples)
470
443
self.outf.write('%s\n' % (as_tuple,))
471
444
472
445
473
446
class cmd_remove_tree(Command):
474
__doc__ = """Remove the working tree from a given branch/checkout.
447
"""Remove the working tree from a given branch/checkout.
475
448
476
449
Since a lightweight checkout is little more than a working tree
477
450
this will refuse to run against one.
479
452
To re-create the working tree, use "bzr checkout".
480
453
"""
481
454
_see_also = ['checkout', 'working-trees']
482
takes_args = ['location*']
455
takes_args = ['location?']
483
456
takes_options = [
484
457
Option('force',
485
458
help='Remove the working tree even if it has '
486
459
'uncommitted changes.'),
487
460
]
488
461
489
def run(self, location_list, force=False):
490
if not location_list:
491
location_list=['.']
492
493
for location in location_list:
494
d = bzrdir.BzrDir.open(location)
495
496
try:
497
working = d.open_workingtree()
498
except errors.NoWorkingTree:
499
raise errors.BzrCommandError("No working tree to remove")
500
except errors.NotLocalUrl:
501
raise errors.BzrCommandError("You cannot remove the working tree"
502
" of a remote path")
503
if not force:
504
if (working.has_changes()):
505
raise errors.UncommittedChanges(working)
506
507
if working.user_url != working.branch.user_url:
508
raise errors.BzrCommandError("You cannot remove the working tree"
509
" from a lightweight checkout")
510
511
d.destroy_workingtree()
462
def run(self, location='.', force=False):
463
d = bzrdir.BzrDir.open(location)
464
465
try:
466
working = d.open_workingtree()
467
except errors.NoWorkingTree:
468
raise errors.BzrCommandError("No working tree to remove")
469
except errors.NotLocalUrl:
470
raise errors.BzrCommandError("You cannot remove the working tree"
471
" of a remote path")
472
if not force:
473
if (working.has_changes()):
474
raise errors.UncommittedChanges(working)
475
476
working_path = working.bzrdir.root_transport.base
477
branch_path = working.branch.bzrdir.root_transport.base
478
if working_path != branch_path:
479
raise errors.BzrCommandError("You cannot remove the working tree"
480
" from a lightweight checkout")
481
482
d.destroy_workingtree()
512
483
513
484
514
485
class cmd_revno(Command):
515
__doc__ = """Show current revision number.
486
"""Show current revision number.
516
487
517
488
This is equal to the number of revisions on this branch.
518
489
"""
528
499
if tree:
529
500
try:
530
501
wt = WorkingTree.open_containing(location)[0]
531
self.add_cleanup(wt.lock_read().unlock)
502
wt.lock_read()
532
503
except (errors.NoWorkingTree, errors.NotLocalUrl):
533
504
raise errors.NoWorkingTree(location)
505
self.add_cleanup(wt.unlock)
534
506
revid = wt.last_revision()
535
507
try:
536
508
revno_t = wt.branch.revision_id_to_dotted_revno(revid)
539
511
revno = ".".join(str(n) for n in revno_t)
540
512
else:
541
513
b = Branch.open_containing(location)[0]
542
self.add_cleanup(b.lock_read().unlock)
514
b.lock_read()
515
self.add_cleanup(b.unlock)
543
516
revno = b.revno()
544
517
self.cleanup_now()
545
518
self.outf.write(str(revno) + '\n')
546
519
547
520
548
521
class cmd_revision_info(Command):
549
__doc__ = """Show revision number and revision id for a given revision identifier.
522
"""Show revision number and revision id for a given revision identifier.
550
523
"""
551
524
hidden = True
552
525
takes_args = ['revision_info*']
568
541
try:
569
542
wt = WorkingTree.open_containing(directory)[0]
570
543
b = wt.branch
571
self.add_cleanup(wt.lock_read().unlock)
544
wt.lock_read()
545
self.add_cleanup(wt.unlock)
572
546
except (errors.NoWorkingTree, errors.NotLocalUrl):
573
547
wt = None
574
548
b = Branch.open_containing(directory)[0]
575
self.add_cleanup(b.lock_read().unlock)
549
b.lock_read()
550
self.add_cleanup(b.unlock)
576
551
revision_ids = []
577
552
if revision is not None:
578
553
revision_ids.extend(rev.as_revision_id(b) for rev in revision)
606
581
607
582
608
583
class cmd_add(Command):
609
__doc__ = """Add specified files or directories.
584
"""Add specified files or directories.
610
585
611
586
In non-recursive mode, all the named items are added, regardless
612
587
of whether they were previously ignored. A warning is given if
677
652
should_print=(not is_quiet()))
678
653
679
654
if base_tree:
680
self.add_cleanup(base_tree.lock_read().unlock)
655
base_tree.lock_read()
656
self.add_cleanup(base_tree.unlock)
681
657
tree, file_list = tree_files_for_add(file_list)
682
658
added, ignored = tree.smart_add(file_list, not
683
659
no_recurse, action=action, save=not dry_run)
691
667
692
668
693
669
class cmd_mkdir(Command):
694
__doc__ = """Create a new versioned directory.
670
"""Create a new versioned directory.
695
671
696
672
This is equivalent to creating the directory and then adding it.
697
673
"""
701
677
702
678
def run(self, dir_list):
703
679
for d in dir_list:
680
os.mkdir(d)
704
681
wt, dd = WorkingTree.open_containing(d)
705
base = os.path.dirname(dd)
706
id = wt.path2id(base)
707
if id != None:
708
os.mkdir(d)
709
wt.add([dd])
710
self.outf.write('added %s\n' % d)
711
else:
712
raise errors.NotVersionedError(path=base)
682
wt.add([dd])
683
self.outf.write('added %s\n' % d)
713
684
714
685
715
686
class cmd_relpath(Command):
716
__doc__ = """Show path of a file relative to root"""
687
"""Show path of a file relative to root"""
717
688
718
689
takes_args = ['filename']
719
690
hidden = True
728
699
729
700
730
701
class cmd_inventory(Command):
731
__doc__ = """Show inventory of the current working copy or a revision.
702
"""Show inventory of the current working copy or a revision.
732
703
733
704
It is possible to limit the output to a particular entry
734
705
type using the --kind option. For example: --kind file.
755
726
756
727
revision = _get_one_revision('inventory', revision)
757
728
work_tree, file_list = tree_files(file_list)
758
self.add_cleanup(work_tree.lock_read().unlock)
729
work_tree.lock_read()
730
self.add_cleanup(work_tree.unlock)
759
731
if revision is not None:
760
732
tree = revision.as_tree(work_tree.branch)
761
733
762
734
extra_trees = [work_tree]
763
self.add_cleanup(tree.lock_read().unlock)
735
tree.lock_read()
736
self.add_cleanup(tree.unlock)
764
737
else:
765
738
tree = work_tree
766
739
extra_trees = []
787
760
788
761
789
762
class cmd_mv(Command):
790
__doc__ = """Move or rename a file.
763
"""Move or rename a file.
791
764
792
765
:Usage:
793
766
bzr mv OLDNAME NEWNAME
826
799
if len(names_list) < 2:
827
800
raise errors.BzrCommandError("missing file argument")
828
801
tree, rel_names = tree_files(names_list, canonicalize=False)
829
self.add_cleanup(tree.lock_tree_write().unlock)
802
tree.lock_tree_write()
803
self.add_cleanup(tree.unlock)
830
804
self._run(tree, names_list, rel_names, after)
831
805
832
806
def run_auto(self, names_list, after, dry_run):
837
811
raise errors.BzrCommandError('--after cannot be specified with'
838
812
' --auto.')
839
813
work_tree, file_list = tree_files(names_list, default_branch='.')
840
self.add_cleanup(work_tree.lock_tree_write().unlock)
814
work_tree.lock_tree_write()
815
self.add_cleanup(work_tree.unlock)
841
816
rename_map.RenameMap.guess_renames(work_tree, dry_run)
842
817
843
818
def _run(self, tree, names_list, rel_names, after):
922
897
923
898
924
899
class cmd_pull(Command):
925
__doc__ = """Turn this branch into a mirror of another branch.
900
"""Turn this branch into a mirror of another branch.
926
901
927
902
By default, this command only works on branches that have not diverged.
928
903
Branches are considered diverged if the destination branch's most recent
977
952
try:
978
953
tree_to = WorkingTree.open_containing(directory)[0]
979
954
branch_to = tree_to.branch
980
self.add_cleanup(tree_to.lock_write().unlock)
981
955
except errors.NoWorkingTree:
982
956
tree_to = None
983
957
branch_to = Branch.open_containing(directory)[0]
984
self.add_cleanup(branch_to.lock_write().unlock)
985
958
986
959
if local and not branch_to.get_bound_location():
987
960
raise errors.LocalRequiresBoundBranch()
988
961
1018
991
else:
1019
992
branch_from = Branch.open(location,
1020
993
possible_transports=possible_transports)
1021
self.add_cleanup(branch_from.lock_read().unlock)
1022
994
1023
995
if branch_to.get_parent() is None or remember:
1024
996
branch_to.set_parent(branch_from.base)
1025
997
998
if branch_from is not branch_to:
999
branch_from.lock_read()
1000
self.add_cleanup(branch_from.unlock)
1026
1001
if revision is not None:
1027
1002
revision_id = revision.as_revision_id(branch_from)
1028
1003
1004
branch_to.lock_write()
1005
self.add_cleanup(branch_to.unlock)
1029
1006
if tree_to is not None:
1030
1007
view_info = _get_view_info_for_change_reporter(tree_to)
1031
1008
change_reporter = delta._ChangeReporter(
1046
1023
1047
1024
1048
1025
class cmd_push(Command):
1049
__doc__ = """Update a mirror of this branch.
1026
"""Update a mirror of this branch.
1050
1027
1051
1028
The target branch will not have its working tree populated because this
1052
1029
is both expensive, and is not supported on remote file systems.
1113
1090
# Get the source branch
1114
1091
(tree, br_from,
1115
1092
_unused) = bzrdir.BzrDir.open_containing_tree_or_branch(directory)
1093
if strict is None:
1094
strict = br_from.get_config().get_user_option_as_bool('push_strict')
1095
if strict is None: strict = True # default value
1116
1096
# Get the tip's revision_id
1117
1097
revision = _get_one_revision('push', revision)
1118
1098
if revision is not None:
1119
1099
revision_id = revision.in_history(br_from).rev_id
1120
1100
else:
1121
1101
revision_id = None
1122
if tree is not None and revision_id is None:
1123
tree.check_changed_or_out_of_date(
1124
strict, 'push_strict',
1125
more_error='Use --no-strict to force the push.',
1126
more_warning='Uncommitted changes will not be pushed.')
1102
if strict and tree is not None and revision_id is None:
1103
if (tree.has_changes()):
1104
raise errors.UncommittedChanges(
1105
tree, more='Use --no-strict to force the push.')
1106
if tree.last_revision() != tree.branch.last_revision():
1107
# The tree has lost sync with its branch, there is little
1108
# chance that the user is aware of it but he can still force
1109
# the push with --no-strict
1110
raise errors.OutOfDateTree(
1111
tree, more='Use --no-strict to force the push.')
1112
1127
1113
# Get the stacked_on branch, if any
1128
1114
if stacked_on is not None:
1129
1115
stacked_on = urlutils.normalize_url(stacked_on)
1161
1147
1162
1148
1163
1149
class cmd_branch(Command):
1164
__doc__ = """Create a new branch that is a copy of an existing branch.
1150
"""Create a new branch that is a copy of an existing branch.
1165
1151
1166
1152
If the TO_LOCATION is omitted, the last component of the FROM_LOCATION will
1167
1153
be used. In other words, "branch ../foo/bar" will attempt to create ./bar.
1207
1193
accelerator_tree, br_from = bzrdir.BzrDir.open_tree_or_branch(
1208
1194
from_location)
1209
1195
revision = _get_one_revision('branch', revision)
1210
self.add_cleanup(br_from.lock_read().unlock)
1196
br_from.lock_read()
1197
self.add_cleanup(br_from.unlock)
1211
1198
if revision is not None:
1212
1199
revision_id = revision.as_revision_id(br_from)
1213
1200
else:
1273
1260
1274
1261
1275
1262
class cmd_checkout(Command):
1276
__doc__ = """Create a new checkout of an existing branch.
1263
"""Create a new checkout of an existing branch.
1277
1264
1278
1265
If BRANCH_LOCATION is omitted, checkout will reconstitute a working tree for
1279
1266
the branch found in '.'. This is useful if you have removed the working tree
1342
1329
1343
1330
1344
1331
class cmd_renames(Command):
1345
__doc__ = """Show list of renamed files.
1332
"""Show list of renamed files.
1346
1333
"""
1347
1334
# TODO: Option to show renames between two historical versions.
1348
1335
1353
1340
@display_command
1354
1341
def run(self, dir=u'.'):
1355
1342
tree = WorkingTree.open_containing(dir)[0]
1356
self.add_cleanup(tree.lock_read().unlock)
1343
tree.lock_read()
1344
self.add_cleanup(tree.unlock)
1357
1345
new_inv = tree.inventory
1358
1346
old_tree = tree.basis_tree()
1359
self.add_cleanup(old_tree.lock_read().unlock)
1347
old_tree.lock_read()
1348
self.add_cleanup(old_tree.unlock)
1360
1349
old_inv = old_tree.inventory
1361
1350
renames = []
1362
1351
iterator = tree.iter_changes(old_tree, include_unchanged=True)
1372
1361
1373
1362
1374
1363
class cmd_update(Command):
1375
__doc__ = """Update a tree to have the latest code committed to its branch.
1364
"""Update a tree to have the latest code committed to its branch.
1376
1365
1377
1366
This will perform a merge into the working tree, and may generate
1378
1367
conflicts. If you have any local changes, you will still
1400
1389
master = branch.get_master_branch(
1401
1390
possible_transports=possible_transports)
1402
1391
if master is not None:
1392
tree.lock_write()
1403
1393
branch_location = master.base
1404
tree.lock_write()
1405
1394
else:
1395
tree.lock_tree_write()
1406
1396
branch_location = tree.branch.base
1407
tree.lock_tree_write()
1408
1397
self.add_cleanup(tree.unlock)
1409
1398
# get rid of the final '/' and be ready for display
1410
branch_location = urlutils.unescape_for_display(
1411
branch_location.rstrip('/'),
1412
self.outf.encoding)
1399
branch_location = urlutils.unescape_for_display(branch_location[:-1],
1400
self.outf.encoding)
1413
1401
existing_pending_merges = tree.get_parent_ids()[1:]
1414
1402
if master is None:
1415
1403
old_tip = None
1423
1411
else:
1424
1412
revision_id = branch.last_revision()
1425
1413
if revision_id == _mod_revision.ensure_null(tree.last_revision()):
1426
revno = branch.revision_id_to_dotted_revno(revision_id)
1427
note("Tree is up to date at revision %s of branch %s" %
1428
('.'.join(map(str, revno)), branch_location))
1414
revno = branch.revision_id_to_revno(revision_id)
1415
note("Tree is up to date at revision %d of branch %s" %
1416
(revno, branch_location))
1429
1417
return 0
1430
1418
view_info = _get_view_info_for_change_reporter(tree)
1431
1419
change_reporter = delta._ChangeReporter(
1443
1431
"bzr update --revision only works"
1444
1432
" for a revision in the branch history"
1445
1433
% (e.revision))
1446
revno = tree.branch.revision_id_to_dotted_revno(
1434
revno = tree.branch.revision_id_to_revno(
1447
1435
_mod_revision.ensure_null(tree.last_revision()))
1448
note('Updated to revision %s of branch %s' %
1449
('.'.join(map(str, revno)), branch_location))
1450
parent_ids = tree.get_parent_ids()
1451
if parent_ids[1:] and parent_ids[1:] != existing_pending_merges:
1436
note('Updated to revision %d of branch %s' %
1437
(revno, branch_location))
1438
if tree.get_parent_ids()[1:] != existing_pending_merges:
1452
1439
note('Your local commits will now show as pending merges with '
1453
1440
"'bzr status', and can be committed with 'bzr commit'.")
1454
1441
if conflicts != 0:
1458
1445
1459
1446
1460
1447
class cmd_info(Command):
1461
__doc__ = """Show information about a working tree, branch or repository.
1448
"""Show information about a working tree, branch or repository.
1462
1449
1463
1450
This command will show all known locations and formats associated to the
1464
1451
tree, branch or repository.
1502
1489
1503
1490
1504
1491
class cmd_remove(Command):
1505
__doc__ = """Remove files or directories.
1492
"""Remove files or directories.
1506
1493
1507
1494
This makes bzr stop tracking changes to the specified files. bzr will delete
1508
1495
them if they can easily be recovered using revert. If no options or
1530
1517
if file_list is not None:
1531
1518
file_list = [f for f in file_list]
1532
1519
1533
self.add_cleanup(tree.lock_write().unlock)
1520
tree.lock_write()
1521
self.add_cleanup(tree.unlock)
1534
1522
# Heuristics should probably all move into tree.remove_smart or
1535
1523
# some such?
1536
1524
if new:
1555
1543
1556
1544
1557
1545
class cmd_file_id(Command):
1558
__doc__ = """Print file_id of a particular file or directory.
1546
"""Print file_id of a particular file or directory.
1559
1547
1560
1548
The file_id is assigned when the file is first added and remains the
1561
1549
same through all revisions where the file exists, even when it is
1577
1565
1578
1566
1579
1567
class cmd_file_path(Command):
1580
__doc__ = """Print path of file_ids to a file or directory.
1568
"""Print path of file_ids to a file or directory.
1581
1569
1582
1570
This prints one line for each directory down to the target,
1583
1571
starting at the branch root.
1599
1587
1600
1588
1601
1589
class cmd_reconcile(Command):
1602
__doc__ = """Reconcile bzr metadata in a branch.
1590
"""Reconcile bzr metadata in a branch.
1603
1591
1604
1592
This can correct data mismatches that may have been caused by
1605
1593
previous ghost operations or bzr upgrades. You should only
1627
1615
1628
1616
1629
1617
class cmd_revision_history(Command):
1630
__doc__ = """Display the list of revision ids on a branch."""
1618
"""Display the list of revision ids on a branch."""
1631
1619
1632
1620
_see_also = ['log']
1633
1621
takes_args = ['location?']
1643
1631
1644
1632
1645
1633
class cmd_ancestry(Command):
1646
__doc__ = """List all revisions merged into this branch."""
1634
"""List all revisions merged into this branch."""
1647
1635
1648
1636
_see_also = ['log', 'revision-history']
1649
1637
takes_args = ['location?']
1668
1656
1669
1657
1670
1658
class cmd_init(Command):
1671
__doc__ = """Make a directory into a versioned branch.
1659
"""Make a directory into a versioned branch.
1672
1660
1673
1661
Use this to create an empty branch, or before importing an
1674
1662
existing project.
1777
1765
1778
1766
1779
1767
class cmd_init_repository(Command):
1780
__doc__ = """Create a shared repository for branches to share storage space.
1768
"""Create a shared repository for branches to share storage space.
1781
1769
1782
1770
New branches created under the repository directory will store their
1783
1771
revisions in the repository, not in the branch directory. For branches
1837
1825
1838
1826
1839
1827
class cmd_diff(Command):
1840
__doc__ = """Show differences in the working tree, between revisions or branches.
1828
"""Show differences in the working tree, between revisions or branches.
1841
1829
1842
1830
If no arguments are given, all changes for the current tree are listed.
1843
1831
If files are given, only the changes in those files are listed.
1929
1917
help='Use this command to compare files.',
1930
1918
type=unicode,
1931
1919
),
1932
RegistryOption('format',
1933
help='Diff format to use.',
1934
lazy_registry=('bzrlib.diff', 'format_registry'),
1935
value_switches=False, title='Diff format'),
1936
1920
]
1937
1921
aliases = ['di', 'dif']
1938
1922
encoding_type = 'exact'
1939
1923
1940
1924
@display_command
1941
1925
def run(self, revision=None, file_list=None, diff_options=None,
1942
prefix=None, old=None, new=None, using=None, format=None):
1943
from bzrlib.diff import (get_trees_and_branches_to_diff_locked,
1944
show_diff_trees)
1926
prefix=None, old=None, new=None, using=None):
1927
from bzrlib.diff import get_trees_and_branches_to_diff, show_diff_trees
1945
1928
1946
1929
if (prefix is None) or (prefix == '0'):
1947
1930
# diff -p0 format
1961
1944
raise errors.BzrCommandError('bzr diff --revision takes exactly'
1962
1945
' one or two revision specifiers')
1963
1946
1964
if using is not None and format is not None:
1965
raise errors.BzrCommandError('--using and --format are mutually '
1966
'exclusive.')
1967
1968
1947
(old_tree, new_tree,
1969
1948
old_branch, new_branch,
1970
specific_files, extra_trees) = get_trees_and_branches_to_diff_locked(
1971
file_list, revision, old, new, self.add_cleanup, apply_view=True)
1949
specific_files, extra_trees) = get_trees_and_branches_to_diff(
1950
file_list, revision, old, new, apply_view=True)
1972
1951
return show_diff_trees(old_tree, new_tree, sys.stdout,
1973
1952
specific_files=specific_files,
1974
1953
external_diff_options=diff_options,
1975
1954
old_label=old_label, new_label=new_label,
1976
extra_trees=extra_trees, using=using,
1977
format_cls=format)
1955
extra_trees=extra_trees, using=using)
1978
1956
1979
1957
1980
1958
class cmd_deleted(Command):
1981
__doc__ = """List files deleted in the working tree.
1959
"""List files deleted in the working tree.
1982
1960
"""
1983
1961
# TODO: Show files deleted since a previous revision, or
1984
1962
# between two revisions.
1992
1970
@display_command
1993
1971
def run(self, show_ids=False):
1994
1972
tree = WorkingTree.open_containing(u'.')[0]
1995
self.add_cleanup(tree.lock_read().unlock)
1973
tree.lock_read()
1974
self.add_cleanup(tree.unlock)
1996
1975
old = tree.basis_tree()
1997
self.add_cleanup(old.lock_read().unlock)
1976
old.lock_read()
1977
self.add_cleanup(old.unlock)
1998
1978
for path, ie in old.inventory.iter_entries():
1999
1979
if not tree.has_id(ie.file_id):
2000
1980
self.outf.write(path)
2005
1985
2006
1986
2007
1987
class cmd_modified(Command):
2008
__doc__ = """List files modified in working tree.
1988
"""List files modified in working tree.
2009
1989
"""
2010
1990
2011
1991
hidden = True
2028
2008
2029
2009
2030
2010
class cmd_added(Command):
2031
__doc__ = """List files added in working tree.
2011
"""List files added in working tree.
2032
2012
"""
2033
2013
2034
2014
hidden = True
2042
2022
@display_command
2043
2023
def run(self, null=False):
2044
2024
wt = WorkingTree.open_containing(u'.')[0]
2045
self.add_cleanup(wt.lock_read().unlock)
2025
wt.lock_read()
2026
self.add_cleanup(wt.unlock)
2046
2027
basis = wt.basis_tree()
2047
self.add_cleanup(basis.lock_read().unlock)
2028
basis.lock_read()
2029
self.add_cleanup(basis.unlock)
2048
2030
basis_inv = basis.inventory
2049
2031
inv = wt.inventory
2050
2032
for file_id in inv:
2062
2044
2063
2045
2064
2046
class cmd_root(Command):
2065
__doc__ = """Show the tree root directory.
2047
"""Show the tree root directory.
2066
2048
2067
2049
The root is the nearest enclosing directory with a .bzr control
2068
2050
directory."""
2092
2074
2093
2075
2094
2076
class cmd_log(Command):
2095
__doc__ = """Show historical log for a branch or subset of a branch.
2077
"""Show historical log for a branch or subset of a branch.
2096
2078
2097
2079
log is bzr's default tool for exploring the history of a branch.
2098
2080
The branch to use is taken from the first parameter. If no parameters
2209
2191
:Tips & tricks:
2210
2192
2211
2193
GUI tools and IDEs are often better at exploring history than command
2212
line tools: you may prefer qlog or viz from qbzr or bzr-gtk, the
2213
bzr-explorer shell, or the Loggerhead web interface. See the Plugin
2214
Guide <http://doc.bazaar.canonical.com/plugins/en/> and
2215
<http://wiki.bazaar.canonical.com/IDEIntegration>.
2194
line tools. You may prefer qlog or glog from the QBzr and Bzr-Gtk packages
2195
respectively for example. (TortoiseBzr uses qlog for displaying logs.) See
2196
http://bazaar-vcs.org/BzrPlugins and http://bazaar-vcs.org/IDEIntegration.
2197
2198
Web interfaces are often better at exploring history than command line
2199
tools, particularly for branches on servers. You may prefer Loggerhead
2200
or one of its alternatives. See http://bazaar-vcs.org/WebInterface.
2216
2201
2217
2202
You may find it useful to add the aliases below to ``bazaar.conf``::
2218
2203
2279
2264
help='Show changes made in each revision as a patch.'),
2280
2265
Option('include-merges',
2281
2266
help='Show merged revisions like --levels 0 does.'),
2282
Option('exclude-common-ancestry',
2283
help='Display only the revisions that are not part'
2284
' of both ancestries (require -rX..Y)'
2285
)
2286
2267
]
2287
2268
encoding_type = 'replace'
2288
2269
2298
2279
message=None,
2299
2280
limit=None,
2300
2281
show_diff=False,
2301
include_merges=False,
2302
exclude_common_ancestry=False,
2303
):
2282
include_merges=False):
2304
2283
from bzrlib.log import (
2305
2284
Logger,
2306
2285
make_log_request_dict,
2307
2286
_get_info_for_log_files,
2308
2287
)
2309
2288
direction = (forward and 'forward') or 'reverse'
2310
if (exclude_common_ancestry
2311
and (revision is None or len(revision) != 2)):
2312
raise errors.BzrCommandError(
2313
'--exclude-common-ancestry requires -r with two revisions')
2314
2289
if include_merges:
2315
2290
if levels is None:
2316
2291
levels = 0
2332
2307
if file_list:
2333
2308
# find the file ids to log and check for directory filtering
2334
2309
b, file_info_list, rev1, rev2 = _get_info_for_log_files(
2335
revision, file_list, self.add_cleanup)
2310
revision, file_list)
2311
self.add_cleanup(b.unlock)
2336
2312
for relpath, file_id, kind in file_info_list:
2337
2313
if file_id is None:
2338
2314
raise errors.BzrCommandError(
2356
2332
location = '.'
2357
2333
dir, relpath = bzrdir.BzrDir.open_containing(location)
2358
2334
b = dir.open_branch()
2359
self.add_cleanup(b.lock_read().unlock)
2335
b.lock_read()
2336
self.add_cleanup(b.unlock)
2360
2337
rev1, rev2 = _get_revision_range(revision, b, self.name())
2361
2338
2362
2339
# Decide on the type of delta & diff filtering to use
2407
2384
direction=direction, specific_fileids=file_ids,
2408
2385
start_revision=rev1, end_revision=rev2, limit=limit,
2409
2386
message_search=message, delta_type=delta_type,
2410
diff_type=diff_type, _match_using_deltas=match_using_deltas,
2411
exclude_common_ancestry=exclude_common_ancestry,
2412
)
2387
diff_type=diff_type, _match_using_deltas=match_using_deltas)
2413
2388
Logger(b, rqst).show(lf)
2414
2389
2415
2390
2434
2409
raise errors.BzrCommandError(
2435
2410
"bzr %s doesn't accept two revisions in different"
2436
2411
" branches." % command_name)
2437
if start_spec.spec is None:
2438
# Avoid loading all the history.
2439
rev1 = RevisionInfo(branch, None, None)
2440
else:
2441
rev1 = start_spec.in_history(branch)
2412
rev1 = start_spec.in_history(branch)
2442
2413
# Avoid loading all of history when we know a missing
2443
2414
# end of range means the last revision ...
2444
2415
if end_spec.spec is None:
2473
2444
2474
2445
2475
2446
class cmd_touching_revisions(Command):
2476
__doc__ = """Return revision-ids which affected a particular file.
2447
"""Return revision-ids which affected a particular file.
2477
2448
2478
2449
A more user-friendly interface is "bzr log FILE".
2479
2450
"""
2486
2457
tree, relpath = WorkingTree.open_containing(filename)
2487
2458
file_id = tree.path2id(relpath)
2488
2459
b = tree.branch
2489
self.add_cleanup(b.lock_read().unlock)
2460
b.lock_read()
2461
self.add_cleanup(b.unlock)
2490
2462
touching_revs = log.find_touching_revisions(b, file_id)
2491
2463
for revno, revision_id, what in touching_revs:
2492
2464
self.outf.write("%6d %s\n" % (revno, what))
2493
2465
2494
2466
2495
2467
class cmd_ls(Command):
2496
__doc__ = """List files in a tree.
2468
"""List files in a tree.
2497
2469
"""
2498
2470
2499
2471
_see_also = ['status', 'cat']
2561
2533
view_str = views.view_display_str(view_files)
2562
2534
note("Ignoring files outside view. View is %s" % view_str)
2563
2535
2564
self.add_cleanup(tree.lock_read().unlock)
2536
tree.lock_read()
2537
self.add_cleanup(tree.unlock)
2565
2538
for fp, fc, fkind, fid, entry in tree.list_files(include_root=False,
2566
2539
from_dir=relpath, recursive=recursive):
2567
2540
# Apply additional masking
2609
2582
2610
2583
2611
2584
class cmd_unknowns(Command):
2612
__doc__ = """List unknown files.
2585
"""List unknown files.
2613
2586
"""
2614
2587
2615
2588
hidden = True
2622
2595
2623
2596
2624
2597
class cmd_ignore(Command):
2625
__doc__ = """Ignore specified files or patterns.
2598
"""Ignore specified files or patterns.
2626
2599
2627
2600
See ``bzr help patterns`` for details on the syntax of patterns.
2628
2601
2637
2610
using this command or directly by using an editor, be sure to commit
2638
2611
it.
2639
2612
2640
Bazaar also supports a global ignore file ~/.bazaar/ignore. On Windows
2641
the global ignore file can be found in the application data directory as
2642
C:\\Documents and Settings\\<user>\\Application Data\\Bazaar\\2.0\\ignore.
2643
Global ignores are not touched by this command. The global ignore file
2644
can be edited directly using an editor.
2645
2646
2613
Patterns prefixed with '!' are exceptions to ignore patterns and take
2647
2614
precedence over regular ignores. Such exceptions are used to specify
2648
2615
files that should be versioned which would otherwise be ignored.
2689
2656
_see_also = ['status', 'ignored', 'patterns']
2690
2657
takes_args = ['name_pattern*']
2691
2658
takes_options = [
2692
Option('default-rules',
2693
help='Display the default ignore rules that bzr uses.')
2659
Option('old-default-rules',
2660
help='Write out the ignore rules bzr < 0.9 always used.')
2694
2661
]
2695
2662
2696
def run(self, name_pattern_list=None, default_rules=None):
2663
def run(self, name_pattern_list=None, old_default_rules=None):
2697
2664
from bzrlib import ignores
2698
if default_rules is not None:
2699
# dump the default rules and exit
2700
for pattern in ignores.USER_DEFAULTS:
2701
self.outf.write("%s\n" % pattern)
2665
if old_default_rules is not None:
2666
# dump the rules and exit
2667
for pattern in ignores.OLD_DEFAULTS:
2668
print pattern
2702
2669
return
2703
2670
if not name_pattern_list:
2704
2671
raise errors.BzrCommandError("ignore requires at least one "
2705
"NAME_PATTERN or --default-rules.")
2672
"NAME_PATTERN or --old-default-rules")
2706
2673
name_pattern_list = [globbing.normalize_pattern(p)
2707
2674
for p in name_pattern_list]
2708
2675
for name_pattern in name_pattern_list:
2720
2687
if id is not None:
2721
2688
filename = entry[0]
2722
2689
if ignored.match(filename):
2723
matches.append(filename)
2690
matches.append(filename.encode('utf-8'))
2724
2691
tree.unlock()
2725
2692
if len(matches) > 0:
2726
self.outf.write("Warning: the following files are version controlled and"
2727
" match your ignore pattern:\n%s"
2728
"\nThese files will continue to be version controlled"
2729
" unless you 'bzr remove' them.\n" % ("\n".join(matches),))
2693
print "Warning: the following files are version controlled and" \
2694
" match your ignore pattern:\n%s" \
2695
"\nThese files will continue to be version controlled" \
2696
" unless you 'bzr remove' them." % ("\n".join(matches),)
2730
2697
2731
2698
2732
2699
class cmd_ignored(Command):
2733
__doc__ = """List ignored files and the patterns that matched them.
2700
"""List ignored files and the patterns that matched them.
2734
2701
2735
2702
List all the ignored files and the ignore pattern that caused the file to
2736
2703
be ignored.
2746
2713
@display_command
2747
2714
def run(self):
2748
2715
tree = WorkingTree.open_containing(u'.')[0]
2749
self.add_cleanup(tree.lock_read().unlock)
2716
tree.lock_read()
2717
self.add_cleanup(tree.unlock)
2750
2718
for path, file_class, kind, file_id, entry in tree.list_files():
2751
2719
if file_class != 'I':
2752
2720
continue
2756
2724
2757
2725
2758
2726
class cmd_lookup_revision(Command):
2759
__doc__ = """Lookup the revision-id from a revision-number
2727
"""Lookup the revision-id from a revision-number
2760
2728
2761
2729
:Examples:
2762
2730
bzr lookup-revision 33
2769
2737
try:
2770
2738
revno = int(revno)
2771
2739
except ValueError:
2772
raise errors.BzrCommandError("not a valid revision-number: %r"
2773
% revno)
2774
revid = WorkingTree.open_containing(u'.')[0].branch.get_rev_id(revno)
2775
self.outf.write("%s\n" % revid)
2740
raise errors.BzrCommandError("not a valid revision-number: %r" % revno)
2741
2742
print WorkingTree.open_containing(u'.')[0].branch.get_rev_id(revno)
2776
2743
2777
2744
2778
2745
class cmd_export(Command):
2779
__doc__ = """Export current or past revision to a destination directory or archive.
2746
"""Export current or past revision to a destination directory or archive.
2780
2747
2781
2748
If no revision is specified this exports the last committed revision.
2782
2749
2814
2781
Option('root',
2815
2782
type=str,
2816
2783
help="Name of the root directory inside the exported file."),
2817
Option('per-file-timestamps',
2818
help='Set modification time of files to that of the last '
2819
'revision in which it was changed.'),
2820
2784
]
2821
2785
def run(self, dest, branch_or_subdir=None, revision=None, format=None,
2822
root=None, filters=False, per_file_timestamps=False):
2786
root=None, filters=False):
2823
2787
from bzrlib.export import export
2824
2788
2825
2789
if branch_or_subdir is None:
2832
2796
2833
2797
rev_tree = _get_one_revision_tree('export', revision, branch=b, tree=tree)
2834
2798
try:
2835
export(rev_tree, dest, format, root, subdir, filtered=filters,
2836
per_file_timestamps=per_file_timestamps)
2799
export(rev_tree, dest, format, root, subdir, filtered=filters)
2837
2800
except errors.NoSuchExportFormat, e:
2838
2801
raise errors.BzrCommandError('Unsupported export format: %s' % e.format)
2839
2802
2840
2803
2841
2804
class cmd_cat(Command):
2842
__doc__ = """Write the contents of a file as of a given revision to standard output.
2805
"""Write the contents of a file as of a given revision to standard output.
2843
2806
2844
2807
If no revision is nominated, the last revision is used.
2845
2808
2865
2828
" one revision specifier")
2866
2829
tree, branch, relpath = \
2867
2830
bzrdir.BzrDir.open_containing_tree_or_branch(filename)
2868
self.add_cleanup(branch.lock_read().unlock)
2831
branch.lock_read()
2832
self.add_cleanup(branch.unlock)
2869
2833
return self._run(tree, branch, relpath, filename, revision,
2870
2834
name_from_revision, filters)
2871
2835
2874
2838
if tree is None:
2875
2839
tree = b.basis_tree()
2876
2840
rev_tree = _get_one_revision_tree('cat', revision, branch=b)
2877
self.add_cleanup(rev_tree.lock_read().unlock)
2841
rev_tree.lock_read()
2842
self.add_cleanup(rev_tree.unlock)
2878
2843
2879
2844
old_file_id = rev_tree.path2id(relpath)
2880
2845
2923
2888
2924
2889
2925
2890
class cmd_local_time_offset(Command):
2926
__doc__ = """Show the offset in seconds from GMT to local time."""
2891
"""Show the offset in seconds from GMT to local time."""
2927
2892
hidden = True
2928
2893
@display_command
2929
2894
def run(self):
2930
self.outf.write("%s\n" % osutils.local_time_offset())
2895
print osutils.local_time_offset()
2931
2896
2932
2897
2933
2898
2934
2899
class cmd_commit(Command):
2935
__doc__ = """Commit changes into a new revision.
2900
"""Commit changes into a new revision.
2936
2901
2937
2902
An explanatory message needs to be given for each commit. This is
2938
2903
often done by using the --message option (getting the message from the
3046
3011
"the master branch until a normal commit "
3047
3012
"is performed."
3048
3013
),
3049
Option('show-diff', short_name='p',
3014
Option('show-diff',
3050
3015
help='When no message is supplied, show the diff along'
3051
3016
' with the status summary in the message editor.'),
3052
3017
]
3132
3097
'(use --file "%(f)s" to take commit message from that file)'
3133
3098
% { 'f': message })
3134
3099
ui.ui_factory.show_warning(warning_msg)
3135
if '\r' in message:
3136
message = message.replace('\r\n', '\n')
3137
message = message.replace('\r', '\n')
3138
if file:
3139
raise errors.BzrCommandError(
3140
"please specify either --message or --file")
3141
3100
3142
3101
def get_message(commit_obj):
3143
3102
"""Callback to get commit message"""
3144
if file:
3145
my_message = codecs.open(
3146
file, 'rt', osutils.get_user_encoding()).read()
3147
elif message is not None:
3148
my_message = message
3149
else:
3150
# No message supplied: make one up.
3151
# text is the status of the tree
3152
text = make_commit_message_template_encoded(tree,
3103
my_message = message
3104
if my_message is not None and '\r' in my_message:
3105
my_message = my_message.replace('\r\n', '\n')
3106
my_message = my_message.replace('\r', '\n')
3107
if my_message is None and not file:
3108
t = make_commit_message_template_encoded(tree,
3153
3109
selected_list, diff=show_diff,
3154
3110
output_encoding=osutils.get_user_encoding())
3155
# start_message is the template generated from hooks
3156
# XXX: Warning - looks like hooks return unicode,
3157
# make_commit_message_template_encoded returns user encoding.
3158
# We probably want to be using edit_commit_message instead to
3159
# avoid this.
3160
3111
start_message = generate_commit_message_template(commit_obj)
3161
my_message = edit_commit_message_encoded(text,
3112
my_message = edit_commit_message_encoded(t,
3162
3113
start_message=start_message)
3163
3114
if my_message is None:
3164
3115
raise errors.BzrCommandError("please specify a commit"
3165
3116
" message with either --message or --file")
3117
elif my_message and file:
3118
raise errors.BzrCommandError(
3119
"please specify either --message or --file")
3120
if file:
3121
my_message = codecs.open(file, 'rt',
3122
osutils.get_user_encoding()).read()
3166
3123
if my_message == "":
3167
3124
raise errors.BzrCommandError("empty commit message specified")
3168
3125
return my_message
3180
3137
timezone=offset,
3181
3138
exclude=safe_relpath_files(tree, exclude))
3182
3139
except PointlessCommit:
3140
# FIXME: This should really happen before the file is read in;
3141
# perhaps prepare the commit; get the message; then actually commit
3183
3142
raise errors.BzrCommandError("No changes to commit."
3184
3143
" Use --unchanged to commit anyhow.")
3185
3144
except ConflictsInTree:
3190
3149
raise errors.BzrCommandError("Commit refused because there are"
3191
3150
" unknown files in the working tree.")
3192
3151
except errors.BoundBranchOutOfDate, e:
3193
e.extra_help = ("\n"
3194
'To commit to master branch, run update and then commit.\n'
3195
'You can also pass --local to commit to continue working '
3196
'disconnected.')
3197
raise
3152
raise errors.BzrCommandError(str(e) + "\n"
3153
'To commit to master branch, run update and then commit.\n'
3154
'You can also pass --local to commit to continue working '
3155
'disconnected.')
3198
3156
3199
3157
3200
3158
class cmd_check(Command):
3201
__doc__ = """Validate working tree structure, branch consistency and repository history.
3159
"""Validate working tree structure, branch consistency and repository history.
3202
3160
3203
3161
This command checks various invariants about branch and repository storage
3204
3162
to detect data corruption or bzr bugs.
3268
3226
3269
3227
3270
3228
class cmd_upgrade(Command):
3271
__doc__ = """Upgrade branch storage to current format.
3229
"""Upgrade branch storage to current format.
3272
3230
3273
3231
The check command or bzr developers may sometimes advise you to run
3274
3232
this command. When the default format has changed you may also be warned
3292
3250
3293
3251
3294
3252
class cmd_whoami(Command):
3295
__doc__ = """Show or set bzr user id.
3253
"""Show or set bzr user id.
3296
3254
3297
3255
:Examples:
3298
3256
Show the email of the current user::
3342
3300
3343
3301
3344
3302
class cmd_nick(Command):
3345
__doc__ = """Print or set the branch nickname.
3303
"""Print or set the branch nickname.
3346
3304
3347
3305
If unset, the tree root directory name is used as the nickname.
3348
3306
To print the current nickname, execute with no argument.
3362
3320
3363
3321
@display_command
3364
3322
def printme(self, branch):
3365
self.outf.write('%s\n' % branch.nick)
3323
print branch.nick
3366
3324
3367
3325
3368
3326
class cmd_alias(Command):
3369
__doc__ = """Set/unset and display aliases.
3327
"""Set/unset and display aliases.
3370
3328
3371
3329
:Examples:
3372
3330
Show the current aliases::
3436
3394
3437
3395
3438
3396
class cmd_selftest(Command):
3439
__doc__ = """Run internal test suite.
3397
"""Run internal test suite.
3440
3398
3441
3399
If arguments are given, they are regular expressions that say which tests
3442
3400
should run. Tests matching any expression are run, and other tests are
3489
3447
from bzrlib.tests import stub_sftp
3490
3448
return stub_sftp.SFTPAbsoluteServer
3491
3449
if typestring == "memory":
3492
from bzrlib.tests import test_server
3493
return memory.MemoryServer
3450
from bzrlib.transport.memory import MemoryServer
3451
return MemoryServer
3494
3452
if typestring == "fakenfs":
3495
from bzrlib.tests import test_server
3496
return test_server.FakeNFSServer
3453
from bzrlib.transport.fakenfs import FakeNFSServer
3454
return FakeNFSServer
3497
3455
msg = "No known transport type %s. Supported types are: sftp\n" %\
3498
3456
(typestring)
3499
3457
raise errors.BzrCommandError(msg)
3583
3541
raise errors.BzrCommandError("subunit not available. subunit "
3584
3542
"needs to be installed to use --subunit.")
3585
3543
self.additional_selftest_args['runner_class'] = SubUnitBzrRunner
3586
# On Windows, disable automatic conversion of '\n' to '\r\n' in
3587
# stdout, which would corrupt the subunit stream.
3588
if sys.platform == "win32" and sys.stdout.fileno() >= 0:
3589
import msvcrt
3590
msvcrt.setmode(sys.stdout.fileno(), os.O_BINARY)
3591
3544
if parallel:
3592
3545
self.additional_selftest_args.setdefault(
3593
3546
'suite_decorators', []).append(parallel)
3624
3577
3625
3578
3626
3579
class cmd_version(Command):
3627
__doc__ = """Show version of bzr."""
3580
"""Show version of bzr."""
3628
3581
3629
3582
encoding_type = 'replace'
3630
3583
takes_options = [
3641
3594
3642
3595
3643
3596
class cmd_rocks(Command):
3644
__doc__ = """Statement of optimism."""
3597
"""Statement of optimism."""
3645
3598
3646
3599
hidden = True
3647
3600
3648
3601
@display_command
3649
3602
def run(self):
3650
self.outf.write("It sure does!\n")
3603
print "It sure does!"
3651
3604
3652
3605
3653
3606
class cmd_find_merge_base(Command):
3654
__doc__ = """Find and print a base revision for merging two branches."""
3607
"""Find and print a base revision for merging two branches."""
3655
3608
# TODO: Options to specify revisions on either side, as if
3656
3609
# merging only part of the history.
3657
3610
takes_args = ['branch', 'other']
3663
3616
3664
3617
branch1 = Branch.open_containing(branch)[0]
3665
3618
branch2 = Branch.open_containing(other)[0]
3666
self.add_cleanup(branch1.lock_read().unlock)
3667
self.add_cleanup(branch2.lock_read().unlock)
3619
branch1.lock_read()
3620
self.add_cleanup(branch1.unlock)
3621
branch2.lock_read()
3622
self.add_cleanup(branch2.unlock)
3668
3623
last1 = ensure_null(branch1.last_revision())
3669
3624
last2 = ensure_null(branch2.last_revision())
3670
3625
3671
3626
graph = branch1.repository.get_graph(branch2.repository)
3672
3627
base_rev_id = graph.find_unique_lca(last1, last2)
3673
3628
3674
self.outf.write('merge base is revision %s\n' % base_rev_id)
3629
print 'merge base is revision %s' % base_rev_id
3675
3630
3676
3631
3677
3632
class cmd_merge(Command):
3678
__doc__ = """Perform a three-way merge.
3633
"""Perform a three-way merge.
3679
3634
3680
3635
The source of the merge can be specified either in the form of a branch,
3681
3636
or in the form of a path to a file containing a merge directive generated
3808
3763
unversioned_filter=tree.is_ignored, view_info=view_info)
3809
3764
pb = ui.ui_factory.nested_progress_bar()
3810
3765
self.add_cleanup(pb.finished)
3811
self.add_cleanup(tree.lock_write().unlock)
3766
tree.lock_write()
3767
self.add_cleanup(tree.unlock)
3812
3768
if location is not None:
3813
3769
try:
3814
3770
mergeable = bundle.read_mergeable_from_url(location,
3824
3780
raise errors.BzrCommandError(
3825
3781
'Cannot use -r with merge directives or bundles')
3826
3782
merger, verified = _mod_merge.Merger.from_mergeable(tree,
3827
mergeable, None)
3783
mergeable, pb)
3828
3784
3829
3785
if merger is None and uncommitted:
3830
3786
if revision is not None and len(revision) > 0:
3831
3787
raise errors.BzrCommandError('Cannot use --uncommitted and'
3832
3788
' --revision at the same time.')
3833
merger = self.get_merger_from_uncommitted(tree, location, None)
3789
merger = self.get_merger_from_uncommitted(tree, location, pb)
3834
3790
allow_pending = False
3835
3791
3836
3792
if merger is None:
3837
3793
merger, allow_pending = self._get_merger_from_branch(tree,
3838
location, revision, remember, possible_transports, None)
3794
location, revision, remember, possible_transports, pb)
3839
3795
3840
3796
merger.merge_type = merge_type
3841
3797
merger.reprocess = reprocess
4035
3991
4036
3992
4037
3993
class cmd_remerge(Command):
4038
__doc__ = """Redo a merge.
3994
"""Redo a merge.
4039
3995
4040
3996
Use this if you want to try a different merge technique while resolving
4041
3997
conflicts. Some merge techniques are better than others, and remerge
4066
4022
4067
4023
def run(self, file_list=None, merge_type=None, show_base=False,
4068
4024
reprocess=False):
4069
from bzrlib.conflicts import restore
4070
4025
if merge_type is None:
4071
4026
merge_type = _mod_merge.Merge3Merger
4072
4027
tree, file_list = tree_files(file_list)
4073
self.add_cleanup(tree.lock_write().unlock)
4028
tree.lock_write()
4029
self.add_cleanup(tree.unlock)
4074
4030
parents = tree.get_parent_ids()
4075
4031
if len(parents) != 2:
4076
4032
raise errors.BzrCommandError("Sorry, remerge only works after normal"
4112
4068
# list, we imply that the working tree text has seen and rejected
4113
4069
# all the changes from the other tree, when in fact those changes
4114
4070
# have not yet been seen.
4071
pb = ui.ui_factory.nested_progress_bar()
4115
4072
tree.set_parent_ids(parents[:1])
4116
4073
try:
4117
merger = _mod_merge.Merger.from_revision_ids(None, tree, parents[1])
4074
merger = _mod_merge.Merger.from_revision_ids(pb,
4075
tree, parents[1])
4118
4076
merger.interesting_ids = interesting_ids
4119
4077
merger.merge_type = merge_type
4120
4078
merger.show_base = show_base
4122
4080
conflicts = merger.do_merge()
4123
4081
finally:
4124
4082
tree.set_parent_ids(parents)
4083
pb.finished()
4125
4084
if conflicts > 0:
4126
4085
return 1
4127
4086
else:
4129
4088
4130
4089
4131
4090
class cmd_revert(Command):
4132
__doc__ = """Revert files to a previous revision.
4091
"""Revert files to a previous revision.
4133
4092
4134
4093
Giving a list of files will revert only those files. Otherwise, all files
4135
4094
will be reverted. If the revision is not specified with '--revision', the
4186
4145
def run(self, revision=None, no_backup=False, file_list=None,
4187
4146
forget_merges=None):
4188
4147
tree, file_list = tree_files(file_list)
4189
self.add_cleanup(tree.lock_tree_write().unlock)
4148
tree.lock_write()
4149
self.add_cleanup(tree.unlock)
4190
4150
if forget_merges:
4191
4151
tree.set_parent_ids(tree.get_parent_ids()[:1])
4192
4152
else:
4195
4155
@staticmethod
4196
4156
def _revert_tree_to_revision(tree, revision, file_list, no_backup):
4197
4157
rev_tree = _get_one_revision_tree('revert', revision, tree=tree)
4198
tree.revert(file_list, rev_tree, not no_backup, None,
4199
report_changes=True)
4158
pb = ui.ui_factory.nested_progress_bar()
4159
try:
4160
tree.revert(file_list, rev_tree, not no_backup, pb,
4161
report_changes=True)
4162
finally:
4163
pb.finished()
4200
4164
4201
4165
4202
4166
class cmd_assert_fail(Command):
4203
__doc__ = """Test reporting of assertion failures"""
4167
"""Test reporting of assertion failures"""
4204
4168
# intended just for use in testing
4205
4169
4206
4170
hidden = True
4210
4174
4211
4175
4212
4176
class cmd_help(Command):
4213
__doc__ = """Show help on a command or other topic.
4177
"""Show help on a command or other topic.
4214
4178
"""
4215
4179
4216
4180
_see_also = ['topics']
4229
4193
4230
4194
4231
4195
class cmd_shell_complete(Command):
4232
__doc__ = """Show appropriate completions for context.
4196
"""Show appropriate completions for context.
4233
4197
4234
4198
For a list of all available commands, say 'bzr shell-complete'.
4235
4199
"""
4244
4208
4245
4209
4246
4210
class cmd_missing(Command):
4247
__doc__ = """Show unmerged/unpulled revisions between two branches.
4211
"""Show unmerged/unpulled revisions between two branches.
4248
4212
4249
4213
OTHER_BRANCH may be local or remote.
4250
4214
4328
4292
restrict = 'remote'
4329
4293
4330
4294
local_branch = Branch.open_containing(u".")[0]
4331
self.add_cleanup(local_branch.lock_read().unlock)
4332
4333
4295
parent = local_branch.get_parent()
4334
4296
if other_branch is None:
4335
4297
other_branch = parent
4344
4306
remote_branch = Branch.open(other_branch)
4345
4307
if remote_branch.base == local_branch.base:
4346
4308
remote_branch = local_branch
4347
else:
4348
self.add_cleanup(remote_branch.lock_read().unlock)
4349
4309
4310
local_branch.lock_read()
4311
self.add_cleanup(local_branch.unlock)
4350
4312
local_revid_range = _revision_range_to_revid_range(
4351
4313
_get_revision_range(my_revision, local_branch,
4352
4314
self.name()))
4353
4315
4316
remote_branch.lock_read()
4317
self.add_cleanup(remote_branch.unlock)
4354
4318
remote_revid_range = _revision_range_to_revid_range(
4355
4319
_get_revision_range(revision,
4356
4320
remote_branch, self.name()))
4406
4370
message("Branches are up to date.\n")
4407
4371
self.cleanup_now()
4408
4372
if not status_code and parent is None and other_branch is not None:
4409
self.add_cleanup(local_branch.lock_write().unlock)
4373
local_branch.lock_write()
4374
self.add_cleanup(local_branch.unlock)
4410
4375
# handle race conditions - a parent might be set while we run.
4411
4376
if local_branch.get_parent() is None:
4412
4377
local_branch.set_parent(remote_branch.base)
4414
4379
4415
4380
4416
4381
class cmd_pack(Command):
4417
__doc__ = """Compress the data within a repository.
4418
4419
This operation compresses the data within a bazaar repository. As
4420
bazaar supports automatic packing of repository, this operation is
4421
normally not required to be done manually.
4422
4423
During the pack operation, bazaar takes a backup of existing repository
4424
data, i.e. pack files. This backup is eventually removed by bazaar
4425
automatically when it is safe to do so. To save disk space by removing
4426
the backed up pack files, the --clean-obsolete-packs option may be
4427
used.
4428
4429
Warning: If you use --clean-obsolete-packs and your machine crashes
4430
during or immediately after repacking, you may be left with a state
4431
where the deletion has been written to disk but the new packs have not
4432
been. In this case the repository may be unusable.
4433
"""
4382
"""Compress the data within a repository."""
4434
4383
4435
4384
_see_also = ['repositories']
4436
4385
takes_args = ['branch_or_repo?']
4437
takes_options = [
4438
Option('clean-obsolete-packs', 'Delete obsolete packs to save disk space.'),
4439
]
4440
4386
4441
def run(self, branch_or_repo='.', clean_obsolete_packs=False):
4387
def run(self, branch_or_repo='.'):
4442
4388
dir = bzrdir.BzrDir.open_containing(branch_or_repo)[0]
4443
4389
try:
4444
4390
branch = dir.open_branch()
4445
4391
repository = branch.repository
4446
4392
except errors.NotBranchError:
4447
4393
repository = dir.open_repository()
4448
repository.pack(clean_obsolete_packs=clean_obsolete_packs)
4394
repository.pack()
4449
4395
4450
4396
4451
4397
class cmd_plugins(Command):
4452
__doc__ = """List the installed plugins.
4398
"""List the installed plugins.
4453
4399
4454
4400
This command displays the list of installed plugins including
4455
4401
version of plugin and a short description of each.
4462
4408
adding new commands, providing additional network transports and
4463
4409
customizing log output.
4464
4410
4465
See the Bazaar Plugin Guide <http://doc.bazaar.canonical.com/plugins/en/>
4466
for further information on plugins including where to find them and how to
4467
install them. Instructions are also provided there on how to write new
4468
plugins using the Python programming language.
4411
See the Bazaar web site, http://bazaar-vcs.org, for further
4412
information on plugins including where to find them and how to
4413
install them. Instructions are also provided there on how to
4414
write new plugins using the Python programming language.
4469
4415
"""
4470
4416
takes_options = ['verbose']
4471
4417
4486
4432
doc = '(no description)'
4487
4433
result.append((name_ver, doc, plugin.path()))
4488
4434
for name_ver, doc, path in sorted(result):
4489
self.outf.write("%s\n" % name_ver)
4490
self.outf.write(" %s\n" % doc)
4435
print name_ver
4436
print ' ', doc
4491
4437
if verbose:
4492
self.outf.write(" %s\n" % path)
4493
self.outf.write("\n")
4438
print ' ', path
4439
print
4494
4440
4495
4441
4496
4442
class cmd_testament(Command):
4497
__doc__ = """Show testament (signing-form) of a revision."""
4443
"""Show testament (signing-form) of a revision."""
4498
4444
takes_options = [
4499
4445
'revision',
4500
4446
Option('long', help='Produce long-format testament.'),
4512
4458
b = Branch.open_containing(branch)[0]
4513
4459
else:
4514
4460
b = Branch.open(branch)
4515
self.add_cleanup(b.lock_read().unlock)
4461
b.lock_read()
4462
self.add_cleanup(b.unlock)
4516
4463
if revision is None:
4517
4464
rev_id = b.last_revision()
4518
4465
else:
4525
4472
4526
4473
4527
4474
class cmd_annotate(Command):
4528
__doc__ = """Show the origin of each line in a file.
4475
"""Show the origin of each line in a file.
4529
4476
4530
4477
This prints out the given file with an annotation on the left side
4531
4478
indicating which revision, author and date introduced the change.
4552
4499
wt, branch, relpath = \
4553
4500
bzrdir.BzrDir.open_containing_tree_or_branch(filename)
4554
4501
if wt is not None:
4555
self.add_cleanup(wt.lock_read().unlock)
4502
wt.lock_read()
4503
self.add_cleanup(wt.unlock)
4556
4504
else:
4557
self.add_cleanup(branch.lock_read().unlock)
4505
branch.lock_read()
4506
self.add_cleanup(branch.unlock)
4558
4507
tree = _get_one_revision_tree('annotate', revision, branch=branch)
4559
self.add_cleanup(tree.lock_read().unlock)
4508
tree.lock_read()
4509
self.add_cleanup(tree.unlock)
4560
4510
if wt is not None:
4561
4511
file_id = wt.path2id(relpath)
4562
4512
else:
4575
4525
4576
4526
4577
4527
class cmd_re_sign(Command):
4578
__doc__ = """Create a digital signature for an existing revision."""
4528
"""Create a digital signature for an existing revision."""
4579
4529
# TODO be able to replace existing ones.
4580
4530
4581
4531
hidden = True # is this right ?
4588
4538
if revision_id_list is None and revision is None:
4589
4539
raise errors.BzrCommandError('You must supply either --revision or a revision_id')
4590
4540
b = WorkingTree.open_containing(u'.')[0].branch
4591
self.add_cleanup(b.lock_write().unlock)
4541
b.lock_write()
4542
self.add_cleanup(b.unlock)
4592
4543
return self._run(b, revision_id_list, revision)
4593
4544
4594
4545
def _run(self, b, revision_id_list, revision):
4640
4591
4641
4592
4642
4593
class cmd_bind(Command):
4643
__doc__ = """Convert the current branch into a checkout of the supplied branch.
4644
If no branch is supplied, rebind to the last bound location.
4594
"""Convert the current branch into a checkout of the supplied branch.
4645
4595
4646
4596
Once converted into a checkout, commits must succeed on the master branch
4647
4597
before they will be applied to the local branch.
4665
4615
'This format does not remember old locations.')
4666
4616
else:
4667
4617
if location is None:
4668
if b.get_bound_location() is not None:
4669
raise errors.BzrCommandError('Branch is already bound')
4670
else:
4671
raise errors.BzrCommandError('No location supplied '
4672
'and no previous location known')
4618
raise errors.BzrCommandError('No location supplied and no '
4619
'previous location known')
4673
4620
b_other = Branch.open(location)
4674
4621
try:
4675
4622
b.bind(b_other)
4681
4628
4682
4629
4683
4630
class cmd_unbind(Command):
4684
__doc__ = """Convert the current checkout into a regular branch.
4631
"""Convert the current checkout into a regular branch.
4685
4632
4686
4633
After unbinding, the local branch is considered independent and subsequent
4687
4634
commits will be local only.
4698
4645
4699
4646
4700
4647
class cmd_uncommit(Command):
4701
__doc__ = """Remove the last committed revision.
4648
"""Remove the last committed revision.
4702
4649
4703
4650
--verbose will print out what is being removed.
4704
4651
--dry-run will go through all the motions, but not actually
4744
4691
b = control.open_branch()
4745
4692
4746
4693
if tree is not None:
4747
self.add_cleanup(tree.lock_write().unlock)
4694
tree.lock_write()
4695
self.add_cleanup(tree.unlock)
4748
4696
else:
4749
self.add_cleanup(b.lock_write().unlock)
4697
b.lock_write()
4698
self.add_cleanup(b.unlock)
4750
4699
return self._run(b, tree, dry_run, verbose, revision, force, local=local)
4751
4700
4752
4701
def _run(self, b, tree, dry_run, verbose, revision, force, local=False):
4785
4734
end_revision=last_revno)
4786
4735
4787
4736
if dry_run:
4788
self.outf.write('Dry-run, pretending to remove'
4789
' the above revisions.\n')
4737
print 'Dry-run, pretending to remove the above revisions.'
4738
if not force:
4739
val = raw_input('Press <enter> to continue')
4790
4740
else:
4791
self.outf.write('The above revision(s) will be removed.\n')
4792
4793
if not force:
4794
if not ui.ui_factory.get_boolean('Are you sure'):
4795
self.outf.write('Canceled')
4796
return 0
4741
print 'The above revision(s) will be removed.'
4742
if not force:
4743
val = raw_input('Are you sure [y/N]? ')
4744
if val.lower() not in ('y', 'yes'):
4745
print 'Canceled'
4746
return 0
4797
4747
4798
4748
mutter('Uncommitting from {%s} to {%s}',
4799
4749
last_rev_id, rev_id)
4800
4750
uncommit(b, tree=tree, dry_run=dry_run, verbose=verbose,
4801
4751
revno=revno, local=local)
4802
self.outf.write('You can restore the old tip by running:\n'
4803
' bzr pull . -r revid:%s\n' % last_rev_id)
4752
note('You can restore the old tip by running:\n'
4753
' bzr pull . -r revid:%s', last_rev_id)
4804
4754
4805
4755
4806
4756
class cmd_break_lock(Command):
4807
__doc__ = """Break a dead lock on a repository, branch or working directory.
4757
"""Break a dead lock on a repository, branch or working directory.
4808
4758
4809
4759
CAUTION: Locks should only be broken when you are sure that the process
4810
4760
holding the lock has been stopped.
4829
4779
4830
4780
4831
4781
class cmd_wait_until_signalled(Command):
4832
__doc__ = """Test helper for test_start_and_stop_bzr_subprocess_send_signal.
4782
"""Test helper for test_start_and_stop_bzr_subprocess_send_signal.
4833
4783
4834
4784
This just prints a line to signal when it is ready, then blocks on stdin.
4835
4785
"""
4843
4793
4844
4794
4845
4795
class cmd_serve(Command):
4846
__doc__ = """Run the bzr server."""
4796
"""Run the bzr server."""
4847
4797
4848
4798
aliases = ['server']
4849
4799
4909
4859
4910
4860
4911
4861
class cmd_join(Command):
4912
__doc__ = """Combine a tree into its containing tree.
4862
"""Combine a tree into its containing tree.
4913
4863
4914
4864
This command requires the target tree to be in a rich-root format.
4915
4865
4955
4905
4956
4906
4957
4907
class cmd_split(Command):
4958
__doc__ = """Split a subdirectory of a tree into a separate tree.
4908
"""Split a subdirectory of a tree into a separate tree.
4959
4909
4960
4910
This command will produce a target tree in a format that supports
4961
4911
rich roots, like 'rich-root' or 'rich-root-pack'. These formats cannot be
4981
4931
4982
4932
4983
4933
class cmd_merge_directive(Command):
4984
__doc__ = """Generate a merge directive for auto-merge tools.
4934
"""Generate a merge directive for auto-merge tools.
4985
4935
4986
4936
A directive requests a merge to be performed, and also provides all the
4987
4937
information necessary to do so. This means it must either include a
5080
5030
5081
5031
5082
5032
class cmd_send(Command):
5083
__doc__ = """Mail or create a merge-directive for submitting changes.
5033
"""Mail or create a merge-directive for submitting changes.
5084
5034
5085
5035
A merge directive provides many things needed for requesting merges:
5086
5036
5168
5118
short_name='f',
5169
5119
type=unicode),
5170
5120
Option('output', short_name='o',
5171
help='Write merge directive to this file or directory; '
5121
help='Write merge directive to this file; '
5172
5122
'use - for stdout.',
5173
5123
type=unicode),
5174
5124
Option('strict',
5197
5147
5198
5148
5199
5149
class cmd_bundle_revisions(cmd_send):
5200
__doc__ = """Create a merge-directive for submitting changes.
5150
"""Create a merge-directive for submitting changes.
5201
5151
5202
5152
A merge directive provides many things needed for requesting merges:
5203
5153
5270
5220
5271
5221
5272
5222
class cmd_tag(Command):
5273
__doc__ = """Create, remove or modify a tag naming a revision.
5223
"""Create, remove or modify a tag naming a revision.
5274
5224
5275
5225
Tags give human-meaningful names to revisions. Commands that take a -r
5276
5226
(--revision) option can be given -rtag:X, where X is any previously
5284
5234
5285
5235
To rename a tag (change the name but keep it on the same revsion), run ``bzr
5286
5236
tag new-name -r tag:old-name`` and then ``bzr tag --delete oldname``.
5287
5288
If no tag name is specified it will be determined through the
5289
'automatic_tag_name' hook. This can e.g. be used to automatically tag
5290
upstream releases by reading configure.ac. See ``bzr help hooks`` for
5291
details.
5292
5237
"""
5293
5238
5294
5239
_see_also = ['commit', 'tags']
5295
takes_args = ['tag_name?']
5240
takes_args = ['tag_name']
5296
5241
takes_options = [
5297
5242
Option('delete',
5298
5243
help='Delete this tag rather than placing it.',
5308
5253
'revision',
5309
5254
]
5310
5255
5311
def run(self, tag_name=None,
5256
def run(self, tag_name,
5312
5257
delete=None,
5313
5258
directory='.',
5314
5259
force=None,
5315
5260
revision=None,
5316
5261
):
5317
5262
branch, relpath = Branch.open_containing(directory)
5318
self.add_cleanup(branch.lock_write().unlock)
5263
branch.lock_write()
5264
self.add_cleanup(branch.unlock)
5319
5265
if delete:
5320
if tag_name is None:
5321
raise errors.BzrCommandError("No tag specified to delete.")
5322
5266
branch.tags.delete_tag(tag_name)
5323
5267
self.outf.write('Deleted tag %s.\n' % tag_name)
5324
5268
else:
5330
5274
revision_id = revision[0].as_revision_id(branch)
5331
5275
else:
5332
5276
revision_id = branch.last_revision()
5333
if tag_name is None:
5334
tag_name = branch.automatic_tag_name(revision_id)
5335
if tag_name is None:
5336
raise errors.BzrCommandError(
5337
"Please specify a tag name.")
5338
5277
if (not force) and branch.tags.has_tag(tag_name):
5339
5278
raise errors.TagAlreadyExists(tag_name)
5340
5279
branch.tags.set_tag(tag_name, revision_id)
5342
5281
5343
5282
5344
5283
class cmd_tags(Command):
5345
__doc__ = """List tags.
5284
"""List tags.
5346
5285
5347
5286
This command shows a table of tag names and the revisions they reference.
5348
5287
"""
5376
5315
if not tags:
5377
5316
return
5378
5317
5379
self.add_cleanup(branch.lock_read().unlock)
5318
branch.lock_read()
5319
self.add_cleanup(branch.unlock)
5380
5320
if revision:
5381
5321
graph = branch.repository.get_graph()
5382
5322
rev1, rev2 = _get_revision_range(revision, branch, self.name())
5415
5355
5416
5356
5417
5357
class cmd_reconfigure(Command):
5418
__doc__ = """Reconfigure the type of a bzr directory.
5358
"""Reconfigure the type of a bzr directory.
5419
5359
5420
5360
A target configuration must be specified.
5421
5361
5506
5446
5507
5447
5508
5448
class cmd_switch(Command):
5509
__doc__ = """Set the branch of a checkout and update.
5449
"""Set the branch of a checkout and update.
5510
5450
5511
5451
For lightweight checkouts, this changes the branch being referenced.
5512
5452
For heavyweight checkouts, this checks that there are no local commits
5602
5542
5603
5543
5604
5544
class cmd_view(Command):
5605
__doc__ = """Manage filtered views.
5545
"""Manage filtered views.
5606
5546
5607
5547
Views provide a mask over the tree so that users can focus on
5608
5548
a subset of a tree when doing their work. After creating a view,
5756
5696
5757
5697
5758
5698
class cmd_hooks(Command):
5759
__doc__ = """Show hooks."""
5699
"""Show hooks."""
5760
5700
5761
5701
hidden = True
5762
5702
5775
5715
self.outf.write(" <no hooks installed>\n")
5776
5716
5777
5717
5778
class cmd_remove_branch(Command):
5779
__doc__ = """Remove a branch.
5780
5781
This will remove the branch from the specified location but
5782
will keep any working tree or repository in place.
5783
5784
:Examples:
5785
5786
Remove the branch at repo/trunk::
5787
5788
bzr remove-branch repo/trunk
5789
5790
"""
5791
5792
takes_args = ["location?"]
5793
5794
aliases = ["rmbranch"]
5795
5796
def run(self, location=None):
5797
if location is None:
5798
location = "."
5799
branch = Branch.open_containing(location)[0]
5800
branch.bzrdir.destroy_branch()
5801
5802
5803
5718
class cmd_shelve(Command):
5804
__doc__ = """Temporarily set aside some changes from the current tree.
5719
"""Temporarily set aside some changes from the current tree.
5805
5720
5806
5721
Shelve allows you to temporarily put changes you've made "on the shelf",
5807
5722
ie. out of the way, until a later time when you can bring them back from
5860
5775
5861
5776
def run_for_list(self):
5862
5777
tree = WorkingTree.open_containing('.')[0]
5863
self.add_cleanup(tree.lock_read().unlock)
5778
tree.lock_read()
5779
self.add_cleanup(tree.unlock)
5864
5780
manager = tree.get_shelf_manager()
5865
5781
shelves = manager.active_shelves()
5866
5782
if len(shelves) == 0:
5875
5791
5876
5792
5877
5793
class cmd_unshelve(Command):
5878
__doc__ = """Restore shelved changes.
5794
"""Restore shelved changes.
5879
5795
5880
5796
By default, the most recently shelved changes are restored. However if you
5881
5797
specify a shelf by id those changes will be restored instead. This works
5907
5823
5908
5824
5909
5825
class cmd_clean_tree(Command):
5910
__doc__ = """Remove unwanted files from working tree.
5826
"""Remove unwanted files from working tree.
5911
5827
5912
5828
By default, only unknown files, not ignored files, are deleted. Versioned
5913
5829
files are never deleted.
5941
5857
5942
5858
5943
5859
class cmd_reference(Command):
5944
__doc__ = """list, view and set branch locations for nested trees.
5860
"""list, view and set branch locations for nested trees.
5945
5861
5946
5862
If no arguments are provided, lists the branch locations for nested trees.
5947
5863
If one argument is provided, display the branch location for that tree.
5987
5903
self.outf.write('%s %s\n' % (path, location))
5988
5904
5989
5905
5990
def _register_lazy_builtins():
5991
# register lazy builtins from other modules; called at startup and should
5992
# be only called once.
5993
for (name, aliases, module_name) in [
5994
('cmd_bundle_info', [], 'bzrlib.bundle.commands'),
5995
('cmd_dpush', [], 'bzrlib.foreign'),
5996
('cmd_version_info', [], 'bzrlib.cmd_version_info'),
5997
('cmd_resolve', ['resolved'], 'bzrlib.conflicts'),
5998
('cmd_conflicts', [], 'bzrlib.conflicts'),
5999
('cmd_sign_my_commits', [], 'bzrlib.sign_my_commits'),
6000
]:
6001
builtin_command_registry.register_lazy(name, aliases, module_name)
5906
# these get imported and then picked up by the scan for cmd_*
5907
# TODO: Some more consistent way to split command definitions across files;
5908
# we do need to load at least some information about them to know of
5909
# aliases. ideally we would avoid loading the implementation until the
5910
# details were needed.
5911
from bzrlib.cmd_version_info import cmd_version_info
5912
from bzrlib.conflicts import cmd_resolve, cmd_conflicts, restore
5913
from bzrlib.bundle.commands import (
5914
cmd_bundle_info,
5915
)
5916
from bzrlib.foreign import cmd_dpush
5917
from bzrlib.sign_my_commits import cmd_sign_my_commits
5918
from bzrlib.weave_commands import cmd_versionedfile_list, \
5919
cmd_weave_plan_merge, cmd_weave_merge_text
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0