~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/builtins.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2010-01-15 05:43:42 UTC
  • mfrom: (4734.4.13 bug-440952-bzrdir)
  • Revision ID: pqm@pqm.ubuntu.com-20100115054342-o6ar5y4ch9tcnzyi
(andrew) Give 'location is a repository' hint for NotBranchError
        (#440952).

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
# Copyright (C) 2005-2010 Canonical Ltd
 
1
# Copyright (C) 2004-2010 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
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
 
2636
2609
    After adding, editing or deleting that file either indirectly by
2637
2610
    using this command or directly by using an editor, be sure to commit
2638
2611
    it.
2639
 
    
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
 
    Patterns prefixed with '!' are exceptions to ignore patterns and take
2647
 
    precedence over regular ignores.  Such exceptions are used to specify
2648
 
    files that should be versioned which would otherwise be ignored.
2649
 
    
2650
 
    Patterns prefixed with '!!' act as regular ignore patterns, but have
2651
 
    precedence over the '!' exception patterns.
2652
2612
 
2653
2613
    Note: ignore patterns containing shell wildcards must be quoted from
2654
2614
    the shell on Unix.
2658
2618
 
2659
2619
            bzr ignore ./Makefile
2660
2620
 
2661
 
        Ignore .class files in all directories...::
 
2621
        Ignore class files in all directories::
2662
2622
 
2663
2623
            bzr ignore "*.class"
2664
2624
 
2665
 
        ...but do not ignore "special.class"::
2666
 
 
2667
 
            bzr ignore "!special.class"
2668
 
 
2669
2625
        Ignore .o files under the lib directory::
2670
2626
 
2671
2627
            bzr ignore "lib/**/*.o"
2677
2633
        Ignore everything but the "debian" toplevel directory::
2678
2634
 
2679
2635
            bzr ignore "RE:(?!debian/).*"
2680
 
        
2681
 
        Ignore everything except the "local" toplevel directory,
2682
 
        but always ignore "*~" autosave files, even under local/::
2683
 
        
2684
 
            bzr ignore "*"
2685
 
            bzr ignore "!./local"
2686
 
            bzr ignore "!!*~"
2687
2636
    """
2688
2637
 
2689
2638
    _see_also = ['status', 'ignored', 'patterns']
2690
2639
    takes_args = ['name_pattern*']
2691
2640
    takes_options = [
2692
 
        Option('default-rules',
2693
 
               help='Display the default ignore rules that bzr uses.')
 
2641
        Option('old-default-rules',
 
2642
               help='Write out the ignore rules bzr < 0.9 always used.')
2694
2643
        ]
2695
2644
 
2696
 
    def run(self, name_pattern_list=None, default_rules=None):
 
2645
    def run(self, name_pattern_list=None, old_default_rules=None):
2697
2646
        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)
 
2647
        if old_default_rules is not None:
 
2648
            # dump the rules and exit
 
2649
            for pattern in ignores.OLD_DEFAULTS:
 
2650
                print pattern
2702
2651
            return
2703
2652
        if not name_pattern_list:
2704
2653
            raise errors.BzrCommandError("ignore requires at least one "
2705
 
                "NAME_PATTERN or --default-rules.")
 
2654
                                  "NAME_PATTERN or --old-default-rules")
2706
2655
        name_pattern_list = [globbing.normalize_pattern(p)
2707
2656
                             for p in name_pattern_list]
2708
2657
        for name_pattern in name_pattern_list:
2720
2669
            if id is not None:
2721
2670
                filename = entry[0]
2722
2671
                if ignored.match(filename):
2723
 
                    matches.append(filename)
 
2672
                    matches.append(filename.encode('utf-8'))
2724
2673
        tree.unlock()
2725
2674
        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),))
 
2675
            print "Warning: the following files are version controlled and" \
 
2676
                  " match your ignore pattern:\n%s" \
 
2677
                  "\nThese files will continue to be version controlled" \
 
2678
                  " unless you 'bzr remove' them." % ("\n".join(matches),)
2730
2679
 
2731
2680
 
2732
2681
class cmd_ignored(Command):
2733
 
    __doc__ = """List ignored files and the patterns that matched them.
 
2682
    """List ignored files and the patterns that matched them.
2734
2683
 
2735
2684
    List all the ignored files and the ignore pattern that caused the file to
2736
2685
    be ignored.
2746
2695
    @display_command
2747
2696
    def run(self):
2748
2697
        tree = WorkingTree.open_containing(u'.')[0]
2749
 
        self.add_cleanup(tree.lock_read().unlock)
 
2698
        tree.lock_read()
 
2699
        self.add_cleanup(tree.unlock)
2750
2700
        for path, file_class, kind, file_id, entry in tree.list_files():
2751
2701
            if file_class != 'I':
2752
2702
                continue
2756
2706
 
2757
2707
 
2758
2708
class cmd_lookup_revision(Command):
2759
 
    __doc__ = """Lookup the revision-id from a revision-number
 
2709
    """Lookup the revision-id from a revision-number
2760
2710
 
2761
2711
    :Examples:
2762
2712
        bzr lookup-revision 33
2769
2719
        try:
2770
2720
            revno = int(revno)
2771
2721
        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)
 
2722
            raise errors.BzrCommandError("not a valid revision-number: %r" % revno)
 
2723
 
 
2724
        print WorkingTree.open_containing(u'.')[0].branch.get_rev_id(revno)
2776
2725
 
2777
2726
 
2778
2727
class cmd_export(Command):
2779
 
    __doc__ = """Export current or past revision to a destination directory or archive.
 
2728
    """Export current or past revision to a destination directory or archive.
2780
2729
 
2781
2730
    If no revision is specified this exports the last committed revision.
2782
2731
 
2814
2763
        Option('root',
2815
2764
               type=str,
2816
2765
               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
2766
        ]
2821
2767
    def run(self, dest, branch_or_subdir=None, revision=None, format=None,
2822
 
        root=None, filters=False, per_file_timestamps=False):
 
2768
        root=None, filters=False):
2823
2769
        from bzrlib.export import export
2824
2770
 
2825
2771
        if branch_or_subdir is None:
2832
2778
 
2833
2779
        rev_tree = _get_one_revision_tree('export', revision, branch=b, tree=tree)
2834
2780
        try:
2835
 
            export(rev_tree, dest, format, root, subdir, filtered=filters,
2836
 
                   per_file_timestamps=per_file_timestamps)
 
2781
            export(rev_tree, dest, format, root, subdir, filtered=filters)
2837
2782
        except errors.NoSuchExportFormat, e:
2838
2783
            raise errors.BzrCommandError('Unsupported export format: %s' % e.format)
2839
2784
 
2840
2785
 
2841
2786
class cmd_cat(Command):
2842
 
    __doc__ = """Write the contents of a file as of a given revision to standard output.
 
2787
    """Write the contents of a file as of a given revision to standard output.
2843
2788
 
2844
2789
    If no revision is nominated, the last revision is used.
2845
2790
 
2865
2810
                                         " one revision specifier")
2866
2811
        tree, branch, relpath = \
2867
2812
            bzrdir.BzrDir.open_containing_tree_or_branch(filename)
2868
 
        self.add_cleanup(branch.lock_read().unlock)
 
2813
        branch.lock_read()
 
2814
        self.add_cleanup(branch.unlock)
2869
2815
        return self._run(tree, branch, relpath, filename, revision,
2870
2816
                         name_from_revision, filters)
2871
2817
 
2874
2820
        if tree is None:
2875
2821
            tree = b.basis_tree()
2876
2822
        rev_tree = _get_one_revision_tree('cat', revision, branch=b)
2877
 
        self.add_cleanup(rev_tree.lock_read().unlock)
 
2823
        rev_tree.lock_read()
 
2824
        self.add_cleanup(rev_tree.unlock)
2878
2825
 
2879
2826
        old_file_id = rev_tree.path2id(relpath)
2880
2827
 
2923
2870
 
2924
2871
 
2925
2872
class cmd_local_time_offset(Command):
2926
 
    __doc__ = """Show the offset in seconds from GMT to local time."""
 
2873
    """Show the offset in seconds from GMT to local time."""
2927
2874
    hidden = True
2928
2875
    @display_command
2929
2876
    def run(self):
2930
 
        self.outf.write("%s\n" % osutils.local_time_offset())
 
2877
        print osutils.local_time_offset()
2931
2878
 
2932
2879
 
2933
2880
 
2934
2881
class cmd_commit(Command):
2935
 
    __doc__ = """Commit changes into a new revision.
 
2882
    """Commit changes into a new revision.
2936
2883
 
2937
2884
    An explanatory message needs to be given for each commit. This is
2938
2885
    often done by using the --message option (getting the message from the
3046
2993
                         "the master branch until a normal commit "
3047
2994
                         "is performed."
3048
2995
                    ),
3049
 
             Option('show-diff', short_name='p',
 
2996
             Option('show-diff',
3050
2997
                    help='When no message is supplied, show the diff along'
3051
2998
                    ' with the status summary in the message editor.'),
3052
2999
             ]
3132
3079
                    '(use --file "%(f)s" to take commit message from that file)'
3133
3080
                    % { 'f': message })
3134
3081
                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
3082
 
3142
3083
        def get_message(commit_obj):
3143
3084
            """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,
 
3085
            my_message = message
 
3086
            if my_message is not None and '\r' in my_message:
 
3087
                my_message = my_message.replace('\r\n', '\n')
 
3088
                my_message = my_message.replace('\r', '\n')
 
3089
            if my_message is None and not file:
 
3090
                t = make_commit_message_template_encoded(tree,
3153
3091
                        selected_list, diff=show_diff,
3154
3092
                        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
3093
                start_message = generate_commit_message_template(commit_obj)
3161
 
                my_message = edit_commit_message_encoded(text,
 
3094
                my_message = edit_commit_message_encoded(t,
3162
3095
                    start_message=start_message)
3163
3096
                if my_message is None:
3164
3097
                    raise errors.BzrCommandError("please specify a commit"
3165
3098
                        " message with either --message or --file")
 
3099
            elif my_message and file:
 
3100
                raise errors.BzrCommandError(
 
3101
                    "please specify either --message or --file")
 
3102
            if file:
 
3103
                my_message = codecs.open(file, 'rt',
 
3104
                                         osutils.get_user_encoding()).read()
3166
3105
            if my_message == "":
3167
3106
                raise errors.BzrCommandError("empty commit message specified")
3168
3107
            return my_message
3180
3119
                        timezone=offset,
3181
3120
                        exclude=safe_relpath_files(tree, exclude))
3182
3121
        except PointlessCommit:
 
3122
            # FIXME: This should really happen before the file is read in;
 
3123
            # perhaps prepare the commit; get the message; then actually commit
3183
3124
            raise errors.BzrCommandError("No changes to commit."
3184
3125
                              " Use --unchanged to commit anyhow.")
3185
3126
        except ConflictsInTree:
3190
3131
            raise errors.BzrCommandError("Commit refused because there are"
3191
3132
                              " unknown files in the working tree.")
3192
3133
        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
 
3134
            raise errors.BzrCommandError(str(e) + "\n"
 
3135
            'To commit to master branch, run update and then commit.\n'
 
3136
            'You can also pass --local to commit to continue working '
 
3137
            'disconnected.')
3198
3138
 
3199
3139
 
3200
3140
class cmd_check(Command):
3201
 
    __doc__ = """Validate working tree structure, branch consistency and repository history.
 
3141
    """Validate working tree structure, branch consistency and repository history.
3202
3142
 
3203
3143
    This command checks various invariants about branch and repository storage
3204
3144
    to detect data corruption or bzr bugs.
3268
3208
 
3269
3209
 
3270
3210
class cmd_upgrade(Command):
3271
 
    __doc__ = """Upgrade branch storage to current format.
 
3211
    """Upgrade branch storage to current format.
3272
3212
 
3273
3213
    The check command or bzr developers may sometimes advise you to run
3274
3214
    this command. When the default format has changed you may also be warned
3292
3232
 
3293
3233
 
3294
3234
class cmd_whoami(Command):
3295
 
    __doc__ = """Show or set bzr user id.
 
3235
    """Show or set bzr user id.
3296
3236
 
3297
3237
    :Examples:
3298
3238
        Show the email of the current user::
3342
3282
 
3343
3283
 
3344
3284
class cmd_nick(Command):
3345
 
    __doc__ = """Print or set the branch nickname.
 
3285
    """Print or set the branch nickname.
3346
3286
 
3347
3287
    If unset, the tree root directory name is used as the nickname.
3348
3288
    To print the current nickname, execute with no argument.
3362
3302
 
3363
3303
    @display_command
3364
3304
    def printme(self, branch):
3365
 
        self.outf.write('%s\n' % branch.nick)
 
3305
        print branch.nick
3366
3306
 
3367
3307
 
3368
3308
class cmd_alias(Command):
3369
 
    __doc__ = """Set/unset and display aliases.
 
3309
    """Set/unset and display aliases.
3370
3310
 
3371
3311
    :Examples:
3372
3312
        Show the current aliases::
3436
3376
 
3437
3377
 
3438
3378
class cmd_selftest(Command):
3439
 
    __doc__ = """Run internal test suite.
 
3379
    """Run internal test suite.
3440
3380
 
3441
3381
    If arguments are given, they are regular expressions that say which tests
3442
3382
    should run.  Tests matching any expression are run, and other tests are
3486
3426
    def get_transport_type(typestring):
3487
3427
        """Parse and return a transport specifier."""
3488
3428
        if typestring == "sftp":
3489
 
            from bzrlib.tests import stub_sftp
3490
 
            return stub_sftp.SFTPAbsoluteServer
 
3429
            from bzrlib.transport.sftp import SFTPAbsoluteServer
 
3430
            return SFTPAbsoluteServer
3491
3431
        if typestring == "memory":
3492
 
            from bzrlib.tests import test_server
3493
 
            return memory.MemoryServer
 
3432
            from bzrlib.transport.memory import MemoryServer
 
3433
            return MemoryServer
3494
3434
        if typestring == "fakenfs":
3495
 
            from bzrlib.tests import test_server
3496
 
            return test_server.FakeNFSServer
 
3435
            from bzrlib.transport.fakenfs import FakeNFSServer
 
3436
            return FakeNFSServer
3497
3437
        msg = "No known transport type %s. Supported types are: sftp\n" %\
3498
3438
            (typestring)
3499
3439
        raise errors.BzrCommandError(msg)
3583
3523
                raise errors.BzrCommandError("subunit not available. subunit "
3584
3524
                    "needs to be installed to use --subunit.")
3585
3525
            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
3526
        if parallel:
3592
3527
            self.additional_selftest_args.setdefault(
3593
3528
                'suite_decorators', []).append(parallel)
3624
3559
 
3625
3560
 
3626
3561
class cmd_version(Command):
3627
 
    __doc__ = """Show version of bzr."""
 
3562
    """Show version of bzr."""
3628
3563
 
3629
3564
    encoding_type = 'replace'
3630
3565
    takes_options = [
3641
3576
 
3642
3577
 
3643
3578
class cmd_rocks(Command):
3644
 
    __doc__ = """Statement of optimism."""
 
3579
    """Statement of optimism."""
3645
3580
 
3646
3581
    hidden = True
3647
3582
 
3648
3583
    @display_command
3649
3584
    def run(self):
3650
 
        self.outf.write("It sure does!\n")
 
3585
        print "It sure does!"
3651
3586
 
3652
3587
 
3653
3588
class cmd_find_merge_base(Command):
3654
 
    __doc__ = """Find and print a base revision for merging two branches."""
 
3589
    """Find and print a base revision for merging two branches."""
3655
3590
    # TODO: Options to specify revisions on either side, as if
3656
3591
    #       merging only part of the history.
3657
3592
    takes_args = ['branch', 'other']
3663
3598
 
3664
3599
        branch1 = Branch.open_containing(branch)[0]
3665
3600
        branch2 = Branch.open_containing(other)[0]
3666
 
        self.add_cleanup(branch1.lock_read().unlock)
3667
 
        self.add_cleanup(branch2.lock_read().unlock)
 
3601
        branch1.lock_read()
 
3602
        self.add_cleanup(branch1.unlock)
 
3603
        branch2.lock_read()
 
3604
        self.add_cleanup(branch2.unlock)
3668
3605
        last1 = ensure_null(branch1.last_revision())
3669
3606
        last2 = ensure_null(branch2.last_revision())
3670
3607
 
3671
3608
        graph = branch1.repository.get_graph(branch2.repository)
3672
3609
        base_rev_id = graph.find_unique_lca(last1, last2)
3673
3610
 
3674
 
        self.outf.write('merge base is revision %s\n' % base_rev_id)
 
3611
        print 'merge base is revision %s' % base_rev_id
3675
3612
 
3676
3613
 
3677
3614
class cmd_merge(Command):
3678
 
    __doc__ = """Perform a three-way merge.
 
3615
    """Perform a three-way merge.
3679
3616
 
3680
3617
    The source of the merge can be specified either in the form of a branch,
3681
3618
    or in the form of a path to a file containing a merge directive generated
3710
3647
    committed to record the result of the merge.
3711
3648
 
3712
3649
    merge refuses to run if there are any uncommitted changes, unless
3713
 
    --force is given. The --force option can also be used to create a
3714
 
    merge revision which has more than two parents.
3715
 
 
3716
 
    If one would like to merge changes from the working tree of the other
3717
 
    branch without merging any committed revisions, the --uncommitted option
3718
 
    can be given.
 
3650
    --force is given.
3719
3651
 
3720
3652
    To select only some changes to merge, use "merge -i", which will prompt
3721
3653
    you to apply each diff hunk and file change, similar to "shelve".
3736
3668
        To apply a merge directive contained in /tmp/merge::
3737
3669
 
3738
3670
            bzr merge /tmp/merge
3739
 
 
3740
 
        To create a merge revision with three parents from two branches
3741
 
        feature1a and feature1b:
3742
 
 
3743
 
            bzr merge ../feature1a
3744
 
            bzr merge ../feature1b --force
3745
 
            bzr commit -m 'revision with three parents'
3746
3671
    """
3747
3672
 
3748
3673
    encoding_type = 'exact'
3808
3733
            unversioned_filter=tree.is_ignored, view_info=view_info)
3809
3734
        pb = ui.ui_factory.nested_progress_bar()
3810
3735
        self.add_cleanup(pb.finished)
3811
 
        self.add_cleanup(tree.lock_write().unlock)
 
3736
        tree.lock_write()
 
3737
        self.add_cleanup(tree.unlock)
3812
3738
        if location is not None:
3813
3739
            try:
3814
3740
                mergeable = bundle.read_mergeable_from_url(location,
3824
3750
                    raise errors.BzrCommandError(
3825
3751
                        'Cannot use -r with merge directives or bundles')
3826
3752
                merger, verified = _mod_merge.Merger.from_mergeable(tree,
3827
 
                   mergeable, None)
 
3753
                   mergeable, pb)
3828
3754
 
3829
3755
        if merger is None and uncommitted:
3830
3756
            if revision is not None and len(revision) > 0:
3831
3757
                raise errors.BzrCommandError('Cannot use --uncommitted and'
3832
3758
                    ' --revision at the same time.')
3833
 
            merger = self.get_merger_from_uncommitted(tree, location, None)
 
3759
            merger = self.get_merger_from_uncommitted(tree, location, pb)
3834
3760
            allow_pending = False
3835
3761
 
3836
3762
        if merger is None:
3837
3763
            merger, allow_pending = self._get_merger_from_branch(tree,
3838
 
                location, revision, remember, possible_transports, None)
 
3764
                location, revision, remember, possible_transports, pb)
3839
3765
 
3840
3766
        merger.merge_type = merge_type
3841
3767
        merger.reprocess = reprocess
4035
3961
 
4036
3962
 
4037
3963
class cmd_remerge(Command):
4038
 
    __doc__ = """Redo a merge.
 
3964
    """Redo a merge.
4039
3965
 
4040
3966
    Use this if you want to try a different merge technique while resolving
4041
3967
    conflicts.  Some merge techniques are better than others, and remerge
4066
3992
 
4067
3993
    def run(self, file_list=None, merge_type=None, show_base=False,
4068
3994
            reprocess=False):
4069
 
        from bzrlib.conflicts import restore
4070
3995
        if merge_type is None:
4071
3996
            merge_type = _mod_merge.Merge3Merger
4072
3997
        tree, file_list = tree_files(file_list)
4073
 
        self.add_cleanup(tree.lock_write().unlock)
 
3998
        tree.lock_write()
 
3999
        self.add_cleanup(tree.unlock)
4074
4000
        parents = tree.get_parent_ids()
4075
4001
        if len(parents) != 2:
4076
4002
            raise errors.BzrCommandError("Sorry, remerge only works after normal"
4112
4038
        # list, we imply that the working tree text has seen and rejected
4113
4039
        # all the changes from the other tree, when in fact those changes
4114
4040
        # have not yet been seen.
 
4041
        pb = ui.ui_factory.nested_progress_bar()
4115
4042
        tree.set_parent_ids(parents[:1])
4116
4043
        try:
4117
 
            merger = _mod_merge.Merger.from_revision_ids(None, tree, parents[1])
 
4044
            merger = _mod_merge.Merger.from_revision_ids(pb,
 
4045
                                                         tree, parents[1])
4118
4046
            merger.interesting_ids = interesting_ids
4119
4047
            merger.merge_type = merge_type
4120
4048
            merger.show_base = show_base
4122
4050
            conflicts = merger.do_merge()
4123
4051
        finally:
4124
4052
            tree.set_parent_ids(parents)
 
4053
            pb.finished()
4125
4054
        if conflicts > 0:
4126
4055
            return 1
4127
4056
        else:
4129
4058
 
4130
4059
 
4131
4060
class cmd_revert(Command):
4132
 
    __doc__ = """Revert files to a previous revision.
 
4061
    """Revert files to a previous revision.
4133
4062
 
4134
4063
    Giving a list of files will revert only those files.  Otherwise, all files
4135
4064
    will be reverted.  If the revision is not specified with '--revision', the
4154
4083
    created as above.  Directories containing unknown files will not be
4155
4084
    deleted.
4156
4085
 
4157
 
    The working tree contains a list of revisions that have been merged but
4158
 
    not yet committed. These revisions will be included as additional parents
4159
 
    of the next commit.  Normally, using revert clears that list as well as
4160
 
    reverting the files.  If any files are specified, revert leaves the list
4161
 
    of uncommitted merges alone and reverts only the files.  Use ``bzr revert
4162
 
    .`` in the tree root to revert all files but keep the recorded merges,
4163
 
    and ``bzr revert --forget-merges`` to clear the pending merge list without
 
4086
    The working tree contains a list of pending merged revisions, which will
 
4087
    be included as parents in the next commit.  Normally, revert clears that
 
4088
    list as well as reverting the files.  If any files are specified, revert
 
4089
    leaves the pending merge list alone and reverts only the files.  Use "bzr
 
4090
    revert ." in the tree root to revert all files but keep the merge record,
 
4091
    and "bzr revert --forget-merges" to clear the pending merge list without
4164
4092
    reverting any files.
4165
4093
 
4166
 
    Using "bzr revert --forget-merges", it is possible to apply all of the
4167
 
    changes from a branch in a single revision.  To do this, perform the merge
4168
 
    as desired.  Then doing revert with the "--forget-merges" option will keep
4169
 
    the content of the tree as it was, but it will clear the list of pending
4170
 
    merges.  The next commit will then contain all of the changes that are
4171
 
    present in the other branch, but without any other parent revisions.
4172
 
    Because this technique forgets where these changes originated, it may
4173
 
    cause additional conflicts on later merges involving the same source and
 
4094
    Using "bzr revert --forget-merges", it is possible to apply the changes
 
4095
    from an arbitrary merge as a single revision.  To do this, perform the
 
4096
    merge as desired.  Then doing revert with the "--forget-merges" option will
 
4097
    keep the content of the tree as it was, but it will clear the list of
 
4098
    pending merges.  The next commit will then contain all of the changes that
 
4099
    would have been in the merge, but without any mention of the other parent
 
4100
    revisions.  Because this technique forgets where these changes originated,
 
4101
    it may cause additional conflicts on later merges involving the source and
4174
4102
    target branches.
4175
4103
    """
4176
4104
 
4186
4114
    def run(self, revision=None, no_backup=False, file_list=None,
4187
4115
            forget_merges=None):
4188
4116
        tree, file_list = tree_files(file_list)
4189
 
        self.add_cleanup(tree.lock_tree_write().unlock)
 
4117
        tree.lock_write()
 
4118
        self.add_cleanup(tree.unlock)
4190
4119
        if forget_merges:
4191
4120
            tree.set_parent_ids(tree.get_parent_ids()[:1])
4192
4121
        else:
4195
4124
    @staticmethod
4196
4125
    def _revert_tree_to_revision(tree, revision, file_list, no_backup):
4197
4126
        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)
 
4127
        pb = ui.ui_factory.nested_progress_bar()
 
4128
        try:
 
4129
            tree.revert(file_list, rev_tree, not no_backup, pb,
 
4130
                report_changes=True)
 
4131
        finally:
 
4132
            pb.finished()
4200
4133
 
4201
4134
 
4202
4135
class cmd_assert_fail(Command):
4203
 
    __doc__ = """Test reporting of assertion failures"""
 
4136
    """Test reporting of assertion failures"""
4204
4137
    # intended just for use in testing
4205
4138
 
4206
4139
    hidden = True
4210
4143
 
4211
4144
 
4212
4145
class cmd_help(Command):
4213
 
    __doc__ = """Show help on a command or other topic.
 
4146
    """Show help on a command or other topic.
4214
4147
    """
4215
4148
 
4216
4149
    _see_also = ['topics']
4229
4162
 
4230
4163
 
4231
4164
class cmd_shell_complete(Command):
4232
 
    __doc__ = """Show appropriate completions for context.
 
4165
    """Show appropriate completions for context.
4233
4166
 
4234
4167
    For a list of all available commands, say 'bzr shell-complete'.
4235
4168
    """
4244
4177
 
4245
4178
 
4246
4179
class cmd_missing(Command):
4247
 
    __doc__ = """Show unmerged/unpulled revisions between two branches.
 
4180
    """Show unmerged/unpulled revisions between two branches.
4248
4181
 
4249
4182
    OTHER_BRANCH may be local or remote.
4250
4183
 
4328
4261
            restrict = 'remote'
4329
4262
 
4330
4263
        local_branch = Branch.open_containing(u".")[0]
4331
 
        self.add_cleanup(local_branch.lock_read().unlock)
4332
 
 
4333
4264
        parent = local_branch.get_parent()
4334
4265
        if other_branch is None:
4335
4266
            other_branch = parent
4344
4275
        remote_branch = Branch.open(other_branch)
4345
4276
        if remote_branch.base == local_branch.base:
4346
4277
            remote_branch = local_branch
4347
 
        else:
4348
 
            self.add_cleanup(remote_branch.lock_read().unlock)
4349
4278
 
 
4279
        local_branch.lock_read()
 
4280
        self.add_cleanup(local_branch.unlock)
4350
4281
        local_revid_range = _revision_range_to_revid_range(
4351
4282
            _get_revision_range(my_revision, local_branch,
4352
4283
                self.name()))
4353
4284
 
 
4285
        remote_branch.lock_read()
 
4286
        self.add_cleanup(remote_branch.unlock)
4354
4287
        remote_revid_range = _revision_range_to_revid_range(
4355
4288
            _get_revision_range(revision,
4356
4289
                remote_branch, self.name()))
4406
4339
            message("Branches are up to date.\n")
4407
4340
        self.cleanup_now()
4408
4341
        if not status_code and parent is None and other_branch is not None:
4409
 
            self.add_cleanup(local_branch.lock_write().unlock)
 
4342
            local_branch.lock_write()
 
4343
            self.add_cleanup(local_branch.unlock)
4410
4344
            # handle race conditions - a parent might be set while we run.
4411
4345
            if local_branch.get_parent() is None:
4412
4346
                local_branch.set_parent(remote_branch.base)
4414
4348
 
4415
4349
 
4416
4350
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
 
    """
 
4351
    """Compress the data within a repository."""
4434
4352
 
4435
4353
    _see_also = ['repositories']
4436
4354
    takes_args = ['branch_or_repo?']
4437
 
    takes_options = [
4438
 
        Option('clean-obsolete-packs', 'Delete obsolete packs to save disk space.'),
4439
 
        ]
4440
4355
 
4441
 
    def run(self, branch_or_repo='.', clean_obsolete_packs=False):
 
4356
    def run(self, branch_or_repo='.'):
4442
4357
        dir = bzrdir.BzrDir.open_containing(branch_or_repo)[0]
4443
4358
        try:
4444
4359
            branch = dir.open_branch()
4445
4360
            repository = branch.repository
4446
4361
        except errors.NotBranchError:
4447
4362
            repository = dir.open_repository()
4448
 
        repository.pack(clean_obsolete_packs=clean_obsolete_packs)
 
4363
        repository.pack()
4449
4364
 
4450
4365
 
4451
4366
class cmd_plugins(Command):
4452
 
    __doc__ = """List the installed plugins.
 
4367
    """List the installed plugins.
4453
4368
 
4454
4369
    This command displays the list of installed plugins including
4455
4370
    version of plugin and a short description of each.
4462
4377
    adding new commands, providing additional network transports and
4463
4378
    customizing log output.
4464
4379
 
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.
 
4380
    See the Bazaar web site, http://bazaar-vcs.org, for further
 
4381
    information on plugins including where to find them and how to
 
4382
    install them. Instructions are also provided there on how to
 
4383
    write new plugins using the Python programming language.
4469
4384
    """
4470
4385
    takes_options = ['verbose']
4471
4386
 
4486
4401
                doc = '(no description)'
4487
4402
            result.append((name_ver, doc, plugin.path()))
4488
4403
        for name_ver, doc, path in sorted(result):
4489
 
            self.outf.write("%s\n" % name_ver)
4490
 
            self.outf.write("   %s\n" % doc)
 
4404
            print name_ver
 
4405
            print '   ', doc
4491
4406
            if verbose:
4492
 
                self.outf.write("   %s\n" % path)
4493
 
            self.outf.write("\n")
 
4407
                print '   ', path
 
4408
            print
4494
4409
 
4495
4410
 
4496
4411
class cmd_testament(Command):
4497
 
    __doc__ = """Show testament (signing-form) of a revision."""
 
4412
    """Show testament (signing-form) of a revision."""
4498
4413
    takes_options = [
4499
4414
            'revision',
4500
4415
            Option('long', help='Produce long-format testament.'),
4512
4427
            b = Branch.open_containing(branch)[0]
4513
4428
        else:
4514
4429
            b = Branch.open(branch)
4515
 
        self.add_cleanup(b.lock_read().unlock)
 
4430
        b.lock_read()
 
4431
        self.add_cleanup(b.unlock)
4516
4432
        if revision is None:
4517
4433
            rev_id = b.last_revision()
4518
4434
        else:
4525
4441
 
4526
4442
 
4527
4443
class cmd_annotate(Command):
4528
 
    __doc__ = """Show the origin of each line in a file.
 
4444
    """Show the origin of each line in a file.
4529
4445
 
4530
4446
    This prints out the given file with an annotation on the left side
4531
4447
    indicating which revision, author and date introduced the change.
4552
4468
        wt, branch, relpath = \
4553
4469
            bzrdir.BzrDir.open_containing_tree_or_branch(filename)
4554
4470
        if wt is not None:
4555
 
            self.add_cleanup(wt.lock_read().unlock)
 
4471
            wt.lock_read()
 
4472
            self.add_cleanup(wt.unlock)
4556
4473
        else:
4557
 
            self.add_cleanup(branch.lock_read().unlock)
 
4474
            branch.lock_read()
 
4475
            self.add_cleanup(branch.unlock)
4558
4476
        tree = _get_one_revision_tree('annotate', revision, branch=branch)
4559
 
        self.add_cleanup(tree.lock_read().unlock)
 
4477
        tree.lock_read()
 
4478
        self.add_cleanup(tree.unlock)
4560
4479
        if wt is not None:
4561
4480
            file_id = wt.path2id(relpath)
4562
4481
        else:
4575
4494
 
4576
4495
 
4577
4496
class cmd_re_sign(Command):
4578
 
    __doc__ = """Create a digital signature for an existing revision."""
 
4497
    """Create a digital signature for an existing revision."""
4579
4498
    # TODO be able to replace existing ones.
4580
4499
 
4581
4500
    hidden = True # is this right ?
4588
4507
        if revision_id_list is None and revision is None:
4589
4508
            raise errors.BzrCommandError('You must supply either --revision or a revision_id')
4590
4509
        b = WorkingTree.open_containing(u'.')[0].branch
4591
 
        self.add_cleanup(b.lock_write().unlock)
 
4510
        b.lock_write()
 
4511
        self.add_cleanup(b.unlock)
4592
4512
        return self._run(b, revision_id_list, revision)
4593
4513
 
4594
4514
    def _run(self, b, revision_id_list, revision):
4640
4560
 
4641
4561
 
4642
4562
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.
 
4563
    """Convert the current branch into a checkout of the supplied branch.
4645
4564
 
4646
4565
    Once converted into a checkout, commits must succeed on the master branch
4647
4566
    before they will be applied to the local branch.
4665
4584
                    'This format does not remember old locations.')
4666
4585
            else:
4667
4586
                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')
 
4587
                    raise errors.BzrCommandError('No location supplied and no '
 
4588
                        'previous location known')
4673
4589
        b_other = Branch.open(location)
4674
4590
        try:
4675
4591
            b.bind(b_other)
4681
4597
 
4682
4598
 
4683
4599
class cmd_unbind(Command):
4684
 
    __doc__ = """Convert the current checkout into a regular branch.
 
4600
    """Convert the current checkout into a regular branch.
4685
4601
 
4686
4602
    After unbinding, the local branch is considered independent and subsequent
4687
4603
    commits will be local only.
4698
4614
 
4699
4615
 
4700
4616
class cmd_uncommit(Command):
4701
 
    __doc__ = """Remove the last committed revision.
 
4617
    """Remove the last committed revision.
4702
4618
 
4703
4619
    --verbose will print out what is being removed.
4704
4620
    --dry-run will go through all the motions, but not actually
4744
4660
            b = control.open_branch()
4745
4661
 
4746
4662
        if tree is not None:
4747
 
            self.add_cleanup(tree.lock_write().unlock)
 
4663
            tree.lock_write()
 
4664
            self.add_cleanup(tree.unlock)
4748
4665
        else:
4749
 
            self.add_cleanup(b.lock_write().unlock)
 
4666
            b.lock_write()
 
4667
            self.add_cleanup(b.unlock)
4750
4668
        return self._run(b, tree, dry_run, verbose, revision, force, local=local)
4751
4669
 
4752
4670
    def _run(self, b, tree, dry_run, verbose, revision, force, local=False):
4785
4703
                 end_revision=last_revno)
4786
4704
 
4787
4705
        if dry_run:
4788
 
            self.outf.write('Dry-run, pretending to remove'
4789
 
                            ' the above revisions.\n')
 
4706
            print 'Dry-run, pretending to remove the above revisions.'
 
4707
            if not force:
 
4708
                val = raw_input('Press <enter> to continue')
4790
4709
        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
 
4710
            print 'The above revision(s) will be removed.'
 
4711
            if not force:
 
4712
                val = raw_input('Are you sure [y/N]? ')
 
4713
                if val.lower() not in ('y', 'yes'):
 
4714
                    print 'Canceled'
 
4715
                    return 0
4797
4716
 
4798
4717
        mutter('Uncommitting from {%s} to {%s}',
4799
4718
               last_rev_id, rev_id)
4800
4719
        uncommit(b, tree=tree, dry_run=dry_run, verbose=verbose,
4801
4720
                 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)
 
4721
        note('You can restore the old tip by running:\n'
 
4722
             '  bzr pull . -r revid:%s', last_rev_id)
4804
4723
 
4805
4724
 
4806
4725
class cmd_break_lock(Command):
4807
 
    __doc__ = """Break a dead lock on a repository, branch or working directory.
 
4726
    """Break a dead lock on a repository, branch or working directory.
4808
4727
 
4809
4728
    CAUTION: Locks should only be broken when you are sure that the process
4810
4729
    holding the lock has been stopped.
4829
4748
 
4830
4749
 
4831
4750
class cmd_wait_until_signalled(Command):
4832
 
    __doc__ = """Test helper for test_start_and_stop_bzr_subprocess_send_signal.
 
4751
    """Test helper for test_start_and_stop_bzr_subprocess_send_signal.
4833
4752
 
4834
4753
    This just prints a line to signal when it is ready, then blocks on stdin.
4835
4754
    """
4843
4762
 
4844
4763
 
4845
4764
class cmd_serve(Command):
4846
 
    __doc__ = """Run the bzr server."""
 
4765
    """Run the bzr server."""
4847
4766
 
4848
4767
    aliases = ['server']
4849
4768
 
4909
4828
 
4910
4829
 
4911
4830
class cmd_join(Command):
4912
 
    __doc__ = """Combine a tree into its containing tree.
 
4831
    """Combine a tree into its containing tree.
4913
4832
 
4914
4833
    This command requires the target tree to be in a rich-root format.
4915
4834
 
4955
4874
 
4956
4875
 
4957
4876
class cmd_split(Command):
4958
 
    __doc__ = """Split a subdirectory of a tree into a separate tree.
 
4877
    """Split a subdirectory of a tree into a separate tree.
4959
4878
 
4960
4879
    This command will produce a target tree in a format that supports
4961
4880
    rich roots, like 'rich-root' or 'rich-root-pack'.  These formats cannot be
4981
4900
 
4982
4901
 
4983
4902
class cmd_merge_directive(Command):
4984
 
    __doc__ = """Generate a merge directive for auto-merge tools.
 
4903
    """Generate a merge directive for auto-merge tools.
4985
4904
 
4986
4905
    A directive requests a merge to be performed, and also provides all the
4987
4906
    information necessary to do so.  This means it must either include a
5080
4999
 
5081
5000
 
5082
5001
class cmd_send(Command):
5083
 
    __doc__ = """Mail or create a merge-directive for submitting changes.
 
5002
    """Mail or create a merge-directive for submitting changes.
5084
5003
 
5085
5004
    A merge directive provides many things needed for requesting merges:
5086
5005
 
5168
5087
               short_name='f',
5169
5088
               type=unicode),
5170
5089
        Option('output', short_name='o',
5171
 
               help='Write merge directive to this file or directory; '
 
5090
               help='Write merge directive to this file; '
5172
5091
                    'use - for stdout.',
5173
5092
               type=unicode),
5174
5093
        Option('strict',
5197
5116
 
5198
5117
 
5199
5118
class cmd_bundle_revisions(cmd_send):
5200
 
    __doc__ = """Create a merge-directive for submitting changes.
 
5119
    """Create a merge-directive for submitting changes.
5201
5120
 
5202
5121
    A merge directive provides many things needed for requesting merges:
5203
5122
 
5270
5189
 
5271
5190
 
5272
5191
class cmd_tag(Command):
5273
 
    __doc__ = """Create, remove or modify a tag naming a revision.
 
5192
    """Create, remove or modify a tag naming a revision.
5274
5193
 
5275
5194
    Tags give human-meaningful names to revisions.  Commands that take a -r
5276
5195
    (--revision) option can be given -rtag:X, where X is any previously
5284
5203
 
5285
5204
    To rename a tag (change the name but keep it on the same revsion), run ``bzr
5286
5205
    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
5206
    """
5293
5207
 
5294
5208
    _see_also = ['commit', 'tags']
5295
 
    takes_args = ['tag_name?']
 
5209
    takes_args = ['tag_name']
5296
5210
    takes_options = [
5297
5211
        Option('delete',
5298
5212
            help='Delete this tag rather than placing it.',
5308
5222
        'revision',
5309
5223
        ]
5310
5224
 
5311
 
    def run(self, tag_name=None,
 
5225
    def run(self, tag_name,
5312
5226
            delete=None,
5313
5227
            directory='.',
5314
5228
            force=None,
5315
5229
            revision=None,
5316
5230
            ):
5317
5231
        branch, relpath = Branch.open_containing(directory)
5318
 
        self.add_cleanup(branch.lock_write().unlock)
 
5232
        branch.lock_write()
 
5233
        self.add_cleanup(branch.unlock)
5319
5234
        if delete:
5320
 
            if tag_name is None:
5321
 
                raise errors.BzrCommandError("No tag specified to delete.")
5322
5235
            branch.tags.delete_tag(tag_name)
5323
5236
            self.outf.write('Deleted tag %s.\n' % tag_name)
5324
5237
        else:
5330
5243
                revision_id = revision[0].as_revision_id(branch)
5331
5244
            else:
5332
5245
                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
5246
            if (not force) and branch.tags.has_tag(tag_name):
5339
5247
                raise errors.TagAlreadyExists(tag_name)
5340
5248
            branch.tags.set_tag(tag_name, revision_id)
5342
5250
 
5343
5251
 
5344
5252
class cmd_tags(Command):
5345
 
    __doc__ = """List tags.
 
5253
    """List tags.
5346
5254
 
5347
5255
    This command shows a table of tag names and the revisions they reference.
5348
5256
    """
5376
5284
        if not tags:
5377
5285
            return
5378
5286
 
5379
 
        self.add_cleanup(branch.lock_read().unlock)
 
5287
        branch.lock_read()
 
5288
        self.add_cleanup(branch.unlock)
5380
5289
        if revision:
5381
5290
            graph = branch.repository.get_graph()
5382
5291
            rev1, rev2 = _get_revision_range(revision, branch, self.name())
5415
5324
 
5416
5325
 
5417
5326
class cmd_reconfigure(Command):
5418
 
    __doc__ = """Reconfigure the type of a bzr directory.
 
5327
    """Reconfigure the type of a bzr directory.
5419
5328
 
5420
5329
    A target configuration must be specified.
5421
5330
 
5506
5415
 
5507
5416
 
5508
5417
class cmd_switch(Command):
5509
 
    __doc__ = """Set the branch of a checkout and update.
 
5418
    """Set the branch of a checkout and update.
5510
5419
 
5511
5420
    For lightweight checkouts, this changes the branch being referenced.
5512
5421
    For heavyweight checkouts, this checks that there are no local commits
5602
5511
 
5603
5512
 
5604
5513
class cmd_view(Command):
5605
 
    __doc__ = """Manage filtered views.
 
5514
    """Manage filtered views.
5606
5515
 
5607
5516
    Views provide a mask over the tree so that users can focus on
5608
5517
    a subset of a tree when doing their work. After creating a view,
5756
5665
 
5757
5666
 
5758
5667
class cmd_hooks(Command):
5759
 
    __doc__ = """Show hooks."""
 
5668
    """Show hooks."""
5760
5669
 
5761
5670
    hidden = True
5762
5671
 
5775
5684
                    self.outf.write("    <no hooks installed>\n")
5776
5685
 
5777
5686
 
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
5687
class cmd_shelve(Command):
5804
 
    __doc__ = """Temporarily set aside some changes from the current tree.
 
5688
    """Temporarily set aside some changes from the current tree.
5805
5689
 
5806
5690
    Shelve allows you to temporarily put changes you've made "on the shelf",
5807
5691
    ie. out of the way, until a later time when you can bring them back from
5860
5744
 
5861
5745
    def run_for_list(self):
5862
5746
        tree = WorkingTree.open_containing('.')[0]
5863
 
        self.add_cleanup(tree.lock_read().unlock)
 
5747
        tree.lock_read()
 
5748
        self.add_cleanup(tree.unlock)
5864
5749
        manager = tree.get_shelf_manager()
5865
5750
        shelves = manager.active_shelves()
5866
5751
        if len(shelves) == 0:
5875
5760
 
5876
5761
 
5877
5762
class cmd_unshelve(Command):
5878
 
    __doc__ = """Restore shelved changes.
 
5763
    """Restore shelved changes.
5879
5764
 
5880
5765
    By default, the most recently shelved changes are restored. However if you
5881
5766
    specify a shelf by id those changes will be restored instead.  This works
5907
5792
 
5908
5793
 
5909
5794
class cmd_clean_tree(Command):
5910
 
    __doc__ = """Remove unwanted files from working tree.
 
5795
    """Remove unwanted files from working tree.
5911
5796
 
5912
5797
    By default, only unknown files, not ignored files, are deleted.  Versioned
5913
5798
    files are never deleted.
5941
5826
 
5942
5827
 
5943
5828
class cmd_reference(Command):
5944
 
    __doc__ = """list, view and set branch locations for nested trees.
 
5829
    """list, view and set branch locations for nested trees.
5945
5830
 
5946
5831
    If no arguments are provided, lists the branch locations for nested trees.
5947
5832
    If one argument is provided, display the branch location for that tree.
5987
5872
            self.outf.write('%s %s\n' % (path, location))
5988
5873
 
5989
5874
 
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)
 
5875
# these get imported and then picked up by the scan for cmd_*
 
5876
# TODO: Some more consistent way to split command definitions across files;
 
5877
# we do need to load at least some information about them to know of
 
5878
# aliases.  ideally we would avoid loading the implementation until the
 
5879
# details were needed.
 
5880
from bzrlib.cmd_version_info import cmd_version_info
 
5881
from bzrlib.conflicts import cmd_resolve, cmd_conflicts, restore
 
5882
from bzrlib.bundle.commands import (
 
5883
    cmd_bundle_info,
 
5884
    )
 
5885
from bzrlib.foreign import cmd_dpush
 
5886
from bzrlib.sign_my_commits import cmd_sign_my_commits
 
5887
from bzrlib.weave_commands import cmd_versionedfile_list, \
 
5888
        cmd_weave_plan_merge, cmd_weave_merge_text