/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: Martin Pool
  • Date: 2010-02-23 07:43:11 UTC
  • mfrom: (4797.2.20 2.1)
  • mto: This revision was merged to the branch mainline in revision 5055.
  • Revision ID: mbp@sourcefrog.net-20100223074311-gnj55xdhrgz9l94e
Merge 2.1 back to trunk

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
 
    _register_builtin_commands()
226
 
    return builtin_command_registry.keys()
 
182
    return _builtin_commands().keys()
227
183
 
228
184
 
229
185
def plugin_command_names():
243
199
        raise errors.BzrCommandError('unknown command "%s"' % cmd_name)
244
200
 
245
201
 
246
 
def _get_cmd_object(cmd_name, plugins_override=True, check_missing=True):
 
202
def _get_cmd_object(cmd_name, plugins_override=True):
247
203
    """Get a command object.
248
204
 
249
205
    :param cmd_name: The name of the command.
250
206
    :param plugins_override: Allow plugins to override builtins.
251
 
    :param check_missing: Look up commands not found in the regular index via
252
 
        the get_missing_command hook.
253
207
    :return: A Command object instance
254
208
    :raises KeyError: If no command is found.
255
209
    """
265
219
            # We've found a non-plugin command, don't permit it to be
266
220
            # overridden.
267
221
            break
268
 
    if cmd is None and check_missing:
 
222
    if cmd is None:
269
223
        for hook in Command.hooks['get_missing_command']:
270
224
            cmd = hook(cmd_name)
271
225
            if cmd is not None:
307
261
 
308
262
def _get_bzr_command(cmd_or_None, cmd_name):
309
263
    """Get a command from bzr's core."""
 
264
    cmds = _builtin_commands()
310
265
    try:
311
 
        cmd_class = builtin_command_registry.get(cmd_name)
 
266
        return cmds[cmd_name]()
312
267
    except KeyError:
313
268
        pass
314
 
    else:
315
 
        return cmd_class()
 
269
    # look for any command which claims this as an alias
 
270
    for real_cmd_name, cmd_class in cmds.iteritems():
 
271
        if cmd_name in cmd_class.aliases:
 
272
            return cmd_class()
316
273
    return cmd_or_None
317
274
 
318
275
 
398
355
            will not mangled.
399
356
 
400
357
    :cvar hooks: An instance of CommandHooks.
401
 
    :ivar __doc__: The help shown by 'bzr help command' for this command.
402
 
        This is set by assigning explicitly to __doc__ so that -OO can
403
 
        be used::
404
 
 
405
 
        class Foo(Command):
406
 
            __doc__ = "My help goes here"
407
358
    """
408
359
    aliases = []
409
360
    takes_args = []
414
365
 
415
366
    def __init__(self):
416
367
        """Construct an instance of this command."""
 
368
        if self.__doc__ == Command.__doc__:
 
369
            warn("No help message set for %r" % self)
417
370
        # List of standard options directly supported
418
371
        self.supported_std_options = []
419
 
        self._setup_run()
420
 
 
 
372
        self._operation = cleanup.OperationWithCleanups(self.run)
 
373
    
421
374
    def add_cleanup(self, cleanup_func, *args, **kwargs):
422
375
        """Register a function to call after self.run returns or raises.
423
376
 
434
387
 
435
388
        This is useful for releasing expensive or contentious resources (such
436
389
        as write locks) before doing further work that does not require those
437
 
        resources (such as writing results to self.outf). Note though, that
438
 
        as it releases all resources, this may release locks that the command
439
 
        wants to hold, so use should be done with care.
 
390
        resources (such as writing results to self.outf).
440
391
        """
441
392
        self._operation.cleanup_now()
442
 
 
 
393
        
443
394
    @deprecated_method(deprecated_in((2, 1, 0)))
444
395
    def _maybe_expand_globs(self, file_list):
445
396
        """Glob expand file_list if the platform does not do that itself.
487
438
            message explaining how to obtain full help.
488
439
        """
489
440
        doc = self.help()
490
 
        if not doc:
491
 
            doc = "No help for this command."
 
441
        if doc is None:
 
442
            raise NotImplementedError("sorry, no detailed help yet for %r" % self.name())
492
443
 
493
444
        # Extract the summary (purpose) and sections out from the text
494
445
        purpose,sections,order = self._get_help_parts(doc)
687
638
 
688
639
        self._setup_outf()
689
640
 
690
 
        return self.run(**all_cmd_args)
691
 
 
692
 
    def _setup_run(self):
693
 
        """Wrap the defined run method on self with a cleanup.
