~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/builtins.py

  • Committer: Martin Pool
  • Date: 2011-07-04 21:10:37 UTC
  • mto: (6034.1.1 filter-tree)
  • mto: This revision was merged to the branch mainline in revision 6035.
  • Revision ID: mbp@canonical.com-20110704211037-ro3417imj3oqnqxp
Support exporting tarballs from ContentFilterTree

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,
45
44
    rename_map,
46
45
    revision as _mod_revision,
47
46
    static_tuple,
48
 
    symbol_versioning,
49
47
    timestamp,
50
48
    transport,
51
49
    ui,
52
50
    urlutils,
53
51
    views,
 
52
    gpg,
54
53
    )
55
54
from bzrlib.branch import Branch
56
55
from bzrlib.conflicts import ConflictList
73
72
    _parse_revision_str,
74
73
    )
75
74
from bzrlib.trace import mutter, note, warning, is_quiet, get_verbosity_level
76
 
 
77
 
 
 
75
from bzrlib import (
 
76
    symbol_versioning,
 
77
    )
 
78
 
 
79
 
 
80
@symbol_versioning.deprecated_function(symbol_versioning.deprecated_in((2, 3, 0)))
78
81
def tree_files(file_list, default_branch=u'.', canonicalize=True,
79
82
    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]))
 
83
    return internal_tree_files(file_list, default_branch, canonicalize,
 
84
        apply_view)
86
85
 
87
86
 
88
87
def tree_files_for_add(file_list):
152
151
 
153
152
# XXX: Bad function name; should possibly also be a class method of
154
153
# WorkingTree rather than a function.
 
154
@symbol_versioning.deprecated_function(symbol_versioning.deprecated_in((2, 3, 0)))
155
155
def internal_tree_files(file_list, default_branch=u'.', canonicalize=True,
156
156
    apply_view=True):
157
157
    """Convert command-line paths to a WorkingTree and relative paths.
158
158
 
 
159
    Deprecated: use WorkingTree.open_containing_paths instead.
 
160
 
159
161
    This is typically used for command-line processors that take one or
160
162
    more filenames, and infer the workingtree that contains them.
161
163
 
171
173
 
172
174
    :return: workingtree, [relative_paths]
173
175
    """
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
 
176
    return WorkingTree.open_containing_paths(
 
177
        file_list, default_directory='.',
 
178
        canonicalize=True,
 
179
        apply_view=True)
221
180
 
222
181
 
223
182
def _get_view_info_for_change_reporter(tree):
232
191
    return view_info
233
192
 
234
193
 
 
194
def _open_directory_or_containing_tree_or_branch(filename, directory):
 
195
    """Open the tree or branch containing the specified file, unless
 
196
    the --directory option is used to specify a different branch."""
 
197
    if directory is not None:
 
198
        return (None, Branch.open(directory), filename)
 
199
    return bzrdir.BzrDir.open_containing_tree_or_branch(filename)
 
200
 
 
201
 
235
202
# TODO: Make sure no commands unconditionally use the working directory as a
236
203
# branch.  If a filename argument is used, the first of them should be used to
237
204
# specify the branch.  (Perhaps this can be factored out into some kind of
286
253
    To skip the display of pending merge information altogether, use
287
254
    the no-pending option or specify a file/directory.
288
255
 
289
 
    If a revision argument is given, the status is calculated against
290
 
    that revision, or between two revisions if two are provided.
 
256
    To compare the working directory to a specific revision, pass a
 
257
    single revision to the revision argument.
 
258
 
 
259
    To see which files have changed in a specific revision, or between
 
260
    two revisions, pass a revision range to the revision argument.
 
261
    This will produce the same results as calling 'bzr diff --summarize'.
291
262
    """
292
263
 
293
264
    # TODO: --no-recurse, --recurse options
315
286
            raise errors.BzrCommandError('bzr status --revision takes exactly'
316
287
                                         ' one or two revision specifiers')
317
288
 
318
 
        tree, relfile_list = tree_files(file_list)
 
289
        tree, relfile_list = WorkingTree.open_containing_paths(file_list)
319
290
        # Avoid asking for specific files when that is not needed.
320
291
        if relfile_list == ['']:
321
292
            relfile_list = None
340
311
 
341
312
    hidden = True
342
313
    takes_args = ['revision_id?']
343
 
    takes_options = ['revision']
 
314
    takes_options = ['directory', 'revision']
344
315
    # cat-revision is more for frontends so should be exact
345
316
    encoding = 'strict'
346
317
 
353
324
        self.outf.write(revtext.decode('utf-8'))
354
325
 
355
326
    @display_command
356
 
    def run(self, revision_id=None, revision=None):
 
327
    def run(self, revision_id=None, revision=None, directory=u'.'):
357
328
        if revision_id is not None and revision is not None:
358
329
            raise errors.BzrCommandError('You can only supply one of'
359
330
                                         ' revision_id or --revision')
360
331
        if revision_id is None and revision is None:
361
332
            raise errors.BzrCommandError('You must supply either'
362
333
                                         ' --revision or a revision_id')
363
 
        b = WorkingTree.open_containing(u'.')[0].branch
 
334
 
 
335
        b = bzrdir.BzrDir.open_containing_tree_or_branch(directory)[1]
364
336
 
365
337
        revisions = b.repository.revisions
366
338
        if revisions is None:
444
416
                self.outf.write(page_bytes[:header_end])
445
417
                page_bytes = data
446
418
            self.outf.write('\nPage %d\n' % (page_idx,))
447
 
            decomp_bytes = zlib.decompress(page_bytes)
448
 
            self.outf.write(decomp_bytes)
449
 
            self.outf.write('\n')
 
419
            if len(page_bytes) == 0:
 
420
                self.outf.write('(empty)\n');
 
421
            else:
 
422
                decomp_bytes = zlib.decompress(page_bytes)
 
423
                self.outf.write(decomp_bytes)
 
424
                self.outf.write('\n')
450
425
 
451
426
    def _dump_entries(self, trans, basename):
452
427
        try:
483
458
    takes_options = [
484
459
        Option('force',
485
460
               help='Remove the working tree even if it has '
486
 
                    'uncommitted changes.'),
 
461
                    'uncommitted or shelved changes.'),
487
462
        ]
488
463
 
489
464
    def run(self, location_list, force=False):
503
478
            if not force:
504
479
                if (working.has_changes()):
505
480
                    raise errors.UncommittedChanges(working)
 
481
                if working.get_shelf_manager().last_shelf() is not None:
 
482
                    raise errors.ShelvedChanges(working)
506
483
 
507
484
            if working.user_url != working.branch.user_url:
508
485
                raise errors.BzrCommandError("You cannot remove the working tree"
511
488
            d.destroy_workingtree()
512
489
 
513
490
 
 
491
class cmd_repair_workingtree(Command):
 
492
    __doc__ = """Reset the working tree state file.
 
493
 
 
494
    This is not meant to be used normally, but more as a way to recover from
 
495
    filesystem corruption, etc. This rebuilds the working inventory back to a
 
496
    'known good' state. Any new modifications (adding a file, renaming, etc)
 
497
    will be lost, though modified files will still be detected as such.
 
498
 
 
499
    Most users will want something more like "bzr revert" or "bzr update"
 
500
    unless the state file has become corrupted.
 
501
 
 
502
    By default this attempts to recover the current state by looking at the
 
503
    headers of the state file. If the state file is too corrupted to even do
 
504
    that, you can supply --revision to force the state of the tree.
 
505
    """
 
506
 
 
507
    takes_options = ['revision', 'directory',
 
508
        Option('force',
 
509
               help='Reset the tree even if it doesn\'t appear to be'
 
510
                    ' corrupted.'),
 
511
    ]
 
512
    hidden = True
 
513
 
 
514
    def run(self, revision=None, directory='.', force=False):
 
515
        tree, _ = WorkingTree.open_containing(directory)
 
516
        self.add_cleanup(tree.lock_tree_write().unlock)
 
517
        if not force:
 
518
            try:
 
519
                tree.check_state()
 
520
            except errors.BzrError:
 
521
                pass # There seems to be a real error here, so we'll reset
 
522
            else:
 
523
                # Refuse
 
524
                raise errors.BzrCommandError(
 
525
                    'The tree does not appear to be corrupt. You probably'
 
526
                    ' want "bzr revert" instead. Use "--force" if you are'
 
527
                    ' sure you want to reset the working tree.')
 
528
        if revision is None:
 
529
            revision_ids = None
 
530
        else:
 
531
            revision_ids = [r.as_revision_id(tree.branch) for r in revision]
 
532
        try:
 
533
            tree.reset_state(revision_ids)
 
534
        except errors.BzrError, e:
 
535
            if revision_ids is None:
 
536
                extra = (', the header appears corrupt, try passing -r -1'
 
537
                         ' to set the state to the last commit')
 
538
            else:
 
539
                extra = ''
 
540
            raise errors.BzrCommandError('failed to reset the tree state'
 
541
                                         + extra)
 
542
 
 
543
 
514
544
class cmd_revno(Command):
515
545
    __doc__ = """Show current revision number.
516
546
 
528
558
        if tree:
529
559
            try:
530
560
                wt = WorkingTree.open_containing(location)[0]
531
 
                wt.lock_read()
 
561
                self.add_cleanup(wt.lock_read().unlock)
532
562
            except (errors.NoWorkingTree, errors.NotLocalUrl):
533
563
                raise errors.NoWorkingTree(location)
534
 
            self.add_cleanup(wt.unlock)
535
564
            revid = wt.last_revision()
536
565
            try:
537
566
                revno_t = wt.branch.revision_id_to_dotted_revno(revid)
540
569
            revno = ".".join(str(n) for n in revno_t)
541
570
        else:
542
571
            b = Branch.open_containing(location)[0]
543
 
            b.lock_read()
544
 
            self.add_cleanup(b.unlock)
 
572
            self.add_cleanup(b.lock_read().unlock)
545
573
            revno = b.revno()
546
574
        self.cleanup_now()
547
575
        self.outf.write(str(revno) + '\n')
554
582
    takes_args = ['revision_info*']
555
583
    takes_options = [
556
584
        'revision',
557
 
        Option('directory',
 
585
        custom_help('directory',
558
586
            help='Branch to examine, '
559
 
                 'rather than the one containing the working directory.',
560
 
            short_name='d',
561
 
            type=unicode,
562
 
            ),
 
587
                 'rather than the one containing the working directory.'),
563
588
        Option('tree', help='Show revno of working tree'),
564
589
        ]
565
590
 
570
595
        try:
571
596
            wt = WorkingTree.open_containing(directory)[0]
572
597
            b = wt.branch
573
 
            wt.lock_read()
574
 
            self.add_cleanup(wt.unlock)
 
598
            self.add_cleanup(wt.lock_read().unlock)
575
599
        except (errors.NoWorkingTree, errors.NotLocalUrl):
576
600
            wt = None
577
601
            b = Branch.open_containing(directory)[0]
578
 
            b.lock_read()
579
 
            self.add_cleanup(b.unlock)
 
602
            self.add_cleanup(b.lock_read().unlock)
580
603
        revision_ids = []
581
604
        if revision is not None:
582
605
            revision_ids.extend(rev.as_revision_id(b) for rev in revision)
681
704
                should_print=(not is_quiet()))
682
705
 
683
706
        if base_tree:
684
 
            base_tree.lock_read()
685
 
            self.add_cleanup(base_tree.unlock)
 
707
            self.add_cleanup(base_tree.lock_read().unlock)
686
708
        tree, file_list = tree_files_for_add(file_list)
687
709
        added, ignored = tree.smart_add(file_list, not
688
710
            no_recurse, action=action, save=not dry_run)
759
781
            raise errors.BzrCommandError('invalid kind %r specified' % (kind,))
760
782
 
761
783
        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)
 
784
        work_tree, file_list = WorkingTree.open_containing_paths(file_list)
 
785
        self.add_cleanup(work_tree.lock_read().unlock)
765
786
        if revision is not None:
766
787
            tree = revision.as_tree(work_tree.branch)
767
788
 
768
789
            extra_trees = [work_tree]
769
 
            tree.lock_read()
770
 
            self.add_cleanup(tree.unlock)
 
790
            self.add_cleanup(tree.lock_read().unlock)
771
791
        else:
772
792
            tree = work_tree
773
793
            extra_trees = []
777
797
                                      require_versioned=True)
778
798
            # find_ids_across_trees may include some paths that don't
779
799
            # exist in 'tree'.
780
 
            entries = sorted((tree.id2path(file_id), tree.inventory[file_id])
781
 
                             for file_id in file_ids if file_id in tree)
 
800
            entries = sorted(
 
801
                (tree.id2path(file_id), tree.inventory[file_id])
 
802
                for file_id in file_ids if tree.has_id(file_id))
782
803
        else:
783
804
            entries = tree.inventory.entries()
784
805
 
832
853
            names_list = []
833
854
        if len(names_list) < 2:
834
855
            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)
 
856
        tree, rel_names = WorkingTree.open_containing_paths(names_list, canonicalize=False)
 
857
        self.add_cleanup(tree.lock_tree_write().unlock)
838
858
        self._run(tree, names_list, rel_names, after)
839
859
 
840
860
    def run_auto(self, names_list, after, dry_run):
844
864
        if after:
