/brz/remove-bazaar

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

« back to all changes in this revision

Viewing changes to bzrlib/commands.py

  • Committer: Andrew Bennetts
  • Date: 2010-03-11 04:33:41 UTC
  • mfrom: (4797.33.4 2.1)
  • mto: This revision was merged to the branch mainline in revision 5082.
  • Revision ID: andrew.bennetts@canonical.com-20100311043341-rzdik83fnactjsxs
Merge lp:bzr/2.1, including fixes for #496813, #526211, #526353.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/commands.py
15
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
16
 
17
17
 
 
18
# TODO: probably should say which arguments are candidates for glob
 
19
# expansion on windows and do that at the command level.
 
20
 
18
21
# TODO: Define arguments by objects, rather than just using names.
19
22
# Those objects can specify the expected type of the argument, which
20
23
# would help with validation and shell completion.  They could also provide
22
25
 
23
26
# TODO: Specific "examples" property on commands for consistent formatting.
24
27
 
 
28
# TODO: "--profile=cum", to change sort order.  Is there any value in leaving
 
29
# the profile output behind so it can be interactively examined?
 
30
 
25
31
import os
26
32
import sys
27
33
 
72
78
 
73
79
 
74
80
class CommandRegistry(registry.Registry):
75
 
    """Special registry mapping command names to command classes.
76
 
    
77
 
    :ivar overridden_registry: Look in this registry for commands being
78
 
        overridden by this registry.  This can be used to tell plugin commands
79
 
        about the builtin they're decorating.
80
 
    """
81
 
 
82
 
    def __init__(self):
83
 
        registry.Registry.__init__(self)
84
 
        self.overridden_registry = None
85
 
        # map from aliases to the real command that implements the name
86
 
        self._alias_dict = {}
87
 
 
88
 
    def get(self, command_name):
89
 
        real_name = self._alias_dict.get(command_name, command_name)
90
 
        return registry.Registry.get(self, real_name)
91
81
 
92
82
    @staticmethod
93
83
    def _get_name(command_name):
109
99
        try:
110
100
            previous = self.get(k_unsquished)
111
101
        except KeyError:
112
 
            previous = None
113
 
            if self.overridden_registry:
114
 
                try:
115
 
                    previous = self.overridden_registry.get(k_unsquished)
116
 
                except KeyError:
117
 
                    pass
 
102
            previous = _builtin_commands().get(k_unsquished)
118
103
        info = CommandInfo.from_command(cmd)
119
104
        try:
120
105
            registry.Registry.register(self, k_unsquished, cmd,
125
110
                sys.modules[cmd.__module__])
126
111
            trace.warning('Previously this command was registered from %r' %
127
112
                sys.modules[previous.__module__])
128
 
        for a in cmd.aliases:
129
 
            self._alias_dict[a] = k_unsquished
130
113
        return previous
131
114
 
132
115
    def register_lazy(self, command_name, aliases, module_name):
139
122
        key = self._get_name(command_name)
140
123
        registry.Registry.register_lazy(self, key, module_name, command_name,
141
124
                                        info=CommandInfo(aliases))
142
 
        for a in aliases:
143
 
            self._alias_dict[a] = key
144
125
 
145
126
 
146
127
plugin_cmds = CommandRegistry()
147
 
builtin_command_registry = CommandRegistry()
148
 
plugin_cmds.overridden_registry = builtin_command_registry
149
128
 
150
129
 
151
130
def register_command(cmd, decorate=False):
152
 
    """Register a plugin command.
153
 
 
154
 
    Should generally be avoided in favor of lazy registration. 
155
 
    """
156
131
    global plugin_cmds
157
132
    return plugin_cmds.register(cmd, decorate)
158
133
 
165
140
    return cmd[4:].replace('_','-')
166
141
 
167
142
 
168
 
