/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/builtins.py

``.bazaar``, ``.bazaar/bazaar.conf`` and ``.bzr.log`` inherit user and group ownership from the containing directory. This allow bzr to work better with sudo.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/builtins.py
60
60
from bzrlib.workingtree import WorkingTree
61
61
""")
62
62
 
63
 
from bzrlib.commands import (
64
 
    Command,
65
 
    builtin_command_registry,
66
 
    display_command,
67
 
    )
 
63
from bzrlib.commands import Command, display_command
68
64
from bzrlib.option import (
69
65
    ListOption,
70
66
    Option,
232
228
    return view_info
233
229
 
234
230
 
235
 
def _open_directory_or_containing_tree_or_branch(filename, directory):
236
 
    """Open the tree or branch containing the specified file, unless
237
 
    the --directory option is used to specify a different branch."""
238
 
    if directory is not None:
239
 
        return (None, Branch.open(directory), filename)
240
 
    return bzrdir.BzrDir.open_containing_tree_or_branch(filename)
241
 
 
242
 
 
243
231
# TODO: Make sure no commands unconditionally use the working directory as a
244
232
# branch.  If a filename argument is used, the first of them should be used to
245
233
# specify the branch.  (Perhaps this can be factored out into some kind of
247
235
# opens the branch?)
248
236
 
249
237
class cmd_status(Command):
250
 
    __doc__ = """Display status summary.
 
238
    """Display status summary.
251
239
 
252
240
    This reports on versioned and unknown files, reporting them
253
241
    grouped by state.  Possible states are:
340
328
 
341
329
 
342
330
class cmd_cat_revision(Command):
343
 
    __doc__ = """Write out metadata for a revision.
 
331
    """Write out metadata for a revision.
344
332
 
345
333
    The revision to print can either be specified by a specific
346
334
    revision identifier, or you can use --revision.
348
336
 
349
337
    hidden = True
350
338
    takes_args = ['revision_id?']
351
 
    takes_options = ['directory', 'revision']
 
339
    takes_options = ['revision']
352
340
    # cat-revision is more for frontends so should be exact
353
341
    encoding = 'strict'
354
342
 
361
349
        self.outf.write(revtext.decode('utf-8'))
362
350
 
363
351
    @display_command
364
 
    def run(self, revision_id=None, revision=None, directory=u'.'):
 
352
    def run(self, revision_id=None, revision=None):
365
353
        if revision_id is not None and revision is not None:
366
354
            raise errors.BzrCommandError('You can only supply one of'
367
355
                                         ' revision_id or --revision')
368
356
        if revision_id is None and revision is None:
369
357
            raise errors.BzrCommandError('You must supply either'
370
358
                                         ' --revision or a revision_id')
371
 
        b = WorkingTree.open_containing(directory)[0].branch
 
359
        b = WorkingTree.open_containing(u'.')[0].branch
372
360
 
373
361
        revisions = b.repository.revisions
374
362
        if revisions is None:
398
386
        
399
387
 
400
388
class cmd_dump_btree(Command):
401
 
    __doc__ = """Dump the contents of a btree index file to stdout.
 
389
    """Dump the contents of a btree index file to stdout.
402
390
 
403
391
    PATH is a btree index file, it can be any URL. This includes things like
404
392
    .bzr/repository/pack-names, or .bzr/repository/indices/a34b3a...ca4a4.iix
479
467
 
480
468
 
481
469
class cmd_remove_tree(Command):
482
 
    __doc__ = """Remove the working tree from a given branch/checkout.
 
470
    """Remove the working tree from a given branch/checkout.
483
471
 
484
472
    Since a lightweight checkout is little more than a working tree
485
473
    this will refuse to run against one.
512
500
                if (working.has_changes()):
513
501
                    raise errors.UncommittedChanges(working)
514
502
 
515
 
            if working.user_url != working.branch.user_url:
 
503
            working_path = working.bzrdir.root_transport.base
 
504
            branch_path = working.branch.bzrdir.root_transport.base
 
505
            if working_path != branch_path:
516
506
                raise errors.BzrCommandError("You cannot remove the working tree"
517
507
                                             " from a lightweight checkout")
518
508
 
520
510
 
521
511
 
522
512
class cmd_revno(Command):
523
 
    __doc__ = """Show current revision number.
 
513
    """Show current revision number.
524
514
 
525
515
    This is equal to the number of revisions on this branch.
526
516
    """
536
526
        if tree:
537
527
            try:
538
528
                wt = WorkingTree.open_containing(location)[0]
539
 
                self.add_cleanup(wt.lock_read().unlock)
 
529
                wt.lock_read()
540
530
            except (errors.NoWorkingTree, errors.NotLocalUrl):
541
531
                raise errors.NoWorkingTree(location)
 
532
            self.add_cleanup(wt.unlock)
542
533
            revid = wt.last_revision()
543
534
            try:
544
535
                revno_t = wt.branch.revision_id_to_dotted_revno(revid)
547
538
            revno = ".".join(str(n) for n in revno_t)
548
539
        else:
549
540
            b = Branch.open_containing(location)[0]
550
 
            self.add_cleanup(b.lock_read().unlock)
 
541
            b.lock_read()
 
542
            self.add_cleanup(b.unlock)
551
543
            revno = b.revno()
552
544
        self.cleanup_now()
553
545
        self.outf.write(str(revno) + '\n')
554
546
 
555
547
 
556
548
class cmd_revision_info(Command):
557
 
    __doc__ = """Show revision number and revision id for a given revision identifier.
 
549
    """Show revision number and revision id for a given revision identifier.
558
550
    """
559
551
    hidden = True
560
552
    takes_args = ['revision_info*']
561
553
    takes_options = [
562
554
        'revision',
563
 
        custom_help('directory',
 
555
        Option('directory',
564
556
            help='Branch to examine, '
565
 
                 'rather than the one containing the working directory.'),
 
557
                 'rather than the one containing the working directory.',
 
558
            short_name='d',
 
559
            type=unicode,
 
560
            ),
566
561
        Option('tree', help='Show revno of working tree'),
567
562
        ]
568
563
 
573
568
        try:
574
569
            wt = WorkingTree.open_containing(directory)[0]
575
570
            b = wt.branch
576
 
            self.add_cleanup(wt.lock_read().unlock)
 
571
            wt.lock_read()
 
572
            self.add_cleanup(wt.unlock)
577
573
        except (errors.NoWorkingTree, errors.NotLocalUrl):
578
574
            wt = None
579
575
            b = Branch.open_containing(directory)[0]
580
 
            self.add_cleanup(b.lock_read().unlock)
 
576
            b.lock_read()
 
577
            self.add_cleanup(b.unlock)
581
578
        revision_ids = []
582
579
        if revision is not None:
583
580
            revision_ids.extend(rev.as_revision_id(b) for rev in revision)
611
608
 
612
609
 
613
610
class cmd_add(Command):
614
 
    __doc__ = """Add specified files or directories.
 
611
    """Add specified files or directories.
615
612
 
616
613
    In non-recursive mode, all the named items are added, regardless
617
614
    of whether they were previously ignored.  A warning is given if
682
679
                should_print=(not is_quiet()))
683
680
 
684
681
        if base_tree:
685
 
            self.add_cleanup(base_tree.lock_read().unlock)
 
682
            base_tree.lock_read()
 
683
            self.add_cleanup(base_tree.unlock)
686
684
        tree, file_list = tree_files_for_add(file_list)
687
685
        added, ignored = tree.smart_add(file_list, not
688
686
            no_recurse, action=action, save=not dry_run)
696
694
 
697
695
 
698
696
class cmd_mkdir(Command):
699
 
    __doc__ = """Create a new versioned directory.
 
697
    """Create a new versioned directory.
700
698
 
701
699
    This is equivalent to creating the directory and then adding it.
702
700
    """
718
716
 
719
717
 
720
718
class cmd_relpath(Command):
721
 
    __doc__ = """Show path of a file relative to root"""
 
719
    """Show path of a file relative to root"""
722
720
 
723
721
    takes_args = ['filename']
724
722
    hidden = True
733
731
 
734
732
 
735
733
class cmd_inventory(Command):
736
 
    __doc__ = """Show inventory of the current working copy or a revision.
 
734
    """Show inventory of the current working copy or a revision.
737
735
 
738
736
    It is possible to limit the output to a particular entry
739
737
    type using the --kind option.  For example: --kind file.
760
758
 
761
759
        revision = _get_one_revision('inventory', revision)
762
760
        work_tree, file_list = tree_files(file_list)
763
 
        self.add_cleanup(work_tree.lock_read().unlock)
 
761
        work_tree.lock_read()
 
762
        self.add_cleanup(work_tree.unlock)
764
763
        if revision is not None:
765
764
            tree = revision.as_tree(work_tree.branch)
766
765
 
767
766
            extra_trees = [work_tree]
768
 
            self.add_cleanup(tree.lock_read().unlock)
 
767
            tree.lock_read()
 
768
            self.add_cleanup(tree.unlock)
769
769
        else:
770
770
            tree = work_tree
771
771
            extra_trees = []
792
792
 
793
793
 
794
794
class cmd_mv(Command):
795
 
    __doc__ = """Move or rename a file.
 
795
    """Move or rename a file.
796
796
 
797
797
    :Usage:
798
798
        bzr mv OLDNAME NEWNAME
831
831
        if len(names_list) < 2:
832
832
            raise errors.BzrCommandError("missing file argument")
833
833
        tree, rel_names = tree_files(names_list, canonicalize=False)
834
 
        self.add_cleanup(tree.lock_tree_write().unlock)
 
834
        tree.lock_tree_write()
 
835
        self.add_cleanup(tree.unlock)
835
836
        self._run(tree, names_list, rel_names, after)
836
837
 
837
838
    def run_auto(self, names_list, after, dry_run):
842
843
            raise errors.BzrCommandError('--after cannot be specified with'
843
844
                                         ' --auto.')
844
845
        work_tree, file_list = tree_files(names_list, default_branch='.')
845
 
        self.add_cleanup(work_tree.lock_tree_write().unlock)
 
846
        work_tree.lock_tree_write()
 
847
        self.add_cleanup(work_tree.unlock)
846
848
        rename_map.RenameMap.guess_renames(work_tree, dry_run)
847
849
 
848
850
    def _run(self, tree, names_list, rel_names, after):
927
929
 
928
930
 
929
931
class cmd_pull(Command):
930
 
    __doc__ = """Turn this branch into a mirror of another branch.
 
932
    """Turn this branch into a mirror of another branch.
931
933
 
932
934
    By default, this command only works on branches that have not diverged.
933
935
    Branches are considered diverged if the destination branch's most recent 