845
865
            raise errors.BzrCommandError('--after cannot be specified with'
846
866
                                         ' --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)
 
867
        work_tree, file_list = WorkingTree.open_containing_paths(
 
868
            names_list, default_directory='.')
 
869
        self.add_cleanup(work_tree.lock_tree_write().unlock)
850
870
        rename_map.RenameMap.guess_renames(work_tree, dry_run)
851
871
 
852
872
    def _run(self, tree, names_list, rel_names, after):
946
966
    match the remote one, use pull --overwrite. This will work even if the two
947
967
    branches have diverged.
948
968
 
949
 
    If there is no default location set, the first pull will set it.  After
950
 
    that, you can omit the location to use the default.  To change the
951
 
    default, use --remember. The value will only be saved if the remote
952
 
    location can be accessed.
 
969
    If there is no default location set, the first pull will set it (use
 
970
    --no-remember to avoid settting it). After that, you can omit the
 
971
    location to use the default.  To change the default, use --remember. The
 
972
    value will only be saved if the remote location can be accessed.
953
973
 
954
974
    Note: The location can be specified either in the form of a branch,
955
975
    or in the form of a path to a file containing a merge directive generated
960
980
    takes_options = ['remember', 'overwrite', 'revision',
961
981
        custom_help('verbose',
962
982
            help='Show logs of pulled revisions.'),
963
 
        Option('directory',
 
983
        custom_help('directory',
964
984
            help='Branch to pull into, '
965
 
                 'rather than the one containing the working directory.',
966
 
            short_name='d',
967
 
            type=unicode,
968
 
            ),
 
985
                 'rather than the one containing the working directory.'),
969
986
        Option('local',
970
987
            help="Perform a local pull in a bound "
971
988
                 "branch.  Local pulls are not applied to "
972
989
                 "the master branch."
973
990
            ),
 
991
        Option('show-base',
 
992
            help="Show base revision text in conflicts.")
974
993
        ]
975
994
    takes_args = ['location?']
976
995
    encoding_type = 'replace'
977
996
 
978
 
    def run(self, location=None, remember=False, overwrite=False,
 
997
    def run(self, location=None, remember=None, overwrite=False,
979
998
            revision=None, verbose=False,
980
 
            directory=None, local=False):
 
999
            directory=None, local=False,
 
1000
            show_base=False):
981
1001
        # FIXME: too much stuff is in the command class
982
1002
        revision_id = None
983
1003
        mergeable = None
986
1006
        try:
987
1007
            tree_to = WorkingTree.open_containing(directory)[0]
988
1008
            branch_to = tree_to.branch
989
 
            tree_to.lock_write()
990
 
            self.add_cleanup(tree_to.unlock)
 
1009
            self.add_cleanup(tree_to.lock_write().unlock)
991
1010
        except errors.NoWorkingTree:
992
1011
            tree_to = None
993
1012
            branch_to = Branch.open_containing(directory)[0]
994
 
            branch_to.lock_write()
995
 
            self.add_cleanup(branch_to.unlock)
 
1013
            self.add_cleanup(branch_to.lock_write().unlock)
 
1014
 
 
1015
        if tree_to is None and show_base:
 
1016
            raise errors.BzrCommandError("Need working tree for --show-base.")
996
1017
 
997
1018
        if local and not branch_to.get_bound_location():
998
1019
            raise errors.LocalRequiresBoundBranch()
1029
1050
        else:
1030
1051
            branch_from = Branch.open(location,
1031
1052
                possible_transports=possible_transports)
1032
 
            branch_from.lock_read()
1033
 
            self.add_cleanup(branch_from.unlock)
1034
 
 
1035
 
            if branch_to.get_parent() is None or remember:
 
1053
            self.add_cleanup(branch_from.lock_read().unlock)
 
1054
            # Remembers if asked explicitly or no previous location is set
 
1055
            if (remember
 
1056
                or (remember is None and branch_to.get_parent() is None)):
1036
1057
                branch_to.set_parent(branch_from.base)
1037
1058
 
1038
1059
        if revision is not None:
1045
1066
                view_info=view_info)
1046
1067
            result = tree_to.pull(
1047
1068
                branch_from, overwrite, revision_id, change_reporter,
1048
 
                possible_transports=possible_transports, local=local)
 
1069
                possible_transports=possible_transports, local=local,
 
1070
                show_base=show_base)
1049
1071
        else:
1050
1072
            result = branch_to.pull(
1051
1073
                branch_from, overwrite, revision_id, local=local)
1055
1077
            log.show_branch_change(
1056
1078
                branch_to, self.outf, result.old_revno,
1057
1079
                result.old_revid)
 
1080
        if getattr(result, 'tag_conflicts', None):
 
1081
            return 1
 
1082
        else:
 
1083
            return 0
1058
1084
 
1059
1085
 
1060
1086
class cmd_push(Command):
1077
1103
    do a merge (see bzr help merge) from the other branch, and commit that.
1078
1104
    After that you will be able to do a push without '--overwrite'.
1079
1105
 
1080
 
    If there is no default push location set, the first push will set it.
1081
 
    After that, you can omit the location to use the default.  To change the
1082
 
    default, use --remember. The value will only be saved if the remote
1083
 
    location can be accessed.
 
1106
    If there is no default push location set, the first push will set it (use
 
1107
    --no-remember to avoid settting it).  After that, you can omit the
 
1108
    location to use the default.  To change the default, use --remember. The
 
1109
    value will only be saved if the remote location can be accessed.
1084
1110
    """
1085
1111
 
1086
1112
    _see_also = ['pull', 'update', 'working-trees']
1088
1114
        Option('create-prefix',
1089
1115
               help='Create the path leading up to the branch '
1090
1116
                    'if it does not already exist.'),
1091
 
        Option('directory',
 
1117
        custom_help('directory',
1092
1118
            help='Branch to push from, '
1093
 
                 'rather than the one containing the working directory.',
1094
 
            short_name='d',
1095
 
            type=unicode,
1096
 
            ),
 
1119
                 'rather than the one containing the working directory.'),
1097
1120
        Option('use-existing-dir',
1098
1121
               help='By default push will fail if the target'
1099
1122
                    ' directory exists, but does not already'
1110
1133
        Option('strict',
1111
1134
               help='Refuse to push if there are uncommitted changes in'
1112
1135
               ' the working tree, --no-strict disables the check.'),
 
1136
        Option('no-tree',
 
1137
               help="Don't populate the working tree, even for protocols"
 
1138
               " that support it."),
1113
1139
        ]
1114
1140
    takes_args = ['location?']
1115
1141
    encoding_type = 'replace'
1116
1142
 
1117
 
    def run(self, location=None, remember=False, overwrite=False,
 
1143
    def run(self, location=None, remember=None, overwrite=False,
1118
1144
        create_prefix=False, verbose=False, revision=None,
1119
1145
        use_existing_dir=False, directory=None, stacked_on=None,
1120
 
        stacked=False, strict=None):
 
1146
        stacked=False, strict=None, no_tree=False):
1121
1147
        from bzrlib.push import _show_push_branch
1122
1148
 
1123
1149
        if directory is None:
1169
1195
        _show_push_branch(br_from, revision_id, location, self.outf,
1170
1196
            verbose=verbose, overwrite=overwrite, remember=remember,
1171
1197
            stacked_on=stacked_on, create_prefix=create_prefix,
1172
 
            use_existing_dir=use_existing_dir)
 
1198
            use_existing_dir=use_existing_dir, no_tree=no_tree)
1173
1199
 
1174
1200
 
1175
1201
class cmd_branch(Command):
1184
1210
 
1185
1211
    To retrieve the branch as of a particular revision, supply the --revision
1186
1212
    parameter, as in "branch foo/bar -r 5".
 
1213
 
 
1214
    The synonyms 'clone' and 'get' for this command are deprecated.
1187
1215
    """
1188
1216
 
1189
1217
    _see_also = ['checkout']
1190
1218
    takes_args = ['from_location', 'to_location?']
1191
 
    takes_options = ['revision', Option('hardlink',
1192
 
        help='Hard-link working tree files where possible.'),
 
1219
    takes_options = ['revision',
 
1220
        Option('hardlink', help='Hard-link working tree files where possible.'),
 
1221
        Option('files-from', type=str,
 
1222
               help="Get file contents from this tree."),
1193
1223
        Option('no-tree',
1194
1224
            help="Create a branch without a working-tree."),
1195
1225
        Option('switch',
1213
1243
 
1214
1244
    def run(self, from_location, to_location=None, revision=None,
1215
1245
            hardlink=False, stacked=False, standalone=False, no_tree=False,
1216
 
            use_existing_dir=False, switch=False, bind=False):
 
1246
            use_existing_dir=False, switch=False, bind=False,
 
1247
            files_from=None):
1217
1248
        from bzrlib import switch as _mod_switch
1218
1249
        from bzrlib.tag import _merge_tags_if_possible
 
1250
        if self.invoked_as in ['get', 'clone']:
 
1251
            ui.ui_factory.show_user_warning(
 
1252
                'deprecated_command',
 
1253
                deprecated_name=self.invoked_as,
 
1254
                recommended_name='branch',
 
1255
                deprecated_in_version='2.4')
1219
1256
        accelerator_tree, br_from = bzrdir.BzrDir.open_tree_or_branch(
1220
1257
            from_location)
 
1258
        if not (hardlink or files_from):
 
1259
            # accelerator_tree is usually slower because you have to read N
 
1260
            # files (no readahead, lots of seeks, etc), but allow the user to
 
1261
            # explicitly request it
 
1262
            accelerator_tree = None
 
1263
        if files_from is not None and files_from != from_location:
 
1264
            accelerator_tree = WorkingTree.open(files_from)
1221
1265
        revision = _get_one_revision('branch', revision)
1222
 
        br_from.lock_read()
1223
 
        self.add_cleanup(br_from.unlock)
 
1266
        self.add_cleanup(br_from.lock_read().unlock)
1224
1267
        if revision is not None:
1225
1268
            revision_id = revision.as_revision_id(br_from)
1226
1269
        else:
1331
1374
            to_location = branch_location
1332
1375
        accelerator_tree, source = bzrdir.BzrDir.open_tree_or_branch(
1333
1376
            branch_location)
 
1377
        if not (hardlink or files_from):
 
1378
            # accelerator_tree is usually slower because you have to read N
 
1379
            # files (no readahead, lots of seeks, etc), but allow the user to
 
1380
            # explicitly request it
 
1381
            accelerator_tree = None
1334
1382
        revision = _get_one_revision('checkout', revision)
1335
 
        if files_from is not None:
 
1383
        if files_from is not None and files_from != branch_location:
1336
1384
            accelerator_tree = WorkingTree.open(files_from)
1337
1385
        if revision is not None:
1338
1386
            revision_id = revision.as_revision_id(source)
1366
1414
    @display_command
1367
1415
    def run(self, dir=u'.'):
1368
1416
        tree = WorkingTree.open_containing(dir)[0]
1369
 
        tree.lock_read()
1370
 
        self.add_cleanup(tree.unlock)
 
1417
        self.add_cleanup(tree.lock_read().unlock)
1371
1418
        new_inv = tree.inventory
1372
1419
        old_tree = tree.basis_tree()
1373
 
        old_tree.lock_read()
1374
 
        self.add_cleanup(old_tree.unlock)
 
1420
        self.add_cleanup(old_tree.lock_read().unlock)
1375
1421
        old_inv = old_tree.inventory
1376
1422
        renames = []
1377
1423
        iterator = tree.iter_changes(old_tree, include_unchanged=True)
1396
1442
    If you want to discard your local changes, you can just do a
1397
1443
    'bzr revert' instead of 'bzr commit' after the update.
1398
1444
 
 
1445
    If you want to restore a file that has been removed locally, use
 
1446
    'bzr revert' instead of 'bzr update'.
 
1447
 
1399
1448
    If the tree's branch is bound to a master branch, it will also update
1400
1449
    the branch from the master.
1401
1450
    """
1402
1451
 
1403
1452
    _see_also = ['pull', 'working-trees', 'status-flags']
1404
1453
    takes_args = ['dir?']
1405
 
    takes_options = ['revision']
 
1454
    takes_options = ['revision',
 
1455
                     Option('show-base',
 
1456
                            help="Show base revision text in conflicts."),
 
1457
                     ]
1406
1458
    aliases = ['up']
1407
1459
 
1408
 
    def run(self, dir='.', revision=None):
 
1460
    def run(self, dir='.', revision=None, show_base=None):
1409
1461
        if revision is not None and len(revision) != 1:
1410
1462
            raise errors.BzrCommandError(
1411
1463
                        "bzr update --revision takes exactly one revision")
1415
1467
        master = branch.get_master_branch(
1416
1468
            possible_transports=possible_transports)
1417
1469
        if master is not None:
1418
 
            tree.lock_write()
1419
1470
            branch_location = master.base
 
1471
            tree.lock_write()
1420
1472
        else:
 
1473
            branch_location = tree.branch.base
1421
1474
            tree.lock_tree_write()
1422
 
            branch_location = tree.branch.base
1423
1475
        self.add_cleanup(tree.unlock)
1424
1476
        # get rid of the final '/' and be ready for display
1425
1477
        branch_location = urlutils.unescape_for_display(
1451
1503
                change_reporter,
1452
1504
                possible_transports=possible_transports,
1453
1505
                revision=revision_id,
1454
 
                old_tip=old_tip)
 
1506
                old_tip=old_tip,
 
1507
                show_base=show_base)
1455
1508
        except errors.NoSuchRevision, e:
1456
1509
            raise errors.BzrCommandError(
1457
1510
                                  "branch has no revision %s\n"
1519
1572
class cmd_remove(Command):
1520
1573
    __doc__ = """Remove files or directories.
1521
1574
 
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.
 
1575
    This makes Bazaar stop tracking changes to the specified files. Bazaar will
 
1576
    delete them if they can easily be recovered using revert otherwise they
 
1577
    will be backed up (adding an extention of the form .~#~). If no options or
 
1578
    parameters are given Bazaar will scan for files that are being tracked by
 
1579
    Bazaar but missing in your tree and stop tracking them for you.
1526
1580
    """
1527
1581
    takes_args = ['file*']
1528
1582
    takes_options = ['verbose',
1530
1584
        RegistryOption.from_kwargs('file-deletion-strategy',
1531
1585
            'The file deletion mode to be used.',
1532
1586
            title='Deletion Strategy', value_switches=True, enum_switch=False,
1533
 
            safe='Only delete files if they can be'
1534
 
                 ' safely recovered (default).',
 
1587
            safe='Backup changed files (default).',
1535
1588
            keep='Delete from bzr but leave the working copy.',
 
1589
            no_backup='Don\'t backup changed files.',
1536
1590
            force='Delete all the specified files, even if they can not be '
1537
 
                'recovered and even if they are non-empty directories.')]
 
1591
                'recovered and even if they are non-empty directories. '
 
1592
                '(deprecated, use no-backup)')]
1538
1593
    aliases = ['rm', 'del']
1539
1594
    encoding_type = 'replace'
1540
1595
 
1541
1596
    def run(self, file_list, verbose=False, new=False,
1542
1597
        file_deletion_strategy='safe'):
1543
 
        tree, file_list = tree_files(file_list)
 
1598
        if file_deletion_strategy == 'force':
 
1599
            note("(The --force option is deprecated, rather use --no-backup "
 
1600
                "in future.)")
 
1601
            file_deletion_strategy = 'no-backup'
 
1602
 
 
1603
        tree, file_list = WorkingTree.open_containing_paths(file_list)
1544
1604
 
1545
1605
        if file_list is not None:
1546
1606
            file_list = [f for f in file_list]
1547
1607
 
1548
 
        tree.lock_write()
1549
 
        self.add_cleanup(tree.unlock)
 
1608
        self.add_cleanup(tree.lock_write().unlock)
1550
1609
        # Heuristics should probably all move into tree.remove_smart or
1551
1610
        # some such?
1552
1611
        if new:
1567
1626
            file_deletion_strategy = 'keep'
1568
1627
        tree.remove(file_list, verbose=verbose, to_file=self.outf,
1569
1628
            keep_files=file_deletion_strategy=='keep',
1570
 
            force=file_deletion_strategy=='force')
 
1629
            force=(file_deletion_strategy=='no-backup'))
1571
1630
 
1572
1631
 
1573
1632
class cmd_file_id(Command):
1635
1694
 
1636
1695
    _see_also = ['check']
1637
1696
    takes_args = ['branch?']
 
1697
    takes_options = [
 
1698
        Option('canonicalize-chks',
 
1699
               help='Make sure CHKs are in canonical form (repairs '
 
1700
                    'bug 522637).',
 
1701
               hidden=True),
 
1702
        ]
1638
1703
 
1639
 
    def run(self, branch="."):
 
1704
    def run(self, branch=".", canonicalize_chks=False):
1640
1705
        from bzrlib.reconcile import reconcile
1641
1706
        dir = bzrdir.BzrDir.open(branch)
1642
 
        reconcile(dir)
 
1707
        reconcile(dir, canonicalize_chks=canonicalize_chks)
1643
1708
 
1644
1709
 
1645
1710
class cmd_revision_history(Command):
1677
1742
            b = wt.branch
1678
1743
            last_revision = wt.last_revision()
1679
1744
 
1680
 
        revision_ids = b.repository.get_ancestry(last_revision)
1681
 
        revision_ids.pop(0)
1682
 
        for revision_id in revision_ids:
 
1745
        self.add_cleanup(b.repository.lock_read().unlock)
 
1746
        graph = b.repository.get_graph()
 
1747
        revisions = [revid for revid, parents in
 
1748
            graph.iter_ancestry([last_revision])]
 
1749
        for revision_id in reversed(revisions):
 
1750
            if _mod_revision.is_null(revision_id):
 
1751
                continue
1683
1752
            self.outf.write(revision_id + '\n')
1684
1753
 
1685
1754
 
1722
1791
                ),
1723
1792
         Option('append-revisions-only',
1724
1793
                help='Never change revnos or the existing log.'
1725
 
                '  Append revisions to it only.')
 
1794
                '  Append revisions to it only.'),
 
1795
         Option('no-tree',
 
1796
                'Create a branch without a working tree.')
1726
1797
         ]
1727
1798
    def run(self, location=None, format=None, append_revisions_only=False,
1728
 
            create_prefix=False):
 
1799
            create_prefix=False, no_tree=False):
1729
1800
        if format is None:
1730
1801
            format = bzrdir.format_registry.make_bzrdir('default')
1731
1802
        if location is None:
1754
1825
        except errors.NotBranchError:
1755
1826
            # really a NotBzrDir error...
1756
1827
            create_branch = bzrdir.BzrDir.create_branch_convenience
 
1828
            if no_tree:
 
1829
                force_new_tree = False
 
1830
            else:
 
1831
                force_new_tree = None
1757
1832
            branch = create_branch(to_transport.base, format=format,
1758
 
                                   possible_transports=[to_transport])
 
1833
                                   possible_transports=[to_transport],
 
1834
                                   force_new_tree=force_new_tree)
1759
1835
            a_bzrdir = branch.bzrdir
1760
1836
        else:
1761
1837
            from bzrlib.transport.local import LocalTransport
1765
1841
                        raise errors.BranchExistsWithoutWorkingTree(location)
1766
1842
                raise errors.AlreadyBranchError(location)
1767
1843
            branch = a_bzrdir.create_branch()
1768
 
            a_bzrdir.create_workingtree()
 
1844
            if not no_tree:
 
1845
                a_bzrdir.create_workingtree()
1769
1846
        if append_revisions_only:
1770
1847
            try:
1771
1848
                branch.set_append_revisions_only(True)
1865
1942
    "bzr diff -p1" is equivalent to "bzr diff --prefix old/:new/", and
1866
1943
    produces patches suitable for "patch -p1".
1867
1944
 
 
1945
    Note that when using the -r argument with a range of revisions, the
 
1946
    differences are computed between the two specified revisions.  That
 
1947
    is, the command does not show the changes introduced by the first 
 
1948
    revision in the range.  This differs from the interpretation of 
 
1949
    revision ranges used by "bzr log" which includes the first revision
 
1950
    in the range.
 
1951
 
1868
1952
    :Exit values:
1869
1953
        1 - changed
1870
1954
        2 - unrepresentable changes
1888
1972
 
1889
1973
            bzr diff -r1..3 xxx
1890
1974
 
1891
 
        To see the changes introduced in revision X::
 
1975
        The changes introduced by revision 2 (equivalent to -r1..2)::
 
1976
 
 
1977
            bzr diff -c2
 
1978
 
 
1979
        To see the changes introduced by revision X::
1892
1980
        
1893
1981
            bzr diff -cX
1894
1982
 
1898
1986
 
1899
1987
            bzr diff -r<chosen_parent>..X
1900
1988
 
1901
 
        The changes introduced by revision 2 (equivalent to -r1..2)::
 
1989
        The changes between the current revision and the previous revision
 
1990
        (equivalent to -c-1 and -r-2..-1)
1902
1991
 
1903
 
            bzr diff -c2
 
1992
            bzr diff -r-2..
1904
1993
 
1905
1994
        Show just the differences for file NEWS::
1906
1995
 
1921
2010
        Same as 'bzr diff' but prefix paths with old/ and new/::
1922
2011
 
1923
2012
            bzr diff --prefix old/:new/
 
2013
            
 
2014
        Show the differences using a custom diff program with options::
 
2015
        
 
2016
            bzr diff --using /usr/bin/diff --diff-options -wu
1924
2017
    """
1925
2018
    _see_also = ['status']
1926
2019
    takes_args = ['file*']
1946
2039
            type=unicode,
1947
2040
            ),
1948
2041
        RegistryOption('format',
 
2042
            short_name='F',
1949
2043
            help='Diff format to use.',
1950
2044
            lazy_registry=('bzrlib.diff', 'format_registry'),
1951
 
            value_switches=False, title='Diff format'),
 
2045
            title='Diff format'),
1952
2046
        ]
1953
2047
    aliases = ['di', 'dif']
1954
2048
    encoding_type = 'exact'
1985
2079
         old_branch, new_branch,
1986
2080
         specific_files, extra_trees) = get_trees_and_branches_to_diff_locked(
1987
2081
            file_list, revision, old, new, self.add_cleanup, apply_view=True)
 
2082
        # GNU diff on Windows uses ANSI encoding for filenames
 
2083
        path_encoding = osutils.get_diff_header_encoding()
1988
2084
        return show_diff_trees(old_tree, new_tree, sys.stdout,
1989
2085
                               specific_files=specific_files,
1990
2086
                               external_diff_options=diff_options,
1991
2087
                               old_label=old_label, new_label=new_label,
1992
 
                               extra_trees=extra_trees, using=using,
 
2088
                               extra_trees=extra_trees,
 
2089
                               path_encoding=path_encoding,
 
2090
                               using=using,
1993
2091
                               format_cls=format)
1994
2092
 
1995
2093
 
2003
2101
    # level of effort but possibly much less IO.  (Or possibly not,
2004
2102
    # if the directories are very large...)
2005
2103
    _see_also = ['status', 'ls']
2006
 
    takes_options = ['show-ids']
 
2104
    takes_options = ['directory', 'show-ids']
2007
2105
 
2008
2106
    @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)
 
2107
    def run(self, show_ids=False, directory=u'.'):
 
2108
        tree = WorkingTree.open_containing(directory)[0]
 
2109
        self.add_cleanup(tree.lock_read().unlock)
2013
2110
        old = tree.basis_tree()
2014
 
        old.lock_read()
2015
 
        self.add_cleanup(old.unlock)
 
2111
        self.add_cleanup(old.lock_read().unlock)
2016
2112
        for path, ie in old.inventory.iter_entries():
2017
2113
            if not tree.has_id(ie.file_id):
2018
2114
                self.outf.write(path)
2028
2124
 
2029
2125
    hidden = True
2030
2126
    _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
 
            ]
 
2127
    takes_options = ['directory', 'null']
2036
2128
 
2037
2129
    @display_command
2038
 
    def run(self, null=False):
2039
 
        tree = WorkingTree.open_containing(u'.')[0]
 
2130
    def run(self, null=False, directory=u'.'):
 
2131
        tree = WorkingTree.open_containing(directory)[0]
 
2132
        self.add_cleanup(tree.lock_read().unlock)
2040
2133
        td = tree.changes_from(tree.basis_tree())
 
2134
        self.cleanup_now()
2041
2135
        for path, id, kind, text_modified, meta_modified in td.modified:
2042
2136
            if null:
2043
2137
                self.outf.write(path + '\0')
2051
2145
 
2052
2146
    hidden = True
2053
2147
    _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
 
            ]
 
2148
    takes_options = ['directory', 'null']
2059
2149
 
2060
2150
    @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)
 
2151
    def run(self, null=False, directory=u'.'):
 
2152
        wt = WorkingTree.open_containing(directory)[0]
 
2153
        self.add_cleanup(wt.lock_read().unlock)
2065
2154
        basis = wt.basis_tree()
2066
 
        basis.lock_read()
2067
 
        self.add_cleanup(basis.unlock)
 
2155
        self.add_cleanup(basis.lock_read().unlock)
2068
2156
        basis_inv = basis.inventory
2069
2157
        inv = wt.inventory
2070
2158
        for file_id in inv:
2071
 
            if file_id in basis_inv:
 
2159
            if basis_inv.has_id(file_id):
2072
2160
                continue
2073
2161
            if inv.is_root(file_id) and len(basis_inv) == 0:
2074
2162
                continue
2075
2163
            path = inv.id2path(file_id)
2076
 
            if not os.access(osutils.abspath(path), os.F_OK):
 
2164
            if not os.access(osutils.pathjoin(wt.basedir, path), os.F_OK):
2077
2165
                continue
2078
2166
            if null:
2079
2167
                self.outf.write(path + '\0')
2279
2367
                   help='Show just the specified revision.'
2280
2368
                   ' See also "help revisionspec".'),
2281
2369
            'log-format',
 
2370
            RegistryOption('authors',
 
2371
                'What names to list as authors - first, all or committer.',
 
2372
                title='Authors',
 
2373
                lazy_registry=('bzrlib.log', 'author_list_registry'),
 
2374
            ),
2282
2375
            Option('levels',
2283
2376
                   short_name='n',
2284
2377
                   help='Number of levels to display - 0 for all, 1 for flat.',
2302
2395
            Option('exclude-common-ancestry',
2303
2396
                   help='Display only the revisions that are not part'
2304
2397
                   ' of both ancestries (require -rX..Y)'
2305
 
                   )
 
2398
                   ),
 
2399
            Option('signatures',
 
2400
                   help='Show digital signature validity'),
2306
2401
            ]
2307
2402
    encoding_type = 'replace'
2308
2403
 
2319
2414
            limit=None,
2320
2415
            show_diff=False,
2321
2416
            include_merges=False,
 
2417
            authors=None,
2322
2418
            exclude_common_ancestry=False,
 
2419
            signatures=False,
2323
2420
            ):
2324
2421
        from bzrlib.log import (
2325
2422
            Logger,
2352
2449
        if file_list:
2353
2450
            # find the file ids to log and check for directory filtering
2354
2451
            b, file_info_list, rev1, rev2 = _get_info_for_log_files(
2355
 
                revision, file_list)
2356
 
            self.add_cleanup(b.unlock)
 
2452
                revision, file_list, self.add_cleanup)
2357
2453
            for relpath, file_id, kind in file_info_list:
2358
2454
                if file_id is None:
2359
2455
                    raise errors.BzrCommandError(
2377
2473
                location = '.'
2378
2474
            dir, relpath = bzrdir.BzrDir.open_containing(location)
2379
2475
            b = dir.open_branch()
2380
 
            b.lock_read()
2381
 
            self.add_cleanup(b.unlock)
 
2476
            self.add_cleanup(b.lock_read().unlock)
2382
2477
            rev1, rev2 = _get_revision_range(revision, b, self.name())
2383
2478
 
 
2479
        if b.get_config().validate_signatures_in_log():
 
2480
            signatures = True
 
2481
 
 
2482
        if signatures:
 
2483
            if not gpg.GPGStrategy.verify_signatures_available():
 
2484
                raise errors.GpgmeNotInstalled(None)
 
2485
 
2384
2486
        # Decide on the type of delta & diff filtering to use
2385
2487
        # TODO: add an --all-files option to make this configurable & consistent
2386
2488
        if not verbose:
2404
2506
                        show_timezone=timezone,
2405
2507
                        delta_format=get_verbosity_level(),
2406
2508
                        levels=levels,
2407
 
                        show_advice=levels is None)
 
2509
                        show_advice=levels is None,
 
2510
                        author_list_handler=authors)
2408
2511
 
2409
2512
        # Choose the algorithm for doing the logging. It's annoying
2410
2513
        # having multiple code paths like this but necessary until
2431
2534
            message_search=message, delta_type=delta_type,
2432
2535
            diff_type=diff_type, _match_using_deltas=match_using_deltas,
2433
2536
            exclude_common_ancestry=exclude_common_ancestry,
 
2537
            signature=signatures
2434
2538
            )
2435
2539
        Logger(b, rqst).show(lf)
2436
2540
 
2508
2612
        tree, relpath = WorkingTree.open_containing(filename)
2509
2613
        file_id = tree.path2id(relpath)
2510
2614
        b = tree.branch
2511
 
        b.lock_read()
2512
 
        self.add_cleanup(b.unlock)
 
2615
        self.add_cleanup(b.lock_read().unlock)
2513
2616
        touching_revs = log.find_touching_revisions(b, file_id)
2514
2617
        for revno, revision_id, what in touching_revs:
2515
2618
            self.outf.write("%6d %s\n" % (revno, what))
2528
2631
                   help='Recurse into subdirectories.'),
2529
2632
            Option('from-root',
2530
2633
                   help='Print paths relative to the root of the branch.'),
2531
 
            Option('unknown', help='Print unknown files.'),
 
2634
            Option('unknown', short_name='u',
 
2635
                help='Print unknown files.'),
2532
2636
            Option('versioned', help='Print versioned files.',
2533
2637
                   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',
 
2638
            Option('ignored', short_name='i',
 
2639
                help='Print ignored files.'),
 
2640
            Option('kind', short_name='k',
2539
2641
                   help='List entries of a particular kind: file, directory, symlink.',
2540
2642
                   type=unicode),
 
2643
            'null',
2541
2644
            'show-ids',
 
2645
            'directory',
2542
2646
            ]
2543
2647
    @display_command
2544
2648
    def run(self, revision=None, verbose=False,
2545
2649
            recursive=False, from_root=False,
2546
2650
            unknown=False, versioned=False, ignored=False,
2547
 
            null=False, kind=None, show_ids=False, path=None):
 
2651
            null=False, kind=None, show_ids=False, path=None, directory=None):
2548
2652
 
2549
2653
        if kind and kind not in ('file', 'directory', 'symlink'):
2550
2654
            raise errors.BzrCommandError('invalid kind specified')
2562
2666
                raise errors.BzrCommandError('cannot specify both --from-root'
2563
2667
                                             ' and PATH')
2564
2668
            fs_path = path
2565
 
        tree, branch, relpath = bzrdir.BzrDir.open_containing_tree_or_branch(
2566
 
            fs_path)
 
2669
        tree, branch, relpath = \
 
2670
            _open_directory_or_containing_tree_or_branch(fs_path, directory)
2567
2671
 
2568
2672
        # Calculate the prefix to use
2569
2673
        prefix = None
2584
2688
                view_str = views.view_display_str(view_files)
2585
2689
                note("Ignoring files outside view. View is %s" % view_str)
2586
2690
 
2587
 
        tree.lock_read()
2588
 
        self.add_cleanup(tree.unlock)
 
2691
        self.add_cleanup(tree.lock_read().unlock)
2589
2692
        for fp, fc, fkind, fid, entry in tree.list_files(include_root=False,
2590
2693
            from_dir=relpath, recursive=recursive):
2591
2694
            # Apply additional masking
2638
2741
 
2639
2742
    hidden = True
2640
2743
    _see_also = ['ls']
 
2744
    takes_options = ['directory']
2641
2745
 
2642
2746
    @display_command
2643
 
    def run(self):
2644
 
        for f in WorkingTree.open_containing(u'.')[0].unknowns():
 
2747
    def run(self, directory=u'.'):
 
2748
        for f in WorkingTree.open_containing(directory)[0].unknowns():
2645
2749
            self.outf.write(osutils.quotefn(f) + '\n')
2646
2750
 
2647
2751
 
2674
2778
    Patterns prefixed with '!!' act as regular ignore patterns, but have
2675
2779
    precedence over the '!' exception patterns.
2676
2780
 
2677
 
    Note: ignore patterns containing shell wildcards must be quoted from
2678
 
    the shell on Unix.
 
2781
    :Notes: 
 
2782
        
 
2783
    * Ignore patterns containing shell wildcards must be quoted from
 
2784
      the shell on Unix.
 
2785
 
 
2786
    * Ignore patterns starting with "#" act as comments in the ignore file.
 
2787
      To ignore patterns that begin with that character, use the "RE:" prefix.
2679
2788
 
2680
2789
    :Examples:
2681
2790
        Ignore the top level Makefile::
2690
2799
 
2691
2800
            bzr ignore "!special.class"
2692
2801
 
 
2802
        Ignore files whose name begins with the "#" character::
 
2803
 
 
2804
            bzr ignore "RE:^#"
 
2805
 
2693
2806
        Ignore .o files under the lib directory::
2694
2807
 
2695
2808
            bzr ignore "lib/**/*.o"
2703
2816
            bzr ignore "RE:(?!debian/).*"
2704
2817
        
2705
2818
        Ignore everything except the "local" toplevel directory,
2706
 
        but always ignore "*~" autosave files, even under local/::
 
2819
        but always ignore autosave files ending in ~, even under local/::
2707
2820
        
2708
2821
            bzr ignore "*"
2709
2822
            bzr ignore "!./local"
2712
2825
 
2713
2826
    _see_also = ['status', 'ignored', 'patterns']
2714
2827
    takes_args = ['name_pattern*']
2715
 
    takes_options = [
 
2828
    takes_options = ['directory',
2716
2829
        Option('default-rules',
2717
2830
               help='Display the default ignore rules that bzr uses.')
2718
2831
        ]
2719
2832
 
2720
 
    def run(self, name_pattern_list=None, default_rules=None):
 
2833
    def run(self, name_pattern_list=None, default_rules=None,
 
2834
            directory=u'.'):
2721
2835
        from bzrlib import ignores
2722
2836
        if default_rules is not None:
2723
2837
            # dump the default rules and exit
2729
2843
                "NAME_PATTERN or --default-rules.")
2730
2844
        name_pattern_list = [globbing.normalize_pattern(p)
2731
2845
                             for p in name_pattern_list]
 
2846
        bad_patterns = ''
 
2847
        for p in name_pattern_list:
 
2848
            if not globbing.Globster.is_pattern_valid(p):
 
2849
                bad_patterns += ('\n  %s' % p)
 
2850
        if bad_patterns:
 
2851
            msg = ('Invalid ignore pattern(s) found. %s' % bad_patterns)
 
2852
            ui.ui_factory.show_error(msg)
 
2853
            raise errors.InvalidPattern('')
2732
2854
        for name_pattern in name_pattern_list:
2733
2855
            if (name_pattern[0] == '/' or
2734
2856
                (len(name_pattern) > 1 and name_pattern[1] == ':')):
2735
2857
                raise errors.BzrCommandError(
2736
2858
                    "NAME_PATTERN should not be an absolute path")
2737
 
        tree, relpath = WorkingTree.open_containing(u'.')
 
2859
        tree, relpath = WorkingTree.open_containing(directory)
2738
2860
        ignores.tree_ignores_add_patterns(tree, name_pattern_list)
2739
2861
        ignored = globbing.Globster(name_pattern_list)
2740
2862
        matches = []
2741
 
        tree.lock_read()
 
2863
        self.add_cleanup(tree.lock_read().unlock)
2742
2864
        for entry in tree.list_files():
2743
2865
            id = entry[3]
2744
2866
            if id is not None:
2745
2867
                filename = entry[0]
2746
2868
                if ignored.match(filename):
2747
2869
                    matches.append(filename)
2748
 
        tree.unlock()
2749
2870
        if len(matches) > 0:
2750
2871
            self.outf.write("Warning: the following files are version controlled and"
2751
2872
                  " match your ignore pattern:\n%s"
2766
2887
 
2767
2888
    encoding_type = 'replace'
2768
2889
    _see_also = ['ignore', 'ls']
 
2890
    takes_options = ['directory']
2769
2891
 
2770
2892
    @display_command
2771
 
    def run(self):
2772
 
        tree = WorkingTree.open_containing(u'.')[0]
2773
 
        tree.lock_read()
2774
 
        self.add_cleanup(tree.unlock)
 
2893
    def run(self, directory=u'.'):
 
2894
        tree = WorkingTree.open_containing(directory)[0]
 
2895
        self.add_cleanup(tree.lock_read().unlock)
2775
2896
        for path, file_class, kind, file_id, entry in tree.list_files():
2776
2897
            if file_class != 'I':
2777
2898
                continue
2788
2909
    """
2789
2910
    hidden = True
2790
2911
    takes_args = ['revno']
 
2912
    takes_options = ['directory']
2791
2913
 
2792
2914
    @display_command
2793
 
    def run(self, revno):
 
2915
    def run(self, revno, directory=u'.'):
2794
2916
        try:
2795
2917
            revno = int(revno)
2796
2918
        except ValueError:
2797
2919
            raise errors.BzrCommandError("not a valid revision-number: %r"
2798
2920
                                         % revno)
2799
 
        revid = WorkingTree.open_containing(u'.')[0].branch.get_rev_id(revno)
 
2921
        revid = WorkingTree.open_containing(directory)[0].branch.get_rev_id(revno)
2800
2922
        self.outf.write("%s\n" % revid)
2801
2923
 
2802
2924
 
2828
2950
         zip                          .zip
2829
2951
      =================       =========================
2830
2952
    """
 
2953
    encoding = 'exact'
2831
2954
    takes_args = ['dest', 'branch_or_subdir?']
2832
 
    takes_options = [
 
2955
    takes_options = ['directory',
2833
2956
        Option('format',
2834
2957
               help="Type of file to export to.",
2835
2958
               type=unicode),
2844
2967
                    'revision in which it was changed.'),
2845
2968
        ]
2846
2969
    def run(self, dest, branch_or_subdir=None, revision=None, format=None,
2847
 
        root=None, filters=False, per_file_timestamps=False):
 
2970
        root=None, filters=False, per_file_timestamps=False, directory=u'.'):
2848
2971
        from bzrlib.export import export
2849
2972
 
2850
2973
        if branch_or_subdir is None:
2851
 
            tree = WorkingTree.open_containing(u'.')[0]
 
2974
            tree = WorkingTree.open_containing(directory)[0]
2852
2975
            b = tree.branch
2853
2976
            subdir = None
2854
2977
        else:
2873
2996
    """
2874
2997
 
2875
2998
    _see_also = ['ls']
2876
 
    takes_options = [
 
2999
    takes_options = ['directory',
2877
3000
        Option('name-from-revision', help='The path name in the old tree.'),
2878
3001
        Option('filters', help='Apply content filters to display the '
2879
3002
                'convenience form.'),
2884
3007
 
2885
3008
    @display_command
2886
3009
    def run(self, filename, revision=None, name_from_revision=False,
2887
 
            filters=False):
 
3010
            filters=False, directory=None):
2888
3011
        if revision is not None and len(revision) != 1:
2889
3012
            raise errors.BzrCommandError("bzr cat --revision takes exactly"
2890
3013
                                         " one revision specifier")
2891
3014
        tree, branch, relpath = \
2892
 
            bzrdir.BzrDir.open_containing_tree_or_branch(filename)
2893
 
        branch.lock_read()
2894
 
        self.add_cleanup(branch.unlock)
 
3015
            _open_directory_or_containing_tree_or_branch(filename, directory)
 
3016
        self.add_cleanup(branch.lock_read().unlock)
2895
3017
        return self._run(tree, branch, relpath, filename, revision,
2896
3018
                         name_from_revision, filters)
2897
3019
 
2900
3022
        if tree is None:
2901
3023
            tree = b.basis_tree()
2902
3024
        rev_tree = _get_one_revision_tree('cat', revision, branch=b)
2903
 
        rev_tree.lock_read()
2904
 
        self.add_cleanup(rev_tree.unlock)
 
3025
        self.add_cleanup(rev_tree.lock_read().unlock)
2905
3026
 
2906
3027
        old_file_id = rev_tree.path2id(relpath)
2907
3028
 
 
3029
        # TODO: Split out this code to something that generically finds the
 
3030
        # best id for a path across one or more trees; it's like
 
3031
        # find_ids_across_trees but restricted to find just one. -- mbp
 
3032
        # 20110705.
2908
3033
        if name_from_revision:
2909
3034
            # Try in revision if requested
2910
3035
            if old_file_id is None:
2912
3037
                    "%r is not present in revision %s" % (
2913
3038
                        filename, rev_tree.get_revision_id()))
2914
3039
            else:
2915
 
                content = rev_tree.get_file_text(old_file_id)
 
3040
                actual_file_id = old_file_id
2916
3041
        else:
2917
3042
            cur_file_id = tree.path2id(relpath)
2918
 
            found = False
2919
 
            if cur_file_id is not None:
2920
 
                # Then try with the actual file id
2921
 
                try:
2922
 
                    content = rev_tree.get_file_text(cur_file_id)
2923
 
                    found = True
2924
 
                except errors.NoSuchId:
2925
 
                    # The actual file id didn't exist at that time
2926
 
                    pass
2927
 
            if not found and old_file_id is not None:
2928
 
                # Finally try with the old file id
2929
 
                content = rev_tree.get_file_text(old_file_id)
2930
 
                found = True
2931
 
            if not found:
2932
 
                # Can't be found anywhere
 
3043
            if cur_file_id is not None and rev_tree.has_id(cur_file_id):
 
3044
                actual_file_id = cur_file_id
 
3045
            elif old_file_id is not None:
 
3046
                actual_file_id = old_file_id
 
3047
            else:
2933
3048
                raise errors.BzrCommandError(
2934
3049
                    "%r is not present in revision %s" % (
2935
3050
                        filename, rev_tree.get_revision_id()))
2936
3051
        if filtered:
2937
 
            from bzrlib.filters import (
2938
 
                ContentFilterContext,
2939
 
                filtered_output_bytes,
2940
 
                )
2941
 
            filters = rev_tree._content_filter_stack(relpath)
2942
 
            chunks = content.splitlines(True)
2943
 
            content = filtered_output_bytes(chunks, filters,
2944
 
                ContentFilterContext(relpath, rev_tree))
2945
 
            self.cleanup_now()
2946
 
            self.outf.writelines(content)
 
3052
            from bzrlib.filter_tree import ContentFilterTree
 
3053
            filter_tree = ContentFilterTree(rev_tree,
 
3054
                rev_tree._content_filter_stack)
 
3055
            content = filter_tree.get_file_text(actual_file_id)
2947
3056
        else:
2948
 
            self.cleanup_now()
2949
 
            self.outf.write(content)
 
3057
            content = rev_tree.get_file_text(actual_file_id)
 
3058
        self.cleanup_now()
 
3059
        self.outf.write(content)
2950
3060
 
2951
3061
 
2952
3062
class cmd_local_time_offset(Command):
3013
3123
      to trigger updates to external systems like bug trackers. The --fixes
3014
3124
      option can be used to record the association between a revision and
3015
3125
      one or more bugs. See ``bzr help bugs`` for details.
3016
 
 
3017
 
      A selective commit may fail in some cases where the committed
3018
 
      tree would be invalid. Consider::
3019
 
  
3020
 
        bzr init foo
3021
 
        mkdir foo/bar
3022
 
        bzr add foo/bar
3023
 
        bzr commit foo -m "committing foo"
3024
 
        bzr mv foo/bar foo/baz
3025
 
        mkdir foo/bar
3026
 
        bzr add foo/bar
3027
 
        bzr commit foo/bar -m "committing bar but not baz"
3028
 
  
3029
 
      In the example above, the last commit will fail by design. This gives
3030
 
      the user the opportunity to decide whether they want to commit the
3031
 
      rename at the same time, separately first, or not at all. (As a general
3032
 
      rule, when in doubt, Bazaar has a policy of Doing the Safe Thing.)
3033
3126
    """
3034
 
    # TODO: Run hooks on tree to-be-committed, and after commit.
3035
 
 
3036
 
    # TODO: Strict commit that fails if there are deleted files.
3037
 
    #       (what does "deleted files" mean ??)
3038
 
 
3039
 
    # TODO: Give better message for -s, --summary, used by tla people
3040
 
 
3041
 
    # XXX: verbose currently does nothing
3042
3127
 
3043
3128
    _see_also = ['add', 'bugs', 'hooks', 'uncommit']
3044
3129
    takes_args = ['selected*']
3076
3161
             Option('show-diff', short_name='p',
3077
3162
                    help='When no message is supplied, show the diff along'
3078
3163
                    ' with the status summary in the message editor.'),
 
3164
             Option('lossy', 
 
3165
                    help='When committing to a foreign version control '
 
3166
                    'system do not push data that can not be natively '
 
3167
                    'represented.'),
3079
3168
             ]
3080
3169
    aliases = ['ci', 'checkin']
3081
3170
 
3100
3189
 
3101
3190
    def run(self, message=None, file=None, verbose=False, selected_list=None,
3102
3191
            unchanged=False, strict=False, local=False, fixes=None,
3103
 
            author=None, show_diff=False, exclude=None, commit_time=None):
 
3192
            author=None, show_diff=False, exclude=None, commit_time=None,
 
3193
            lossy=False):
3104
3194
        from bzrlib.errors import (
3105
3195
            PointlessCommit,
3106
3196
            ConflictsInTree,
3109
3199
        from bzrlib.msgeditor import (
3110
3200
            edit_commit_message_encoded,
3111
3201
            generate_commit_message_template,
3112
 
            make_commit_message_template_encoded
 
3202
            make_commit_message_template_encoded,
 
3203
            set_commit_message,
3113
3204
        )
3114
3205
 
3115
3206
        commit_stamp = offset = None
3120
3211
                raise errors.BzrCommandError(
3121
3212
                    "Could not parse --commit-time: " + str(e))
3122
3213
 
3123
 
        # TODO: Need a blackbox test for invoking the external editor; may be
3124
 
        # slightly problematic to run this cross-platform.
3125
 
 
3126
 
        # TODO: do more checks that the commit will succeed before
3127
 
        # spending the user's valuable time typing a commit message.
3128
 
 
3129
3214
        properties = {}
3130
3215
 
3131
 
        tree, selected_list = tree_files(selected_list)
 
3216
        tree, selected_list = WorkingTree.open_containing_paths(selected_list)
3132
3217
        if selected_list == ['']:
3133
3218
            # workaround - commit of root of tree should be exactly the same
3134
3219
            # as just default commit in that tree, and succeed even though
3169
3254
        def get_message(commit_obj):
3170
3255
            """Callback to get commit message"""
3171
3256
            if file:
3172
 
                my_message = codecs.open(
3173
 
                    file, 'rt', osutils.get_user_encoding()).read()
 
3257
                f = open(file)
 
3258
                try:
 
3259
                    my_message = f.read().decode(osutils.get_user_encoding())
 
3260
                finally:
 
3261
                    f.close()
3174
3262
            elif message is not None:
3175
3263
                my_message = message
3176
3264
            else:
3184
3272
                # make_commit_message_template_encoded returns user encoding.
3185
3273
                # We probably want to be using edit_commit_message instead to
3186
3274
                # avoid this.
3187
 
                start_message = generate_commit_message_template(commit_obj)
3188
 
                my_message = edit_commit_message_encoded(text,
3189
 
                    start_message=start_message)
 
3275
                my_message = set_commit_message(commit_obj)
 
3276
                if my_message is None:
 
3277
                    start_message = generate_commit_message_template(commit_obj)
 
3278
                    my_message = edit_commit_message_encoded(text,
 
3279
                        start_message=start_message)
3190
3280
                if my_message is None:
3191
3281
                    raise errors.BzrCommandError("please specify a commit"
3192
3282
                        " message with either --message or --file")
3205
3295
                        reporter=None, verbose=verbose, revprops=properties,
3206
3296
                        authors=author, timestamp=commit_stamp,
3207
3297
                        timezone=offset,
3208
 
                        exclude=safe_relpath_files(tree, exclude))
 
3298
                        exclude=tree.safe_relpath_files(exclude),
 
3299
                        lossy=lossy)
3209
3300
        except PointlessCommit:
3210
3301
            raise errors.BzrCommandError("No changes to commit."
3211
 
                              " Use --unchanged to commit anyhow.")
 
3302
                " Please 'bzr add' the files you want to commit, or use"
 
3303
                " --unchanged to force an empty commit.")
3212
3304
        except ConflictsInTree:
3213
3305
            raise errors.BzrCommandError('Conflicts detected in working '
3214
3306
                'tree.  Use "bzr conflicts" to list, "bzr resolve FILE" to'
3295
3387
 
3296
3388
 
3297
3389
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.
 
3390
    __doc__ = """Upgrade a repository, branch or working tree to a newer format.
 
3391
 
 
3392
    When the default format has changed after a major new release of
 
3393
    Bazaar, you may be informed during certain operations that you
 
3394
    should upgrade. Upgrading to a newer format may improve performance
 
3395
    or make new features available. It may however limit interoperability
 
3396
    with older repositories or with older versions of Bazaar.
 
3397
 
 
3398
    If you wish to upgrade to a particular format rather than the
 
3399
    current default, that can be specified using the --format option.
 
3400
    As a consequence, you can use the upgrade command this way to
 
3401
    "downgrade" to an earlier format, though some conversions are
 
3402
    a one way process (e.g. changing from the 1.x default to the
 
3403
    2.x default) so downgrading is not always possible.
 
3404
 
 
3405
    A backup.bzr.~#~ directory is created at the start of the conversion
 
3406
    process (where # is a number). By default, this is left there on
 
3407
    completion. If the conversion fails, delete the new .bzr directory
 
3408
    and rename this one back in its place. Use the --clean option to ask
 
3409
    for the backup.bzr directory to be removed on successful conversion.
 
3410
    Alternatively, you can delete it by hand if everything looks good
 
3411
    afterwards.
 
3412
 
 
3413
    If the location given is a shared repository, dependent branches
 
3414
    are also converted provided the repository converts successfully.
 
3415
    If the conversion of a branch fails, remaining branches are still
 
3416
    tried.
 
3417
 
 
3418
    For more information on upgrades, see the Bazaar Upgrade Guide,
 
3419
    http://doc.bazaar.canonical.com/latest/en/upgrade-guide/.
3303
3420
    """
3304
3421
 
3305
 
    _see_also = ['check']
 
3422
    _see_also = ['check', 'reconcile', 'formats']
3306
3423
    takes_args = ['url?']
3307
3424
    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
 
                    ]
 
3425
        RegistryOption('format',
 
3426
            help='Upgrade to a specific format.  See "bzr help'
 
3427
                 ' formats" for details.',
 
3428
            lazy_registry=('bzrlib.bzrdir', 'format_registry'),
 
3429
            converter=lambda name: bzrdir.format_registry.make_bzrdir(name),
 
3430
            value_switches=True, title='Branch format'),
 
3431
        Option('clean',
 
3432
            help='Remove the backup.bzr directory if successful.'),
 
3433
        Option('dry-run',
 
3434
            help="Show what would be done, but don't actually do anything."),
 
3435
    ]
3315
3436
 
3316
 
    def run(self, url='.', format=None):
 
3437
    def run(self, url='.', format=None, clean=False, dry_run=False):
3317
3438
        from bzrlib.upgrade import upgrade
3318
 
        upgrade(url, format)
 
3439
        exceptions = upgrade(url, format, clean_up=clean, dry_run=dry_run)
 
3440
        if exceptions:
 
3441
            if len(exceptions) == 1:
 
3442
                # Compatibility with historical behavior
 
3443
                raise exceptions[0]
 
3444
            else:
 
3445
                return 3
3319
3446
 
3320
3447
 
3321
3448
class cmd_whoami(Command):
3330
3457
 
3331
3458
            bzr whoami "Frank Chu <fchu@example.com>"
3332
3459
    """
3333
 
    takes_options = [ Option('email',
 
3460
    takes_options = [ 'directory',
 
3461
                      Option('email',
3334
3462
                             help='Display email address only.'),
3335
3463
                      Option('branch',
3336
3464
                             help='Set identity for the current branch instead of '
3340
3468
    encoding_type = 'replace'
3341
3469
 
3342
3470
    @display_command
3343
 
    def run(self, email=False, branch=False, name=None):
 
3471
    def run(self, email=False, branch=False, name=None, directory=None):
3344
3472
        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()
 
3473
            if directory is None:
 
3474
                # use branch if we're inside one; otherwise global config
 
3475
                try:
 
3476
                    c = Branch.open_containing(u'.')[0].get_config()
 
3477
                except errors.NotBranchError:
 
3478
                    c = _mod_config.GlobalConfig()
 
3479
            else:
 
3480
                c = Branch.open(directory).get_config()
3350
3481
            if email:
3351
3482
                self.outf.write(c.user_email() + '\n')
3352
3483
            else:
3353
3484
                self.outf.write(c.username() + '\n')
3354
3485
            return
3355
3486
 
 
3487
        if email:
 
3488
            raise errors.BzrCommandError("--email can only be used to display existing "
 
3489
                                         "identity")
 
3490
 
3356
3491
        # display a warning if an email address isn't included in the given name.
3357
3492
        try:
3358
 
            config.extract_email_address(name)
 
3493
            _mod_config.extract_email_address(name)
3359
3494
        except errors.NoEmailInUsername, e:
3360
3495
            warning('"%s" does not seem to contain an email address.  '
3361
3496
                    'This is allowed, but not recommended.', name)
3362
3497
 
3363
3498
        # use global config unless --branch given
3364
3499
        if branch:
3365
 
            c = Branch.open_containing('.')[0].get_config()
 
3500
            if directory is None:
 
3501
                c = Branch.open_containing(u'.')[0].get_config()
 
3502
            else:
 
3503
                c = Branch.open(directory).get_config()
3366
3504
        else:
3367
 
            c = config.GlobalConfig()
 
3505
            c = _mod_config.GlobalConfig()
3368
3506
        c.set_user_option('email', name)
3369
3507
 
3370
3508
 
3380
3518
 
3381
3519
    _see_also = ['info']
3382
3520
    takes_args = ['nickname?']
3383
 
    def run(self, nickname=None):
3384
 
        branch = Branch.open_containing(u'.')[0]
 
3521
    takes_options = ['directory']
 
3522
    def run(self, nickname=None, directory=u'.'):
 
3523
        branch = Branch.open_containing(directory)[0]
3385
3524
        if nickname is None:
3386
3525
            self.printme(branch)
3387
3526
        else:
3436
3575
                'bzr alias --remove expects an alias to remove.')
3437
3576
        # If alias is not found, print something like:
3438
3577
        # unalias: foo: not found
3439
 
        c = config.GlobalConfig()
 
3578
        c = _mod_config.GlobalConfig()
3440
3579
        c.unset_alias(alias_name)
3441
3580
 
3442
3581
    @display_command
3443
3582
    def print_aliases(self):
3444
3583
        """Print out the defined aliases in a similar format to bash."""
3445
 
        aliases = config.GlobalConfig().get_aliases()
 
3584
        aliases = _mod_config.GlobalConfig().get_aliases()
3446
3585
        for key, value in sorted(aliases.iteritems()):
3447
3586
            self.outf.write('bzr alias %s="%s"\n' % (key, value))
3448
3587
 
3458
3597
 
3459
3598
    def set_alias(self, alias_name, alias_command):
3460
3599
        """Save the alias in the global config."""
3461
 
        c = config.GlobalConfig()
 
3600
        c = _mod_config.GlobalConfig()
3462
3601
        c.set_alias(alias_name, alias_command)
3463
3602
 
3464
3603
 
3499
3638
    If you set BZR_TEST_PDB=1 when running selftest, failing tests will drop
3500
3639
    into a pdb postmortem session.
3501
3640
 
 
3641
    The --coverage=DIRNAME global option produces a report with covered code
 
3642
    indicated.
 
3643
 
3502
3644
    :Examples:
3503
3645
        Run only tests relating to 'ignore'::
3504
3646
 
3515
3657
        if typestring == "sftp":
3516
3658
            from bzrlib.tests import stub_sftp
3517
3659
            return stub_sftp.SFTPAbsoluteServer
3518
 
        if typestring == "memory":
 
3660
        elif typestring == "memory":
3519
3661
            from bzrlib.tests import test_server
3520
3662
            return memory.MemoryServer
3521
 
        if typestring == "fakenfs":
 
3663
        elif typestring == "fakenfs":
3522
3664
            from bzrlib.tests import test_server
3523
3665
            return test_server.FakeNFSServer
3524
3666
        msg = "No known transport type %s. Supported types are: sftp\n" %\
3537
3679
                                 'throughout the test suite.',
3538
3680
                            type=get_transport_type),
3539
3681
                     Option('benchmark',
3540
 
                            help='Run the benchmarks rather than selftests.'),
 
3682
                            help='Run the benchmarks rather than selftests.',
 
3683
                            hidden=True),
3541
3684
                     Option('lsprof-timed',
3542
3685
                            help='Generate lsprof output for benchmarked'
3543
3686
                                 ' sections of code.'),
3544
3687
                     Option('lsprof-tests',
3545
3688
                            help='Generate lsprof output for each test.'),
3546
 
                     Option('cache-dir', type=str,
3547
 
                            help='Cache intermediate benchmark output in this '
3548
 
                                 'directory.'),
3549
3689
                     Option('first',
3550
3690
                            help='Run all tests, but run specified tests first.',
3551
3691
                            short_name='f',
3560
3700
                     Option('randomize', type=str, argname="SEED",
3561
3701
                            help='Randomize the order of tests using the given'
3562
3702
                                 ' seed or "now" for the current time.'),
3563
 
                     Option('exclude', type=str, argname="PATTERN",
3564
 
                            short_name='x',
3565
 
                            help='Exclude tests that match this regular'
3566
 
                                 ' expression.'),
 
3703
                     ListOption('exclude', type=str, argname="PATTERN",
 
3704
                                short_name='x',
 
3705
                                help='Exclude tests that match this regular'
 
3706
                                ' expression.'),
3567
3707
                     Option('subunit',
3568
3708
                        help='Output test progress via subunit.'),
3569
3709
                     Option('strict', help='Fail on missing dependencies or '
3585
3725
 
3586
3726
    def run(self, testspecs_list=None, verbose=False, one=False,
3587
3727
            transport=None, benchmark=None,
3588
 
            lsprof_timed=None, cache_dir=None,
 
3728
            lsprof_timed=None,
3589
3729
            first=False, list_only=False,
3590
3730
            randomize=None, exclude=None, strict=False,
3591
3731
            load_list=None, debugflag=None, starting_with=None, subunit=False,
3592
3732
            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)
 
3733
        from bzrlib import tests
 
3734
 
3602
3735
        if testspecs_list is not None:
3603
3736
            pattern = '|'.join(testspecs_list)
3604
3737
        else:
3612
3745
            self.additional_selftest_args['runner_class'] = SubUnitBzrRunner
3613
3746
            # On Windows, disable automatic conversion of '\n' to '\r\n' in
3614
3747
            # stdout, which would corrupt the subunit stream. 
3615
 
            if sys.platform == "win32" and sys.stdout.fileno() >= 0:
 
3748
            # FIXME: This has been fixed in subunit trunk (>0.0.5) so the
 
3749
            # following code can be deleted when it's sufficiently deployed
 
3750
            # -- vila/mgz 20100514
 
3751
            if (sys.platform == "win32"
 
3752
                and getattr(sys.stdout, 'fileno', None) is not None):
3616
3753
                import msvcrt
3617
3754
                msvcrt.setmode(sys.stdout.fileno(), os.O_BINARY)
3618
3755
        if parallel:
3619
3756
            self.additional_selftest_args.setdefault(
3620
3757
                'suite_decorators', []).append(parallel)
3621
3758
        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)
 
3759
            raise errors.BzrCommandError(
 
3760
                "--benchmark is no longer supported from bzr 2.2; "
 
3761
                "use bzr-usertest instead")
 
3762
        test_suite_factory = None
 
3763
        if not exclude:
 
3764
            exclude_pattern = None
3628
3765
        else:
3629
 
            test_suite_factory = None
3630
 
            benchfile = None
 
3766
            exclude_pattern = '(' + '|'.join(exclude) + ')'
3631
3767
        selftest_kwargs = {"verbose": verbose,
3632
3768
                          "pattern": pattern,
3633
3769
                          "stop_on_failure": one,
3635
3771
                          "test_suite_factory": test_suite_factory,
3636
3772
                          "lsprof_timed": lsprof_timed,
3637
3773
                          "lsprof_tests": lsprof_tests,
3638
 
                          "bench_history": benchfile,
3639
3774
                          "matching_tests_first": first,
3640
3775
                          "list_only": list_only,
3641
3776
                          "random_seed": randomize,
3642
 
                          "exclude_pattern": exclude,
 
3777
                          "exclude_pattern": exclude_pattern,
3643
3778
                          "strict": strict,
3644
3779
                          "load_list": load_list,
3645
3780
                          "debug_flags": debugflag,
3646
3781
                          "starting_with": starting_with
3647
3782
                          }
3648
3783
        selftest_kwargs.update(self.additional_selftest_args)
3649
 
        result = selftest(**selftest_kwargs)
 
3784
 
 
3785
        # Make deprecation warnings visible, unless -Werror is set
 
3786
        cleanup = symbol_versioning.activate_deprecation_warnings(
 
3787
            override=False)
 
3788
        try:
 
3789
            result = tests.selftest(**selftest_kwargs)
 
3790
        finally:
 
3791
            cleanup()
3650
3792
        return int(not result)
3651
3793
 
3652
3794
 
3690
3832
 
3691
3833
        branch1 = Branch.open_containing(branch)[0]
3692
3834
        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)
 
3835
        self.add_cleanup(branch1.lock_read().unlock)
 
3836
        self.add_cleanup(branch2.lock_read().unlock)
3697
3837
        last1 = ensure_null(branch1.last_revision())
3698
3838
        last2 = ensure_null(branch2.last_revision())
3699
3839
 
3709
3849
    The source of the merge can be specified either in the form of a branch,
3710
3850
    or in the form of a path to a file containing a merge directive generated
3711
3851
    with bzr send. If neither is specified, the default is the upstream branch
3712
 
    or the branch most recently merged using --remember.
3713
 
 
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.
 
3852
    or the branch most recently merged using --remember.  The source of the
 
3853
    merge may also be specified in the form of a path to a file in another
 
3854
    branch:  in this case, only the modifications to that file are merged into
 
3855
    the current working tree.
 
3856
 
 
3857
    When merging from a branch, by default bzr will try to merge in all new
 
3858
    work from the other branch, automatically determining an appropriate base
 
3859
    revision.  If this fails, you may need to give an explicit base.
 
3860
 
 
3861
    To pick a different ending revision, pass "--revision OTHER".  bzr will
 
3862
    try to merge in all new work up to and including revision OTHER.
 
3863
 
 
3864
    If you specify two values, "--revision BASE..OTHER", only revisions BASE
 
3865
    through OTHER, excluding BASE but including OTHER, will be merged.  If this
 
3866
    causes some revisions to be skipped, i.e. if the destination branch does
 
3867
    not already contain revision BASE, such a merge is commonly referred to as
 
3868
    a "cherrypick". Unlike a normal merge, Bazaar does not currently track
 
3869
    cherrypicks. The changes look like a normal commit, and the history of the
 
3870
    changes from the other branch is not stored in the commit.
 
3871
 
 
3872
    Revision numbers are always relative to the source branch.
3724
3873
 
3725
3874
    Merge will do its best to combine the changes in two branches, but there
3726
3875
    are some kinds of problems only a human can fix.  When it encounters those,
3729
3878
 
3730
3879
    Use bzr resolve when you have fixed a problem.  See also bzr conflicts.
3731
3880
 
3732
 
    If there is no default branch set, the first merge will set it. After
3733
 
    that, you can omit the branch to use the default.  To change the
3734
 
    default, use --remember. The value will only be saved if the remote
3735
 
    location can be accessed.
 
3881
    If there is no default branch set, the first merge will set it (use
 
3882
    --no-remember to avoid settting it). After that, you can omit the branch
 
3883
    to use the default.  To change the default, use --remember. The value will
 
3884
    only be saved if the remote location can be accessed.
3736
3885
 
3737
3886
    The results of the merge are placed into the destination working
3738
3887
    directory, where they can be reviewed (with bzr diff), tested, and then
3739
3888
    committed to record the result of the merge.
3740
3889
 
3741
3890
    merge refuses to run if there are any uncommitted changes, unless
3742
 
    --force is given. The --force option can also be used to create a
 
3891
    --force is given.  If --force is given, then the changes from the source 
 
3892
    will be merged with the current working tree, including any uncommitted
 
3893
    changes in the tree.  The --force option can also be used to create a
3743
3894
    merge revision which has more than two parents.
3744
3895
 
3745
3896
    If one would like to merge changes from the working tree of the other
3750
3901
    you to apply each diff hunk and file change, similar to "shelve".
3751
3902
 
3752
3903
    :Examples:
3753
 
        To merge the latest revision from bzr.dev::
 
3904
        To merge all new revisions from bzr.dev::
3754
3905
 
3755
3906
            bzr merge ../bzr.dev
3756
3907
 
3793
3944
                ' completely merged into the source, pull from the'
3794
3945
                ' source rather than merging.  When this happens,'
3795
3946
                ' you do not need to commit the result.'),
3796
 
        Option('directory',
 
3947
        custom_help('directory',
3797
3948
               help='Branch to merge into, '
3798
 
                    'rather than the one containing the working directory.',
3799
 
               short_name='d',
3800
 
               type=unicode,
3801
 
               ),
 
3949
                    'rather than the one containing the working directory.'),
3802
3950
        Option('preview', help='Instead of merging, show a diff of the'
3803
3951
               ' merge.'),
3804
3952
        Option('interactive', help='Select changes interactively.',
3806
3954
    ]
3807
3955
 
3808
3956
    def run(self, location=None, revision=None, force=False,
3809
 
            merge_type=None, show_base=False, reprocess=None, remember=False,
 
3957
            merge_type=None, show_base=False, reprocess=None, remember=None,
3810
3958
            uncommitted=False, pull=False,
3811
3959
            directory=None,
3812
3960
            preview=False,
3820
3968
        merger = None
3821
3969
        allow_pending = True
3822
3970
        verified = 'inapplicable'
 
3971
 
3823
3972
        tree = WorkingTree.open_containing(directory)[0]
 
3973
        if tree.branch.revno() == 0:
 
3974
            raise errors.BzrCommandError('Merging into empty branches not currently supported, '
 
3975
                                         'https://bugs.launchpad.net/bzr/+bug/308562')
3824
3976
 
3825
3977
        try:
3826
3978
            basis_tree = tree.revision_tree(tree.last_revision())
3837
3989
            unversioned_filter=tree.is_ignored, view_info=view_info)
3838
3990
        pb = ui.ui_factory.nested_progress_bar()
3839
3991
        self.add_cleanup(pb.finished)
3840
 
        tree.lock_write()
3841
 
        self.add_cleanup(tree.unlock)
 
3992
        self.add_cleanup(tree.lock_write().unlock)
3842
3993
        if location is not None:
3843
3994
            try:
3844
3995
                mergeable = bundle.read_mergeable_from_url(location,
3873
4024
        self.sanity_check_merger(merger)
3874
4025
        if (merger.base_rev_id == merger.other_rev_id and
3875
4026
            merger.other_rev_id is not None):
 
4027
            # check if location is a nonexistent file (and not a branch) to
 
4028
            # disambiguate the 'Nothing to do'
 
4029
            if merger.interesting_files:
 
4030
                if not merger.other_tree.has_filename(
 
4031
                    merger.interesting_files[0]):
 
4032
                    note("merger: " + str(merger))
 
4033
                    raise errors.PathsDoNotExist([location])
3876
4034
            note('Nothing to do.')
3877
4035
            return 0
3878
 
        if pull:
 
4036
        if pull and not preview:
3879
4037
            if merger.interesting_files is not None:
3880
4038
                raise errors.BzrCommandError('Cannot pull individual files')
3881
4039
            if (merger.base_rev_id == tree.last_revision()):
3905
4063
    def _do_preview(self, merger):
3906
4064
        from bzrlib.diff import show_diff_trees
3907
4065
        result_tree = self._get_preview(merger)
 
4066
        path_encoding = osutils.get_diff_header_encoding()
3908
4067
        show_diff_trees(merger.this_tree, result_tree, self.outf,
3909
 
                        old_label='', new_label='')
 
4068
                        old_label='', new_label='',
 
4069
                        path_encoding=path_encoding)
3910
4070
 
3911
4071
    def _do_merge(self, merger, change_reporter, allow_pending, verified):
3912
4072
        merger.change_reporter = change_reporter
3988
4148
        if other_revision_id is None:
3989
4149
            other_revision_id = _mod_revision.ensure_null(
3990
4150
                other_branch.last_revision())
3991
 
        # Remember where we merge from
3992
 
        if ((remember or tree.branch.get_submit_branch() is None) and
3993
 
             user_location is not None):
 
4151
        # Remember where we merge from. We need to remember if:
 
4152
        # - user specify a location (and we don't merge from the parent
 
4153
        #   branch)
 
4154
        # - user ask to remember or there is no previous location set to merge
 
4155
        #   from and user didn't ask to *not* remember
 
4156
        if (user_location is not None
 
4157
            and ((remember
 
4158
                  or (remember is None
 
4159
                      and tree.branch.get_submit_branch() is None)))):
3994
4160
            tree.branch.set_submit_branch(other_branch.base)
3995
 
        _merge_tags_if_possible(other_branch, tree.branch)
 
4161
        # Merge tags (but don't set them in the master branch yet, the user
 
4162
        # might revert this merge).  Commit will propagate them.
 
4163
        _merge_tags_if_possible(other_branch, tree.branch, ignore_master=True)
3996
4164
        merger = _mod_merge.Merger.from_revision_ids(pb, tree,
3997
4165
            other_revision_id, base_revision_id, other_branch, base_branch)
3998
4166
        if other_path != '':
4099
4267
        from bzrlib.conflicts import restore
4100
4268
        if merge_type is None:
4101
4269
            merge_type = _mod_merge.Merge3Merger
4102
 
        tree, file_list = tree_files(file_list)
4103
 
        tree.lock_write()
4104
 
        self.add_cleanup(tree.unlock)
 
4270
        tree, file_list = WorkingTree.open_containing_paths(file_list)
 
4271
        self.add_cleanup(tree.lock_write().unlock)
4105
4272
        parents = tree.get_parent_ids()
4106
4273
        if len(parents) != 2:
4107
4274
            raise errors.BzrCommandError("Sorry, remerge only works after normal"
4167
4334
    last committed revision is used.
4168
4335
 
4169
4336
    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.
 
4337
    merge instead.  For example, "merge . -r -2..-3" (don't forget the ".")
 
4338
    will remove the changes introduced by the second last commit (-2), without
 
4339
    affecting the changes introduced by the last commit (-1).  To remove
 
4340
    certain changes on a hunk-by-hunk basis, see the shelve command.
4173
4341
 
4174
4342
    By default, any files that have been manually changed will be backed up
4175
4343
    first.  (Files changed only by merge are not backed up.)  Backup files have
4205
4373
    target branches.
4206
4374
    """
4207
4375
 
4208
 
    _see_also = ['cat', 'export']
 
4376
    _see_also = ['cat', 'export', 'merge', 'shelve']
4209
4377
    takes_options = [
4210
4378
        'revision',
4211
4379
        Option('no-backup', "Do not save backups of reverted files."),
4216
4384
 
4217
4385
    def run(self, revision=None, no_backup=False, file_list=None,
4218
4386
            forget_merges=None):
4219
 
        tree, file_list = tree_files(file_list)
4220
 
        tree.lock_tree_write()
4221
 
        self.add_cleanup(tree.unlock)
 
4387
        tree, file_list = WorkingTree.open_containing_paths(file_list)
 
4388
        self.add_cleanup(tree.lock_tree_write().unlock)
4222
4389
        if forget_merges:
4223
4390
            tree.set_parent_ids(tree.get_parent_ids()[:1])
4224
4391
        else:
4313
4480
    _see_also = ['merge', 'pull']
4314
4481
    takes_args = ['other_branch?']
4315
4482
    takes_options = [
 
4483
        'directory',
4316
4484
        Option('reverse', 'Reverse the order of revisions.'),
4317
4485
        Option('mine-only',
4318
4486
               'Display changes in the local branch only.'),
4340
4508
            theirs_only=False,
4341
4509
            log_format=None, long=False, short=False, line=False,
4342
4510
            show_ids=False, verbose=False, this=False, other=False,
4343
 
            include_merges=False, revision=None, my_revision=None):
 
4511
            include_merges=False, revision=None, my_revision=None,
 
4512
            directory=u'.'):
4344
4513
        from bzrlib.missing import find_unmerged, iter_log_revisions
4345
4514
        def message(s):
4346
4515
            if not is_quiet():
4359
4528
        elif theirs_only:
4360
4529
            restrict = 'remote'
4361
4530
 
4362
 
        local_branch = Branch.open_containing(u".")[0]
4363
 
        local_branch.lock_read()
4364
 
        self.add_cleanup(local_branch.unlock)
 
4531
        local_branch = Branch.open_containing(directory)[0]
 
4532
        self.add_cleanup(local_branch.lock_read().unlock)
4365
4533
 
4366
4534
        parent = local_branch.get_parent()
4367
4535
        if other_branch is None:
4378
4546
        if remote_branch.base == local_branch.base:
4379
4547
            remote_branch = local_branch
4380
4548
        else:
4381
 
            remote_branch.lock_read()
4382
 
            self.add_cleanup(remote_branch.unlock)
 
4549
            self.add_cleanup(remote_branch.lock_read().unlock)
4383
4550
 
4384
4551
        local_revid_range = _revision_range_to_revid_range(
4385
4552
            _get_revision_range(my_revision, local_branch,
4440
4607
            message("Branches are up to date.\n")
4441
4608
        self.cleanup_now()
4442
4609
        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)
 
4610
            self.add_cleanup(local_branch.lock_write().unlock)
4445
4611
            # handle race conditions - a parent might be set while we run.
4446
4612
            if local_branch.get_parent() is None:
4447
4613
                local_branch.set_parent(remote_branch.base)
4506
4672
 
4507
4673
    @display_command
4508
4674
    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")
 
4675
        from bzrlib import plugin
 
4676
        # Don't give writelines a generator as some codecs don't like that
 
4677
        self.outf.writelines(
 
4678
            list(plugin.describe_plugins(show_paths=verbose)))
4529
4679
 
4530
4680
 
4531
4681
class cmd_testament(Command):
4547
4697
            b = Branch.open_containing(branch)[0]
4548
4698
        else:
4549
4699
            b = Branch.open(branch)
4550
 
        b.lock_read()
4551
 
        self.add_cleanup(b.unlock)
 
4700
        self.add_cleanup(b.lock_read().unlock)
4552
4701
        if revision is None:
4553
4702
            rev_id = b.last_revision()
4554
4703
        else:
4578
4727
                     Option('long', help='Show commit date in annotations.'),
4579
4728
                     'revision',
4580
4729
                     'show-ids',
 
4730
                     'directory',
4581
4731
                     ]
4582
4732
    encoding_type = 'exact'
4583
4733
 
4584
4734
    @display_command
4585
4735
    def run(self, filename, all=False, long=False, revision=None,
4586
 
            show_ids=False):
4587
 
        from bzrlib.annotate import annotate_file, annotate_file_tree
 
4736
            show_ids=False, directory=None):
 
4737
        from bzrlib.annotate import (
 
4738
            annotate_file_tree,
 
4739
            )
4588
4740
        wt, branch, relpath = \
4589
 
            bzrdir.BzrDir.open_containing_tree_or_branch(filename)
 
4741
            _open_directory_or_containing_tree_or_branch(filename, directory)
4590
4742
        if wt is not None:
4591
 
            wt.lock_read()
4592
 
            self.add_cleanup(wt.unlock)
 
4743
            self.add_cleanup(wt.lock_read().unlock)
4593
4744
        else:
4594
 
            branch.lock_read()
4595
 
            self.add_cleanup(branch.unlock)
 
4745
            self.add_cleanup(branch.lock_read().unlock)
4596
4746
        tree = _get_one_revision_tree('annotate', revision, branch=branch)
4597
 
        tree.lock_read()
4598
 
        self.add_cleanup(tree.unlock)
4599
 
        if wt is not None:
 
4747
        self.add_cleanup(tree.lock_read().unlock)
 
4748
        if wt is not None and revision is None:
4600
4749
            file_id = wt.path2id(relpath)
4601
4750
        else:
4602
4751
            file_id = tree.path2id(relpath)
4603
4752
        if file_id is None:
4604
4753
            raise errors.NotVersionedError(filename)
4605
 
        file_version = tree.inventory[file_id].revision
4606
4754
        if wt is not None and revision is None:
4607
4755
            # If there is a tree and we're not annotating historical
4608
4756
            # versions, annotate the working tree's content.
4609
4757
            annotate_file_tree(wt, file_id, self.outf, long, all,
4610
4758
                show_ids=show_ids)
4611
4759
        else:
4612
 
            annotate_file(branch, file_version, file_id, long, all, self.outf,
4613
 
                          show_ids=show_ids)
 
4760
            annotate_file_tree(tree, file_id, self.outf, long, all,
 
4761
                show_ids=show_ids, branch=branch)
4614
4762
 
4615
4763
 
4616
4764
class cmd_re_sign(Command):
4619
4767
 
4620
4768
    hidden = True # is this right ?
4621
4769
    takes_args = ['revision_id*']
4622
 
    takes_options = ['revision']
 
4770
    takes_options = ['directory', 'revision']
4623
4771
 
4624
 
    def run(self, revision_id_list=None, revision=None):
 
4772
    def run(self, revision_id_list=None, revision=None, directory=u'.'):
4625
4773
        if revision_id_list is not None and revision is not None:
4626
4774
            raise errors.BzrCommandError('You can only supply one of revision_id or --revision')
4627
4775
        if revision_id_list is None and revision is None:
4628
4776
            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)
 
4777
        b = WorkingTree.open_containing(directory)[0].branch
 
4778
        self.add_cleanup(b.lock_write().unlock)
4632
4779
        return self._run(b, revision_id_list, revision)
4633
4780
 
4634
4781
    def _run(self, b, revision_id_list, revision):
4693
4840
 
4694
4841
    _see_also = ['checkouts', 'unbind']
4695
4842
    takes_args = ['location?']
4696
 
    takes_options = []
 
4843
    takes_options = ['directory']
4697
4844
 
4698
 
    def run(self, location=None):
4699
 
        b, relpath = Branch.open_containing(u'.')
 
4845
    def run(self, location=None, directory=u'.'):
 
4846
        b, relpath = Branch.open_containing(directory)
4700
4847
        if location is None:
4701
4848
            try:
4702
4849
                location = b.get_old_bound_location()
4729
4876
 
4730
4877
    _see_also = ['checkouts', 'bind']
4731
4878
    takes_args = []
4732
 
    takes_options = []
 
4879
    takes_options = ['directory']
4733
4880
 
4734
 
    def run(self):
4735
 
        b, relpath = Branch.open_containing(u'.')
 
4881
    def run(self, directory=u'.'):
 
4882
        b, relpath = Branch.open_containing(directory)
4736
4883
        if not b.unbind():
4737
4884
            raise errors.BzrCommandError('Local branch is not bound')
4738
4885
 
4784
4931
            b = control.open_branch()
4785
4932
 
4786
4933
        if tree is not None:
4787
 
            tree.lock_write()
4788
 
            self.add_cleanup(tree.unlock)
 
4934
            self.add_cleanup(tree.lock_write().unlock)
4789
4935
        else:
4790
 
            b.lock_write()
4791
 
            self.add_cleanup(b.unlock)
 
4936
            self.add_cleanup(b.lock_write().unlock)
4792
4937
        return self._run(b, tree, dry_run, verbose, revision, force, local=local)
4793
4938
 
4794
4939
    def _run(self, b, tree, dry_run, verbose, revision, force, local=False):
4833
4978
            self.outf.write('The above revision(s) will be removed.\n')
4834
4979
 
4835
4980
        if not force:
4836
 
            if not ui.ui_factory.get_boolean('Are you sure'):
4837
 
                self.outf.write('Canceled')
 
4981
            if not ui.ui_factory.confirm_action(
 
4982
                    u'Uncommit these revisions',
 
4983
                    'bzrlib.builtins.uncommit',
 
4984
                    {}):
 
4985
                self.outf.write('Canceled\n')
4838
4986
                return 0
4839
4987
 
4840
4988
        mutter('Uncommitting from {%s} to {%s}',
4846
4994
 
4847
4995
 
4848
4996
class cmd_break_lock(Command):
4849
 
    __doc__ = """Break a dead lock on a repository, branch or working directory.
 
4997
    __doc__ = """Break a dead lock.
 
4998
 
 
4999
    This command breaks a lock on a repository, branch, working directory or
 
5000
    config file.
4850
5001
 
4851
5002
    CAUTION: Locks should only be broken when you are sure that the process
4852
5003
    holding the lock has been stopped.
4857
5008
    :Examples:
4858
5009
        bzr break-lock
4859
5010
        bzr break-lock bzr+ssh://example.com/bzr/foo
 
5011
        bzr break-lock --conf ~/.bazaar
4860
5012
    """
 
5013
 
4861
5014
    takes_args = ['location?']
 
5015
    takes_options = [
 
5016
        Option('config',
 
5017
               help='LOCATION is the directory where the config lock is.'),
 
5018
        Option('force',
 
5019
            help='Do not ask for confirmation before breaking the lock.'),
 
5020
        ]
4862
5021
 
4863
 
    def run(self, location=None, show=False):
 
5022
    def run(self, location=None, config=False, force=False):
4864
5023
        if location is None:
4865
5024
            location = u'.'
4866
 
        control, relpath = bzrdir.BzrDir.open_containing(location)
4867
 
        try:
4868
 
            control.break_lock()
4869
 
        except NotImplementedError:
4870
 
            pass
 
5025
        if force:
 
5026
            ui.ui_factory = ui.ConfirmationUserInterfacePolicy(ui.ui_factory,
 
5027
                None,
 
5028
                {'bzrlib.lockdir.break': True})
 
5029
        if config:
 
5030
            conf = _mod_config.LockableConfig(file_name=location)
 
5031
            conf.break_lock()
 
5032
        else:
 
5033
            control, relpath = bzrdir.BzrDir.open_containing(location)
 
5034
            try:
 
5035
                control.break_lock()
 
5036
            except NotImplementedError:
 
5037
                pass
4871
5038
 
4872
5039
 
4873
5040
class cmd_wait_until_signalled(Command):
4902
5069
                    'result in a dynamically allocated port.  The default port '
4903
5070
                    'depends on the protocol.',
4904
5071
               type=str),
4905
 
        Option('directory',
4906
 
               help='Serve contents of this directory.',
4907
 
               type=unicode),
 
5072
        custom_help('directory',
 
5073
               help='Serve contents of this directory.'),
4908
5074
        Option('allow-writes',
4909
5075
               help='By default the server is a readonly server.  Supplying '
4910
5076
                    '--allow-writes enables write access to the contents of '
4937
5103
 
4938
5104
    def run(self, port=None, inet=False, directory=None, allow_writes=False,
4939
5105
            protocol=None):
4940
 
        from bzrlib.transport import get_transport, transport_server_registry
 
5106
        from bzrlib import transport
4941
5107
        if directory is None:
4942
5108
            directory = os.getcwd()
4943
5109
        if protocol is None:
4944
 
            protocol = transport_server_registry.get()
 
5110
            protocol = transport.transport_server_registry.get()
4945
5111
        host, port = self.get_host_and_port(port)
4946
5112
        url = urlutils.local_path_to_url(directory)
4947
5113
        if not allow_writes:
4948
5114
            url = 'readonly+' + url
4949
 
        transport = get_transport(url)
4950
 
        protocol(transport, host, port, inet)
 
5115
        t = transport.get_transport(url)
 
5116
        protocol(t, host, port, inet)
4951
5117
 
4952
5118
 
4953
5119
class cmd_join(Command):
4959
5125
    not part of it.  (Such trees can be produced by "bzr split", but also by
4960
5126
    running "bzr branch" with the target inside a tree.)
4961
5127
 
4962
 
    The result is a combined tree, with the subtree no longer an independant
 
5128
    The result is a combined tree, with the subtree no longer an independent
4963
5129
    part.  This is marked as a merge of the subtree into the containing tree,
4964
5130
    and all history is preserved.
4965
5131
    """
5046
5212
    _see_also = ['send']
5047
5213
 
5048
5214
    takes_options = [
 
5215
        'directory',
5049
5216
        RegistryOption.from_kwargs('patch-type',
5050
5217
            'The type of patch to include in the directive.',
5051
5218
            title='Patch type',
5064
5231
    encoding_type = 'exact'
5065
5232
 
5066
5233
    def run(self, submit_branch=None, public_branch=None, patch_type='bundle',
5067
 
            sign=False, revision=None, mail_to=None, message=None):
 
5234
            sign=False, revision=None, mail_to=None, message=None,
 
5235
            directory=u'.'):
5068
5236
        from bzrlib.revision import ensure_null, NULL_REVISION
5069
5237
        include_patch, include_bundle = {
5070
5238
            'plain': (False, False),
5071
5239
            'diff': (True, False),
5072
5240
            'bundle': (True, True),
5073
5241
            }[patch_type]
5074
 
        branch = Branch.open('.')
 
5242
        branch = Branch.open(directory)
5075
5243
        stored_submit_branch = branch.get_submit_branch()
5076
5244
        if submit_branch is None:
5077
5245
            submit_branch = stored_submit_branch
5153
5321
    source branch defaults to that containing the working directory, but can
5154
5322
    be changed using --from.
5155
5323
 
 
5324
    Both the submit branch and the public branch follow the usual behavior with
 
5325
    respect to --remember: If there is no default location set, the first send
 
5326
    will set it (use --no-remember to avoid settting it). After that, you can
 
5327
    omit the location to use the default.  To change the default, use
 
5328
    --remember. The value will only be saved if the location can be accessed.
 
5329
 
5156
5330
    In order to calculate those changes, bzr must analyse the submit branch.
5157
5331
    Therefore it is most efficient for the submit branch to be a local mirror.
5158
5332
    If a public location is known for the submit_branch, that location is used
5162
5336
    given, in which case it is sent to a file.
5163
5337
 
5164
5338
    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.
 
5339
    on Windows (it uses MAPI).  On Unix, it requires the xdg-email utility.
5166
5340
    If the preferred client can't be found (or used), your editor will be used.
5167
5341
 
5168
5342
    To use a specific mail program, set the mail_client configuration option.
5227
5401
        ]
5228
5402
 
5229
5403
    def run(self, submit_branch=None, public_branch=None, no_bundle=False,
5230
 
            no_patch=False, revision=None, remember=False, output=None,
 
5404
            no_patch=False, revision=None, remember=None, output=None,
5231
5405
            format=None, mail_to=None, message=None, body=None,
5232
5406
            strict=None, **kwargs):
5233
5407
        from bzrlib.send import send
5339
5513
        Option('delete',
5340
5514
            help='Delete this tag rather than placing it.',
5341
5515
            ),
5342
 
        Option('directory',
5343
 
            help='Branch in which to place the tag.',
5344
 
            short_name='d',
5345
 
            type=unicode,
5346
 
            ),
 
5516
        custom_help('directory',
 
5517
            help='Branch in which to place the tag.'),
5347
5518
        Option('force',
5348
5519
            help='Replace existing tags.',
5349
5520
            ),
5357
5528
            revision=None,
5358
5529
            ):
5359
5530
        branch, relpath = Branch.open_containing(directory)
5360
 
        branch.lock_write()
5361
 
        self.add_cleanup(branch.unlock)
 
5531
        self.add_cleanup(branch.lock_write().unlock)
5362
5532
        if delete:
5363
5533
            if tag_name is None:
5364
5534
                raise errors.BzrCommandError("No tag specified to delete.")
5365
5535
            branch.tags.delete_tag(tag_name)
5366
 
            self.outf.write('Deleted tag %s.\n' % tag_name)
 
5536
            note('Deleted tag %s.' % tag_name)
5367
5537
        else:
5368
5538
            if revision:
5369
5539
                if len(revision) != 1:
5381
5551
            if (not force) and branch.tags.has_tag(tag_name):
5382
5552
                raise errors.TagAlreadyExists(tag_name)
5383
5553
            branch.tags.set_tag(tag_name, revision_id)
5384
 
            self.outf.write('Created tag %s.\n' % tag_name)
 
5554
            note('Created tag %s.' % tag_name)
5385
5555
 
5386
5556
 
5387
5557
class cmd_tags(Command):
5392
5562
 
5393
5563
    _see_also = ['tag']
5394
5564
    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',
 
5565
        custom_help('directory',
 
5566
            help='Branch whose tags should be displayed.'),
 
5567
        RegistryOption('sort',
5401
5568
            'Sort tags by different criteria.', title='Sorting',
5402
 
            alpha='Sort tags lexicographically (default).',
5403
 
            time='Sort tags chronologically.',
 
5569
            lazy_registry=('bzrlib.tag', 'tag_sort_methods')
5404
5570
            ),
5405
5571
        'show-ids',
5406
5572
        'revision',
5407
5573
    ]
5408
5574
 
5409
5575
    @display_command
5410
 
    def run(self,
5411
 
            directory='.',
5412
 
            sort='alpha',
5413
 
            show_ids=False,
5414
 
            revision=None,
5415
 
            ):
 
5576
    def run(self, directory='.', sort=None, show_ids=False, revision=None):
 
5577
        from bzrlib.tag import tag_sort_methods
5416
5578
        branch, relpath = Branch.open_containing(directory)
5417
5579
 
5418
5580
        tags = branch.tags.get_tag_dict().items()
5419
5581
        if not tags:
5420
5582
            return
5421
5583
 
5422
 
        branch.lock_read()
5423
 
        self.add_cleanup(branch.unlock)
 
5584
        self.add_cleanup(branch.lock_read().unlock)
5424
5585
        if revision:
5425
5586
            graph = branch.repository.get_graph()
5426
5587
            rev1, rev2 = _get_revision_range(revision, branch, self.name())
5428
5589
            # only show revisions between revid1 and revid2 (inclusive)
5429
5590
            tags = [(tag, revid) for tag, revid in tags if
5430
5591
                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]])
 
5592
        if sort is None:
 
5593
            sort = tag_sort_methods.get()
 
5594
        sort(branch, tags)
5444
5595
        if not show_ids:
5445
5596
            # [ (tag, revid), ... ] -> [ (tag, dotted_revno), ... ]
5446
5597
            for index, (tag, revid) in enumerate(tags):
5448
5599
                    revno = branch.revision_id_to_dotted_revno(revid)
5449
5600
                    if isinstance(revno, tuple):
5450
5601
                        revno = '.'.join(map(str, revno))
5451
 
                except errors.NoSuchRevision:
 
5602
                except (errors.NoSuchRevision, errors.GhostRevisionsHaveNoRevno):
5452
5603
                    # Bad tag data/merges can lead to tagged revisions
5453
5604
                    # which are not in this branch. Fail gracefully ...
5454
5605
                    revno = '?'
5512
5663
            unstacked=None):
5513
5664
        directory = bzrdir.BzrDir.open(location)
5514
5665
        if stacked_on and unstacked:
5515
 
            raise BzrCommandError("Can't use both --stacked-on and --unstacked")
 
5666
            raise errors.BzrCommandError("Can't use both --stacked-on and --unstacked")
5516
5667
        elif stacked_on is not None:
5517
5668
            reconfigure.ReconfigureStackedOn().apply(directory, stacked_on)
5518
5669
        elif unstacked:
5573
5724
    """
5574
5725
 
5575
5726
    takes_args = ['to_location?']
5576
 
    takes_options = [Option('force',
 
5727
    takes_options = ['directory',
 
5728
                     Option('force',
5577
5729
                        help='Switch even if local commits will be lost.'),
5578
5730
                     'revision',
5579
5731
                     Option('create-branch', short_name='b',
5582
5734
                    ]
5583
5735
 
5584
5736
    def run(self, to_location=None, force=False, create_branch=False,
5585
 
            revision=None):
 
5737
            revision=None, directory=u'.'):
5586
5738
        from bzrlib import switch
5587
 
        tree_location = '.'
 
5739
        tree_location = directory
5588
5740
        revision = _get_one_revision('switch', revision)
5589
5741
        control_dir = bzrdir.BzrDir.open_containing(tree_location)[0]
5590
5742
        if to_location is None:
5591
5743
            if revision is None:
5592
5744
                raise errors.BzrCommandError('You must supply either a'
5593
5745
                                             ' revision or a location')
5594
 
            to_location = '.'
 
5746
            to_location = tree_location
5595
5747
        try:
5596
5748
            branch = control_dir.open_branch()
5597
5749
            had_explicit_nick = branch.get_config().has_explicit_nickname()
5732
5884
            name=None,
5733
5885
            switch=None,
5734
5886
            ):
5735
 
        tree, file_list = tree_files(file_list, apply_view=False)
 
5887
        tree, file_list = WorkingTree.open_containing_paths(file_list,
 
5888
            apply_view=False)
5736
5889
        current_view, view_dict = tree.views.get_view_info()
5737
5890
        if name is None:
5738
5891
            name = current_view
5842
5995
            location = "."
5843
5996
        branch = Branch.open_containing(location)[0]
5844
5997
        branch.bzrdir.destroy_branch()
5845
 
        
 
5998
 
5846
5999
 
5847
6000
class cmd_shelve(Command):
5848
6001
    __doc__ = """Temporarily set aside some changes from the current tree.
5867
6020
 
5868
6021
    You can put multiple items on the shelf, and by default, 'unshelve' will
5869
6022
    restore the most recently shelved changes.
 
6023
 
 
6024
    For complicated changes, it is possible to edit the changes in a separate
 
6025
    editor program to decide what the file remaining in the working copy
 
6026
    should look like.  To do this, add the configuration option
 
6027
 
 
6028
        change_editor = PROGRAM @new_path @old_path
 
6029
 
 
6030
    where @new_path is replaced with the path of the new version of the 
 
6031
    file and @old_path is replaced with the path of the old version of 
 
6032
    the file.  The PROGRAM should save the new file with the desired 
 
6033
    contents of the file in the working tree.
 
6034
        
5870
6035
    """
5871
6036
 
5872
6037
    takes_args = ['file*']
5873
6038
 
5874
6039
    takes_options = [
 
6040
        'directory',
5875
6041
        'revision',
5876
6042
        Option('all', help='Shelve all changes.'),
5877
6043
        'message',
5883
6049
        Option('destroy',
5884
6050
               help='Destroy removed changes instead of shelving them.'),
5885
6051
    ]
5886
 
    _see_also = ['unshelve']
 
6052
    _see_also = ['unshelve', 'configuration']
5887
6053
 
5888
6054
    def run(self, revision=None, all=False, file_list=None, message=None,
5889
 
            writer=None, list=False, destroy=False):
 
6055
            writer=None, list=False, destroy=False, directory=None):
5890
6056
        if list:
5891
 
            return self.run_for_list()
 
6057
            return self.run_for_list(directory=directory)
5892
6058
        from bzrlib.shelf_ui import Shelver
5893
6059
        if writer is None:
5894
6060
            writer = bzrlib.option.diff_writer_registry.get()
5895
6061
        try:
5896
6062
            shelver = Shelver.from_args(writer(sys.stdout), revision, all,
5897
 
                file_list, message, destroy=destroy)
 
6063
                file_list, message, destroy=destroy, directory=directory)
5898
6064
            try:
5899
6065
                shelver.run()
5900
6066
            finally:
5902
6068
        except errors.UserAbort:
5903
6069
            return 0
5904
6070
 
5905
 
    def run_for_list(self):
5906
 
        tree = WorkingTree.open_containing('.')[0]
5907
 
        tree.lock_read()
5908
 
        self.add_cleanup(tree.unlock)
 
6071
    def run_for_list(self, directory=None):
 
6072
        if directory is None:
 
6073
            directory = u'.'
 
6074
        tree = WorkingTree.open_containing(directory)[0]
 
6075
        self.add_cleanup(tree.lock_read().unlock)
5909
6076
        manager = tree.get_shelf_manager()
5910
6077
        shelves = manager.active_shelves()
5911
6078
        if len(shelves) == 0:
5929
6096
 
5930
6097
    takes_args = ['shelf_id?']
5931
6098
    takes_options = [
 
6099
        'directory',
5932
6100
        RegistryOption.from_kwargs(
5933
6101
            'action', help="The action to perform.",
5934
6102
            enum_switch=False, value_switches=True,
5942
6110
    ]
5943
6111
    _see_also = ['shelve']
5944
6112
 
5945
 
    def run(self, shelf_id=None, action='apply'):
 
6113
    def run(self, shelf_id=None, action='apply', directory=u'.'):
5946
6114
        from bzrlib.shelf_ui import Unshelver
5947
 
        unshelver = Unshelver.from_args(shelf_id, action)
 
6115
        unshelver = Unshelver.from_args(shelf_id, action, directory=directory)
5948
6116
        try:
5949
6117
            unshelver.run()
5950
6118
        finally:
5966
6134
 
5967
6135
    To check what clean-tree will do, use --dry-run.
5968
6136
    """
5969
 
    takes_options = [Option('ignored', help='Delete all ignored files.'),
5970
 
                     Option('detritus', help='Delete conflict files, merge'
 
6137
    takes_options = ['directory',
 
6138
                     Option('ignored', help='Delete all ignored files.'),
 
6139
                     Option('detritus', help='Delete conflict files, merge and revert'
5971
6140
                            ' backups, and failed selftest dirs.'),
5972
6141
                     Option('unknown',
5973
6142
                            help='Delete files unknown to bzr (default).'),
5975
6144
                            ' deleting them.'),
5976
6145
                     Option('force', help='Do not prompt before deleting.')]
5977
6146
    def run(self, unknown=False, ignored=False, detritus=False, dry_run=False,
5978
 
            force=False):
 
6147
            force=False, directory=u'.'):
5979
6148
        from bzrlib.clean_tree import clean_tree
5980
6149
        if not (unknown or ignored or detritus):
5981
6150
            unknown = True
5982
6151
        if dry_run:
5983
6152
            force = True
5984
 
        clean_tree('.', unknown=unknown, ignored=ignored, detritus=detritus,
5985
 
                   dry_run=dry_run, no_prompt=force)
 
6153
        clean_tree(directory, unknown=unknown, ignored=ignored,
 
6154
                   detritus=detritus, dry_run=dry_run, no_prompt=force)
5986
6155
 
5987
6156
 
5988
6157
class cmd_reference(Command):
6032
6201
            self.outf.write('%s %s\n' % (path, location))
6033
6202
 
6034
6203
 
 
6204
class cmd_export_pot(Command):
 
6205
    __doc__ = """Export command helps and error messages in po format."""
 
6206
 
 
6207
    hidden = True
 
6208
 
 
6209
    def run(self):
 
6210
        from bzrlib.export_pot import export_pot
 
6211
        export_pot(self.outf)
 
6212
 
 
6213
 
6035
6214
def _register_lazy_builtins():
6036
6215
    # register lazy builtins from other modules; called at startup and should
6037
6216
    # be only called once.
6038
6217
    for (name, aliases, module_name) in [
6039
6218
        ('cmd_bundle_info', [], 'bzrlib.bundle.commands'),
 
6219
        ('cmd_config', [], 'bzrlib.config'),
6040
6220
        ('cmd_dpush', [], 'bzrlib.foreign'),
6041
6221
        ('cmd_version_info', [], 'bzrlib.cmd_version_info'),
6042
6222
        ('cmd_resolve', ['resolved'], 'bzrlib.conflicts'),
6043
6223
        ('cmd_conflicts', [], 'bzrlib.conflicts'),
6044
 
        ('cmd_sign_my_commits', [], 'bzrlib.sign_my_commits'),
 
6224
        ('cmd_sign_my_commits', [], 'bzrlib.commit_signature_commands'),
 
6225
        ('cmd_verify_signatures', [],
 
6226
                                        'bzrlib.commit_signature_commands'),
 
6227
        ('cmd_test_script', [], 'bzrlib.cmd_test_script'),
6045
6228
        ]:
6046
6229
        builtin_command_registry.register_lazy(name, aliases, module_name)