@deprecated_function(deprecated_in((2, 2, 0)))
169
143
def _builtin_commands():
170
 
    """Return a dict of {name: cmd_class} for builtin commands.
171
 
 
172
 
    :deprecated: Use the builtin_command_registry registry instead
173
 
    """
174
 
    # return dict(name: cmd_class)
175
 
    return dict(builtin_command_registry.items())
176
 
 
177
 
 
178
 
def _register_builtin_commands():
179
 
    if builtin_command_registry.keys():
180
 
        # only load once
181
 
        return
182
144
    import bzrlib.builtins
183
 
    for cmd_class in _scan_module_for_commands(bzrlib.builtins).values():
184
 
        builtin_command_registry.register(cmd_class)
185
 
    bzrlib.builtins._register_lazy_builtins()
 
145
    return _scan_module_for_commands(bzrlib.builtins)
186
146
 
187
147
 
188
148
def _scan_module_for_commands(module):
195
155
 
196
156
 
197
157
def _list_bzr_commands(names):
198
 
    """Find commands from bzr's core and plugins.
199
 
    
200
 
    This is not the public interface, just the default hook called by all_command_names.
201
 
    """
 
158
    """Find commands from bzr's core and plugins."""
202
159
    # to eliminate duplicates
203
160
    names.update(builtin_command_names())
204
161
    names.update(plugin_command_names())
222
179
    Use of all_command_names() is encouraged rather than builtin_command_names
223
180
    and/or plugin_command_names.
224
181
    """
225
 
    return builtin_command_registry.keys()
 
182
    return _builtin_commands().keys()
226
183
 
227
184
 
228
185
def plugin_command_names():
306
263
 
307
264
def _get_bzr_command(cmd_or_None, cmd_name):
308
265
    """Get a command from bzr's core."""
 
266
    cmds = _builtin_commands()
309
267
    try:
310
 
        cmd_class = builtin_command_registry.get(cmd_name)
 
268
        return cmds[cmd_name]()
311
269
    except KeyError:
312
270
        pass
313
 
    else:
314
 
        return cmd_class()
 
271
    # look for any command which claims this as an alias
 
272
    for real_cmd_name, cmd_class in cmds.iteritems():
 
273
        if cmd_name in cmd_class.aliases:
 
274
            return cmd_class()
315
275
    return cmd_or_None
316
276
 
317
277
 
397
357
            will not mangled.
398
358
 
399
359
    :cvar hooks: An instance of CommandHooks.
400
 
    :ivar __doc__: The help shown by 'bzr help command' for this command.
401
 
        This is set by assigning explicitly to __doc__ so that -OO can
402
 
        be used::
403
 
 
404
 
        class Foo(Command):
405
 
            __doc__ = "My help goes here"
406
360
    """
407
361
    aliases = []
408
362
    takes_args = []
413
367
 
414
368
    def __init__(self):
415
369
        """Construct an instance of this command."""
 
370
        if self.__doc__ == Command.__doc__:
 
371
            warn("No help message set for %r" % self)
416
372
        # List of standard options directly supported
417
373
        self.supported_std_options = []
418
 
        self._setup_run()
 
374
        self._operation = cleanup.OperationWithCleanups(self.run)
419
375
 
420
376
    def add_cleanup(self, cleanup_func, *args, **kwargs):
421
377
        """Register a function to call after self.run returns or raises.
433
389
 
434
390
        This is useful for releasing expensive or contentious resources (such
435
391
        as write locks) before doing further work that does not require those
436
 
        resources (such as writing results to self.outf). Note though, that
437
 
        as it releases all resources, this may release locks that the command
438
 
        wants to hold, so use should be done with care.
 
392
        resources (such as writing results to self.outf).
439
393
        """
440
394
        self._operation.cleanup_now()
441
395
 
486
440
            message explaining how to obtain full help.
487
441
        """
488
442
        doc = self.help()
489
 
        if not doc:
490
 
            doc = "No help for this command."
 
443
        if doc is None:
 
444
            raise NotImplementedError("sorry, no detailed help yet for %r" % self.name())
491
445
 
492
446
        # Extract the summary (purpose) and sections out from the text
493
447
        purpose,sections,order = self._get_help_parts(doc)
686
640
 
687
641
        self._setup_outf()
688
642
 
689
 
        return self.run(**all_cmd_args)
690
 
 
691
 
    def _setup_run(self):
692
 
        """Wrap the defined run method on self with a cleanup.
693
 
 
694
 
        This is called by __init__ to make the Command be able to be run
695
 
        by just calling run(), as it could be before cleanups were added.
696
 
 
697
 
        If a different form of cleanups are in use by your Command subclass,
698
 
        you can override this method.
699
 
        """
700
 
        class_run = self.run
701
 
        def run(*args, **kwargs):
702
 
            self._operation = cleanup.OperationWithCleanups(class_run)
703
 
            try:
704
 
                return self._operation.run_simple(*args, **kwargs)
705
 
            finally:
706
 
                del self._operation
707
 
        self.run = run
708
 
 
709
 
    @deprecated_method(deprecated_in((2, 2, 0)))
 
643
        return self.run_direct(**all_cmd_args)
 
644
 
710
645
    def run_direct(self, *args, **kwargs):
711
 
        """Deprecated thunk from bzrlib 2.1."""
712
 
        return self.run(*args, **kwargs)
 
646
        """Call run directly with objects (without parsing an argv list)."""
 
647
        return self._operation.run_simple(*args, **kwargs)
713
648
 
714
649
    def run(self):
715
650
        """Actually run the command.
720
655
        Return 0 or None if the command was successful, or a non-zero
721
656
        shell error code if not.  It's OK for this method to allow
722
657
        an exception to raise up.
723
 
 
724
 
        This method is automatically wrapped by Command.__init__ with a 
725
 
        cleanup operation, stored as self._operation. This can be used
726
 
        via self.add_cleanup to perform automatic cleanups at the end of
727
 
        run().
728
 
 
729
 
        The argument for run are assembled by introspection. So for instance,
730
 
        if your command takes an argument files, you would declare::
731
 
 
732
 
            def run(self, files=None):
733
 
                pass
734
658
        """
735
659
        raise NotImplementedError('no implementation of command %r'
736
660
                                  % self.name())
1054
978
        elif a == '--coverage':
1055
979
            opt_coverage_dir = argv[i + 1]
1056
980
            i += 1
1057
 
        elif a == '--profile-imports':
1058
 
            pass # already handled in startup script Bug #588277
1059
981
        elif a.startswith('-D'):
1060
982
            debug.debug_flags.add(a[2:])
1061
983
        else:
1083
1005
    if not opt_no_aliases:
1084
1006
        alias_argv = get_alias(argv[0])
1085
1007
        if alias_argv:
 
1008
            user_encoding = osutils.get_user_encoding()
 
1009
            alias_argv = [a.decode(user_encoding) for a in alias_argv]
1086
1010
            argv[0] = alias_argv.pop(0)
1087
1011
 
1088
1012
    cmd = argv.pop(0)
 
1013
    # We want only 'ascii' command names, but the user may have typed
 
1014
    # in a Unicode name. In that case, they should just get a
 
1015
    # 'command not found' error later.
 
1016
 
1089
1017
    cmd_obj = get_cmd_object(cmd, plugins_override=not opt_builtin)
1090
1018
    run = cmd_obj.run_argv_aliases
1091
1019
    run_argv = [argv, alias_argv]
1188
1116
    :return: exit code of bzr command.
1189
1117
    """
1190
1118
    argv = _specified_or_unicode_argv(argv)
1191
 
    _register_builtin_commands()
1192
1119
    ret = run_bzr_catch_errors(argv)
1193
1120
    bzrlib.ui.ui_factory.log_transport_activity(
1194
1121
        display=('bytes' in debug.debug_flags))