694
 
 
695
 
        This is called by __init__ to make the Command be able to be run
696
 
        by just calling run(), as it could be before cleanups were added.
697
 
 
698
 
        If a different form of cleanups are in use by your Command subclass,
699
 
        you can override this method.
700
 
        """
701
 
        class_run = self.run
702
 
        def run(*args, **kwargs):
703
 
            self._operation = cleanup.OperationWithCleanups(class_run)
704
 
            try:
705
 
                return self._operation.run_simple(*args, **kwargs)
706
 
            finally:
707
 
                del self._operation
708
 
        self.run = run
709
 
 
710
 
    @deprecated_method(deprecated_in((2, 2, 0)))
 
641
        return self.run_direct(**all_cmd_args)
 
642
 
711
643
    def run_direct(self, *args, **kwargs):
712
 
        """Deprecated thunk from bzrlib 2.1."""
713
 
        return self.run(*args, **kwargs)
 
644
        """Call run directly with objects (without parsing an argv list)."""
 
645
        return self._operation.run_simple(*args, **kwargs)
714
646
 
715
647
    def run(self):
716
648
        """Actually run the command.
721
653
        Return 0 or None if the command was successful, or a non-zero
722
654
        shell error code if not.  It's OK for this method to allow
723
655
        an exception to raise up.
724
 
 
725
 
        This method is automatically wrapped by Command.__init__ with a 
726
 
        cleanup operation, stored as self._operation. This can be used
727
 
        via self.add_cleanup to perform automatic cleanups at the end of
728
 
        run().
729
 
 
730
 
        The argument for run are assembled by introspection. So for instance,
731
 
        if your command takes an argument files, you would declare::
732
 
 
733
 
            def run(self, files=None):
734
 
                pass
735
656
        """
736
657
        raise NotImplementedError('no implementation of command %r'
737
658
                                  % self.name())
954
875
    return ret
955
876
 
956
877
 
957
 
@deprecated_function(deprecated_in((2, 2, 0)))
958
 
def shlex_split_unicode(unsplit):
959
 
    return cmdline.split(unsplit)
960
 
 
961
 
 
962
878
def get_alias(cmd, config=None):
963
879
    """Return an expanded alias, or None if no alias exists.
964
880
 
1055
971
        elif a == '--coverage':
1056
972
            opt_coverage_dir = argv[i + 1]
1057
973
            i += 1
1058
 
        elif a == '--profile-imports':
1059
 
            pass # already handled in startup script Bug #588277
1060
974
        elif a.startswith('-D'):
1061
975
            debug.debug_flags.add(a[2:])
1062
976
        else:
1084
998
    if not opt_no_aliases:
1085
999
        alias_argv = get_alias(argv[0])
1086
1000
        if alias_argv:
 
1001
            user_encoding = osutils.get_user_encoding()
 
1002
            alias_argv = [a.decode(user_encoding) for a in alias_argv]
1087
1003
            argv[0] = alias_argv.pop(0)
1088
1004
 
1089
1005
    cmd = argv.pop(0)
 
1006
    # We want only 'ascii' command names, but the user may have typed
 
1007
    # in a Unicode name. In that case, they should just get a
 
1008
    # 'command not found' error later.
 
1009
 
1090
1010
    cmd_obj = get_cmd_object(cmd, plugins_override=not opt_builtin)
1091
1011
    run = cmd_obj.run_argv_aliases
1092
1012
    run_argv = [argv, alias_argv]
1189
1109
    :return: exit code of bzr command.
1190
1110
    """
1191
1111
    argv = _specified_or_unicode_argv(argv)
1192
 
    _register_builtin_commands()
1193
1112
    ret = run_bzr_catch_errors(argv)
1194
1113
    bzrlib.ui.ui_factory.log_transport_activity(
1195
1114
        display=('bytes' in debug.debug_flags))
1243
1162
        if topic and topic.startswith(self.prefix):
1244
1163
            topic = topic[len(self.prefix):]
1245
1164
        try:
1246
 
            cmd = _get_cmd_object(topic, check_missing=False)
 
1165
            cmd = _get_cmd_object(topic)
1247
1166
        except KeyError:
1248
1167
            return []
1249
1168
        else: