/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

  • Committer: John Arbash Meinel
  • Date: 2011-01-25 22:54:08 UTC
  • mto: This revision was merged to the branch mainline in revision 5636.
  • Revision ID: john@arbash-meinel.com-20110125225408-w5b5mmh117q4jjz1
Implement a reset-to-known-state ability for DirState.

Use this in reset_state(). Allow it to use header information if it can
be parsed, otherwise allow us to pass in the information.

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
# Copyright (C) 2005-2010 Canonical Ltd
 
1
# Copyright (C) 2005-2011 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
20
20
 
21
21
from bzrlib.lazy_import import lazy_import
22
22
lazy_import(globals(), """
23
 
import codecs
24
23
import cStringIO
25
24
import sys
26
25
import time
33
32
    bzrdir,
34
33
    directory_service,
35
34
    delta,
36
 
    config,
 
35
    config as _mod_config,
37
36
    errors,
38
37
    globbing,
39
38
    hooks,
75
74
from bzrlib.trace import mutter, note, warning, is_quiet, get_verbosity_level
76
75
 
77
76
 
 
77
@symbol_versioning.deprecated_function(symbol_versioning.deprecated_in((2, 3, 0)))
78
78
def tree_files(file_list, default_branch=u'.', canonicalize=True,
79
79
    apply_view=True):
80
 
    try:
81
 
        return internal_tree_files(file_list, default_branch, canonicalize,
82
 
            apply_view)
83
 
    except errors.FileInWrongBranch, e:
84
 
        raise errors.BzrCommandError("%s is not in the same branch as %s" %
85
 
                                     (e.path, file_list[0]))
 
80
    return internal_tree_files(file_list, default_branch, canonicalize,
 
81
        apply_view)
86
82
 
87
83
 
88
84
def tree_files_for_add(file_list):
152
148
 
153
149
# XXX: Bad function name; should possibly also be a class method of
154
150
# WorkingTree rather than a function.
 
151
@symbol_versioning.deprecated_function(symbol_versioning.deprecated_in((2, 3, 0)))
155
152
def internal_tree_files(file_list, default_branch=u'.', canonicalize=True,
156
153
    apply_view=True):
157
154
    """Convert command-line paths to a WorkingTree and relative paths.
158
155
 
 
156
    Deprecated: use WorkingTree.open_containing_paths instead.
 
157
 
159
158
    This is typically used for command-line processors that take one or
160
159
    more filenames, and infer the workingtree that contains them.
161
160
 
171
170
 
172
171
    :return: workingtree, [relative_paths]
173
172
    """
174
 
    if file_list is None or len(file_list) == 0:
175
 
        tree = WorkingTree.open_containing(default_branch)[0]
176
 
        if tree.supports_views() and apply_view:
177
 
            view_files = tree.views.lookup_view()
178
 
            if view_files:
179
 
                file_list = view_files
180
 
                view_str = views.view_display_str(view_files)
181
 
                note("Ignoring files outside view. View is %s" % view_str)
182
 
        return tree, file_list
183
 
    tree = WorkingTree.open_containing(osutils.realpath(file_list[0]))[0]
184
 
    return tree, safe_relpath_files(tree, file_list, canonicalize,
185
 
        apply_view=apply_view)
186
 
 
187
 
 
188
 
def safe_relpath_files(tree, file_list, canonicalize=True, apply_view=True):
189
 
    """Convert file_list into a list of relpaths in tree.
190
 
 
191
 
    :param tree: A tree to operate on.
192
 
    :param file_list: A list of user provided paths or None.
193
 
    :param apply_view: if True and a view is set, apply it or check that
194
 
        specified files are within it
195
 
    :return: A list of relative paths.
196
 
    :raises errors.PathNotChild: When a provided path is in a different tree
197
 
        than tree.
198
 
    """
199
 
    if file_list is None:
200
 
        return None
201
 
    if tree.supports_views() and apply_view:
202
 
        view_files = tree.views.lookup_view()
203
 
    else:
204
 
        view_files = []
205
 
    new_list = []
206
 
    # tree.relpath exists as a "thunk" to osutils, but canonical_relpath
207
 
    # doesn't - fix that up here before we enter the loop.
208
 
    if canonicalize:
209
 
        fixer = lambda p: osutils.canonical_relpath(tree.basedir, p)
210
 
    else:
211
 
        fixer = tree.relpath
212
 
    for filename in file_list:
213
 
        try:
214
 
            relpath = fixer(osutils.dereference_path(filename))
215
 
            if  view_files and not osutils.is_inside_any(view_files, relpath):
216
 
                raise errors.FileOutsideView(filename, view_files)
217
 
            new_list.append(relpath)
218
 
        except errors.PathNotChild:
219
 
            raise errors.FileInWrongBranch(tree.branch, filename)
220
 
    return new_list
 
173
    return WorkingTree.open_containing_paths(
 
174
        file_list, default_directory='.',
 
175
        canonicalize=True,
 
176
        apply_view=True)
221
177
 
222
178
 
223
179
def _get_view_info_for_change_reporter(tree):
232
188
    return view_info
233
189
 
234
190
 
 
191
def _open_directory_or_containing_tree_or_branch(filename, directory):
 
192
    """Open the tree or branch containing the specified file, unless
 
193
    the --directory option is used to specify a different branch."""
 
194
    if directory is not None:
 
195
        return (None, Branch.open(directory), filename)
 
196
    return bzrdir.BzrDir.open_containing_tree_or_branch(filename)
 
197
 
 
198
 
235
199
# TODO: Make sure no commands unconditionally use the working directory as a
236
200
# branch.  If a filename argument is used, the first of them should be used to
237
201
# specify the branch.  (Perhaps this can be factored out into some kind of
286
250
    To skip the display of pending merge information altogether, use
287
251
    the no-pending option or specify a file/directory.
288
252
 
289
 
    If a revision argument is given, the status is calculated against
290
 
    that revision, or between two revisions if two are provided.
 
253
    To compare the working directory to a specific revision, pass a
 
254
    single revision to the revision argument.
 
255
 
 
256
    To see which files have changed in a specific revision, or between
 
257
    two revisions, pass a revision range to the revision argument.
 
258
    This will produce the same results as calling 'bzr diff --summarize'.
291
259
    """
292
260
 
293
261
    # TODO: --no-recurse, --recurse options
315
283
            raise errors.BzrCommandError('bzr status --revision takes exactly'
316
284
                                         ' one or two revision specifiers')
317
285
 
318
 
        tree, relfile_list = tree_files(file_list)
 
286
        tree, relfile_list = WorkingTree.open_containing_paths(file_list)
319
287
        # Avoid asking for specific files when that is not needed.
320
288
        if relfile_list == ['']:
321
289
            relfile_list = None
340
308
 
341
309
    hidden = True
342
310
    takes_args = ['revision_id?']
343
 
    takes_options = ['revision']
 
311
    takes_options = ['directory', 'revision']
344
312
    # cat-revision is more for frontends so should be exact
345
313
    encoding = 'strict'
346
314
 
353
321
        self.outf.write(revtext.decode('utf-8'))
354
322
 
355
323
    @display_command
356
 
    def run(self, revision_id=None, revision=None):
 
324
    def run(self, revision_id=None, revision=None, directory=u'.'):
357
325
        if revision_id is not None and revision is not None:
358
326
            raise errors.BzrCommandError('You can only supply one of'
359
327
                                         ' revision_id or --revision')
360
328
        if revision_id is None and revision is None:
361
329
            raise errors.BzrCommandError('You must supply either'
362
330
                                         ' --revision or a revision_id')
363
 
        b = WorkingTree.open_containing(u'.')[0].branch
 
331
 
 
332
        b = bzrdir.BzrDir.open_containing_tree_or_branch(directory)[1]
364
333
 
365
334
        revisions = b.repository.revisions
366
335
        if revisions is None:
483
452
    takes_options = [
484
453
        Option('force',
485
454
               help='Remove the working tree even if it has '
486
 
                    'uncommitted changes.'),
 
455
                    'uncommitted or shelved changes.'),
487
456
        ]
488
457
 
489
458
    def run(self, location_list, force=False):
503
472
            if not force:
504
473
                if (working.has_changes()):
505
474
                    raise errors.UncommittedChanges(working)
 
475
                if working.get_shelf_manager().last_shelf() is not None:
 
476
                    raise errors.ShelvedChanges(working)
506
477
 
507
478
            if working.user_url != working.branch.user_url:
508
479
                raise errors.BzrCommandError("You cannot remove the working tree"
511
482
            d.destroy_workingtree()
512
483
 
513
484
 
 
485
class cmd_reset_workingtree(Command):
 
486
    __doc__ = """Reset the working tree state file.
 
487
 
 
488
    This is not meant to be used normally, but more as a way to recover from
 
489
    filesystem corruption, etc. This rebuilds the working inventory back to a
 
490
    'known good' state. Any new modifications (adding a file, renaming, etc)
 
491
    will be lost, though modified files will still be detected as such.
 
492
 
 
493
    Most users will want something more like "bzr revert" or "bzr update"
 
494
    unless the state file has become corrupted.
 
495
 
 
496
    By default this attempts to recover the current state by looking at the
 
497
    headers of the state file. If the state file is too corrupted to even do
 
498
    that, you can supply --revision to force the state of the tree.
 
499
    """
 
500
 
 
501
    takes_options = ['revision']
 
502
    hidden = True
 
503
 
 
504
    def run(self, revision=None):
 
505
        pass
 
506
 
 
507
 
514
508
class cmd_revno(Command):
515
509
    __doc__ = """Show current revision number.
516
510
 
528
522
        if tree:
529
523
            try:
530
524
                wt = WorkingTree.open_containing(location)[0]
531
 
                wt.lock_read()
 
525
                self.add_cleanup(wt.lock_read().unlock)
532
526
            except (errors.NoWorkingTree, errors.NotLocalUrl):
533
527
                raise errors.NoWorkingTree(location)
534
 
            self.add_cleanup(wt.unlock)
535
528
            revid = wt.last_revision()
536
529
            try:
537
530
                revno_t = wt.branch.revision_id_to_dotted_revno(revid)
540
533
            revno = ".".join(str(n) for n in revno_t)
541
534
        else:
542
535
            b = Branch.open_containing(location)[0]
543
 
            b.lock_read()
544
 
            self.add_cleanup(b.unlock)
 
536
            self.add_cleanup(b.lock_read().unlock)
545
537
            revno = b.revno()
546
538
        self.cleanup_now()
547
539
        self.outf.write(str(revno) + '\n')
554
546
    takes_args = ['revision_info*']
555
547
    takes_options = [
556
548
        'revision',
557
 
        Option('directory',
 
549
        custom_help('directory',
558
550
            help='Branch to examine, '
559
 
                 'rather than the one containing the working directory.',
560
 
            short_name='d',
561
 
            type=unicode,
562
 
            ),
 
551
                 'rather than the one containing the working directory.'),
563
552
        Option('tree', help='Show revno of working tree'),
564
553
        ]
565
554
 
570
559
        try:
571
560
            wt = WorkingTree.open_containing(directory)[0]
572
561
            b = wt.branch
573
 
            wt.lock_read()
574
 
            self.add_cleanup(wt.unlock)
 
562
            self.add_cleanup(wt.lock_read().unlock)
575
563
        except (errors.NoWorkingTree, errors.NotLocalUrl):
576
564
            wt = None
577
565
            b = Branch.open_containing(directory)[0]
578
 
            b.lock_read()
579
 
            self.add_cleanup(b.unlock)
 
566
            self.add_cleanup(b.lock_read().unlock)
580
567
        revision_ids = []
581
568
        if revision is not None:
582
569
            revision_ids.extend(rev.as_revision_id(b) for rev in revision)
681
668
                should_print=(not is_quiet()))
682
669
 
683
670
        if base_tree:
684
 
            base_tree.lock_read()
685
 
            self.add_cleanup(base_tree.unlock)
 
671
            self.add_cleanup(base_tree.lock_read().unlock)
686
672
        tree, file_list = tree_files_for_add(file_list)
687
673
        added, ignored = tree.smart_add(file_list, not
688
674
            no_recurse, action=action, save=not dry_run)
759
745
            raise errors.BzrCommandError('invalid kind %r specified' % (kind,))
760
746
 
761
747
        revision = _get_one_revision('inventory', revision)
762
 
        work_tree, file_list = tree_files(file_list)
763
 
        work_tree.lock_read()
764
 
        self.add_cleanup(work_tree.unlock)
 
748
        work_tree, file_list = WorkingTree.open_containing_paths(file_list)
 
749
        self.add_cleanup(work_tree.lock_read().unlock)
765
750
        if revision is not None:
766
751
            tree = revision.as_tree(work_tree.branch)
767
752
 
768
753
            extra_trees = [work_tree]
769
 
            tree.lock_read()
770
 
            self.add_cleanup(tree.unlock)
 
754
            self.add_cleanup(tree.lock_read().unlock)
771
755
        else:
772
756
            tree = work_tree
773
757
            extra_trees = []
832
816
            names_list = []
833
817
        if len(names_list) < 2:
834
818
            raise errors.BzrCommandError("missing file argument")
835
 
        tree, rel_names = tree_files(names_list, canonicalize=False)
836
 
        tree.lock_tree_write()
837
 
        self.add_cleanup(tree.unlock)
 
819
        tree, rel_names = WorkingTree.open_containing_paths(names_list, canonicalize=False)
 
820
        self.add_cleanup(tree.lock_tree_write().unlock)
838
821
        self._run(tree, names_list, rel_names, after)
839
822
 
840
823
    def run_auto(self, names_list, after, dry_run):
844
827
        if after:
845
828
            raise errors.BzrCommandError('--after cannot be specified with'
846
829
                                         ' --auto.')
847
 
        work_tree, file_list = tree_files(names_list, default_branch='.')
848
 
        work_tree.lock_tree_write()
849
 
        self.add_cleanup(work_tree.unlock)
 
830
        work_tree, file_list = WorkingTree.open_containing_paths(
 
831
            names_list, default_directory='.')
 
832
        self.add_cleanup(work_tree.lock_tree_write().unlock)
850
833
        rename_map.RenameMap.guess_renames(work_tree, dry_run)
851
834
 
852
835
    def _run(self, tree, names_list, rel_names, after):
960
943
    takes_options = ['remember', 'overwrite', 'revision',
961
944
        custom_help('verbose',
962
945
            help='Show logs of pulled revisions.'),
963
 
        Option('directory',
 
946
        custom_help('directory',
964
947
            help='Branch to pull into, '
965
 
                 'rather than the one containing the working directory.',
966
 
            short_name='d',
967
 
            type=unicode,
968
 
            ),
 
948
                 'rather than the one containing the working directory.'),
969
949
        Option('local',
970
950
            help="Perform a local pull in a bound "
971
951
                 "branch.  Local pulls are not applied to "
972
952
                 "the master branch."
973
953
            ),
 
954
        Option('show-base',
 
955
            help="Show base revision text in conflicts.")
974
956
        ]
975
957
    takes_args = ['location?']
976
958
    encoding_type = 'replace'
977
959
 
978
960
    def run(self, location=None, remember=False, overwrite=False,
979
961
            revision=None, verbose=False,
980
 
            directory=None, local=False):
 
962
            directory=None, local=False,
 
963
            show_base=False):
981
964
        # FIXME: too much stuff is in the command class
982
965
        revision_id = None
983
966
        mergeable = None
986
969
        try:
987
970
            tree_to = WorkingTree.open_containing(directory)[0]
988
971
            branch_to = tree_to.branch
989
 
            tree_to.lock_write()
990
 
            self.add_cleanup(tree_to.unlock)
 
972
            self.add_cleanup(tree_to.lock_write().unlock)
991
973
        except errors.NoWorkingTree:
992
974
            tree_to = None
993
975
            branch_to = Branch.open_containing(directory)[0]
994
 
            branch_to.lock_write()
995
 
            self.add_cleanup(branch_to.unlock)
 
976
            self.add_cleanup(branch_to.lock_write().unlock)
 
977
 
 
978
        if tree_to is None and show_base:
 
979
            raise errors.BzrCommandError("Need working tree for --show-base.")
996
980
 
997
981
        if local and not branch_to.get_bound_location():
998
982
            raise errors.LocalRequiresBoundBranch()
1029
1013
        else:
1030
1014
            branch_from = Branch.open(location,
1031
1015
                possible_transports=possible_transports)
1032
 
            branch_from.lock_read()
1033
 
            self.add_cleanup(branch_from.unlock)
 
1016
            self.add_cleanup(branch_from.lock_read().unlock)
1034
1017
 
1035
1018
            if branch_to.get_parent() is None or remember:
1036
1019
                branch_to.set_parent(branch_from.base)
1045
1028
                view_info=view_info)
1046
1029
            result = tree_to.pull(
1047
1030
                branch_from, overwrite, revision_id, change_reporter,
1048
 
                possible_transports=possible_transports, local=local)
 
1031
                possible_transports=possible_transports, local=local,
 
1032
                show_base=show_base)
1049
1033
        else:
1050
1034
            result = branch_to.pull(
1051
1035
                branch_from, overwrite, revision_id, local=local)
1055
1039
            log.show_branch_change(
1056
1040
                branch_to, self.outf, result.old_revno,
1057
1041
                result.old_revid)
 
1042
        if getattr(result, 'tag_conflicts', None):
 
1043
            return 1
 
1044
        else:
 
1045
            return 0
1058
1046
 
1059
1047
 
1060
1048
class cmd_push(Command):
1088
1076
        Option('create-prefix',
1089
1077
               help='Create the path leading up to the branch '
1090
1078
                    'if it does not already exist.'),
1091
 
        Option('directory',
 
1079
        custom_help('directory',
1092
1080
            help='Branch to push from, '
1093
 
                 'rather than the one containing the working directory.',
1094
 
            short_name='d',
1095
 
            type=unicode,
1096
 
            ),
 
1081
                 'rather than the one containing the working directory.'),
1097
1082
        Option('use-existing-dir',
1098
1083
               help='By default push will fail if the target'
1099
1084
                    ' directory exists, but does not already'
1110
1095
        Option('strict',
1111
1096
               help='Refuse to push if there are uncommitted changes in'
1112
1097
               ' the working tree, --no-strict disables the check.'),
 
1098
        Option('no-tree',
 
1099
               help="Don't populate the working tree, even for protocols"
 
1100
               " that support it."),
1113
1101
        ]
1114
1102
    takes_args = ['location?']
1115
1103
    encoding_type = 'replace'
1117
1105
    def run(self, location=None, remember=False, overwrite=False,
1118
1106
        create_prefix=False, verbose=False, revision=None,
1119
1107
        use_existing_dir=False, directory=None, stacked_on=None,
1120
 
        stacked=False, strict=None):
 
1108
        stacked=False, strict=None, no_tree=False):
1121
1109
        from bzrlib.push import _show_push_branch
1122
1110
 
1123
1111
        if directory is None:
1169
1157
        _show_push_branch(br_from, revision_id, location, self.outf,
1170
1158
            verbose=verbose, overwrite=overwrite, remember=remember,
1171
1159
            stacked_on=stacked_on, create_prefix=create_prefix,
1172
 
            use_existing_dir=use_existing_dir)
 
1160
            use_existing_dir=use_existing_dir, no_tree=no_tree)
1173
1161
 
1174
1162
 
1175
1163
class cmd_branch(Command):
1188
1176
 
1189
1177
    _see_also = ['checkout']
1190
1178
    takes_args = ['from_location', 'to_location?']
1191
 
    takes_options = ['revision', Option('hardlink',
1192
 
        help='Hard-link working tree files where possible.'),
 
1179
    takes_options = ['revision',
 
1180
        Option('hardlink', help='Hard-link working tree files where possible.'),
 
1181
        Option('files-from', type=str,
 
1182
               help="Get file contents from this tree."),
1193
1183
        Option('no-tree',
1194
1184
            help="Create a branch without a working-tree."),
1195
1185
        Option('switch',
1213
1203
 
1214
1204
    def run(self, from_location, to_location=None, revision=None,
1215
1205
            hardlink=False, stacked=False, standalone=False, no_tree=False,
1216
 
            use_existing_dir=False, switch=False, bind=False):
 
1206
            use_existing_dir=False, switch=False, bind=False,
 
1207
            files_from=None):
1217
1208
        from bzrlib import switch as _mod_switch
1218
1209
        from bzrlib.tag import _merge_tags_if_possible
1219
1210
        accelerator_tree, br_from = bzrdir.BzrDir.open_tree_or_branch(
1220
1211
            from_location)
 
1212
        if not (hardlink or files_from):
 
1213
            # accelerator_tree is usually slower because you have to read N
 
1214
            # files (no readahead, lots of seeks, etc), but allow the user to
 
1215
            # explicitly request it
 
1216
            accelerator_tree = None
 
1217
        if files_from is not None and files_from != from_location:
 
1218
            accelerator_tree = WorkingTree.open(files_from)
1221
1219
        revision = _get_one_revision('branch', revision)
1222
 
        br_from.lock_read()
1223
 
        self.add_cleanup(br_from.unlock)
 
1220
        self.add_cleanup(br_from.lock_read().unlock)
1224
1221
        if revision is not None:
1225
1222
            revision_id = revision.as_revision_id(br_from)
1226
1223
        else:
1331
1328
            to_location = branch_location
1332
1329
        accelerator_tree, source = bzrdir.BzrDir.open_tree_or_branch(
1333
1330
            branch_location)
 
1331
        if not (hardlink or files_from):
 
1332
            # accelerator_tree is usually slower because you have to read N
 
1333
            # files (no readahead, lots of seeks, etc), but allow the user to
 
1334
            # explicitly request it
 
1335
            accelerator_tree = None
1334
1336
        revision = _get_one_revision('checkout', revision)
1335
 
        if files_from is not None:
 
1337
        if files_from is not None and files_from != branch_location:
1336
1338
            accelerator_tree = WorkingTree.open(files_from)
1337
1339
        if revision is not None:
1338
1340
            revision_id = revision.as_revision_id(source)
1366
1368
    @display_command
1367
1369
    def run(self, dir=u'.'):
1368
1370
        tree = WorkingTree.open_containing(dir)[0]
1369
 
        tree.lock_read()
1370
 
        self.add_cleanup(tree.unlock)
 
1371
        self.add_cleanup(tree.lock_read().unlock)
1371
1372
        new_inv = tree.inventory
1372
1373
        old_tree = tree.basis_tree()
1373
 
        old_tree.lock_read()
1374
 
        self.add_cleanup(old_tree.unlock)
 
1374
        self.add_cleanup(old_tree.lock_read().unlock)
1375
1375
        old_inv = old_tree.inventory
1376
1376
        renames = []
1377
1377
        iterator = tree.iter_changes(old_tree, include_unchanged=True)
1396
1396
    If you want to discard your local changes, you can just do a
1397
1397
    'bzr revert' instead of 'bzr commit' after the update.
1398
1398
 
 
1399
    If you want to restore a file that has been removed locally, use
 
1400
    'bzr revert' instead of 'bzr update'.
 
1401
 
1399
1402
    If the tree's branch is bound to a master branch, it will also update
1400
1403
    the branch from the master.
1401
1404
    """
1402
1405
 
1403
1406
    _see_also = ['pull', 'working-trees', 'status-flags']
1404
1407
    takes_args = ['dir?']
1405
 
    takes_options = ['revision']
 
1408
    takes_options = ['revision',
 
1409
                     Option('show-base',
 
1410
                            help="Show base revision text in conflicts."),
 
1411
                     ]
1406
1412
    aliases = ['up']
1407
1413
 
1408
 
    def run(self, dir='.', revision=None):
 
1414
    def run(self, dir='.', revision=None, show_base=None):
1409
1415
        if revision is not None and len(revision) != 1:
1410
1416
            raise errors.BzrCommandError(
1411
1417
                        "bzr update --revision takes exactly one revision")
1415
1421
        master = branch.get_master_branch(
1416
1422
            possible_transports=possible_transports)
1417
1423
        if master is not None:
1418
 
            tree.lock_write()
1419
1424
            branch_location = master.base
 
1425
            tree.lock_write()
1420
1426
        else:
 
1427
            branch_location = tree.branch.base
1421
1428
            tree.lock_tree_write()
1422
 
            branch_location = tree.branch.base
1423
1429
        self.add_cleanup(tree.unlock)
1424
1430
        # get rid of the final '/' and be ready for display
1425
1431
        branch_location = urlutils.unescape_for_display(
1451
1457
                change_reporter,
1452
1458
                possible_transports=possible_transports,
1453
1459
                revision=revision_id,
1454
 
                old_tip=old_tip)
 
1460
                old_tip=old_tip,
 
1461
                show_base=show_base)
1455
1462
        except errors.NoSuchRevision, e:
1456
1463
            raise errors.BzrCommandError(
1457
1464
                                  "branch has no revision %s\n"
1519
1526
class cmd_remove(Command):
1520
1527
    __doc__ = """Remove files or directories.
1521
1528
 
1522
 
    This makes bzr stop tracking changes to the specified files. bzr will delete
1523
 
    them if they can easily be recovered using revert. If no options or
1524
 
    parameters are given bzr will scan for files that are being tracked by bzr
1525
 
    but missing in your tree and stop tracking them for you.
 
1529
    This makes Bazaar stop tracking changes to the specified files. Bazaar will
 
1530
    delete them if they can easily be recovered using revert otherwise they
 
1531
    will be backed up (adding an extention of the form .~#~). If no options or
 
1532
    parameters are given Bazaar will scan for files that are being tracked by
 
1533
    Bazaar but missing in your tree and stop tracking them for you.
1526
1534
    """
1527
1535
    takes_args = ['file*']
1528
1536
    takes_options = ['verbose',
1530
1538
        RegistryOption.from_kwargs('file-deletion-strategy',
1531
1539
            'The file deletion mode to be used.',
1532
1540
            title='Deletion Strategy', value_switches=True, enum_switch=False,
1533
 
            safe='Only delete files if they can be'
1534
 
                 ' safely recovered (default).',
 
1541
            safe='Backup changed files (default).',
1535
1542
            keep='Delete from bzr but leave the working copy.',
 
1543
            no_backup='Don\'t backup changed files.',
1536
1544
            force='Delete all the specified files, even if they can not be '
1537
 
                'recovered and even if they are non-empty directories.')]
 
1545
                'recovered and even if they are non-empty directories. '
 
1546
                '(deprecated, use no-backup)')]
1538
1547
    aliases = ['rm', 'del']
1539
1548
    encoding_type = 'replace'
1540
1549
 
1541
1550
    def run(self, file_list, verbose=False, new=False,
1542
1551
        file_deletion_strategy='safe'):
1543
 
        tree, file_list = tree_files(file_list)
 
1552
        if file_deletion_strategy == 'force':
 
1553
            note("(The --force option is deprecated, rather use --no-backup "
 
1554
                "in future.)")
 
1555
            file_deletion_strategy = 'no-backup'
 
1556
 
 
1557
        tree, file_list = WorkingTree.open_containing_paths(file_list)
1544
1558
 
1545
1559
        if file_list is not None:
1546
1560
            file_list = [f for f in file_list]
1547
1561
 
1548
 
        tree.lock_write()
1549
 
        self.add_cleanup(tree.unlock)
 
1562
        self.add_cleanup(tree.lock_write().unlock)
1550
1563
        # Heuristics should probably all move into tree.remove_smart or
1551
1564
        # some such?
1552
1565
        if new:
1567
1580
            file_deletion_strategy = 'keep'
1568
1581
        tree.remove(file_list, verbose=verbose, to_file=self.outf,
1569
1582
            keep_files=file_deletion_strategy=='keep',
1570
 
            force=file_deletion_strategy=='force')
 
1583
            force=(file_deletion_strategy=='no-backup'))
1571
1584
 
1572
1585
 
1573
1586
class cmd_file_id(Command):
1635
1648
 
1636
1649
    _see_also = ['check']
1637
1650
    takes_args = ['branch?']
 
1651
    takes_options = [
 
1652
        Option('canonicalize-chks',
 
1653
               help='Make sure CHKs are in canonical form (repairs '
 
1654
                    'bug 522637).',
 
1655
               hidden=True),
 
1656
        ]
1638
1657
 
1639
 
    def run(self, branch="."):
 
1658
    def run(self, branch=".", canonicalize_chks=False):
1640
1659
        from bzrlib.reconcile import reconcile
1641
1660
        dir = bzrdir.BzrDir.open(branch)
1642
 
        reconcile(dir)
 
1661
        reconcile(dir, canonicalize_chks=canonicalize_chks)
1643
1662
 
1644
1663
 
1645
1664
class cmd_revision_history(Command):
1722
1741
                ),
1723
1742
         Option('append-revisions-only',
1724
1743
                help='Never change revnos or the existing log.'
1725
 
                '  Append revisions to it only.')
 
1744
                '  Append revisions to it only.'),
 
1745
         Option('no-tree',
 
1746
                'Create a branch without a working tree.')
1726
1747
         ]
1727
1748
    def run(self, location=None, format=None, append_revisions_only=False,
1728
 
            create_prefix=False):
 
1749
            create_prefix=False, no_tree=False):
1729
1750
        if format is None:
1730
1751
            format = bzrdir.format_registry.make_bzrdir('default')
1731
1752
        if location is None:
1754
1775
        except errors.NotBranchError:
1755
1776
            # really a NotBzrDir error...
1756
1777
            create_branch = bzrdir.BzrDir.create_branch_convenience
 
1778
            if no_tree:
 
1779
                force_new_tree = False
 
1780
            else:
 
1781
                force_new_tree = None
1757
1782
            branch = create_branch(to_transport.base, format=format,
1758
 
                                   possible_transports=[to_transport])
 
1783
                                   possible_transports=[to_transport],
 
1784
                                   force_new_tree=force_new_tree)
1759
1785
            a_bzrdir = branch.bzrdir
1760
1786
        else:
1761
1787
            from bzrlib.transport.local import LocalTransport
1765
1791
                        raise errors.BranchExistsWithoutWorkingTree(location)
1766
1792
                raise errors.AlreadyBranchError(location)
1767
1793
            branch = a_bzrdir.create_branch()
1768
 
            a_bzrdir.create_workingtree()
 
1794
            if not no_tree:
 
1795
                a_bzrdir.create_workingtree()
1769
1796
        if append_revisions_only:
1770
1797
            try:
1771
1798
                branch.set_append_revisions_only(True)
1865
1892
    "bzr diff -p1" is equivalent to "bzr diff --prefix old/:new/", and
1866
1893
    produces patches suitable for "patch -p1".
1867
1894
 
 
1895
    Note that when using the -r argument with a range of revisions, the
 
1896
    differences are computed between the two specified revisions.  That
 
1897
    is, the command does not show the changes introduced by the first 
 
1898
    revision in the range.  This differs from the interpretation of 
 
1899
    revision ranges used by "bzr log" which includes the first revision
 
1900
    in the range.
 
1901
 
1868
1902
    :Exit values:
1869
1903
        1 - changed
1870
1904
        2 - unrepresentable changes
1888
1922
 
1889
1923
            bzr diff -r1..3 xxx
1890
1924
 
1891
 
        To see the changes introduced in revision X::
 
1925
        The changes introduced by revision 2 (equivalent to -r1..2)::
 
1926
 
 
1927
            bzr diff -c2
 
1928
 
 
1929
        To see the changes introduced by revision X::
1892
1930
        
1893
1931
            bzr diff -cX
1894
1932
 
1898
1936
 
1899
1937
            bzr diff -r<chosen_parent>..X
1900
1938
 
1901
 
        The changes introduced by revision 2 (equivalent to -r1..2)::
 
1939
        The changes between the current revision and the previous revision
 
1940
        (equivalent to -c-1 and -r-2..-1)
1902
1941
 
1903
 
            bzr diff -c2
 
1942
            bzr diff -r-2..
1904
1943
 
1905
1944
        Show just the differences for file NEWS::
1906
1945
 
1921
1960
        Same as 'bzr diff' but prefix paths with old/ and new/::
1922
1961
 
1923
1962
            bzr diff --prefix old/:new/
 
1963
            
 
1964
        Show the differences using a custom diff program with options::
 
1965
        
 
1966
            bzr diff --using /usr/bin/diff --diff-options -wu
1924
1967
    """
1925
1968
    _see_also = ['status']
1926
1969
    takes_args = ['file*']
1946
1989
            type=unicode,
1947
1990
            ),
1948
1991
        RegistryOption('format',
 
1992
            short_name='F',
1949
1993
            help='Diff format to use.',
1950
1994
            lazy_registry=('bzrlib.diff', 'format_registry'),
1951
 
            value_switches=False, title='Diff format'),
 
1995
            title='Diff format'),
1952
1996
        ]
1953
1997
    aliases = ['di', 'dif']
1954
1998
    encoding_type = 'exact'
1985
2029
         old_branch, new_branch,
1986
2030
         specific_files, extra_trees) = get_trees_and_branches_to_diff_locked(
1987
2031
            file_list, revision, old, new, self.add_cleanup, apply_view=True)
 
2032
        # GNU diff on Windows uses ANSI encoding for filenames
 
2033
        path_encoding = osutils.get_diff_header_encoding()
1988
2034
        return show_diff_trees(old_tree, new_tree, sys.stdout,
1989
2035
                               specific_files=specific_files,
1990
2036
                               external_diff_options=diff_options,
1991
2037
                               old_label=old_label, new_label=new_label,
1992
 
                               extra_trees=extra_trees, using=using,
 
2038
                               extra_trees=extra_trees,
 
2039
                               path_encoding=path_encoding,
 
2040
                               using=using,
1993
2041
                               format_cls=format)
1994
2042
 
1995
2043
 
2003
2051
    # level of effort but possibly much less IO.  (Or possibly not,
2004
2052
    # if the directories are very large...)
2005
2053
    _see_also = ['status', 'ls']
2006
 
    takes_options = ['show-ids']
 
2054
    takes_options = ['directory', 'show-ids']
2007
2055
 
2008
2056
    @display_command
2009
 
    def run(self, show_ids=False):
2010
 
        tree = WorkingTree.open_containing(u'.')[0]
2011
 
        tree.lock_read()
2012
 
        self.add_cleanup(tree.unlock)
 
2057
    def run(self, show_ids=False, directory=u'.'):
 
2058
        tree = WorkingTree.open_containing(directory)[0]
 
2059
        self.add_cleanup(tree.lock_read().unlock)
2013
2060
        old = tree.basis_tree()
2014
 
        old.lock_read()
2015
 
        self.add_cleanup(old.unlock)
 
2061
        self.add_cleanup(old.lock_read().unlock)
2016
2062
        for path, ie in old.inventory.iter_entries():
2017
2063
            if not tree.has_id(ie.file_id):
2018
2064
                self.outf.write(path)
2028
2074
 
2029
2075
    hidden = True
2030
2076
    _see_also = ['status', 'ls']
2031
 
    takes_options = [
2032
 
            Option('null',
2033
 
                   help='Write an ascii NUL (\\0) separator '
2034
 
                   'between files rather than a newline.')
2035
 
            ]
 
2077
    takes_options = ['directory', 'null']
2036
2078
 
2037
2079
    @display_command
2038
 
    def run(self, null=False):
2039
 
        tree = WorkingTree.open_containing(u'.')[0]
 
2080
    def run(self, null=False, directory=u'.'):
 
2081
        tree = WorkingTree.open_containing(directory)[0]
 
2082
        self.add_cleanup(tree.lock_read().unlock)
2040
2083
        td = tree.changes_from(tree.basis_tree())
 
2084
        self.cleanup_now()
2041
2085
        for path, id, kind, text_modified, meta_modified in td.modified:
2042
2086
            if null:
2043
2087
                self.outf.write(path + '\0')
2051
2095
 
2052
2096
    hidden = True
2053
2097
    _see_also = ['status', 'ls']
2054
 
    takes_options = [
2055
 
            Option('null',
2056
 
                   help='Write an ascii NUL (\\0) separator '
2057
 
                   'between files rather than a newline.')
2058
 
            ]
 
2098
    takes_options = ['directory', 'null']
2059
2099
 
2060
2100
    @display_command
2061
 
    def run(self, null=False):
2062
 
        wt = WorkingTree.open_containing(u'.')[0]
2063
 
        wt.lock_read()
2064
 
        self.add_cleanup(wt.unlock)
 
2101
    def run(self, null=False, directory=u'.'):
 
2102
        wt = WorkingTree.open_containing(directory)[0]
 
2103
        self.add_cleanup(wt.lock_read().unlock)
2065
2104
        basis = wt.basis_tree()
2066
 
        basis.lock_read()
2067
 
        self.add_cleanup(basis.unlock)
 
2105
        self.add_cleanup(basis.lock_read().unlock)
2068
2106
        basis_inv = basis.inventory
2069
2107
        inv = wt.inventory
2070
2108
        for file_id in inv:
2073
2111
            if inv.is_root(file_id) and len(basis_inv) == 0:
2074
2112
                continue
2075
2113
            path = inv.id2path(file_id)
2076
 
            if not os.access(osutils.abspath(path), os.F_OK):
 
2114
            if not os.access(osutils.pathjoin(wt.basedir, path), os.F_OK):
2077
2115
                continue
2078
2116
            if null:
2079
2117
                self.outf.write(path + '\0')
2279
2317
                   help='Show just the specified revision.'
2280
2318
                   ' See also "help revisionspec".'),
2281
2319
            'log-format',
 
2320
            RegistryOption('authors',
 
2321
                'What names to list as authors - first, all or committer.',
 
2322
                title='Authors',
 
2323
                lazy_registry=('bzrlib.log', 'author_list_registry'),
 
2324
            ),
2282
2325
            Option('levels',
2283
2326
                   short_name='n',
2284
2327
                   help='Number of levels to display - 0 for all, 1 for flat.',
2319
2362
            limit=None,
2320
2363
            show_diff=False,
2321
2364
            include_merges=False,
 
2365
            authors=None,
2322
2366
            exclude_common_ancestry=False,
2323
2367
            ):
2324
2368
        from bzrlib.log import (
2352
2396
        if file_list:
2353
2397
            # find the file ids to log and check for directory filtering
2354
2398
            b, file_info_list, rev1, rev2 = _get_info_for_log_files(
2355
 
                revision, file_list)
2356
 
            self.add_cleanup(b.unlock)
 
2399
                revision, file_list, self.add_cleanup)
2357
2400
            for relpath, file_id, kind in file_info_list:
2358
2401
                if file_id is None:
2359
2402
                    raise errors.BzrCommandError(
2377
2420
                location = '.'
2378
2421
            dir, relpath = bzrdir.BzrDir.open_containing(location)
2379
2422
            b = dir.open_branch()
2380
 
            b.lock_read()
2381
 
            self.add_cleanup(b.unlock)
 
2423
            self.add_cleanup(b.lock_read().unlock)
2382
2424
            rev1, rev2 = _get_revision_range(revision, b, self.name())
2383
2425
 
2384
2426
        # Decide on the type of delta & diff filtering to use
2404
2446
                        show_timezone=timezone,
2405
2447
                        delta_format=get_verbosity_level(),
2406
2448
                        levels=levels,
2407
 
                        show_advice=levels is None)
 
2449
                        show_advice=levels is None,
 
2450
                        author_list_handler=authors)
2408
2451
 
2409
2452
        # Choose the algorithm for doing the logging. It's annoying
2410
2453
        # having multiple code paths like this but necessary until
2508
2551
        tree, relpath = WorkingTree.open_containing(filename)
2509
2552
        file_id = tree.path2id(relpath)
2510
2553
        b = tree.branch
2511
 
        b.lock_read()
2512
 
        self.add_cleanup(b.unlock)
 
2554
        self.add_cleanup(b.lock_read().unlock)
2513
2555
        touching_revs = log.find_touching_revisions(b, file_id)
2514
2556
        for revno, revision_id, what in touching_revs:
2515
2557
            self.outf.write("%6d %s\n" % (revno, what))
2528
2570
                   help='Recurse into subdirectories.'),
2529
2571
            Option('from-root',
2530
2572
                   help='Print paths relative to the root of the branch.'),
2531
 
            Option('unknown', help='Print unknown files.'),
 
2573
            Option('unknown', short_name='u',
 
2574
                help='Print unknown files.'),
2532
2575
            Option('versioned', help='Print versioned files.',
2533
2576
                   short_name='V'),
2534
 
            Option('ignored', help='Print ignored files.'),
2535
 
            Option('null',
2536
 
                   help='Write an ascii NUL (\\0) separator '
2537
 
                   'between files rather than a newline.'),
2538
 
            Option('kind',
 
2577
            Option('ignored', short_name='i',
 
2578
                help='Print ignored files.'),
 
2579
            Option('kind', short_name='k',
2539
2580
                   help='List entries of a particular kind: file, directory, symlink.',
2540
2581
                   type=unicode),
 
2582
            'null',
2541
2583
            'show-ids',
 
2584
            'directory',
2542
2585
            ]
2543
2586
    @display_command
2544
2587
    def run(self, revision=None, verbose=False,
2545
2588
            recursive=False, from_root=False,
2546
2589
            unknown=False, versioned=False, ignored=False,
2547
 
            null=False, kind=None, show_ids=False, path=None):
 
2590
            null=False, kind=None, show_ids=False, path=None, directory=None):
2548
2591
 
2549
2592
        if kind and kind not in ('file', 'directory', 'symlink'):
2550
2593
            raise errors.BzrCommandError('invalid kind specified')
2562
2605
                raise errors.BzrCommandError('cannot specify both --from-root'
2563
2606
                                             ' and PATH')
2564
2607
            fs_path = path
2565
 
        tree, branch, relpath = bzrdir.BzrDir.open_containing_tree_or_branch(
2566
 
            fs_path)
 
2608
        tree, branch, relpath = \
 
2609
            _open_directory_or_containing_tree_or_branch(fs_path, directory)
2567
2610
 
2568
2611
        # Calculate the prefix to use
2569
2612
        prefix = None
2584
2627
                view_str = views.view_display_str(view_files)
2585
2628
                note("Ignoring files outside view. View is %s" % view_str)
2586
2629
 
2587
 
        tree.lock_read()
2588
 
        self.add_cleanup(tree.unlock)
 
2630
        self.add_cleanup(tree.lock_read().unlock)
2589
2631
        for fp, fc, fkind, fid, entry in tree.list_files(include_root=False,
2590
2632
            from_dir=relpath, recursive=recursive):
2591
2633
            # Apply additional masking
2638
2680
 
2639
2681
    hidden = True
2640
2682
    _see_also = ['ls']
 
2683
    takes_options = ['directory']
2641
2684
 
2642
2685
    @display_command
2643
 
    def run(self):
2644
 
        for f in WorkingTree.open_containing(u'.')[0].unknowns():
 
2686
    def run(self, directory=u'.'):
 
2687
        for f in WorkingTree.open_containing(directory)[0].unknowns():
2645
2688
            self.outf.write(osutils.quotefn(f) + '\n')
2646
2689
 
2647
2690
 
2674
2717
    Patterns prefixed with '!!' act as regular ignore patterns, but have
2675
2718
    precedence over the '!' exception patterns.
2676
2719
 
2677
 
    Note: ignore patterns containing shell wildcards must be quoted from
2678
 
    the shell on Unix.
 
2720
    :Notes: 
 
2721
        
 
2722
    * Ignore patterns containing shell wildcards must be quoted from
 
2723
      the shell on Unix.
 
2724
 
 
2725
    * Ignore patterns starting with "#" act as comments in the ignore file.
 
2726
      To ignore patterns that begin with that character, use the "RE:" prefix.
2679
2727
 
2680
2728
    :Examples:
2681
2729
        Ignore the top level Makefile::
2690
2738
 
2691
2739
            bzr ignore "!special.class"
2692
2740
 
 
2741
        Ignore files whose name begins with the "#" character::
 
2742
 
 
2743
            bzr ignore "RE:^#"
 
2744
 
2693
2745
        Ignore .o files under the lib directory::
2694
2746
 
2695
2747
            bzr ignore "lib/**/*.o"
2712
2764
 
2713
2765
    _see_also = ['status', 'ignored', 'patterns']
2714
2766
    takes_args = ['name_pattern*']
2715
 
    takes_options = [
 
2767
    takes_options = ['directory',
2716
2768
        Option('default-rules',
2717
2769
               help='Display the default ignore rules that bzr uses.')
2718
2770
        ]
2719
2771
 
2720
 
    def run(self, name_pattern_list=None, default_rules=None):
 
2772
    def run(self, name_pattern_list=None, default_rules=None,
 
2773
            directory=u'.'):
2721
2774
        from bzrlib import ignores
2722
2775
        if default_rules is not None:
2723
2776
            # dump the default rules and exit
2729
2782
                "NAME_PATTERN or --default-rules.")
2730
2783
        name_pattern_list = [globbing.normalize_pattern(p)
2731
2784
                             for p in name_pattern_list]
 
2785
        bad_patterns = ''
 
2786
        for p in name_pattern_list:
 
2787
            if not globbing.Globster.is_pattern_valid(p):
 
2788
                bad_patterns += ('\n  %s' % p)
 
2789
        if bad_patterns:
 
2790
            msg = ('Invalid ignore pattern(s) found. %s' % bad_patterns)
 
2791
            ui.ui_factory.show_error(msg)
 
2792
            raise errors.InvalidPattern('')
2732
2793
        for name_pattern in name_pattern_list:
2733
2794
            if (name_pattern[0] == '/' or
2734
2795
                (len(name_pattern) > 1 and name_pattern[1] == ':')):
2735
2796
                raise errors.BzrCommandError(
2736
2797
                    "NAME_PATTERN should not be an absolute path")
2737
 
        tree, relpath = WorkingTree.open_containing(u'.')
 
2798
        tree, relpath = WorkingTree.open_containing(directory)
2738
2799
        ignores.tree_ignores_add_patterns(tree, name_pattern_list)
2739
2800
        ignored = globbing.Globster(name_pattern_list)
2740
2801
        matches = []
2741
 
        tree.lock_read()
 
2802
        self.add_cleanup(tree.lock_read().unlock)
2742
2803
        for entry in tree.list_files():
2743
2804
            id = entry[3]
2744
2805
            if id is not None:
2745
2806
                filename = entry[0]
2746
2807
                if ignored.match(filename):
2747
2808
                    matches.append(filename)
2748
 
        tree.unlock()
2749
2809
        if len(matches) > 0:
2750
2810
            self.outf.write("Warning: the following files are version controlled and"
2751
2811
                  " match your ignore pattern:\n%s"
2766
2826
 
2767
2827
    encoding_type = 'replace'
2768
2828
    _see_also = ['ignore', 'ls']
 
2829
    takes_options = ['directory']
2769
2830
 
2770
2831
    @display_command
2771
 
    def run(self):
2772
 
        tree = WorkingTree.open_containing(u'.')[0]
2773
 
        tree.lock_read()
2774
 
        self.add_cleanup(tree.unlock)
 
2832
    def run(self, directory=u'.'):
 
2833
        tree = WorkingTree.open_containing(directory)[0]
 
2834
        self.add_cleanup(tree.lock_read().unlock)
2775
2835
        for path, file_class, kind, file_id, entry in tree.list_files():
2776
2836
            if file_class != 'I':
2777
2837
                continue
2788
2848
    """
2789
2849
    hidden = True
2790
2850
    takes_args = ['revno']
 
2851
    takes_options = ['directory']
2791
2852
 
2792
2853
    @display_command
2793
 
    def run(self, revno):
 
2854
    def run(self, revno, directory=u'.'):
2794
2855
        try:
2795
2856
            revno = int(revno)
2796
2857
        except ValueError:
2797
2858
            raise errors.BzrCommandError("not a valid revision-number: %r"
2798
2859
                                         % revno)
2799
 
        revid = WorkingTree.open_containing(u'.')[0].branch.get_rev_id(revno)
 
2860
        revid = WorkingTree.open_containing(directory)[0].branch.get_rev_id(revno)
2800
2861
        self.outf.write("%s\n" % revid)
2801
2862
 
2802
2863
 
2829
2890
      =================       =========================
2830
2891
    """
2831
2892
    takes_args = ['dest', 'branch_or_subdir?']
2832
 
    takes_options = [
 
2893
    takes_options = ['directory',
2833
2894
        Option('format',
2834
2895
               help="Type of file to export to.",
2835
2896
               type=unicode),
2844
2905
                    'revision in which it was changed.'),
2845
2906
        ]
2846
2907
    def run(self, dest, branch_or_subdir=None, revision=None, format=None,
2847
 
        root=None, filters=False, per_file_timestamps=False):
 
2908
        root=None, filters=False, per_file_timestamps=False, directory=u'.'):
2848
2909
        from bzrlib.export import export
2849
2910
 
2850
2911
        if branch_or_subdir is None:
2851
 
            tree = WorkingTree.open_containing(u'.')[0]
 
2912
            tree = WorkingTree.open_containing(directory)[0]
2852
2913
            b = tree.branch
2853
2914
            subdir = None
2854
2915
        else:
2873
2934
    """
2874
2935
 
2875
2936
    _see_also = ['ls']
2876
 
    takes_options = [
 
2937
    takes_options = ['directory',
2877
2938
        Option('name-from-revision', help='The path name in the old tree.'),
2878
2939
        Option('filters', help='Apply content filters to display the '
2879
2940
                'convenience form.'),
2884
2945
 
2885
2946
    @display_command
2886
2947
    def run(self, filename, revision=None, name_from_revision=False,
2887
 
            filters=False):
 
2948
            filters=False, directory=None):
2888
2949
        if revision is not None and len(revision) != 1:
2889
2950
            raise errors.BzrCommandError("bzr cat --revision takes exactly"
2890
2951
                                         " one revision specifier")
2891
2952
        tree, branch, relpath = \
2892
 
            bzrdir.BzrDir.open_containing_tree_or_branch(filename)
2893
 
        branch.lock_read()
2894
 
        self.add_cleanup(branch.unlock)
 
2953
            _open_directory_or_containing_tree_or_branch(filename, directory)
 
2954
        self.add_cleanup(branch.lock_read().unlock)
2895
2955
        return self._run(tree, branch, relpath, filename, revision,
2896
2956
                         name_from_revision, filters)
2897
2957
 
2900
2960
        if tree is None:
2901
2961
            tree = b.basis_tree()
2902
2962
        rev_tree = _get_one_revision_tree('cat', revision, branch=b)
2903
 
        rev_tree.lock_read()
2904
 
        self.add_cleanup(rev_tree.unlock)
 
2963
        self.add_cleanup(rev_tree.lock_read().unlock)
2905
2964
 
2906
2965
        old_file_id = rev_tree.path2id(relpath)
2907
2966
 
3128
3187
 
3129
3188
        properties = {}
3130
3189
 
3131
 
        tree, selected_list = tree_files(selected_list)
 
3190
        tree, selected_list = WorkingTree.open_containing_paths(selected_list)
3132
3191
        if selected_list == ['']:
3133
3192
            # workaround - commit of root of tree should be exactly the same
3134
3193
            # as just default commit in that tree, and succeed even though
3169
3228
        def get_message(commit_obj):
3170
3229
            """Callback to get commit message"""
3171
3230
            if file:
3172
 
                my_message = codecs.open(
3173
 
                    file, 'rt', osutils.get_user_encoding()).read()
 
3231
                f = open(file)
 
3232
                try:
 
3233
                    my_message = f.read().decode(osutils.get_user_encoding())
 
3234
                finally:
 
3235
                    f.close()
3174
3236
            elif message is not None:
3175
3237
                my_message = message
3176
3238
            else:
3205
3267
                        reporter=None, verbose=verbose, revprops=properties,
3206
3268
                        authors=author, timestamp=commit_stamp,
3207
3269
                        timezone=offset,
3208
 
                        exclude=safe_relpath_files(tree, exclude))
 
3270
                        exclude=tree.safe_relpath_files(exclude))
3209
3271
        except PointlessCommit:
3210
3272
            raise errors.BzrCommandError("No changes to commit."
3211
3273
                              " Use --unchanged to commit anyhow.")
3295
3357
 
3296
3358
 
3297
3359
class cmd_upgrade(Command):
3298
 
    __doc__ = """Upgrade branch storage to current format.
3299
 
 
3300
 
    The check command or bzr developers may sometimes advise you to run
3301
 
    this command. When the default format has changed you may also be warned
3302
 
    during other operations to upgrade.
 
3360
    __doc__ = """Upgrade a repository, branch or working tree to a newer format.
 
3361
 
 
3362
    When the default format has changed after a major new release of
 
3363
    Bazaar, you may be informed during certain operations that you
 
3364
    should upgrade. Upgrading to a newer format may improve performance
 
3365
    or make new features available. It may however limit interoperability
 
3366
    with older repositories or with older versions of Bazaar.
 
3367
 
 
3368
    If you wish to upgrade to a particular format rather than the
 
3369
    current default, that can be specified using the --format option.
 
3370
    As a consequence, you can use the upgrade command this way to
 
3371
    "downgrade" to an earlier format, though some conversions are
 
3372
    a one way process (e.g. changing from the 1.x default to the
 
3373
    2.x default) so downgrading is not always possible.
 
3374
 
 
3375
    A backup.bzr.~#~ directory is created at the start of the conversion
 
3376
    process (where # is a number). By default, this is left there on
 
3377
    completion. If the conversion fails, delete the new .bzr directory
 
3378
    and rename this one back in its place. Use the --clean option to ask
 
3379
    for the backup.bzr directory to be removed on successful conversion.
 
3380
    Alternatively, you can delete it by hand if everything looks good
 
3381
    afterwards.
 
3382
 
 
3383
    If the location given is a shared repository, dependent branches
 
3384
    are also converted provided the repository converts successfully.
 
3385
    If the conversion of a branch fails, remaining branches are still
 
3386
    tried.
 
3387
 
 
3388
    For more information on upgrades, see the Bazaar Upgrade Guide,
 
3389
    http://doc.bazaar.canonical.com/latest/en/upgrade-guide/.
3303
3390
    """
3304
3391
 
3305
 
    _see_also = ['check']
 
3392
    _see_also = ['check', 'reconcile', 'formats']
3306
3393
    takes_args = ['url?']
3307
3394
    takes_options = [
3308
 
                    RegistryOption('format',
3309
 
                        help='Upgrade to a specific format.  See "bzr help'
3310
 
                             ' formats" for details.',
3311
 
                        lazy_registry=('bzrlib.bzrdir', 'format_registry'),
3312
 
                        converter=lambda name: bzrdir.format_registry.make_bzrdir(name),
3313
 
                        value_switches=True, title='Branch format'),
3314
 
                    ]
 
3395
        RegistryOption('format',
 
3396
            help='Upgrade to a specific format.  See "bzr help'
 
3397
                 ' formats" for details.',
 
3398
            lazy_registry=('bzrlib.bzrdir', 'format_registry'),
 
3399
            converter=lambda name: bzrdir.format_registry.make_bzrdir(name),
 
3400
            value_switches=True, title='Branch format'),
 
3401
        Option('clean',
 
3402
            help='Remove the backup.bzr directory if successful.'),
 
3403
        Option('dry-run',
 
3404
            help="Show what would be done, but don't actually do anything."),
 
3405
    ]
3315
3406
 
3316
 
    def run(self, url='.', format=None):
 
3407
    def run(self, url='.', format=None, clean=False, dry_run=False):
3317
3408
        from bzrlib.upgrade import upgrade
3318
 
        upgrade(url, format)
 
3409
        exceptions = upgrade(url, format, clean_up=clean, dry_run=dry_run)
 
3410
        if exceptions:
 
3411
            if len(exceptions) == 1:
 
3412
                # Compatibility with historical behavior
 
3413
                raise exceptions[0]
 
3414
            else:
 
3415
                return 3
3319
3416
 
3320
3417
 
3321
3418
class cmd_whoami(Command):
3330
3427
 
3331
3428
            bzr whoami "Frank Chu <fchu@example.com>"
3332
3429
    """
3333
 
    takes_options = [ Option('email',
 
3430
    takes_options = [ 'directory',
 
3431
                      Option('email',
3334
3432
                             help='Display email address only.'),
3335
3433
                      Option('branch',
3336
3434
                             help='Set identity for the current branch instead of '
3340
3438
    encoding_type = 'replace'
3341
3439
 
3342
3440
    @display_command
3343
 
    def run(self, email=False, branch=False, name=None):
 
3441
    def run(self, email=False, branch=False, name=None, directory=None):
3344
3442
        if name is None:
3345
 
            # use branch if we're inside one; otherwise global config
3346
 
            try:
3347
 
                c = Branch.open_containing('.')[0].get_config()
3348
 
            except errors.NotBranchError:
3349
 
                c = config.GlobalConfig()
 
3443
            if directory is None:
 
3444
                # use branch if we're inside one; otherwise global config
 
3445
                try:
 
3446
                    c = Branch.open_containing(u'.')[0].get_config()
 
3447
                except errors.NotBranchError:
 
3448
                    c = _mod_config.GlobalConfig()
 
3449
            else:
 
3450
                c = Branch.open(directory).get_config()
3350
3451
            if email:
3351
3452
                self.outf.write(c.user_email() + '\n')
3352
3453
            else:
3353
3454
                self.outf.write(c.username() + '\n')
3354
3455
            return
3355
3456
 
 
3457
        if email:
 
3458
            raise errors.BzrCommandError("--email can only be used to display existing "
 
3459
                                         "identity")
 
3460
 
3356
3461
        # display a warning if an email address isn't included in the given name.
3357
3462
        try:
3358
 
            config.extract_email_address(name)
 
3463
            _mod_config.extract_email_address(name)
3359
3464
        except errors.NoEmailInUsername, e:
3360
3465
            warning('"%s" does not seem to contain an email address.  '
3361
3466
                    'This is allowed, but not recommended.', name)
3362
3467
 
3363
3468
        # use global config unless --branch given
3364
3469
        if branch:
3365
 
            c = Branch.open_containing('.')[0].get_config()
 
3470
            if directory is None:
 
3471
                c = Branch.open_containing(u'.')[0].get_config()
 
3472
            else:
 
3473
                c = Branch.open(directory).get_config()
3366
3474
        else:
3367
 
            c = config.GlobalConfig()
 
3475
            c = _mod_config.GlobalConfig()
3368
3476
        c.set_user_option('email', name)
3369
3477
 
3370
3478
 
3380
3488
 
3381
3489
    _see_also = ['info']
3382
3490
    takes_args = ['nickname?']
3383
 
    def run(self, nickname=None):
3384
 
        branch = Branch.open_containing(u'.')[0]
 
3491
    takes_options = ['directory']
 
3492
    def run(self, nickname=None, directory=u'.'):
 
3493
        branch = Branch.open_containing(directory)[0]
3385
3494
        if nickname is None:
3386
3495
            self.printme(branch)
3387
3496
        else:
3436
3545
                'bzr alias --remove expects an alias to remove.')
3437
3546
        # If alias is not found, print something like:
3438
3547
        # unalias: foo: not found
3439
 
        c = config.GlobalConfig()
 
3548
        c = _mod_config.GlobalConfig()
3440
3549
        c.unset_alias(alias_name)
3441
3550
 
3442
3551
    @display_command
3443
3552
    def print_aliases(self):
3444
3553
        """Print out the defined aliases in a similar format to bash."""
3445
 
        aliases = config.GlobalConfig().get_aliases()
 
3554
        aliases = _mod_config.GlobalConfig().get_aliases()
3446
3555
        for key, value in sorted(aliases.iteritems()):
3447
3556
            self.outf.write('bzr alias %s="%s"\n' % (key, value))
3448
3557
 
3458
3567
 
3459
3568
    def set_alias(self, alias_name, alias_command):
3460
3569
        """Save the alias in the global config."""
3461
 
        c = config.GlobalConfig()
 
3570
        c = _mod_config.GlobalConfig()
3462
3571
        c.set_alias(alias_name, alias_command)
3463
3572
 
3464
3573
 
3499
3608
    If you set BZR_TEST_PDB=1 when running selftest, failing tests will drop
3500
3609
    into a pdb postmortem session.
3501
3610
 
 
3611
    The --coverage=DIRNAME global option produces a report with covered code
 
3612
    indicated.
 
3613
 
3502
3614
    :Examples:
3503
3615
        Run only tests relating to 'ignore'::
3504
3616
 
3537
3649
                                 'throughout the test suite.',
3538
3650
                            type=get_transport_type),
3539
3651
                     Option('benchmark',
3540
 
                            help='Run the benchmarks rather than selftests.'),
 
3652
                            help='Run the benchmarks rather than selftests.',
 
3653
                            hidden=True),
3541
3654
                     Option('lsprof-timed',
3542
3655
                            help='Generate lsprof output for benchmarked'
3543
3656
                                 ' sections of code.'),
3544
3657
                     Option('lsprof-tests',
3545
3658
                            help='Generate lsprof output for each test.'),
3546
 
                     Option('cache-dir', type=str,
3547
 
                            help='Cache intermediate benchmark output in this '
3548
 
                                 'directory.'),
3549
3659
                     Option('first',
3550
3660
                            help='Run all tests, but run specified tests first.',
3551
3661
                            short_name='f',
3585
3695
 
3586
3696
    def run(self, testspecs_list=None, verbose=False, one=False,
3587
3697
            transport=None, benchmark=None,
3588
 
            lsprof_timed=None, cache_dir=None,
 
3698
            lsprof_timed=None,
3589
3699
            first=False, list_only=False,
3590
3700
            randomize=None, exclude=None, strict=False,
3591
3701
            load_list=None, debugflag=None, starting_with=None, subunit=False,
3592
3702
            parallel=None, lsprof_tests=False):
3593
 
        from bzrlib.tests import selftest
3594
 
        import bzrlib.benchmarks as benchmarks
3595
 
        from bzrlib.benchmarks import tree_creator
3596
 
 
3597
 
        # Make deprecation warnings visible, unless -Werror is set
3598
 
        symbol_versioning.activate_deprecation_warnings(override=False)
3599
 
 
3600
 
        if cache_dir is not None:
3601
 
            tree_creator.TreeCreator.CACHE_ROOT = osutils.abspath(cache_dir)
 
3703
        from bzrlib import tests
 
3704
 
3602
3705
        if testspecs_list is not None:
3603
3706
            pattern = '|'.join(testspecs_list)
3604
3707
        else:
3612
3715
            self.additional_selftest_args['runner_class'] = SubUnitBzrRunner
3613
3716
            # On Windows, disable automatic conversion of '\n' to '\r\n' in
3614
3717
            # stdout, which would corrupt the subunit stream. 
3615
 
            if sys.platform == "win32" and sys.stdout.fileno() >= 0:
 
3718
            # FIXME: This has been fixed in subunit trunk (>0.0.5) so the
 
3719
            # following code can be deleted when it's sufficiently deployed
 
3720
            # -- vila/mgz 20100514
 
3721
            if (sys.platform == "win32"
 
3722
                and getattr(sys.stdout, 'fileno', None) is not None):
3616
3723
                import msvcrt
3617
3724
                msvcrt.setmode(sys.stdout.fileno(), os.O_BINARY)
3618
3725
        if parallel:
3619
3726
            self.additional_selftest_args.setdefault(
3620
3727
                'suite_decorators', []).append(parallel)
3621
3728
        if benchmark:
3622
 
            test_suite_factory = benchmarks.test_suite
3623
 
            # Unless user explicitly asks for quiet, be verbose in benchmarks
3624
 
            verbose = not is_quiet()
3625
 
            # TODO: should possibly lock the history file...
3626
 
            benchfile = open(".perf_history", "at", buffering=1)
3627
 
            self.add_cleanup(benchfile.close)
3628
 
        else:
3629
 
            test_suite_factory = None
3630
 
            benchfile = None
 
3729
            raise errors.BzrCommandError(
 
3730
                "--benchmark is no longer supported from bzr 2.2; "
 
3731
                "use bzr-usertest instead")
 
3732
        test_suite_factory = None
3631
3733
        selftest_kwargs = {"verbose": verbose,
3632
3734
                          "pattern": pattern,
3633
3735
                          "stop_on_failure": one,
3635
3737
                          "test_suite_factory": test_suite_factory,
3636
3738
                          "lsprof_timed": lsprof_timed,
3637
3739
                          "lsprof_tests": lsprof_tests,
3638
 
                          "bench_history": benchfile,
3639
3740
                          "matching_tests_first": first,
3640
3741
                          "list_only": list_only,
3641
3742
                          "random_seed": randomize,
3646
3747
                          "starting_with": starting_with
3647
3748
                          }
3648
3749
        selftest_kwargs.update(self.additional_selftest_args)
3649
 
        result = selftest(**selftest_kwargs)
 
3750
 
 
3751
        # Make deprecation warnings visible, unless -Werror is set
 
3752
        cleanup = symbol_versioning.activate_deprecation_warnings(
 
3753
            override=False)
 
3754
        try:
 
3755
            result = tests.selftest(**selftest_kwargs)
 
3756
        finally:
 
3757
            cleanup()
3650
3758
        return int(not result)
3651
3759
 
3652
3760
 
3690
3798
 
3691
3799
        branch1 = Branch.open_containing(branch)[0]
3692
3800
        branch2 = Branch.open_containing(other)[0]
3693
 
        branch1.lock_read()
3694
 
        self.add_cleanup(branch1.unlock)
3695
 
        branch2.lock_read()
3696
 
        self.add_cleanup(branch2.unlock)
 
3801
        self.add_cleanup(branch1.lock_read().unlock)
 
3802
        self.add_cleanup(branch2.lock_read().unlock)
3697
3803
        last1 = ensure_null(branch1.last_revision())
3698
3804
        last2 = ensure_null(branch2.last_revision())
3699
3805
 
3711
3817
    with bzr send. If neither is specified, the default is the upstream branch
3712
3818
    or the branch most recently merged using --remember.
3713
3819
 
3714
 
    When merging a branch, by default the tip will be merged. To pick a different
3715
 
    revision, pass --revision. If you specify two values, the first will be used as
3716
 
    BASE and the second one as OTHER. Merging individual revisions, or a subset of
3717
 
    available revisions, like this is commonly referred to as "cherrypicking".
3718
 
 
3719
 
    Revision numbers are always relative to the branch being merged.
3720
 
 
3721
 
    By default, bzr will try to merge in all new work from the other
3722
 
    branch, automatically determining an appropriate base.  If this
3723
 
    fails, you may need to give an explicit base.
 
3820
    When merging from a branch, by default bzr will try to merge in all new
 
3821
    work from the other branch, automatically determining an appropriate base
 
3822
    revision.  If this fails, you may need to give an explicit base.
 
3823
 
 
3824
    To pick a different ending revision, pass "--revision OTHER".  bzr will
 
3825
    try to merge in all new work up to and including revision OTHER.
 
3826
 
 
3827
    If you specify two values, "--revision BASE..OTHER", only revisions BASE
 
3828
    through OTHER, excluding BASE but including OTHER, will be merged.  If this
 
3829
    causes some revisions to be skipped, i.e. if the destination branch does
 
3830
    not already contain revision BASE, such a merge is commonly referred to as
 
3831
    a "cherrypick".
 
3832
 
 
3833
    Revision numbers are always relative to the source branch.
3724
3834
 
3725
3835
    Merge will do its best to combine the changes in two branches, but there
3726
3836
    are some kinds of problems only a human can fix.  When it encounters those,
3750
3860
    you to apply each diff hunk and file change, similar to "shelve".
3751
3861
 
3752
3862
    :Examples:
3753
 
        To merge the latest revision from bzr.dev::
 
3863
        To merge all new revisions from bzr.dev::
3754
3864
 
3755
3865
            bzr merge ../bzr.dev
3756
3866
 
3793
3903
                ' completely merged into the source, pull from the'
3794
3904
                ' source rather than merging.  When this happens,'
3795
3905
                ' you do not need to commit the result.'),
3796
 
        Option('directory',
 
3906
        custom_help('directory',
3797
3907
               help='Branch to merge into, '
3798
 
                    'rather than the one containing the working directory.',
3799
 
               short_name='d',
3800
 
               type=unicode,
3801
 
               ),
 
3908
                    'rather than the one containing the working directory.'),
3802
3909
        Option('preview', help='Instead of merging, show a diff of the'
3803
3910
               ' merge.'),
3804
3911
        Option('interactive', help='Select changes interactively.',
3837
3944
            unversioned_filter=tree.is_ignored, view_info=view_info)
3838
3945
        pb = ui.ui_factory.nested_progress_bar()
3839
3946
        self.add_cleanup(pb.finished)
3840
 
        tree.lock_write()
3841
 
        self.add_cleanup(tree.unlock)
 
3947
        self.add_cleanup(tree.lock_write().unlock)
3842
3948
        if location is not None:
3843
3949
            try:
3844
3950
                mergeable = bundle.read_mergeable_from_url(location,
3905
4011
    def _do_preview(self, merger):
3906
4012
        from bzrlib.diff import show_diff_trees
3907
4013
        result_tree = self._get_preview(merger)
 
4014
        path_encoding = osutils.get_diff_header_encoding()
3908
4015
        show_diff_trees(merger.this_tree, result_tree, self.outf,
3909
 
                        old_label='', new_label='')
 
4016
                        old_label='', new_label='',
 
4017
                        path_encoding=path_encoding)
3910
4018
 
3911
4019
    def _do_merge(self, merger, change_reporter, allow_pending, verified):
3912
4020
        merger.change_reporter = change_reporter
3992
4100
        if ((remember or tree.branch.get_submit_branch() is None) and
3993
4101
             user_location is not None):
3994
4102
            tree.branch.set_submit_branch(other_branch.base)
3995
 
        _merge_tags_if_possible(other_branch, tree.branch)
 
4103
        # Merge tags (but don't set them in the master branch yet, the user
 
4104
        # might revert this merge).  Commit will propagate them.
 
4105
        _merge_tags_if_possible(other_branch, tree.branch, ignore_master=True)
3996
4106
        merger = _mod_merge.Merger.from_revision_ids(pb, tree,
3997
4107
            other_revision_id, base_revision_id, other_branch, base_branch)
3998
4108
        if other_path != '':
4099
4209
        from bzrlib.conflicts import restore
4100
4210
        if merge_type is None:
4101
4211
            merge_type = _mod_merge.Merge3Merger
4102
 
        tree, file_list = tree_files(file_list)
4103
 
        tree.lock_write()
4104
 
        self.add_cleanup(tree.unlock)
 
4212
        tree, file_list = WorkingTree.open_containing_paths(file_list)
 
4213
        self.add_cleanup(tree.lock_write().unlock)
4105
4214
        parents = tree.get_parent_ids()
4106
4215
        if len(parents) != 2:
4107
4216
            raise errors.BzrCommandError("Sorry, remerge only works after normal"
4167
4276
    last committed revision is used.
4168
4277
 
4169
4278
    To remove only some changes, without reverting to a prior version, use
4170
 
    merge instead.  For example, "merge . --revision -2..-3" will remove the
4171
 
    changes introduced by -2, without affecting the changes introduced by -1.
4172
 
    Or to remove certain changes on a hunk-by-hunk basis, see the Shelf plugin.
 
4279
    merge instead.  For example, "merge . -r -2..-3" (don't forget the ".")
 
4280
    will remove the changes introduced by the second last commit (-2), without
 
4281
    affecting the changes introduced by the last commit (-1).  To remove
 
4282
    certain changes on a hunk-by-hunk basis, see the shelve command.
4173
4283
 
4174
4284
    By default, any files that have been manually changed will be backed up
4175
4285
    first.  (Files changed only by merge are not backed up.)  Backup files have
4205
4315
    target branches.
4206
4316
    """
4207
4317
 
4208
 
    _see_also = ['cat', 'export']
 
4318
    _see_also = ['cat', 'export', 'merge', 'shelve']
4209
4319
    takes_options = [
4210
4320
        'revision',
4211
4321
        Option('no-backup', "Do not save backups of reverted files."),
4216
4326
 
4217
4327
    def run(self, revision=None, no_backup=False, file_list=None,
4218
4328
            forget_merges=None):
4219
 
        tree, file_list = tree_files(file_list)
4220
 
        tree.lock_tree_write()
4221
 
        self.add_cleanup(tree.unlock)
 
4329
        tree, file_list = WorkingTree.open_containing_paths(file_list)
 
4330
        self.add_cleanup(tree.lock_tree_write().unlock)
4222
4331
        if forget_merges:
4223
4332
            tree.set_parent_ids(tree.get_parent_ids()[:1])
4224
4333
        else:
4313
4422
    _see_also = ['merge', 'pull']
4314
4423
    takes_args = ['other_branch?']
4315
4424
    takes_options = [
 
4425
        'directory',
4316
4426
        Option('reverse', 'Reverse the order of revisions.'),
4317
4427
        Option('mine-only',
4318
4428
               'Display changes in the local branch only.'),
4340
4450
            theirs_only=False,
4341
4451
            log_format=None, long=False, short=False, line=False,
4342
4452
            show_ids=False, verbose=False, this=False, other=False,
4343
 
            include_merges=False, revision=None, my_revision=None):
 
4453
            include_merges=False, revision=None, my_revision=None,
 
4454
            directory=u'.'):
4344
4455
        from bzrlib.missing import find_unmerged, iter_log_revisions
4345
4456
        def message(s):
4346
4457
            if not is_quiet():
4359
4470
        elif theirs_only:
4360
4471
            restrict = 'remote'
4361
4472
 
4362
 
        local_branch = Branch.open_containing(u".")[0]
4363
 
        local_branch.lock_read()
4364
 
        self.add_cleanup(local_branch.unlock)
 
4473
        local_branch = Branch.open_containing(directory)[0]
 
4474
        self.add_cleanup(local_branch.lock_read().unlock)
4365
4475
 
4366
4476
        parent = local_branch.get_parent()
4367
4477
        if other_branch is None:
4378
4488
        if remote_branch.base == local_branch.base:
4379
4489
            remote_branch = local_branch
4380
4490
        else:
4381
 
            remote_branch.lock_read()
4382
 
            self.add_cleanup(remote_branch.unlock)
 
4491
            self.add_cleanup(remote_branch.lock_read().unlock)
4383
4492
 
4384
4493
        local_revid_range = _revision_range_to_revid_range(
4385
4494
            _get_revision_range(my_revision, local_branch,
4440
4549
            message("Branches are up to date.\n")
4441
4550
        self.cleanup_now()
4442
4551
        if not status_code and parent is None and other_branch is not None:
4443
 
            local_branch.lock_write()
4444
 
            self.add_cleanup(local_branch.unlock)
 
4552
            self.add_cleanup(local_branch.lock_write().unlock)
4445
4553
            # handle race conditions - a parent might be set while we run.
4446
4554
            if local_branch.get_parent() is None:
4447
4555
                local_branch.set_parent(remote_branch.base)
4506
4614
 
4507
4615
    @display_command
4508
4616
    def run(self, verbose=False):
4509
 
        import bzrlib.plugin
4510
 
        from inspect import getdoc
4511
 
        result = []
4512
 
        for name, plugin in bzrlib.plugin.plugins().items():
4513
 
            version = plugin.__version__
4514
 
            if version == 'unknown':
4515
 
                version = ''
4516
 
            name_ver = '%s %s' % (name, version)
4517
 
            d = getdoc(plugin.module)
4518
 
            if d:
4519
 
                doc = d.split('\n')[0]
4520
 
            else:
4521
 
                doc = '(no description)'
4522
 
            result.append((name_ver, doc, plugin.path()))
4523
 
        for name_ver, doc, path in sorted(result):
4524
 
            self.outf.write("%s\n" % name_ver)
4525
 
            self.outf.write("   %s\n" % doc)
4526
 
            if verbose:
4527
 
                self.outf.write("   %s\n" % path)
4528
 
            self.outf.write("\n")
 
4617
        from bzrlib import plugin
 
4618
        self.outf.writelines(
 
4619
            plugin.describe_plugins(show_paths=verbose))
4529
4620
 
4530
4621
 
4531
4622
class cmd_testament(Command):
4547
4638
            b = Branch.open_containing(branch)[0]
4548
4639
        else:
4549
4640
            b = Branch.open(branch)
4550
 
        b.lock_read()
4551
 
        self.add_cleanup(b.unlock)
 
4641
        self.add_cleanup(b.lock_read().unlock)
4552
4642
        if revision is None:
4553
4643
            rev_id = b.last_revision()
4554
4644
        else:
4578
4668
                     Option('long', help='Show commit date in annotations.'),
4579
4669
                     'revision',
4580
4670
                     'show-ids',
 
4671
                     'directory',
4581
4672
                     ]
4582
4673
    encoding_type = 'exact'
4583
4674
 
4584
4675
    @display_command
4585
4676
    def run(self, filename, all=False, long=False, revision=None,
4586
 
            show_ids=False):
 
4677
            show_ids=False, directory=None):
4587
4678
        from bzrlib.annotate import annotate_file, annotate_file_tree
4588
4679
        wt, branch, relpath = \
4589
 
            bzrdir.BzrDir.open_containing_tree_or_branch(filename)
 
4680
            _open_directory_or_containing_tree_or_branch(filename, directory)
4590
4681
        if wt is not None:
4591
 
            wt.lock_read()
4592
 
            self.add_cleanup(wt.unlock)
 
4682
            self.add_cleanup(wt.lock_read().unlock)
4593
4683
        else:
4594
 
            branch.lock_read()
4595
 
            self.add_cleanup(branch.unlock)
 
4684
            self.add_cleanup(branch.lock_read().unlock)
4596
4685
        tree = _get_one_revision_tree('annotate', revision, branch=branch)
4597
 
        tree.lock_read()
4598
 
        self.add_cleanup(tree.unlock)
 
4686
        self.add_cleanup(tree.lock_read().unlock)
4599
4687
        if wt is not None:
4600
4688
            file_id = wt.path2id(relpath)
4601
4689
        else:
4619
4707
 
4620
4708
    hidden = True # is this right ?
4621
4709
    takes_args = ['revision_id*']
4622
 
    takes_options = ['revision']
 
4710
    takes_options = ['directory', 'revision']
4623
4711
 
4624
 
    def run(self, revision_id_list=None, revision=None):
 
4712
    def run(self, revision_id_list=None, revision=None, directory=u'.'):
4625
4713
        if revision_id_list is not None and revision is not None:
4626
4714
            raise errors.BzrCommandError('You can only supply one of revision_id or --revision')
4627
4715
        if revision_id_list is None and revision is None:
4628
4716
            raise errors.BzrCommandError('You must supply either --revision or a revision_id')
4629
 
        b = WorkingTree.open_containing(u'.')[0].branch
4630
 
        b.lock_write()
4631
 
        self.add_cleanup(b.unlock)
 
4717
        b = WorkingTree.open_containing(directory)[0].branch
 
4718
        self.add_cleanup(b.lock_write().unlock)
4632
4719
        return self._run(b, revision_id_list, revision)
4633
4720
 
4634
4721
    def _run(self, b, revision_id_list, revision):
4693
4780
 
4694
4781
    _see_also = ['checkouts', 'unbind']
4695
4782
    takes_args = ['location?']
4696
 
    takes_options = []
 
4783
    takes_options = ['directory']
4697
4784
 
4698
 
    def run(self, location=None):
4699
 
        b, relpath = Branch.open_containing(u'.')
 
4785
    def run(self, location=None, directory=u'.'):
 
4786
        b, relpath = Branch.open_containing(directory)
4700
4787
        if location is None:
4701
4788
            try:
4702
4789
                location = b.get_old_bound_location()
4729
4816
 
4730
4817
    _see_also = ['checkouts', 'bind']
4731
4818
    takes_args = []
4732
 
    takes_options = []
 
4819
    takes_options = ['directory']
4733
4820
 
4734
 
    def run(self):
4735
 
        b, relpath = Branch.open_containing(u'.')
 
4821
    def run(self, directory=u'.'):
 
4822
        b, relpath = Branch.open_containing(directory)
4736
4823
        if not b.unbind():
4737
4824
            raise errors.BzrCommandError('Local branch is not bound')
4738
4825
 
4784
4871
            b = control.open_branch()
4785
4872
 
4786
4873
        if tree is not None:
4787
 
            tree.lock_write()
4788
 
            self.add_cleanup(tree.unlock)
 
4874
            self.add_cleanup(tree.lock_write().unlock)
4789
4875
        else:
4790
 
            b.lock_write()
4791
 
            self.add_cleanup(b.unlock)
 
4876
            self.add_cleanup(b.lock_write().unlock)
4792
4877
        return self._run(b, tree, dry_run, verbose, revision, force, local=local)
4793
4878
 
4794
4879
    def _run(self, b, tree, dry_run, verbose, revision, force, local=False):
4833
4918
            self.outf.write('The above revision(s) will be removed.\n')
4834
4919
 
4835
4920
        if not force:
4836
 
            if not ui.ui_factory.get_boolean('Are you sure'):
4837
 
                self.outf.write('Canceled')
 
4921
            if not ui.ui_factory.confirm_action(
 
4922
                    'Uncommit these revisions',
 
4923
                    'bzrlib.builtins.uncommit',
 
4924
                    {}):
 
4925
                self.outf.write('Canceled\n')
4838
4926
                return 0
4839
4927
 
4840
4928
        mutter('Uncommitting from {%s} to {%s}',
4846
4934
 
4847
4935
 
4848
4936
class cmd_break_lock(Command):
4849
 
    __doc__ = """Break a dead lock on a repository, branch or working directory.
 
4937
    __doc__ = """Break a dead lock.
 
4938
 
 
4939
    This command breaks a lock on a repository, branch, working directory or
 
4940
    config file.
4850
4941
 
4851
4942
    CAUTION: Locks should only be broken when you are sure that the process
4852
4943
    holding the lock has been stopped.
4857
4948
    :Examples:
4858
4949
        bzr break-lock
4859
4950
        bzr break-lock bzr+ssh://example.com/bzr/foo
 
4951
        bzr break-lock --conf ~/.bazaar
4860
4952
    """
 
4953
 
4861
4954
    takes_args = ['location?']
 
4955
    takes_options = [
 
4956
        Option('config',
 
4957
               help='LOCATION is the directory where the config lock is.'),
 
4958
        Option('force',
 
4959
            help='Do not ask for confirmation before breaking the lock.'),
 
4960
        ]
4862
4961
 
4863
 
    def run(self, location=None, show=False):
 
4962
    def run(self, location=None, config=False, force=False):
4864
4963
        if location is None:
4865
4964
            location = u'.'
4866
 
        control, relpath = bzrdir.BzrDir.open_containing(location)
4867
 
        try:
4868
 
            control.break_lock()
4869
 
        except NotImplementedError:
4870
 
            pass
 
4965
        if force:
 
4966
            ui.ui_factory = ui.ConfirmationUserInterfacePolicy(ui.ui_factory,
 
4967
                None,
 
4968
                {'bzrlib.lockdir.break': True})
 
4969
        if config:
 
4970
            conf = _mod_config.LockableConfig(file_name=location)
 
4971
            conf.break_lock()
 
4972
        else:
 
4973
            control, relpath = bzrdir.BzrDir.open_containing(location)
 
4974
            try:
 
4975
                control.break_lock()
 
4976
            except NotImplementedError:
 
4977
                pass
4871
4978
 
4872
4979
 
4873
4980
class cmd_wait_until_signalled(Command):
4902
5009
                    'result in a dynamically allocated port.  The default port '
4903
5010
                    'depends on the protocol.',
4904
5011
               type=str),
4905
 
        Option('directory',
4906
 
               help='Serve contents of this directory.',
4907
 
               type=unicode),
 
5012
        custom_help('directory',
 
5013
               help='Serve contents of this directory.'),
4908
5014
        Option('allow-writes',
4909
5015
               help='By default the server is a readonly server.  Supplying '
4910
5016
                    '--allow-writes enables write access to the contents of '
4937
5043
 
4938
5044
    def run(self, port=None, inet=False, directory=None, allow_writes=False,
4939
5045
            protocol=None):
4940
 
        from bzrlib.transport import get_transport, transport_server_registry
 
5046
        from bzrlib import transport
4941
5047
        if directory is None:
4942
5048
            directory = os.getcwd()
4943
5049
        if protocol is None:
4944
 
            protocol = transport_server_registry.get()
 
5050
            protocol = transport.transport_server_registry.get()
4945
5051
        host, port = self.get_host_and_port(port)
4946
5052
        url = urlutils.local_path_to_url(directory)
4947
5053
        if not allow_writes:
4948
5054
            url = 'readonly+' + url
4949
 
        transport = get_transport(url)
4950
 
        protocol(transport, host, port, inet)
 
5055
        t = transport.get_transport(url)
 
5056
        protocol(t, host, port, inet)
4951
5057
 
4952
5058
 
4953
5059
class cmd_join(Command):
4959
5065
    not part of it.  (Such trees can be produced by "bzr split", but also by
4960
5066
    running "bzr branch" with the target inside a tree.)
4961
5067
 
4962
 
    The result is a combined tree, with the subtree no longer an independant
 
5068
    The result is a combined tree, with the subtree no longer an independent
4963
5069
    part.  This is marked as a merge of the subtree into the containing tree,
4964
5070
    and all history is preserved.
4965
5071
    """
5046
5152
    _see_also = ['send']
5047
5153
 
5048
5154
    takes_options = [
 
5155
        'directory',
5049
5156
        RegistryOption.from_kwargs('patch-type',
5050
5157
            'The type of patch to include in the directive.',
5051
5158
            title='Patch type',
5064
5171
    encoding_type = 'exact'
5065
5172
 
5066
5173
    def run(self, submit_branch=None, public_branch=None, patch_type='bundle',
5067
 
            sign=False, revision=None, mail_to=None, message=None):
 
5174
            sign=False, revision=None, mail_to=None, message=None,
 
5175
            directory=u'.'):
5068
5176
        from bzrlib.revision import ensure_null, NULL_REVISION
5069
5177
        include_patch, include_bundle = {
5070
5178
            'plain': (False, False),
5071
5179
            'diff': (True, False),
5072
5180
            'bundle': (True, True),
5073
5181
            }[patch_type]
5074
 
        branch = Branch.open('.')
 
5182
        branch = Branch.open(directory)
5075
5183
        stored_submit_branch = branch.get_submit_branch()
5076
5184
        if submit_branch is None:
5077
5185
            submit_branch = stored_submit_branch
5162
5270
    given, in which case it is sent to a file.
5163
5271
 
5164
5272
    Mail is sent using your preferred mail program.  This should be transparent
5165
 
    on Windows (it uses MAPI).  On Linux, it requires the xdg-email utility.
 
5273
    on Windows (it uses MAPI).  On Unix, it requires the xdg-email utility.
5166
5274
    If the preferred client can't be found (or used), your editor will be used.
5167
5275
 
5168
5276
    To use a specific mail program, set the mail_client configuration option.
5339
5447
        Option('delete',
5340
5448
            help='Delete this tag rather than placing it.',
5341
5449
            ),
5342
 
        Option('directory',
5343
 
            help='Branch in which to place the tag.',
5344
 
            short_name='d',
5345
 
            type=unicode,
5346
 
            ),
 
5450
        custom_help('directory',
 
5451
            help='Branch in which to place the tag.'),
5347
5452
        Option('force',
5348
5453
            help='Replace existing tags.',
5349
5454
            ),
5357
5462
            revision=None,
5358
5463
            ):
5359
5464
        branch, relpath = Branch.open_containing(directory)
5360
 
        branch.lock_write()
5361
 
        self.add_cleanup(branch.unlock)
 
5465
        self.add_cleanup(branch.lock_write().unlock)
5362
5466
        if delete:
5363
5467
            if tag_name is None:
5364
5468
                raise errors.BzrCommandError("No tag specified to delete.")
5365
5469
            branch.tags.delete_tag(tag_name)
5366
 
            self.outf.write('Deleted tag %s.\n' % tag_name)
 
5470
            note('Deleted tag %s.' % tag_name)
5367
5471
        else:
5368
5472
            if revision:
5369
5473
                if len(revision) != 1:
5381
5485
            if (not force) and branch.tags.has_tag(tag_name):
5382
5486
                raise errors.TagAlreadyExists(tag_name)
5383
5487
            branch.tags.set_tag(tag_name, revision_id)
5384
 
            self.outf.write('Created tag %s.\n' % tag_name)
 
5488
            note('Created tag %s.' % tag_name)
5385
5489
 
5386
5490
 
5387
5491
class cmd_tags(Command):
5392
5496
 
5393
5497
    _see_also = ['tag']
5394
5498
    takes_options = [
5395
 
        Option('directory',
5396
 
            help='Branch whose tags should be displayed.',
5397
 
            short_name='d',
5398
 
            type=unicode,
5399
 
            ),
5400
 
        RegistryOption.from_kwargs('sort',
 
5499
        custom_help('directory',
 
5500
            help='Branch whose tags should be displayed.'),
 
5501
        RegistryOption('sort',
5401
5502
            'Sort tags by different criteria.', title='Sorting',
5402
 
            alpha='Sort tags lexicographically (default).',
5403
 
            time='Sort tags chronologically.',
 
5503
            lazy_registry=('bzrlib.tag', 'tag_sort_methods')
5404
5504
            ),
5405
5505
        'show-ids',
5406
5506
        'revision',
5407
5507
    ]
5408
5508
 
5409
5509
    @display_command
5410
 
    def run(self,
5411
 
            directory='.',
5412
 
            sort='alpha',
5413
 
            show_ids=False,
5414
 
            revision=None,
5415
 
            ):
 
5510
    def run(self, directory='.', sort=None, show_ids=False, revision=None):
 
5511
        from bzrlib.tag import tag_sort_methods
5416
5512
        branch, relpath = Branch.open_containing(directory)
5417
5513
 
5418
5514
        tags = branch.tags.get_tag_dict().items()
5419
5515
        if not tags:
5420
5516
            return
5421
5517
 
5422
 
        branch.lock_read()
5423
 
        self.add_cleanup(branch.unlock)
 
5518
        self.add_cleanup(branch.lock_read().unlock)
5424
5519
        if revision:
5425
5520
            graph = branch.repository.get_graph()
5426
5521
            rev1, rev2 = _get_revision_range(revision, branch, self.name())
5428
5523
            # only show revisions between revid1 and revid2 (inclusive)
5429
5524
            tags = [(tag, revid) for tag, revid in tags if
5430
5525
                graph.is_between(revid, revid1, revid2)]
5431
 
        if sort == 'alpha':
5432
 
            tags.sort()
5433
 
        elif sort == 'time':
5434
 
            timestamps = {}
5435
 
            for tag, revid in tags:
5436
 
                try:
5437
 
                    revobj = branch.repository.get_revision(revid)
5438
 
                except errors.NoSuchRevision:
5439
 
                    timestamp = sys.maxint # place them at the end
5440
 
                else:
5441
 
                    timestamp = revobj.timestamp
5442
 
                timestamps[revid] = timestamp
5443
 
            tags.sort(key=lambda x: timestamps[x[1]])
 
5526
        if sort is None:
 
5527
            sort = tag_sort_methods.get()
 
5528
        sort(branch, tags)
5444
5529
        if not show_ids:
5445
5530
            # [ (tag, revid), ... ] -> [ (tag, dotted_revno), ... ]
5446
5531
            for index, (tag, revid) in enumerate(tags):
5573
5658
    """
5574
5659
 
5575
5660
    takes_args = ['to_location?']
5576
 
    takes_options = [Option('force',
 
5661
    takes_options = ['directory',
 
5662
                     Option('force',
5577
5663
                        help='Switch even if local commits will be lost.'),
5578
5664
                     'revision',
5579
5665
                     Option('create-branch', short_name='b',
5582
5668
                    ]
5583
5669
 
5584
5670
    def run(self, to_location=None, force=False, create_branch=False,
5585
 
            revision=None):
 
5671
            revision=None, directory=u'.'):
5586
5672
        from bzrlib import switch
5587
 
        tree_location = '.'
 
5673
        tree_location = directory
5588
5674
        revision = _get_one_revision('switch', revision)
5589
5675
        control_dir = bzrdir.BzrDir.open_containing(tree_location)[0]
5590
5676
        if to_location is None:
5591
5677
            if revision is None:
5592
5678
                raise errors.BzrCommandError('You must supply either a'
5593
5679
                                             ' revision or a location')
5594
 
            to_location = '.'
 
5680
            to_location = tree_location
5595
5681
        try:
5596
5682
            branch = control_dir.open_branch()
5597
5683
            had_explicit_nick = branch.get_config().has_explicit_nickname()
5732
5818
            name=None,
5733
5819
            switch=None,
5734
5820
            ):
5735
 
        tree, file_list = tree_files(file_list, apply_view=False)
 
5821
        tree, file_list = WorkingTree.open_containing_paths(file_list,
 
5822
            apply_view=False)
5736
5823
        current_view, view_dict = tree.views.get_view_info()
5737
5824
        if name is None:
5738
5825
            name = current_view
5842
5929
            location = "."
5843
5930
        branch = Branch.open_containing(location)[0]
5844
5931
        branch.bzrdir.destroy_branch()
5845
 
        
 
5932
 
5846
5933
 
5847
5934
class cmd_shelve(Command):
5848
5935
    __doc__ = """Temporarily set aside some changes from the current tree.
5867
5954
 
5868
5955
    You can put multiple items on the shelf, and by default, 'unshelve' will
5869
5956
    restore the most recently shelved changes.
 
5957
 
 
5958
    For complicated changes, it is possible to edit the changes in a separate
 
5959
    editor program to decide what the file remaining in the working copy
 
5960
    should look like.  To do this, add the configuration option
 
5961
 
 
5962
        change_editor = PROGRAM @new_path @old_path
 
5963
 
 
5964
    where @new_path is replaced with the path of the new version of the 
 
5965
    file and @old_path is replaced with the path of the old version of 
 
5966
    the file.  The PROGRAM should save the new file with the desired 
 
5967
    contents of the file in the working tree.
 
5968
        
5870
5969
    """
5871
5970
 
5872
5971
    takes_args = ['file*']
5873
5972
 
5874
5973
    takes_options = [
 
5974
        'directory',
5875
5975
        'revision',
5876
5976
        Option('all', help='Shelve all changes.'),
5877
5977
        'message',
5883
5983
        Option('destroy',
5884
5984
               help='Destroy removed changes instead of shelving them.'),
5885
5985
    ]
5886
 
    _see_also = ['unshelve']
 
5986
    _see_also = ['unshelve', 'configuration']
5887
5987
 
5888
5988
    def run(self, revision=None, all=False, file_list=None, message=None,
5889
 
            writer=None, list=False, destroy=False):
 
5989
            writer=None, list=False, destroy=False, directory=None):
5890
5990
        if list:
5891
 
            return self.run_for_list()
 
5991
            return self.run_for_list(directory=directory)
5892
5992
        from bzrlib.shelf_ui import Shelver
5893
5993
        if writer is None:
5894
5994
            writer = bzrlib.option.diff_writer_registry.get()
5895
5995
        try:
5896
5996
            shelver = Shelver.from_args(writer(sys.stdout), revision, all,
5897
 
                file_list, message, destroy=destroy)
 
5997
                file_list, message, destroy=destroy, directory=directory)
5898
5998
            try:
5899
5999
                shelver.run()
5900
6000
            finally:
5902
6002
        except errors.UserAbort:
5903
6003
            return 0
5904
6004
 
5905
 
    def run_for_list(self):
5906
 
        tree = WorkingTree.open_containing('.')[0]
5907
 
        tree.lock_read()
5908
 
        self.add_cleanup(tree.unlock)
 
6005
    def run_for_list(self, directory=None):
 
6006
        if directory is None:
 
6007
            directory = u'.'
 
6008
        tree = WorkingTree.open_containing(directory)[0]
 
6009
        self.add_cleanup(tree.lock_read().unlock)
5909
6010
        manager = tree.get_shelf_manager()
5910
6011
        shelves = manager.active_shelves()
5911
6012
        if len(shelves) == 0:
5929
6030
 
5930
6031
    takes_args = ['shelf_id?']
5931
6032
    takes_options = [
 
6033
        'directory',
5932
6034
        RegistryOption.from_kwargs(
5933
6035
            'action', help="The action to perform.",
5934
6036
            enum_switch=False, value_switches=True,
5942
6044
    ]
5943
6045
    _see_also = ['shelve']
5944
6046
 
5945
 
    def run(self, shelf_id=None, action='apply'):
 
6047
    def run(self, shelf_id=None, action='apply', directory=u'.'):
5946
6048
        from bzrlib.shelf_ui import Unshelver
5947
 
        unshelver = Unshelver.from_args(shelf_id, action)
 
6049
        unshelver = Unshelver.from_args(shelf_id, action, directory=directory)
5948
6050
        try:
5949
6051
            unshelver.run()
5950
6052
        finally:
5966
6068
 
5967
6069
    To check what clean-tree will do, use --dry-run.
5968
6070
    """
5969
 
    takes_options = [Option('ignored', help='Delete all ignored files.'),
 
6071
    takes_options = ['directory',
 
6072
                     Option('ignored', help='Delete all ignored files.'),
5970
6073
                     Option('detritus', help='Delete conflict files, merge'
5971
6074
                            ' backups, and failed selftest dirs.'),
5972
6075
                     Option('unknown',
5975
6078
                            ' deleting them.'),
5976
6079
                     Option('force', help='Do not prompt before deleting.')]
5977
6080
    def run(self, unknown=False, ignored=False, detritus=False, dry_run=False,
5978
 
            force=False):
 
6081
            force=False, directory=u'.'):
5979
6082
        from bzrlib.clean_tree import clean_tree
5980
6083
        if not (unknown or ignored or detritus):
5981
6084
            unknown = True
5982
6085
        if dry_run:
5983
6086
            force = True
5984
 
        clean_tree('.', unknown=unknown, ignored=ignored, detritus=detritus,
5985
 
                   dry_run=dry_run, no_prompt=force)
 
6087
        clean_tree(directory, unknown=unknown, ignored=ignored,
 
6088
                   detritus=detritus, dry_run=dry_run, no_prompt=force)
5986
6089
 
5987
6090
 
5988
6091
class cmd_reference(Command):
6037
6140
    # be only called once.
6038
6141
    for (name, aliases, module_name) in [
6039
6142
        ('cmd_bundle_info', [], 'bzrlib.bundle.commands'),
 
6143
        ('cmd_config', [], 'bzrlib.config'),
6040
6144
        ('cmd_dpush', [], 'bzrlib.foreign'),
6041
6145
        ('cmd_version_info', [], 'bzrlib.cmd_version_info'),
6042
6146
        ('cmd_resolve', ['resolved'], 'bzrlib.conflicts'),
6043
6147
        ('cmd_conflicts', [], 'bzrlib.conflicts'),
6044
6148
        ('cmd_sign_my_commits', [], 'bzrlib.sign_my_commits'),
 
6149
        ('cmd_test_script', [], 'bzrlib.cmd_test_script'),
6045
6150
        ]:
6046
6151
        builtin_command_registry.register_lazy(name, aliases, module_name)