/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: Ian Clatworthy
  • Date: 2010-03-04 04:15:18 UTC
  • mto: (5094.1.1 integration)
  • mto: This revision was merged to the branch mainline in revision 5096.
  • Revision ID: ian.clatworthy@canonical.com-20100304041518-vf8v1ivn8jrh9fs5
Initial cut at a What's New in 2.2 document

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():
307
263
 
308
264
def _get_bzr_command(cmd_or_None, cmd_name):
309
265
    """Get a command from bzr's core."""
 
266
    cmds = _builtin_commands()
310
267
    try:
311
 
        cmd_class = builtin_command_registry.get(cmd_name)
 
268
        return cmds[cmd_name]()
312
269
    except KeyError:
313
270
        pass
314
 
    else:
315
 
        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()
316
275
    return cmd_or_None
317
276
 
318
277
 
398
357
            will not mangled.
399
358
 
400
359
    :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
360
    """
408
361
    aliases = []
409
362
    takes_args = []
414
367
 
415
368
    def __init__(self):
416
369
        """Construct an instance of this command."""
 
370
        if self.__doc__ == Command.__doc__:
 
371
            warn("No help message set for %r" % self)
417
372
        # List of standard options directly supported
418
373
        self.supported_std_options = []
419
 
        self._setup_run()
 
374
        self._operation = cleanup.OperationWithCleanups(self.run)
420
375
 
421
376
    def add_cleanup(self, cleanup_func, *args, **kwargs):
422
377
        """Register a function to call after self.run returns or raises.
434
389
 
435
390
        This is useful for releasing expensive or contentious resources (such
436
391
        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.
 
392
        resources (such as writing results to self.outf).
440
393
        """
441
394
        self._operation.cleanup_now()
442
395
 
487
440
            message explaining how to obtain full help.
488
441
        """
489
442
        doc = self.help()
490
 
        if not doc:
491
 
            doc = "No help for this command."
 
443
        if doc is None:
 
444
            raise NotImplementedError("sorry, no detailed help yet for %r" % self.name())
492
445
 
493
446
        # Extract the summary (purpose) and sections out from the text
494
447
        purpose,sections,order = self._get_help_parts(doc)
687
640
 
688
641
        self._setup_outf()
689
642
 
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)))
 
643
        return self.run_direct(**all_cmd_args)
 
644
 
711
645
    def run_direct(self, *args, **kwargs):
712
 
        """Deprecated thunk from bzrlib 2.1."""
713
 
        return self.run(*args, **kwargs)
 
646
        """Call run directly with objects (without parsing an argv list)."""
 
647
        return self._operation.run_simple(*args, **kwargs)
714
648
 
715
649
    def run(self):
716
650
        """Actually run the command.
721
655
        Return 0 or None if the command was successful, or a non-zero
722
656
        shell error code if not.  It's OK for this method to allow
723
657
        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
658
        """
736
659
        raise NotImplementedError('no implementation of command %r'
737
660
                                  % self.name())
1055
978
        elif a == '--coverage':
1056
979
            opt_coverage_dir = argv[i + 1]
1057
980
            i += 1
1058
 
        elif a == '--profile-imports':
1059
 
            pass # already handled in startup script Bug #588277
1060
981
        elif a.startswith('-D'):
1061
982
            debug.debug_flags.add(a[2:])
1062
983
        else:
1084
1005
    if not opt_no_aliases:
1085
1006
        alias_argv = get_alias(argv[0])
1086
1007
        if alias_argv:
 
1008
            user_encoding = osutils.get_user_encoding()
 
1009
            alias_argv = [a.decode(user_encoding) for a in alias_argv]
1087
1010
            argv[0] = alias_argv.pop(0)
1088
1011
 
1089
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
 
1090
1017
    cmd_obj = get_cmd_object(cmd, plugins_override=not opt_builtin)
1091
1018
    run = cmd_obj.run_argv_aliases
1092
1019
    run_argv = [argv, alias_argv]
1189
1116
    :return: exit code of bzr command.
1190
1117
    """
1191
1118
    argv = _specified_or_unicode_argv(argv)
1192
 
    _register_builtin_commands()
1193
1119
    ret = run_bzr_catch_errors(argv)
1194
1120
    bzrlib.ui.ui_factory.log_transport_activity(
1195
1121
        display=('bytes' in debug.debug_flags))