956
958
    takes_options = ['remember', 'overwrite', 'revision',
957
959
        custom_help('verbose',
958
960
            help='Show logs of pulled revisions.'),
959
 
        custom_help('directory',
 
961
        Option('directory',
960
962
            help='Branch to pull into, '
961
 
                 'rather than the one containing the working directory.'),
 
963
                 'rather than the one containing the working directory.',
 
964
            short_name='d',
 
965
            type=unicode,
 
966
            ),
962
967
        Option('local',
963
968
            help="Perform a local pull in a bound "
964
969
                 "branch.  Local pulls are not applied to "
979
984
        try:
980
985
            tree_to = WorkingTree.open_containing(directory)[0]
981
986
            branch_to = tree_to.branch
982
 
            self.add_cleanup(tree_to.lock_write().unlock)
983
987
        except errors.NoWorkingTree:
984
988
            tree_to = None
985
989
            branch_to = Branch.open_containing(directory)[0]
986
 
            self.add_cleanup(branch_to.lock_write().unlock)
987
 
 
 
990
        
988
991
        if local and not branch_to.get_bound_location():
989
992
            raise errors.LocalRequiresBoundBranch()
990
993
 
1020
1023
        else:
1021
1024
            branch_from = Branch.open(location,
1022
1025
                possible_transports=possible_transports)
1023
 
            self.add_cleanup(branch_from.lock_read().unlock)
1024
1026
 
1025
1027
            if branch_to.get_parent() is None or remember:
1026
1028
                branch_to.set_parent(branch_from.base)
1027
1029
 
 
1030
        if branch_from is not branch_to:
 
1031
            branch_from.lock_read()
 
1032
            self.add_cleanup(branch_from.unlock)
1028
1033
        if revision is not None:
1029
1034
            revision_id = revision.as_revision_id(branch_from)
1030
1035
 
 
1036
        branch_to.lock_write()
 
1037
        self.add_cleanup(branch_to.unlock)
1031
1038
        if tree_to is not None:
1032
1039
            view_info = _get_view_info_for_change_reporter(tree_to)
1033
1040
            change_reporter = delta._ChangeReporter(
1048
1055
 
1049
1056
 
1050
1057
class cmd_push(Command):
1051
 
    __doc__ = """Update a mirror of this branch.
 
1058
    """Update a mirror of this branch.
1052
1059
 
1053
1060
    The target branch will not have its working tree populated because this
1054
1061
    is both expensive, and is not supported on remote file systems.
1078
1085
        Option('create-prefix',
1079
1086
               help='Create the path leading up to the branch '
1080
1087
                    'if it does not already exist.'),
1081
 
        custom_help('directory',
 
1088
        Option('directory',
1082
1089
            help='Branch to push from, '
1083
 
                 'rather than the one containing the working directory.'),
 
1090
                 'rather than the one containing the working directory.',
 
1091
            short_name='d',
 
1092
            type=unicode,
 
1093
            ),
1084
1094
        Option('use-existing-dir',
1085
1095
               help='By default push will fail if the target'
1086
1096
                    ' directory exists, but does not already'
1112
1122
        # Get the source branch
1113
1123
        (tree, br_from,
1114
1124
         _unused) = bzrdir.BzrDir.open_containing_tree_or_branch(directory)
 
1125
        if strict is None:
 
1126
            strict = br_from.get_config().get_user_option_as_bool('push_strict')
 
1127
        if strict is None: strict = True # default value
1115
1128
        # Get the tip's revision_id
1116
1129
        revision = _get_one_revision('push', revision)
1117
1130
        if revision is not None:
1118
1131
            revision_id = revision.in_history(br_from).rev_id
1119
1132
        else:
1120
1133
            revision_id = None
1121
 
        if tree is not None and revision_id is None:
1122
 
            tree.check_changed_or_out_of_date(
1123
 
                strict, 'push_strict',
1124
 
                more_error='Use --no-strict to force the push.',
1125
 
                more_warning='Uncommitted changes will not be pushed.')
 
1134
        if strict and tree is not None and revision_id is None:
 
1135
            if (tree.has_changes()):
 
1136
                raise errors.UncommittedChanges(
 
1137
                    tree, more='Use --no-strict to force the push.')
 
1138
            if tree.last_revision() != tree.branch.last_revision():
 
1139
                # The tree has lost sync with its branch, there is little
 
1140
                # chance that the user is aware of it but he can still force
 
1141
                # the push with --no-strict
 
1142
                raise errors.OutOfDateTree(
 
1143
                    tree, more='Use --no-strict to force the push.')
 
1144
 
1126
1145
        # Get the stacked_on branch, if any
1127
1146
        if stacked_on is not None:
1128
1147
            stacked_on = urlutils.normalize_url(stacked_on)
1160
1179
 
1161
1180
 
1162
1181
class cmd_branch(Command):
1163
 
    __doc__ = """Create a new branch that is a copy of an existing branch.
 
1182
    """Create a new branch that is a copy of an existing branch.
1164
1183
 
1165
1184
    If the TO_LOCATION is omitted, the last component of the FROM_LOCATION will
1166
1185
    be used.  In other words, "branch ../foo/bar" will attempt to create ./bar.
1206
1225
        accelerator_tree, br_from = bzrdir.BzrDir.open_tree_or_branch(
1207
1226
            from_location)
1208
1227
        revision = _get_one_revision('branch', revision)
1209
 
        self.add_cleanup(br_from.lock_read().unlock)
 
1228
        br_from.lock_read()
 
1229
        self.add_cleanup(br_from.unlock)
1210
1230
        if revision is not None:
1211
1231
            revision_id = revision.as_revision_id(br_from)
1212
1232
        else:
1272
1292
 
1273
1293
 
1274
1294
class cmd_checkout(Command):
1275
 
    __doc__ = """Create a new checkout of an existing branch.
 
1295
    """Create a new checkout of an existing branch.
1276
1296
 
1277
1297
    If BRANCH_LOCATION is omitted, checkout will reconstitute a working tree for
1278
1298
    the branch found in '.'. This is useful if you have removed the working tree
1336
1356
            except errors.NoWorkingTree:
1337
1357
                source.bzrdir.create_workingtree(revision_id)
1338
1358
                return
1339
 
 
1340
 
        if not lightweight:
1341
 
            message = ('Copying history to "%s". '
1342
 
                'To checkout without local history use --lightweight.' % to_location)
1343
 
            ui.ui_factory.show_message(message)
1344
1359
        source.create_checkout(to_location, revision_id, lightweight,
1345
1360
                               accelerator_tree, hardlink)
1346
1361
 
1347
1362
 
1348
1363
class cmd_renames(Command):
1349
 
    __doc__ = """Show list of renamed files.
 
1364
    """Show list of renamed files.
1350
1365
    """
1351
1366
    # TODO: Option to show renames between two historical versions.
1352
1367
 
1357
1372
    @display_command
1358
1373
    def run(self, dir=u'.'):
1359
1374
        tree = WorkingTree.open_containing(dir)[0]
1360
 
        self.add_cleanup(tree.lock_read().unlock)
 
1375
        tree.lock_read()
 
1376
        self.add_cleanup(tree.unlock)
1361
1377
        new_inv = tree.inventory
1362
1378
        old_tree = tree.basis_tree()
1363
 
        self.add_cleanup(old_tree.lock_read().unlock)
 
1379
        old_tree.lock_read()
 
1380
        self.add_cleanup(old_tree.unlock)
1364
1381
        old_inv = old_tree.inventory
1365
1382
        renames = []
1366
1383
        iterator = tree.iter_changes(old_tree, include_unchanged=True)
1376
1393
 
1377
1394
 
1378
1395
class cmd_update(Command):
1379
 
    __doc__ = """Update a tree to have the latest code committed to its branch.
 
1396
    """Update a tree to have the latest code committed to its branch.
1380
1397
 
1381
1398
    This will perform a merge into the working tree, and may generate
1382
1399
    conflicts. If you have any local changes, you will still
1404
1421
        master = branch.get_master_branch(
1405
1422
            possible_transports=possible_transports)
1406
1423
        if master is not None:
 
1424
            tree.lock_write()
1407
1425
            branch_location = master.base
1408
 
            tree.lock_write()
1409
1426
        else:
 
1427
            tree.lock_tree_write()
1410
1428
            branch_location = tree.branch.base
1411
 
            tree.lock_tree_write()
1412
1429
        self.add_cleanup(tree.unlock)
1413
1430
        # get rid of the final '/' and be ready for display
1414
 
        branch_location = urlutils.unescape_for_display(
1415
 
            branch_location.rstrip('/'),
1416
 
            self.outf.encoding)
 
1431
        branch_location = urlutils.unescape_for_display(branch_location[:-1],
 
1432
                                                        self.outf.encoding)
1417
1433
        existing_pending_merges = tree.get_parent_ids()[1:]
1418
1434
        if master is None:
1419
1435
            old_tip = None
1427
1443
        else:
1428
1444
            revision_id = branch.last_revision()
1429
1445
        if revision_id == _mod_revision.ensure_null(tree.last_revision()):
1430
 
            revno = branch.revision_id_to_dotted_revno(revision_id)
1431
 
            note("Tree is up to date at revision %s of branch %s" %
1432
 
                ('.'.join(map(str, revno)), branch_location))
 
1446
            revno = branch.revision_id_to_revno(revision_id)
 
1447
            note("Tree is up to date at revision %d of branch %s" %
 
1448
                (revno, branch_location))
1433
1449
            return 0
1434
1450
        view_info = _get_view_info_for_change_reporter(tree)
1435
1451
        change_reporter = delta._ChangeReporter(
1447
1463
                                  "bzr update --revision only works"
1448
1464
                                  " for a revision in the branch history"
1449
1465
                                  % (e.revision))
1450
 
        revno = tree.branch.revision_id_to_dotted_revno(
 
1466
        revno = tree.branch.revision_id_to_revno(
1451
1467
            _mod_revision.ensure_null(tree.last_revision()))
1452
 
        note('Updated to revision %s of branch %s' %
1453
 
             ('.'.join(map(str, revno)), branch_location))
1454
 
        parent_ids = tree.get_parent_ids()
1455
 
        if parent_ids[1:] and parent_ids[1:] != existing_pending_merges:
 
1468
        note('Updated to revision %d of branch %s' %
 
1469
             (revno, branch_location))
 
1470
        if tree.get_parent_ids()[1:] != existing_pending_merges:
1456
1471
            note('Your local commits will now show as pending merges with '
1457
1472
                 "'bzr status', and can be committed with 'bzr commit'.")
1458
1473
        if conflicts != 0:
1462
1477
 
1463
1478
 
1464
1479
class cmd_info(Command):
1465
 
    __doc__ = """Show information about a working tree, branch or repository.
 
1480
    """Show information about a working tree, branch or repository.
1466
1481
 
1467
1482
    This command will show all known locations and formats associated to the
1468
1483
    tree, branch or repository.
1506
1521
 
1507
1522
 
1508
1523
class cmd_remove(Command):
1509
 
    __doc__ = """Remove files or directories.
 
1524
    """Remove files or directories.
1510
1525
 
1511
1526
    This makes bzr stop tracking changes to the specified files. bzr will delete
1512
1527
    them if they can easily be recovered using revert. If no options or
1534
1549
        if file_list is not None:
1535
1550
            file_list = [f for f in file_list]
1536
1551
 
1537
 
        self.add_cleanup(tree.lock_write().unlock)
 
1552
        tree.lock_write()
 
1553
        self.add_cleanup(tree.unlock)
1538
1554
        # Heuristics should probably all move into tree.remove_smart or
1539
1555
        # some such?
1540
1556
        if new:
1559
1575
 
1560
1576
 
1561
1577
class cmd_file_id(Command):
1562
 
    __doc__ = """Print file_id of a particular file or directory.
 
1578
    """Print file_id of a particular file or directory.
1563
1579
 
1564
1580
    The file_id is assigned when the file is first added and remains the
1565
1581
    same through all revisions where the file exists, even when it is
1581
1597
 
1582
1598
 
1583
1599
class cmd_file_path(Command):
1584
 
    __doc__ = """Print path of file_ids to a file or directory.
 
1600
    """Print path of file_ids to a file or directory.
1585
1601
 
1586
1602
    This prints one line for each directory down to the target,
1587
1603
    starting at the branch root.
1603
1619
 
1604
1620
 
1605
1621
class cmd_reconcile(Command):
1606
 
    __doc__ = """Reconcile bzr metadata in a branch.
 
1622
    """Reconcile bzr metadata in a branch.
1607
1623
 
1608
1624
    This can correct data mismatches that may have been caused by
1609
1625
    previous ghost operations or bzr upgrades. You should only
1631
1647
 
1632
1648
 
1633
1649
class cmd_revision_history(Command):
1634
 
    __doc__ = """Display the list of revision ids on a branch."""
 
1650
    """Display the list of revision ids on a branch."""
1635
1651
 
1636
1652
    _see_also = ['log']
1637
1653
    takes_args = ['location?']
1647
1663
 
1648
1664
 
1649
1665
class cmd_ancestry(Command):
1650
 
    __doc__ = """List all revisions merged into this branch."""
 
1666
    """List all revisions merged into this branch."""
1651
1667
 
1652
1668
    _see_also = ['log', 'revision-history']
1653
1669
    takes_args = ['location?']
1672
1688
 
1673
1689
 
1674
1690
class cmd_init(Command):
1675
 
    __doc__ = """Make a directory into a versioned branch.
 
1691
    """Make a directory into a versioned branch.
1676
1692
 
1677
1693
    Use this to create an empty branch, or before importing an
1678
1694
    existing project.
1781
1797
 
1782
1798
 
1783
1799
class cmd_init_repository(Command):
1784
 
    __doc__ = """Create a shared repository for branches to share storage space.
 
1800
    """Create a shared repository for branches to share storage space.
1785
1801
 
1786
1802
    New branches created under the repository directory will store their
1787
1803
    revisions in the repository, not in the branch directory.  For branches
1841
1857
 
1842
1858
 
1843
1859
class cmd_diff(Command):
1844
 
    __doc__ = """Show differences in the working tree, between revisions or branches.
 
1860
    """Show differences in the working tree, between revisions or branches.
1845
1861
 
1846
1862
    If no arguments are given, all changes for the current tree are listed.
1847
1863
    If files are given, only the changes in those files are listed.
1933
1949
            help='Use this command to compare files.',
1934
1950
            type=unicode,
1935
1951
            ),
1936
 
        RegistryOption('format',
1937
 
            help='Diff format to use.',
1938
 
            lazy_registry=('bzrlib.diff', 'format_registry'),
1939
 
            value_switches=False, title='Diff format'),
1940
1952
        ]
1941
1953
    aliases = ['di', 'dif']
1942
1954
    encoding_type = 'exact'
1943
1955
 
1944
1956
    @display_command
1945
1957
    def run(self, revision=None, file_list=None, diff_options=None,
1946
 
            prefix=None, old=None, new=None, using=None, format=None):
1947
 
        from bzrlib.diff import (get_trees_and_branches_to_diff_locked,
1948
 
            show_diff_trees)
 
1958
            prefix=None, old=None, new=None, using=None):
 
1959
        from bzrlib.diff import get_trees_and_branches_to_diff, show_diff_trees
1949
1960
 
1950
1961
        if (prefix is None) or (prefix == '0'):
1951
1962
            # diff -p0 format
1965
1976
            raise errors.BzrCommandError('bzr diff --revision takes exactly'
1966
1977
                                         ' one or two revision specifiers')
1967
1978
 
1968
 
        if using is not None and format is not None:
1969
 
            raise errors.BzrCommandError('--using and --format are mutually '
1970
 
                'exclusive.')
1971
 
 
1972
1979
        (old_tree, new_tree,
1973
1980
         old_branch, new_branch,
1974
 
         specific_files, extra_trees) = get_trees_and_branches_to_diff_locked(
1975
 
            file_list, revision, old, new, self.add_cleanup, apply_view=True)
 
1981
         specific_files, extra_trees) = get_trees_and_branches_to_diff(
 
1982
            file_list, revision, old, new, apply_view=True)
1976
1983
        return show_diff_trees(old_tree, new_tree, sys.stdout,
1977
1984
                               specific_files=specific_files,
1978
1985
                               external_diff_options=diff_options,
1979
1986
                               old_label=old_label, new_label=new_label,
1980
 
                               extra_trees=extra_trees, using=using,
1981
 
                               format_cls=format)
 
1987
                               extra_trees=extra_trees, using=using)
1982
1988
 
1983
1989
 
1984
1990
class cmd_deleted(Command):
1985
 
    __doc__ = """List files deleted in the working tree.
 
1991
    """List files deleted in the working tree.
1986
1992
    """
1987
1993
    # TODO: Show files deleted since a previous revision, or
1988
1994
    # between two revisions.
1991
1997
    # level of effort but possibly much less IO.  (Or possibly not,
1992
1998
    # if the directories are very large...)
1993
1999
    _see_also = ['status', 'ls']
1994
 
    takes_options = ['directory', 'show-ids']
 
2000
    takes_options = ['show-ids']
1995
2001
 
1996
2002
    @display_command
1997
 
    def run(self, show_ids=False, directory=u'.'):
1998
 
        tree = WorkingTree.open_containing(directory)[0]
1999
 
        self.add_cleanup(tree.lock_read().unlock)
 
2003
    def run(self, show_ids=False):
 
2004
        tree = WorkingTree.open_containing(u'.')[0]
 
2005
        tree.lock_read()
 
2006
        self.add_cleanup(tree.unlock)
2000
2007
        old = tree.basis_tree()
2001
 
        self.add_cleanup(old.lock_read().unlock)
 
2008
        old.lock_read()
 
2009
        self.add_cleanup(old.unlock)
2002
2010
        for path, ie in old.inventory.iter_entries():
2003
2011
            if not tree.has_id(ie.file_id):
2004
2012
                self.outf.write(path)
2009
2017
 
2010
2018
 
2011
2019
class cmd_modified(Command):
2012
 
    __doc__ = """List files modified in working tree.
 
2020
    """List files modified in working tree.
2013
2021
    """
2014
2022
 
2015
2023
    hidden = True
2016
2024
    _see_also = ['status', 'ls']
2017
 
    takes_options = ['directory', 'null']
 
2025
    takes_options = [
 
2026
            Option('null',
 
2027
                   help='Write an ascii NUL (\\0) separator '
 
2028
                   'between files rather than a newline.')
 
2029
            ]
2018
2030
 
2019
2031
    @display_command
2020
 
    def run(self, null=False, directory=u'.'):
2021
 
        tree = WorkingTree.open_containing(directory)[0]
 
2032
    def run(self, null=False):
 
2033
        tree = WorkingTree.open_containing(u'.')[0]
2022
2034
        td = tree.changes_from(tree.basis_tree())
2023
2035
        for path, id, kind, text_modified, meta_modified in td.modified:
2024
2036
            if null:
2028
2040
 
2029
2041
 
2030
2042
class cmd_added(Command):
2031
 
    __doc__ = """List files added in working tree.
 
2043
    """List files added in working tree.
2032
2044
    """
2033
2045
 
2034
2046
    hidden = True
2035
2047
    _see_also = ['status', 'ls']
2036
 
    takes_options = ['directory', 'null']
 
2048
    takes_options = [
 
2049
            Option('null',
 
2050
                   help='Write an ascii NUL (\\0) separator '
 
2051
                   'between files rather than a newline.')
 
2052
            ]
2037
2053
 
2038
2054
    @display_command
2039
 
    def run(self, null=False, directory=u'.'):
2040
 
        wt = WorkingTree.open_containing(directory)[0]
2041
 
        self.add_cleanup(wt.lock_read().unlock)
 
2055
    def run(self, null=False):
 
2056
        wt = WorkingTree.open_containing(u'.')[0]
 
2057
        wt.lock_read()
 
2058
        self.add_cleanup(wt.unlock)
2042
2059
        basis = wt.basis_tree()
2043
 
        self.add_cleanup(basis.lock_read().unlock)
 
2060
        basis.lock_read()
 
2061
        self.add_cleanup(basis.unlock)
2044
2062
        basis_inv = basis.inventory
2045
2063
        inv = wt.inventory
2046
2064
        for file_id in inv:
2049
2067
            if inv.is_root(file_id) and len(basis_inv) == 0:
2050
2068
                continue
2051
2069
            path = inv.id2path(file_id)
2052
 
            if not os.access(osutils.pathjoin(wt.basedir, path), os.F_OK):
 
2070
            if not os.access(osutils.abspath(path), os.F_OK):
2053
2071
                continue
2054
2072
            if null:
2055
2073
                self.outf.write(path + '\0')
2058
2076
 
2059
2077
 
2060
2078
class cmd_root(Command):
2061
 
    __doc__ = """Show the tree root directory.
 
2079
    """Show the tree root directory.
2062
2080
 
2063
2081
    The root is the nearest enclosing directory with a .bzr control
2064
2082
    directory."""
2088
2106
 
2089
2107
 
2090
2108
class cmd_log(Command):
2091
 
    __doc__ = """Show historical log for a branch or subset of a branch.
 
2109
    """Show historical log for a branch or subset of a branch.
2092
2110
 
2093
2111
    log is bzr's default tool for exploring the history of a branch.
2094
2112
    The branch to use is taken from the first parameter. If no parameters
2255
2273
                   help='Show just the specified revision.'
2256
2274
                   ' See also "help revisionspec".'),
2257
2275
            'log-format',
2258
 
            RegistryOption('authors',
2259
 
                'What names to list as authors - first, all or committer.',
2260
 
                title='Authors',
2261
 
                lazy_registry=('bzrlib.log', 'author_list_registry'),
2262
 
            ),
2263
2276
            Option('levels',
2264
2277
                   short_name='n',
2265
2278
                   help='Number of levels to display - 0 for all, 1 for flat.',
2280
2293
                   help='Show changes made in each revision as a patch.'),
2281
2294
            Option('include-merges',
2282
2295
                   help='Show merged revisions like --levels 0 does.'),
2283
 
            Option('exclude-common-ancestry',
2284
 
                   help='Display only the revisions that are not part'
2285
 
                   ' of both ancestries (require -rX..Y)'
2286
 
                   )
2287
2296
            ]
2288
2297
    encoding_type = 'replace'
2289
2298
 
2299
2308
            message=None,
2300
2309
            limit=None,
2301
2310
            show_diff=False,
2302
 
            include_merges=False,
2303
 
            authors=None,
2304
 
            exclude_common_ancestry=False,
2305
 
            ):
 
2311
            include_merges=False):
2306
2312
        from bzrlib.log import (
2307
2313
            Logger,
2308
2314
            make_log_request_dict,
2309
2315
            _get_info_for_log_files,
2310
2316
            )
2311
2317
        direction = (forward and 'forward') or 'reverse'
2312
 
        if (exclude_common_ancestry
2313
 
            and (revision is None or len(revision) != 2)):
2314
 
            raise errors.BzrCommandError(
2315
 
                '--exclude-common-ancestry requires -r with two revisions')
2316
2318
        if include_merges:
2317
2319
            if levels is None:
2318
2320
                levels = 0
2334
2336
        if file_list:
2335
2337
            # find the file ids to log and check for directory filtering
2336
2338
            b, file_info_list, rev1, rev2 = _get_info_for_log_files(
2337
 
                revision, file_list, self.add_cleanup)
 
2339
                revision, file_list)
 
2340
            self.add_cleanup(b.unlock)
2338
2341
            for relpath, file_id, kind in file_info_list:
2339
2342
                if file_id is None:
2340
2343
                    raise errors.BzrCommandError(
2358
2361
                location = '.'
2359
2362
            dir, relpath = bzrdir.BzrDir.open_containing(location)
2360
2363
            b = dir.open_branch()
2361
 
            self.add_cleanup(b.lock_read().unlock)
 
2364
            b.lock_read()
 
2365
            self.add_cleanup(b.unlock)
2362
2366
            rev1, rev2 = _get_revision_range(revision, b, self.name())
2363
2367
 
2364
2368
        # Decide on the type of delta & diff filtering to use
2384
2388
                        show_timezone=timezone,
2385
2389
                        delta_format=get_verbosity_level(),
2386
2390
                        levels=levels,
2387
 
                        show_advice=levels is None,
2388
 
                        author_list_handler=authors)
 
2391
                        show_advice=levels is None)
2389
2392
 
2390
2393
        # Choose the algorithm for doing the logging. It's annoying
2391
2394
        # having multiple code paths like this but necessary until
2410
2413
            direction=direction, specific_fileids=file_ids,
2411
2414
            start_revision=rev1, end_revision=rev2, limit=limit,
2412
2415
            message_search=message, delta_type=delta_type,
2413
 
            diff_type=diff_type, _match_using_deltas=match_using_deltas,
2414
 
            exclude_common_ancestry=exclude_common_ancestry,
2415
 
            )
 
2416
            diff_type=diff_type, _match_using_deltas=match_using_deltas)
2416
2417
        Logger(b, rqst).show(lf)
2417
2418
 
2418
2419
 
2437
2438
            raise errors.BzrCommandError(
2438
2439
                "bzr %s doesn't accept two revisions in different"
2439
2440
                " branches." % command_name)
2440
 
        if start_spec.spec is None:
2441
 
            # Avoid loading all the history.
2442
 
            rev1 = RevisionInfo(branch, None, None)
2443
 
        else:
2444
 
            rev1 = start_spec.in_history(branch)
 
2441
        rev1 = start_spec.in_history(branch)
2445
2442
        # Avoid loading all of history when we know a missing
2446
2443
        # end of range means the last revision ...
2447
2444
        if end_spec.spec is None:
2476
2473
 
2477
2474
 
2478
2475
class cmd_touching_revisions(Command):
2479
 
    __doc__ = """Return revision-ids which affected a particular file.
 
2476
    """Return revision-ids which affected a particular file.
2480
2477
 
2481
2478
    A more user-friendly interface is "bzr log FILE".
2482
2479
    """
2489
2486
        tree, relpath = WorkingTree.open_containing(filename)
2490
2487
        file_id = tree.path2id(relpath)
2491
2488
        b = tree.branch
2492
 
        self.add_cleanup(b.lock_read().unlock)
 
2489
        b.lock_read()
 
2490
        self.add_cleanup(b.unlock)
2493
2491
        touching_revs = log.find_touching_revisions(b, file_id)
2494
2492
        for revno, revision_id, what in touching_revs:
2495
2493
            self.outf.write("%6d %s\n" % (revno, what))
2496
2494
 
2497
2495
 
2498
2496
class cmd_ls(Command):
2499
 
    __doc__ = """List files in a tree.
 
2497
    """List files in a tree.
2500
2498
    """
2501
2499
 
2502
2500
    _see_also = ['status', 'cat']
2508
2506
                   help='Recurse into subdirectories.'),
2509
2507
            Option('from-root',
2510
2508
                   help='Print paths relative to the root of the branch.'),
2511
 
            Option('unknown', short_name='u',
2512
 
                help='Print unknown files.'),
 
2509
            Option('unknown', help='Print unknown files.'),
2513
2510
            Option('versioned', help='Print versioned files.',
2514
2511
                   short_name='V'),
2515
 
            Option('ignored', short_name='i',
2516
 
                help='Print ignored files.'),
2517
 
            Option('kind', short_name='k',
 
2512
            Option('ignored', help='Print ignored files.'),
 
2513
            Option('null',
 
2514
                   help='Write an ascii NUL (\\0) separator '
 
2515
                   'between files rather than a newline.'),
 
2516
            Option('kind',
2518
2517
                   help='List entries of a particular kind: file, directory, symlink.',
2519
2518
                   type=unicode),
2520
 
            'null',
2521
2519
            'show-ids',
2522
 
            'directory',
2523
2520
            ]
2524
2521
    @display_command
2525
2522
    def run(self, revision=None, verbose=False,
2526
2523
            recursive=False, from_root=False,
2527
2524
            unknown=False, versioned=False, ignored=False,
2528
 
            null=False, kind=None, show_ids=False, path=None, directory=None):
 
2525
            null=False, kind=None, show_ids=False, path=None):
2529
2526
 
2530
2527
        if kind and kind not in ('file', 'directory', 'symlink'):
2531
2528
            raise errors.BzrCommandError('invalid kind specified')
2543
2540
                raise errors.BzrCommandError('cannot specify both --from-root'
2544
2541
                                             ' and PATH')
2545
2542
            fs_path = path
2546
 
        tree, branch, relpath = \
2547
 
            _open_directory_or_containing_tree_or_branch(fs_path, directory)
 
2543
        tree, branch, relpath = bzrdir.BzrDir.open_containing_tree_or_branch(
 
2544
            fs_path)
2548
2545
 
2549
2546
        # Calculate the prefix to use
2550
2547
        prefix = None
2565
2562
                view_str = views.view_display_str(view_files)
2566
2563
                note("Ignoring files outside view. View is %s" % view_str)
2567
2564
 
2568
 
        self.add_cleanup(tree.lock_read().unlock)
 
2565
        tree.lock_read()
 
2566
        self.add_cleanup(tree.unlock)
2569
2567
        for fp, fc, fkind, fid, entry in tree.list_files(include_root=False,
2570
2568
            from_dir=relpath, recursive=recursive):
2571
2569
            # Apply additional masking
2613
2611
 
2614
2612
 
2615
2613
class cmd_unknowns(Command):
2616
 
    __doc__ = """List unknown files.
 
2614
    """List unknown files.
2617
2615
    """
2618
2616
 
2619
2617
    hidden = True
2620
2618
    _see_also = ['ls']
2621
 
    takes_options = ['directory']
2622
2619
 
2623
2620
    @display_command
2624
 
    def run(self, directory=u'.'):
2625
 
        for f in WorkingTree.open_containing(directory)[0].unknowns():
 
2621
    def run(self):
 
2622
        for f in WorkingTree.open_containing(u'.')[0].unknowns():
2626
2623
            self.outf.write(osutils.quotefn(f) + '\n')
2627
2624
 
2628
2625
 
2629
2626
class cmd_ignore(Command):
2630
 
    __doc__ = """Ignore specified files or patterns.
 
2627
    """Ignore specified files or patterns.
2631
2628
 
2632
2629
    See ``bzr help patterns`` for details on the syntax of patterns.
2633
2630
 
2642
2639
    using this command or directly by using an editor, be sure to commit
2643
2640
    it.
2644
2641
    
2645
 
    Bazaar also supports a global ignore file ~/.bazaar/ignore. On Windows
2646
 
    the global ignore file can be found in the application data directory as
2647
 
    C:\\Documents and Settings\\<user>\\Application Data\\Bazaar\\2.0\\ignore.
2648
 
    Global ignores are not touched by this command. The global ignore file
2649
 
    can be edited directly using an editor.
2650
 
 
2651
2642
    Patterns prefixed with '!' are exceptions to ignore patterns and take
2652
2643
    precedence over regular ignores.  Such exceptions are used to specify
2653
2644
    files that should be versioned which would otherwise be ignored.
2693
2684
 
2694
2685
    _see_also = ['status', 'ignored', 'patterns']
2695
2686
    takes_args = ['name_pattern*']
2696
 
    takes_options = ['directory',
2697
 
        Option('default-rules',
2698
 
               help='Display the default ignore rules that bzr uses.')
 
2687
    takes_options = [
 
2688
        Option('old-default-rules',
 
2689
               help='Write out the ignore rules bzr < 0.9 always used.')
2699
2690
        ]
2700
2691
 
2701
 
    def run(self, name_pattern_list=None, default_rules=None,
2702
 
            directory=u'.'):
 
2692
    def run(self, name_pattern_list=None, old_default_rules=None):
2703
2693
        from bzrlib import ignores
2704
 
        if default_rules is not None:
2705
 
            # dump the default rules and exit
2706
 
            for pattern in ignores.USER_DEFAULTS:
 
2694
        if old_default_rules is not None:
 
2695
            # dump the rules and exit
 
2696
            for pattern in ignores.OLD_DEFAULTS:
2707
2697
                self.outf.write("%s\n" % pattern)
2708
2698
            return
2709
2699
        if not name_pattern_list:
2710
2700
            raise errors.BzrCommandError("ignore requires at least one "
2711
 
                "NAME_PATTERN or --default-rules.")
 
2701
                                  "NAME_PATTERN or --old-default-rules")
2712
2702
        name_pattern_list = [globbing.normalize_pattern(p)
2713
2703
                             for p in name_pattern_list]
2714
2704
        for name_pattern in name_pattern_list:
2716
2706
                (len(name_pattern) > 1 and name_pattern[1] == ':')):
2717
2707
                raise errors.BzrCommandError(
2718
2708
                    "NAME_PATTERN should not be an absolute path")
2719
 
        tree, relpath = WorkingTree.open_containing(directory)
 
2709
        tree, relpath = WorkingTree.open_containing(u'.')
2720
2710
        ignores.tree_ignores_add_patterns(tree, name_pattern_list)
2721
2711
        ignored = globbing.Globster(name_pattern_list)
2722
2712
        matches = []
2736
2726
 
2737
2727
 
2738
2728
class cmd_ignored(Command):
2739
 
    __doc__ = """List ignored files and the patterns that matched them.
 
2729
    """List ignored files and the patterns that matched them.
2740
2730
 
2741
2731
    List all the ignored files and the ignore pattern that caused the file to
2742
2732
    be ignored.
2748
2738
 
2749
2739
    encoding_type = 'replace'
2750
2740
    _see_also = ['ignore', 'ls']
2751
 
    takes_options = ['directory']
2752
2741
 
2753
2742
    @display_command
2754
 
    def run(self, directory=u'.'):
2755
 
        tree = WorkingTree.open_containing(directory)[0]
2756
 
        self.add_cleanup(tree.lock_read().unlock)
 
2743
    def run(self):
 
2744
        tree = WorkingTree.open_containing(u'.')[0]
 
2745
        tree.lock_read()
 
2746
        self.add_cleanup(tree.unlock)
2757
2747
        for path, file_class, kind, file_id, entry in tree.list_files():
2758
2748
            if file_class != 'I':
2759
2749
                continue
2763
2753
 
2764
2754
 
2765
2755
class cmd_lookup_revision(Command):
2766
 
    __doc__ = """Lookup the revision-id from a revision-number
 
2756
    """Lookup the revision-id from a revision-number
2767
2757
 
2768
2758
    :Examples:
2769
2759
        bzr lookup-revision 33
2770
2760
    """
2771
2761
    hidden = True
2772
2762
    takes_args = ['revno']
2773
 
    takes_options = ['directory']
2774
2763
 
2775
2764
    @display_command
2776
 
    def run(self, revno, directory=u'.'):
 
2765
    def run(self, revno):
2777
2766
        try:
2778
2767
            revno = int(revno)
2779
2768
        except ValueError:
2780
2769
            raise errors.BzrCommandError("not a valid revision-number: %r"
2781
2770
                                         % revno)
2782
 
        revid = WorkingTree.open_containing(directory)[0].branch.get_rev_id(revno)
 
2771
        revid = WorkingTree.open_containing(u'.')[0].branch.get_rev_id(revno)
2783
2772
        self.outf.write("%s\n" % revid)
2784
2773
 
2785
2774
 
2786
2775
class cmd_export(Command):
2787
 
    __doc__ = """Export current or past revision to a destination directory or archive.
 
2776
    """Export current or past revision to a destination directory or archive.
2788
2777
 
2789
2778
    If no revision is specified this exports the last committed revision.
2790
2779
 
2812
2801
      =================       =========================
2813
2802
    """
2814
2803
    takes_args = ['dest', 'branch_or_subdir?']
2815
 
    takes_options = ['directory',
 
2804
    takes_options = [
2816
2805
        Option('format',
2817
2806
               help="Type of file to export to.",
2818
2807
               type=unicode),
2827
2816
                    'revision in which it was changed.'),
2828
2817
        ]
2829
2818
    def run(self, dest, branch_or_subdir=None, revision=None, format=None,
2830
 
        root=None, filters=False, per_file_timestamps=False, directory=u'.'):
 
2819
        root=None, filters=False, per_file_timestamps=False):
2831
2820
        from bzrlib.export import export
2832
2821
 
2833
2822
        if branch_or_subdir is None:
2834
 
            tree = WorkingTree.open_containing(directory)[0]
 
2823
            tree = WorkingTree.open_containing(u'.')[0]
2835
2824
            b = tree.branch
2836
2825
            subdir = None
2837
2826
        else:
2847
2836
 
2848
2837
 
2849
2838
class cmd_cat(Command):
2850
 
    __doc__ = """Write the contents of a file as of a given revision to standard output.
 
2839
    """Write the contents of a file as of a given revision to standard output.
2851
2840
 
2852
2841
    If no revision is nominated, the last revision is used.
2853
2842
 
2856
2845
    """
2857
2846
 
2858
2847
    _see_also = ['ls']
2859
 
    takes_options = ['directory',
 
2848
    takes_options = [
2860
2849
        Option('name-from-revision', help='The path name in the old tree.'),
2861
2850
        Option('filters', help='Apply content filters to display the '
2862
2851
                'convenience form.'),
2867
2856
 
2868
2857
    @display_command
2869
2858
    def run(self, filename, revision=None, name_from_revision=False,
2870
 
            filters=False, directory=None):
 
2859
            filters=False):
2871
2860
        if revision is not None and len(revision) != 1:
2872
2861
            raise errors.BzrCommandError("bzr cat --revision takes exactly"
2873
2862
                                         " one revision specifier")
2874
2863
        tree, branch, relpath = \
2875
 
            _open_directory_or_containing_tree_or_branch(filename, directory)
2876
 
        self.add_cleanup(branch.lock_read().unlock)
 
2864
            bzrdir.BzrDir.open_containing_tree_or_branch(filename)
 
2865
        branch.lock_read()
 
2866
        self.add_cleanup(branch.unlock)
2877
2867
        return self._run(tree, branch, relpath, filename, revision,
2878
2868
                         name_from_revision, filters)
2879
2869
 
2882
2872
        if tree is None:
2883
2873
            tree = b.basis_tree()
2884
2874
        rev_tree = _get_one_revision_tree('cat', revision, branch=b)
2885
 
        self.add_cleanup(rev_tree.lock_read().unlock)
 
2875
        rev_tree.lock_read()
 
2876
        self.add_cleanup(rev_tree.unlock)
2886
2877
 
2887
2878
        old_file_id = rev_tree.path2id(relpath)
2888
2879
 
2931
2922
 
2932
2923
 
2933
2924
class cmd_local_time_offset(Command):
2934
 
    __doc__ = """Show the offset in seconds from GMT to local time."""
 
2925
    """Show the offset in seconds from GMT to local time."""
2935
2926
    hidden = True
2936
2927
    @display_command
2937
2928
    def run(self):
2940
2931
 
2941
2932
 
2942
2933
class cmd_commit(Command):
2943
 
    __doc__ = """Commit changes into a new revision.
 
2934
    """Commit changes into a new revision.
2944
2935
 
2945
2936
    An explanatory message needs to be given for each commit. This is
2946
2937
    often done by using the --message option (getting the message from the
3054
3045
                         "the master branch until a normal commit "
3055
3046
                         "is performed."
3056
3047
                    ),
3057
 
             Option('show-diff', short_name='p',
 
3048
             Option('show-diff',
3058
3049
                    help='When no message is supplied, show the diff along'
3059
3050
                    ' with the status summary in the message editor.'),
3060
3051
             ]
3140
3131
                    '(use --file "%(f)s" to take commit message from that file)'
3141
3132
                    % { 'f': message })
3142
3133
                ui.ui_factory.show_warning(warning_msg)
3143
 
            if '\r' in message:
3144
 
                message = message.replace('\r\n', '\n')
3145
 
                message = message.replace('\r', '\n')
3146
 
            if file:
3147
 
                raise errors.BzrCommandError(
3148
 
                    "please specify either --message or --file")
3149
3134
 
3150
3135
        def get_message(commit_obj):
3151
3136
            """Callback to get commit message"""
3152
 
            if file:
3153
 
                my_message = codecs.open(
3154
 
                    file, 'rt', osutils.get_user_encoding()).read()
3155
 
            elif message is not None:
3156
 
                my_message = message
3157
 
            else:
3158
 
                # No message supplied: make one up.
3159
 
                # text is the status of the tree
3160
 
                text = make_commit_message_template_encoded(tree,
 
3137
            my_message = message
 
3138
            if my_message is not None and '\r' in my_message:
 
3139
                my_message = my_message.replace('\r\n', '\n')
 
3140
                my_message = my_message.replace('\r', '\n')
 
3141
            if my_message is None and not file:
 
3142
                t = make_commit_message_template_encoded(tree,
3161
3143
                        selected_list, diff=show_diff,
3162
3144
                        output_encoding=osutils.get_user_encoding())
3163
 
                # start_message is the template generated from hooks
3164
 
                # XXX: Warning - looks like hooks return unicode,
3165
 
                # make_commit_message_template_encoded returns user encoding.
3166
 
                # We probably want to be using edit_commit_message instead to
3167
 
                # avoid this.
3168
3145
                start_message = generate_commit_message_template(commit_obj)
3169
 
                my_message = edit_commit_message_encoded(text,
 
3146
                my_message = edit_commit_message_encoded(t,
3170
3147
                    start_message=start_message)
3171
3148
                if my_message is None:
3172
3149
                    raise errors.BzrCommandError("please specify a commit"
3173
3150
                        " message with either --message or --file")
 
3151
            elif my_message and file:
 
3152
                raise errors.BzrCommandError(
 
3153
                    "please specify either --message or --file")
 
3154
            if file:
 
3155
                my_message = codecs.open(file, 'rt',
 
3156
                                         osutils.get_user_encoding()).read()
3174
3157
            if my_message == "":
3175
3158
                raise errors.BzrCommandError("empty commit message specified")
3176
3159
            return my_message
3188
3171
                        timezone=offset,
3189
3172
                        exclude=safe_relpath_files(tree, exclude))
3190
3173
        except PointlessCommit:
 
3174
            # FIXME: This should really happen before the file is read in;
 
3175
            # perhaps prepare the commit; get the message; then actually commit
3191
3176
            raise errors.BzrCommandError("No changes to commit."
3192
3177
                              " Use --unchanged to commit anyhow.")
3193
3178
        except ConflictsInTree:
3206
3191
 
3207
3192
 
3208
3193
class cmd_check(Command):
3209
 
    __doc__ = """Validate working tree structure, branch consistency and repository history.
 
3194
    """Validate working tree structure, branch consistency and repository history.
3210
3195
 
3211
3196
    This command checks various invariants about branch and repository storage
3212
3197
    to detect data corruption or bzr bugs.
3276
3261
 
3277
3262
 
3278
3263
class cmd_upgrade(Command):
3279
 
    __doc__ = """Upgrade branch storage to current format.
 
3264
    """Upgrade branch storage to current format.
3280
3265
 
3281
3266
    The check command or bzr developers may sometimes advise you to run
3282
3267
    this command. When the default format has changed you may also be warned
3300
3285
 
3301
3286
 
3302
3287
class cmd_whoami(Command):
3303
 
    __doc__ = """Show or set bzr user id.
 
3288
    """Show or set bzr user id.
3304
3289
 
3305
3290
    :Examples:
3306
3291
        Show the email of the current user::
3350
3335
 
3351
3336
 
3352
3337
class cmd_nick(Command):
3353
 
    __doc__ = """Print or set the branch nickname.
 
3338
    """Print or set the branch nickname.
3354
3339
 
3355
3340
    If unset, the tree root directory name is used as the nickname.
3356
3341
    To print the current nickname, execute with no argument.
3361
3346
 
3362
3347
    _see_also = ['info']
3363
3348
    takes_args = ['nickname?']
3364
 
    takes_options = ['directory']
3365
 
    def run(self, nickname=None, directory=u'.'):
3366
 
        branch = Branch.open_containing(directory)[0]
 
3349
    def run(self, nickname=None):
 
3350
        branch = Branch.open_containing(u'.')[0]
3367
3351
        if nickname is None:
3368
3352
            self.printme(branch)
3369
3353
        else:
3375
3359
 
3376
3360
 
3377
3361
class cmd_alias(Command):
3378
 
    __doc__ = """Set/unset and display aliases.
 
3362
    """Set/unset and display aliases.
3379
3363
 
3380
3364
    :Examples:
3381
3365
        Show the current aliases::
3445
3429
 
3446
3430
 
3447
3431
class cmd_selftest(Command):
3448
 
    __doc__ = """Run internal test suite.
 
3432
    """Run internal test suite.
3449
3433
 
3450
3434
    If arguments are given, they are regular expressions that say which tests
3451
3435
    should run.  Tests matching any expression are run, and other tests are
3592
3576
                raise errors.BzrCommandError("subunit not available. subunit "
3593
3577
                    "needs to be installed to use --subunit.")
3594
3578
            self.additional_selftest_args['runner_class'] = SubUnitBzrRunner
3595
 
            # On Windows, disable automatic conversion of '\n' to '\r\n' in
3596
 
            # stdout, which would corrupt the subunit stream. 
3597
 
            if sys.platform == "win32" and sys.stdout.fileno() >= 0:
3598
 
                import msvcrt
3599
 
                msvcrt.setmode(sys.stdout.fileno(), os.O_BINARY)
3600
3579
        if parallel:
3601
3580
            self.additional_selftest_args.setdefault(
3602
3581
                'suite_decorators', []).append(parallel)
3633
3612
 
3634
3613
 
3635
3614
class cmd_version(Command):
3636
 
    __doc__ = """Show version of bzr."""
 
3615
    """Show version of bzr."""
3637
3616
 
3638
3617
    encoding_type = 'replace'
3639
3618
    takes_options = [
3650
3629
 
3651
3630
 
3652
3631
class cmd_rocks(Command):
3653
 
    __doc__ = """Statement of optimism."""
 
3632
    """Statement of optimism."""
3654
3633
 
3655
3634
    hidden = True
3656
3635
 
3660
3639
 
3661
3640
 
3662
3641
class cmd_find_merge_base(Command):
3663
 
    __doc__ = """Find and print a base revision for merging two branches."""
 
3642
    """Find and print a base revision for merging two branches."""
3664
3643
    # TODO: Options to specify revisions on either side, as if
3665
3644
    #       merging only part of the history.
3666
3645
    takes_args = ['branch', 'other']
3672
3651
 
3673
3652
        branch1 = Branch.open_containing(branch)[0]
3674
3653
        branch2 = Branch.open_containing(other)[0]
3675
 
        self.add_cleanup(branch1.lock_read().unlock)
3676
 
        self.add_cleanup(branch2.lock_read().unlock)
 
3654
        branch1.lock_read()
 
3655
        self.add_cleanup(branch1.unlock)
 
3656
        branch2.lock_read()
 
3657
        self.add_cleanup(branch2.unlock)
3677
3658
        last1 = ensure_null(branch1.last_revision())
3678
3659
        last2 = ensure_null(branch2.last_revision())
3679
3660
 
3684
3665
 
3685
3666
 
3686
3667
class cmd_merge(Command):
3687
 
    __doc__ = """Perform a three-way merge.
 
3668
    """Perform a three-way merge.
3688
3669
 
3689
3670
    The source of the merge can be specified either in the form of a branch,
3690
3671
    or in the form of a path to a file containing a merge directive generated
3773
3754
                ' completely merged into the source, pull from the'
3774
3755
                ' source rather than merging.  When this happens,'
3775
3756
                ' you do not need to commit the result.'),
3776
 
        custom_help('directory',
 
3757
        Option('directory',
3777
3758
               help='Branch to merge into, '
3778
 
                    'rather than the one containing the working directory.'),
 
3759
                    'rather than the one containing the working directory.',
 
3760
               short_name='d',
 
3761
               type=unicode,
 
3762
               ),
3779
3763
        Option('preview', help='Instead of merging, show a diff of the'
3780
3764
               ' merge.'),
3781
3765
        Option('interactive', help='Select changes interactively.',
3814
3798
            unversioned_filter=tree.is_ignored, view_info=view_info)
3815
3799
        pb = ui.ui_factory.nested_progress_bar()
3816
3800
        self.add_cleanup(pb.finished)
3817
 
        self.add_cleanup(tree.lock_write().unlock)
 
3801
        tree.lock_write()
 
3802
        self.add_cleanup(tree.unlock)
3818
3803
        if location is not None:
3819
3804
            try:
3820
3805
                mergeable = bundle.read_mergeable_from_url(location,
4041
4026
 
4042
4027
 
4043
4028
class cmd_remerge(Command):
4044
 
    __doc__ = """Redo a merge.
 
4029
    """Redo a merge.
4045
4030
 
4046
4031
    Use this if you want to try a different merge technique while resolving
4047
4032
    conflicts.  Some merge techniques are better than others, and remerge
4072
4057
 
4073
4058
    def run(self, file_list=None, merge_type=None, show_base=False,
4074
4059
            reprocess=False):
4075
 
        from bzrlib.conflicts import restore
4076
4060
        if merge_type is None:
4077
4061
            merge_type = _mod_merge.Merge3Merger
4078
4062
        tree, file_list = tree_files(file_list)
4079
 
        self.add_cleanup(tree.lock_write().unlock)
 
4063
        tree.lock_write()
 
4064
        self.add_cleanup(tree.unlock)
4080
4065
        parents = tree.get_parent_ids()
4081
4066
        if len(parents) != 2:
4082
4067
            raise errors.BzrCommandError("Sorry, remerge only works after normal"
4135
4120
 
4136
4121
 
4137
4122
class cmd_revert(Command):
4138
 
    __doc__ = """Revert files to a previous revision.
 
4123
    """Revert files to a previous revision.
4139
4124
 
4140
4125
    Giving a list of files will revert only those files.  Otherwise, all files
4141
4126
    will be reverted.  If the revision is not specified with '--revision', the
4192
4177
    def run(self, revision=None, no_backup=False, file_list=None,
4193
4178
            forget_merges=None):
4194
4179
        tree, file_list = tree_files(file_list)
4195
 
        self.add_cleanup(tree.lock_tree_write().unlock)
 
4180
        tree.lock_write()
 
4181
        self.add_cleanup(tree.unlock)
4196
4182
        if forget_merges:
4197
4183
            tree.set_parent_ids(tree.get_parent_ids()[:1])
4198
4184
        else:
4206
4192
 
4207
4193
 
4208
4194
class cmd_assert_fail(Command):
4209
 
    __doc__ = """Test reporting of assertion failures"""
 
4195
    """Test reporting of assertion failures"""
4210
4196
    # intended just for use in testing
4211
4197
 
4212
4198
    hidden = True
4216
4202
 
4217
4203
 
4218
4204
class cmd_help(Command):
4219
 
    __doc__ = """Show help on a command or other topic.
 
4205
    """Show help on a command or other topic.
4220
4206
    """
4221
4207
 
4222
4208
    _see_also = ['topics']
4235
4221
 
4236
4222
 
4237
4223
class cmd_shell_complete(Command):
4238
 
    __doc__ = """Show appropriate completions for context.
 
4224
    """Show appropriate completions for context.
4239
4225
 
4240
4226
    For a list of all available commands, say 'bzr shell-complete'.
4241
4227
    """
4250
4236
 
4251
4237
 
4252
4238
class cmd_missing(Command):
4253
 
    __doc__ = """Show unmerged/unpulled revisions between two branches.
 
4239
    """Show unmerged/unpulled revisions between two branches.
4254
4240
 
4255
4241
    OTHER_BRANCH may be local or remote.
4256
4242
 
4334
4320
            restrict = 'remote'
4335
4321
 
4336
4322
        local_branch = Branch.open_containing(u".")[0]
4337
 
        self.add_cleanup(local_branch.lock_read().unlock)
4338
 
 
4339
4323
        parent = local_branch.get_parent()
4340
4324
        if other_branch is None:
4341
4325
            other_branch = parent
4350
4334
        remote_branch = Branch.open(other_branch)
4351
4335
        if remote_branch.base == local_branch.base:
4352
4336
            remote_branch = local_branch
4353
 
        else:
4354
 
            self.add_cleanup(remote_branch.lock_read().unlock)
4355
4337
 
 
4338
        local_branch.lock_read()
 
4339
        self.add_cleanup(local_branch.unlock)
4356
4340
        local_revid_range = _revision_range_to_revid_range(
4357
4341
            _get_revision_range(my_revision, local_branch,
4358
4342
                self.name()))
4359
4343
 
 
4344
        remote_branch.lock_read()
 
4345
        self.add_cleanup(remote_branch.unlock)
4360
4346
        remote_revid_range = _revision_range_to_revid_range(
4361
4347
            _get_revision_range(revision,
4362
4348
                remote_branch, self.name()))
4412
4398
            message("Branches are up to date.\n")
4413
4399
        self.cleanup_now()
4414
4400
        if not status_code and parent is None and other_branch is not None:
4415
 
            self.add_cleanup(local_branch.lock_write().unlock)
 
4401
            local_branch.lock_write()
 
4402
            self.add_cleanup(local_branch.unlock)
4416
4403
            # handle race conditions - a parent might be set while we run.
4417
4404
            if local_branch.get_parent() is None:
4418
4405
                local_branch.set_parent(remote_branch.base)
4420
4407
 
4421
4408
 
4422
4409
class cmd_pack(Command):
4423
 
    __doc__ = """Compress the data within a repository.
4424
 
 
4425
 
    This operation compresses the data within a bazaar repository. As
4426
 
    bazaar supports automatic packing of repository, this operation is
4427
 
    normally not required to be done manually.
4428
 
 
4429
 
    During the pack operation, bazaar takes a backup of existing repository
4430
 
    data, i.e. pack files. This backup is eventually removed by bazaar
4431
 
    automatically when it is safe to do so. To save disk space by removing
4432
 
    the backed up pack files, the --clean-obsolete-packs option may be
4433
 
    used.
4434
 
 
4435
 
    Warning: If you use --clean-obsolete-packs and your machine crashes
4436
 
    during or immediately after repacking, you may be left with a state
4437
 
    where the deletion has been written to disk but the new packs have not
4438
 
    been. In this case the repository may be unusable.
4439
 
    """
 
4410
    """Compress the data within a repository."""
4440
4411
 
4441
4412
    _see_also = ['repositories']
4442
4413
    takes_args = ['branch_or_repo?']
4443
 
    takes_options = [
4444
 
        Option('clean-obsolete-packs', 'Delete obsolete packs to save disk space.'),
4445
 
        ]
4446
4414
 
4447
 
    def run(self, branch_or_repo='.', clean_obsolete_packs=False):
 
4415
    def run(self, branch_or_repo='.'):
4448
4416
        dir = bzrdir.BzrDir.open_containing(branch_or_repo)[0]
4449
4417
        try:
4450
4418
            branch = dir.open_branch()
4451
4419
            repository = branch.repository
4452
4420
        except errors.NotBranchError:
4453
4421
            repository = dir.open_repository()
4454
 
        repository.pack(clean_obsolete_packs=clean_obsolete_packs)
 
4422
        repository.pack()
4455
4423
 
4456
4424
 
4457
4425
class cmd_plugins(Command):
4458
 
    __doc__ = """List the installed plugins.
 
4426
    """List the installed plugins.
4459
4427
 
4460
4428
    This command displays the list of installed plugins including
4461
4429
    version of plugin and a short description of each.
4500
4468
 
4501
4469
 
4502
4470
class cmd_testament(Command):
4503
 
    __doc__ = """Show testament (signing-form) of a revision."""
 
4471
    """Show testament (signing-form) of a revision."""
4504
4472
    takes_options = [
4505
4473
            'revision',
4506
4474
            Option('long', help='Produce long-format testament.'),
4518
4486
            b = Branch.open_containing(branch)[0]
4519
4487
        else:
4520
4488
            b = Branch.open(branch)
4521
 
        self.add_cleanup(b.lock_read().unlock)
 
4489
        b.lock_read()
 
4490
        self.add_cleanup(b.unlock)
4522
4491
        if revision is None:
4523
4492
            rev_id = b.last_revision()
4524
4493
        else:
4531
4500
 
4532
4501
 
4533
4502
class cmd_annotate(Command):
4534
 
    __doc__ = """Show the origin of each line in a file.
 
4503
    """Show the origin of each line in a file.
4535
4504
 
4536
4505
    This prints out the given file with an annotation on the left side
4537
4506
    indicating which revision, author and date introduced the change.
4548
4517
                     Option('long', help='Show commit date in annotations.'),
4549
4518
                     'revision',
4550
4519
                     'show-ids',
4551
 
                     'directory',
4552
4520
                     ]
4553
4521
    encoding_type = 'exact'
4554
4522
 
4555
4523
    @display_command
4556
4524
    def run(self, filename, all=False, long=False, revision=None,
4557
 
            show_ids=False, directory=None):
 
4525
            show_ids=False):
4558
4526
        from bzrlib.annotate import annotate_file, annotate_file_tree
4559
4527
        wt, branch, relpath = \
4560
 
            _open_directory_or_containing_tree_or_branch(filename, directory)
 
4528
            bzrdir.BzrDir.open_containing_tree_or_branch(filename)
4561
4529
        if wt is not None:
4562
 
            self.add_cleanup(wt.lock_read().unlock)
 
4530
            wt.lock_read()
 
4531
            self.add_cleanup(wt.unlock)
4563
4532
        else:
4564
 
            self.add_cleanup(branch.lock_read().unlock)
 
4533
            branch.lock_read()
 
4534
            self.add_cleanup(branch.unlock)
4565
4535
        tree = _get_one_revision_tree('annotate', revision, branch=branch)
4566
 
        self.add_cleanup(tree.lock_read().unlock)
 
4536
        tree.lock_read()
 
4537
        self.add_cleanup(tree.unlock)
4567
4538
        if wt is not None:
4568
4539
            file_id = wt.path2id(relpath)
4569
4540
        else:
4582
4553
 
4583
4554
 
4584
4555
class cmd_re_sign(Command):
4585
 
    __doc__ = """Create a digital signature for an existing revision."""
 
4556
    """Create a digital signature for an existing revision."""
4586
4557
    # TODO be able to replace existing ones.
4587
4558
 
4588
4559
    hidden = True # is this right ?
4589
4560
    takes_args = ['revision_id*']
4590
 
    takes_options = ['directory', 'revision']
 
4561
    takes_options = ['revision']
4591
4562
 
4592
 
    def run(self, revision_id_list=None, revision=None, directory=u'.'):
 
4563
    def run(self, revision_id_list=None, revision=None):
4593
4564
        if revision_id_list is not None and revision is not None:
4594
4565
            raise errors.BzrCommandError('You can only supply one of revision_id or --revision')
4595
4566
        if revision_id_list is None and revision is None:
4596
4567
            raise errors.BzrCommandError('You must supply either --revision or a revision_id')
4597
 
        b = WorkingTree.open_containing(directory)[0].branch
4598
 
        self.add_cleanup(b.lock_write().unlock)
 
4568
        b = WorkingTree.open_containing(u'.')[0].branch
 
4569
        b.lock_write()
 
4570
        self.add_cleanup(b.unlock)
4599
4571
        return self._run(b, revision_id_list, revision)
4600
4572
 
4601
4573
    def _run(self, b, revision_id_list, revision):
4647
4619
 
4648
4620
 
4649
4621
class cmd_bind(Command):
4650
 
    __doc__ = """Convert the current branch into a checkout of the supplied branch.
4651
 
    If no branch is supplied, rebind to the last bound location.
 
4622
    """Convert the current branch into a checkout of the supplied branch.
4652
4623
 
4653
4624
    Once converted into a checkout, commits must succeed on the master branch
4654
4625
    before they will be applied to the local branch.
4660
4631
 
4661
4632
    _see_also = ['checkouts', 'unbind']
4662
4633
    takes_args = ['location?']
4663
 
    takes_options = ['directory']
 
4634
    takes_options = []
4664
4635
 
4665
 
    def run(self, location=None, directory=u'.'):
4666
 
        b, relpath = Branch.open_containing(directory)
 
4636
    def run(self, location=None):
 
4637
        b, relpath = Branch.open_containing(u'.')
4667
4638
        if location is None:
4668
4639
            try:
4669
4640
                location = b.get_old_bound_location()
4688
4659
 
4689
4660
 
4690
4661
class cmd_unbind(Command):
4691
 
    __doc__ = """Convert the current checkout into a regular branch.
 
4662
    """Convert the current checkout into a regular branch.
4692
4663
 
4693
4664
    After unbinding, the local branch is considered independent and subsequent
4694
4665
    commits will be local only.
4696
4667
 
4697
4668
    _see_also = ['checkouts', 'bind']
4698
4669
    takes_args = []
4699
 
    takes_options = ['directory']
 
4670
    takes_options = []
4700
4671
 
4701
 
    def run(self, directory=u'.'):
4702
 
        b, relpath = Branch.open_containing(directory)
 
4672
    def run(self):
 
4673
        b, relpath = Branch.open_containing(u'.')
4703
4674
        if not b.unbind():
4704
4675
            raise errors.BzrCommandError('Local branch is not bound')
4705
4676
 
4706
4677
 
4707
4678
class cmd_uncommit(Command):
4708
 
    __doc__ = """Remove the last committed revision.
 
4679
    """Remove the last committed revision.
4709
4680
 
4710
4681
    --verbose will print out what is being removed.
4711
4682
    --dry-run will go through all the motions, but not actually
4751
4722
            b = control.open_branch()
4752
4723
 
4753
4724
        if tree is not None:
4754
 
            self.add_cleanup(tree.lock_write().unlock)
 
4725
            tree.lock_write()
 
4726
            self.add_cleanup(tree.unlock)
4755
4727
        else:
4756
 
            self.add_cleanup(b.lock_write().unlock)
 
4728
            b.lock_write()
 
4729
            self.add_cleanup(b.unlock)
4757
4730
        return self._run(b, tree, dry_run, verbose, revision, force, local=local)
4758
4731
 
4759
4732
    def _run(self, b, tree, dry_run, verbose, revision, force, local=False):
4811
4784
 
4812
4785
 
4813
4786
class cmd_break_lock(Command):
4814
 
    __doc__ = """Break a dead lock on a repository, branch or working directory.
 
4787
    """Break a dead lock on a repository, branch or working directory.
4815
4788
 
4816
4789
    CAUTION: Locks should only be broken when you are sure that the process
4817
4790
    holding the lock has been stopped.
4836
4809
 
4837
4810
 
4838
4811
class cmd_wait_until_signalled(Command):
4839
 
    __doc__ = """Test helper for test_start_and_stop_bzr_subprocess_send_signal.
 
4812
    """Test helper for test_start_and_stop_bzr_subprocess_send_signal.
4840
4813
 
4841
4814
    This just prints a line to signal when it is ready, then blocks on stdin.
4842
4815
    """
4850
4823
 
4851
4824
 
4852
4825
class cmd_serve(Command):
4853
 
    __doc__ = """Run the bzr server."""
 
4826
    """Run the bzr server."""
4854
4827
 
4855
4828
    aliases = ['server']
4856
4829
 
4867
4840
                    'result in a dynamically allocated port.  The default port '
4868
4841
                    'depends on the protocol.',
4869
4842
               type=str),
4870
 
        custom_help('directory',
4871
 
               help='Serve contents of this directory.'),
 
4843
        Option('directory',
 
4844
               help='Serve contents of this directory.',
 
4845
               type=unicode),
4872
4846
        Option('allow-writes',
4873
4847
               help='By default the server is a readonly server.  Supplying '
4874
4848
                    '--allow-writes enables write access to the contents of '
4915
4889
 
4916
4890
 
4917
4891
class cmd_join(Command):
4918
 
    __doc__ = """Combine a tree into its containing tree.
 
4892
    """Combine a tree into its containing tree.
4919
4893
 
4920
4894
    This command requires the target tree to be in a rich-root format.
4921
4895
 
4961
4935
 
4962
4936
 
4963
4937
class cmd_split(Command):
4964
 
    __doc__ = """Split a subdirectory of a tree into a separate tree.
 
4938
    """Split a subdirectory of a tree into a separate tree.
4965
4939
 
4966
4940
    This command will produce a target tree in a format that supports
4967
4941
    rich roots, like 'rich-root' or 'rich-root-pack'.  These formats cannot be
4987
4961
 
4988
4962
 
4989
4963
class cmd_merge_directive(Command):
4990
 
    __doc__ = """Generate a merge directive for auto-merge tools.
 
4964
    """Generate a merge directive for auto-merge tools.
4991
4965
 
4992
4966
    A directive requests a merge to be performed, and also provides all the
4993
4967
    information necessary to do so.  This means it must either include a
5086
5060
 
5087
5061
 
5088
5062
class cmd_send(Command):
5089
 
    __doc__ = """Mail or create a merge-directive for submitting changes.
 
5063
    """Mail or create a merge-directive for submitting changes.
5090
5064
 
5091
5065
    A merge directive provides many things needed for requesting merges:
5092
5066
 
5203
5177
 
5204
5178
 
5205
5179
class cmd_bundle_revisions(cmd_send):
5206
 
    __doc__ = """Create a merge-directive for submitting changes.
 
5180
    """Create a merge-directive for submitting changes.
5207
5181
 
5208
5182
    A merge directive provides many things needed for requesting merges:
5209
5183
 
5276
5250
 
5277
5251
 
5278
5252
class cmd_tag(Command):
5279
 
    __doc__ = """Create, remove or modify a tag naming a revision.
 
5253
    """Create, remove or modify a tag naming a revision.
5280
5254
 
5281
5255
    Tags give human-meaningful names to revisions.  Commands that take a -r
5282
5256
    (--revision) option can be given -rtag:X, where X is any previously
5290
5264
 
5291
5265
    To rename a tag (change the name but keep it on the same revsion), run ``bzr
5292
5266
    tag new-name -r tag:old-name`` and then ``bzr tag --delete oldname``.
5293
 
 
5294
 
    If no tag name is specified it will be determined through the 
5295
 
    'automatic_tag_name' hook. This can e.g. be used to automatically tag
5296
 
    upstream releases by reading configure.ac. See ``bzr help hooks`` for
5297
 
    details.
5298
5267
    """
5299
5268
 
5300
5269
    _see_also = ['commit', 'tags']
5301
 
    takes_args = ['tag_name?']
 
5270
    takes_args = ['tag_name']
5302
5271
    takes_options = [
5303
5272
        Option('delete',
5304
5273
            help='Delete this tag rather than placing it.',
5305
5274
            ),
5306
 
        custom_help('directory',
5307
 
            help='Branch in which to place the tag.'),
 
5275
        Option('directory',
 
5276
            help='Branch in which to place the tag.',
 
5277
            short_name='d',
 
5278
            type=unicode,
 
5279
            ),
5308
5280
        Option('force',
5309
5281
            help='Replace existing tags.',
5310
5282
            ),
5311
5283
        'revision',
5312
5284
        ]
5313
5285
 
5314
 
    def run(self, tag_name=None,
 
5286
    def run(self, tag_name,
5315
5287
            delete=None,
5316
5288
            directory='.',
5317
5289
            force=None,
5318
5290
            revision=None,
5319
5291
            ):
5320
5292
        branch, relpath = Branch.open_containing(directory)
5321
 
        self.add_cleanup(branch.lock_write().unlock)
 
5293
        branch.lock_write()
 
5294
        self.add_cleanup(branch.unlock)
5322
5295
        if delete:
5323
 
            if tag_name is None:
5324
 
                raise errors.BzrCommandError("No tag specified to delete.")
5325
5296
            branch.tags.delete_tag(tag_name)
5326
5297
            self.outf.write('Deleted tag %s.\n' % tag_name)
5327
5298
        else:
5333
5304
                revision_id = revision[0].as_revision_id(branch)
5334
5305
            else:
5335
5306
                revision_id = branch.last_revision()
5336
 
            if tag_name is None:
5337
 
                tag_name = branch.automatic_tag_name(revision_id)
5338
 
                if tag_name is None:
5339
 
                    raise errors.BzrCommandError(
5340
 
                        "Please specify a tag name.")
5341
5307
            if (not force) and branch.tags.has_tag(tag_name):
5342
5308
                raise errors.TagAlreadyExists(tag_name)
5343
5309
            branch.tags.set_tag(tag_name, revision_id)
5345
5311
 
5346
5312
 
5347
5313
class cmd_tags(Command):
5348
 
    __doc__ = """List tags.
 
5314
    """List tags.
5349
5315
 
5350
5316
    This command shows a table of tag names and the revisions they reference.
5351
5317
    """
5352
5318
 
5353
5319
    _see_also = ['tag']
5354
5320
    takes_options = [
5355
 
        custom_help('directory',
5356
 
            help='Branch whose tags should be displayed.'),
 
5321
        Option('directory',
 
5322
            help='Branch whose tags should be displayed.',
 
5323
            short_name='d',
 
5324
            type=unicode,
 
5325
            ),
5357
5326
        RegistryOption.from_kwargs('sort',
5358
5327
            'Sort tags by different criteria.', title='Sorting',
5359
5328
            alpha='Sort tags lexicographically (default).',
5376
5345
        if not tags:
5377
5346
            return
5378
5347
 
5379
 
        self.add_cleanup(branch.lock_read().unlock)
 
5348
        branch.lock_read()
 
5349
        self.add_cleanup(branch.unlock)
5380
5350
        if revision:
5381
5351
            graph = branch.repository.get_graph()
5382
5352
            rev1, rev2 = _get_revision_range(revision, branch, self.name())
5415
5385
 
5416
5386
 
5417
5387
class cmd_reconfigure(Command):
5418
 
    __doc__ = """Reconfigure the type of a bzr directory.
 
5388
    """Reconfigure the type of a bzr directory.
5419
5389
 
5420
5390
    A target configuration must be specified.
5421
5391
 
5506
5476
 
5507
5477
 
5508
5478
class cmd_switch(Command):
5509
 
    __doc__ = """Set the branch of a checkout and update.
 
5479
    """Set the branch of a checkout and update.
5510
5480
 
5511
5481
    For lightweight checkouts, this changes the branch being referenced.
5512
5482
    For heavyweight checkouts, this checks that there are no local commits
5602
5572
 
5603
5573
 
5604
5574
class cmd_view(Command):
5605
 
    __doc__ = """Manage filtered views.
 
5575
    """Manage filtered views.
5606
5576
 
5607
5577
    Views provide a mask over the tree so that users can focus on
5608
5578
    a subset of a tree when doing their work. After creating a view,
5756
5726
 
5757
5727
 
5758
5728
class cmd_hooks(Command):
5759
 
    __doc__ = """Show hooks."""
 
5729
    """Show hooks."""
5760
5730
 
5761
5731
    hidden = True
5762
5732
 
5775
5745
                    self.outf.write("    <no hooks installed>\n")
5776
5746
 
5777
5747
 
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
5748
class cmd_shelve(Command):
5804
 
    __doc__ = """Temporarily set aside some changes from the current tree.
 
5749
    """Temporarily set aside some changes from the current tree.
5805
5750
 
5806
5751
    Shelve allows you to temporarily put changes you've made "on the shelf",
5807
5752
    ie. out of the way, until a later time when you can bring them back from
5860
5805
 
5861
5806
    def run_for_list(self):
5862
5807
        tree = WorkingTree.open_containing('.')[0]
5863
 
        self.add_cleanup(tree.lock_read().unlock)
 
5808
        tree.lock_read()
 
5809
        self.add_cleanup(tree.unlock)
5864
5810
        manager = tree.get_shelf_manager()
5865
5811
        shelves = manager.active_shelves()
5866
5812
        if len(shelves) == 0:
5875
5821
 
5876
5822
 
5877
5823
class cmd_unshelve(Command):
5878
 
    __doc__ = """Restore shelved changes.
 
5824
    """Restore shelved changes.
5879
5825
 
5880
5826
    By default, the most recently shelved changes are restored. However if you
5881
5827
    specify a shelf by id those changes will be restored instead.  This works
5907
5853
 
5908
5854
 
5909
5855
class cmd_clean_tree(Command):
5910
 
    __doc__ = """Remove unwanted files from working tree.
 
5856
    """Remove unwanted files from working tree.
5911
5857
 
5912
5858
    By default, only unknown files, not ignored files, are deleted.  Versioned
5913
5859
    files are never deleted.
5921
5867
 
5922
5868
    To check what clean-tree will do, use --dry-run.
5923
5869
    """
5924
 
    takes_options = ['directory',
5925
 
                     Option('ignored', help='Delete all ignored files.'),
 
5870
    takes_options = [Option('ignored', help='Delete all ignored files.'),
5926
5871
                     Option('detritus', help='Delete conflict files, merge'
5927
5872
                            ' backups, and failed selftest dirs.'),
5928
5873
                     Option('unknown',
5931
5876
                            ' deleting them.'),
5932
5877
                     Option('force', help='Do not prompt before deleting.')]
5933
5878
    def run(self, unknown=False, ignored=False, detritus=False, dry_run=False,
5934
 
            force=False, directory=u'.'):
 
5879
            force=False):
5935
5880
        from bzrlib.clean_tree import clean_tree
5936
5881
        if not (unknown or ignored or detritus):
5937
5882
            unknown = True
5938
5883
        if dry_run:
5939
5884
            force = True
5940
 
        clean_tree(directory, unknown=unknown, ignored=ignored,
5941
 
                   detritus=detritus, dry_run=dry_run, no_prompt=force)
 
5885
        clean_tree('.', unknown=unknown, ignored=ignored, detritus=detritus,
 
5886
                   dry_run=dry_run, no_prompt=force)
5942
5887
 
5943
5888
 
5944
5889
class cmd_reference(Command):
5945
 
    __doc__ = """list, view and set branch locations for nested trees.
 
5890
    """list, view and set branch locations for nested trees.
5946
5891
 
5947
5892
    If no arguments are provided, lists the branch locations for nested trees.
5948
5893
    If one argument is provided, display the branch location for that tree.
5988
5933
            self.outf.write('%s %s\n' % (path, location))
5989
5934
 
5990
5935
 
5991
 
def _register_lazy_builtins():
5992
 
    # register lazy builtins from other modules; called at startup and should
5993
 
    # be only called once.
5994
 
    for (name, aliases, module_name) in [
5995
 
        ('cmd_bundle_info', [], 'bzrlib.bundle.commands'),
5996
 
        ('cmd_dpush', [], 'bzrlib.foreign'),
5997
 
        ('cmd_version_info', [], 'bzrlib.cmd_version_info'),
5998
 
        ('cmd_resolve', ['resolved'], 'bzrlib.conflicts'),
5999
 
        ('cmd_conflicts', [], 'bzrlib.conflicts'),
6000
 
        ('cmd_sign_my_commits', [], 'bzrlib.sign_my_commits'),
6001
 
        ]:
6002
 
        builtin_command_registry.register_lazy(name, aliases, module_name)
 
5936
# these get imported and then picked up by the scan for cmd_*
 
5937
# TODO: Some more consistent way to split command definitions across files;
 
5938
# we do need to load at least some information about them to know of
 
5939
# aliases.  ideally we would avoid loading the implementation until the
 
5940
# details were needed.
 
5941
from bzrlib.cmd_version_info import cmd_version_info
 
5942
from bzrlib.conflicts import cmd_resolve, cmd_conflicts, restore
 
5943
from bzrlib.bundle.commands import (
 
5944
    cmd_bundle_info,
 
5945
    )
 
5946
from bzrlib.foreign import cmd_dpush
 
5947
from bzrlib.sign_my_commits import cmd_sign_my_commits