← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/commands.py

  • Committer: Launchpad Translations on behalf of bzr-core
  • Date: 2012-02-22 06:50:36 UTC
  • mto: (6437.35.1 2.5.0-dev)
  • mto: This revision was merged to the branch mainline in revision 6475.
  • Revision ID: launchpad_translations_on_behalf_of_bzr-core-20120222065036-ssi1nphovuqv8ou2
Launchpad automatic translations update.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/commands.py
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
14
14
# along with this program; if not, write to the Free Software
15
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
16
 
17
 
 
18
 
# TODO: probably should say which arguments are candidates for glob
19
 
# expansion on windows and do that at the command level.
 
17
from __future__ import absolute_import
20
18
 
21
19
# TODO: Define arguments by objects, rather than just using names.
22
20
# Those objects can specify the expected type of the argument, which
25
23
 
26
24
# TODO: Specific "examples" property on commands for consistent formatting.
27
25
 
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
 
 
31
26
import os
32
27
import sys
33
28
 
34
29
from bzrlib.lazy_import import lazy_import
35
30
lazy_import(globals(), """
36
 
import codecs
37
31
import errno
38
32
import threading
39
 
from warnings import warn
40
33
 
41
34
import bzrlib
42
35
from bzrlib import (
44
37
    cmdline,
45
38
    debug,
46
39
    errors,
 
40
    i18n,
47
41
    option,
48
42
    osutils,
49
43
    trace,
50
44
    ui,
51
 
    win32utils,
52
45
    )
53
46
""")
54
47
 
55
 
from bzrlib.hooks import HookPoint, Hooks
 
48
from bzrlib.hooks import Hooks
 
49
from bzrlib.i18n import gettext
56
50
# Compatibility - Option used to be in commands.
57
51
from bzrlib.option import Option
58
52
from bzrlib.plugin import disable_plugins, load_plugins
59
53
from bzrlib import registry
60
 
from bzrlib.symbol_versioning import (
61
 
    deprecated_function,
62
 
    deprecated_in,
63
 
    deprecated_method,
64
 
    )
65
54
 
66
55
 
67
56
class CommandInfo(object):
78
67
 
79
68
 
80
69
class CommandRegistry(registry.Registry):
 
70
    """Special registry mapping command names to command classes.
 
71
    
 
72
    :ivar overridden_registry: Look in this registry for commands being
 
73
        overridden by this registry.  This can be used to tell plugin commands
 
74
        about the builtin they're decorating.
 
75
    """
 
76
 
 
77
    def __init__(self):
 
78
        registry.Registry.__init__(self)
 
79
        self.overridden_registry = None
 
80
        # map from aliases to the real command that implements the name
 
81
        self._alias_dict = {}
 
82
 
 
83
    def get(self, command_name):
 
84
        real_name = self._alias_dict.get(command_name, command_name)
 
85
        return registry.Registry.get(self, real_name)
81
86
 
82
87
    @staticmethod
83
88
    def _get_name(command_name):
99
104
        try:
100
105
            previous = self.get(k_unsquished)
101
106
        except KeyError:
102
 
            previous = _builtin_commands().get(k_unsquished)
 
107
            previous = None
 
108
            if self.overridden_registry:
 
109
                try:
 
110
                    previous = self.overridden_registry.get(k_unsquished)
 
111
                except KeyError:
 
112
                    pass
103
113
        info = CommandInfo.from_command(cmd)
104
114
        try:
105
115
            registry.Registry.register(self, k_unsquished, cmd,
110
120
                sys.modules[cmd.__module__])
111
121
            trace.warning('Previously this command was registered from %r' %
112
122
                sys.modules[previous.__module__])
 
123
        for a in cmd.aliases:
 
124
            self._alias_dict[a] = k_unsquished
113
125
        return previous
114
126
 
115
127
    def register_lazy(self, command_name, aliases, module_name):
122
134
        key = self._get_name(command_name)
123
135
        registry.Registry.register_lazy(self, key, module_name, command_name,
124
136
                                        info=CommandInfo(aliases))
 
137
        for a in aliases:
 
138
            self._alias_dict[a] = key
125
139
 
126
140
 
127
141
plugin_cmds = CommandRegistry()
 
142
builtin_command_registry = CommandRegistry()
 
143
plugin_cmds.overridden_registry = builtin_command_registry
128
144
 
129
145
 
130
146
def register_command(cmd, decorate=False):
 
147
    """Register a plugin command.
 
148
 
 
149
    Should generally be avoided in favor of lazy registration. 
 
150
    """
131
151
    global plugin_cmds
132
152
    return plugin_cmds.register(cmd, decorate)
133
153
 
140
160
    return cmd[4:].replace('_','-')
141
161
 
142
162
 
143
 
def _builtin_commands():
 
163
def _register_builtin_commands():
 
164
    if builtin_command_registry.keys():
 
165
        # only load once
 
166
        return
144
167
    import bzrlib.builtins
145
 
    return _scan_module_for_commands(bzrlib.builtins)
 
168
    for cmd_class in _scan_module_for_commands(bzrlib.builtins).values():
 
169
        builtin_command_registry.register(cmd_class)
 
170
    bzrlib.builtins._register_lazy_builtins()
146
171
 
147
172
 
148
173
def _scan_module_for_commands(module):
155
180
 
156
181
 
157
182
def _list_bzr_commands(names):
158
 
    """Find commands from bzr's core and plugins."""
 
183
    """Find commands from bzr's core and plugins.
 
184
    
 
185
    This is not the public interface, just the default hook called by all_command_names.
 
186
    """
159
187
    # to eliminate duplicates
160
188
    names.update(builtin_command_names())
161
189
    names.update(plugin_command_names())
179
207
    Use of all_command_names() is encouraged rather than builtin_command_names
180
208
    and/or plugin_command_names.
181
209
    """
182
 
    return _builtin_commands().keys()
 
210
    _register_builtin_commands()
 
211
    return builtin_command_registry.keys()
183
212
 
184
213
 
185
214
def plugin_command_names():
196
225
    try:
197
226
        return _get_cmd_object(cmd_name, plugins_override)
198
227
    except KeyError:
199
 
        raise errors.BzrCommandError('unknown command "%s"' % cmd_name)
 
228
        raise errors.BzrCommandError(gettext('unknown command "%s"') % cmd_name)
200
229
 
201
230
 
202
231
def _get_cmd_object(cmd_name, plugins_override=True, check_missing=True):
232
261
    # Allow plugins to extend commands
233
262
    for hook in Command.hooks['extend_command']:
234
263
        hook(cmd)
 
264
    if getattr(cmd, 'invoked_as', None) is None:
 
265
        cmd.invoked_as = cmd_name
235
266
    return cmd
236
267
 
237
268
 
263
294
 
264
295
def _get_bzr_command(cmd_or_None, cmd_name):
265
296
    """Get a command from bzr's core."""
266
 
    cmds = _builtin_commands()
267
297
    try:
268
 
        return cmds[cmd_name]()
 
298
        cmd_class = builtin_command_registry.get(cmd_name)
269
299
    except KeyError:
270
300
        pass
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()
 
301
    else:
 
302
        return cmd_class()
275
303
    return cmd_or_None
276
304
 
277
305
 
317
345
    summary, then a complete description of the command.  A grammar
318
346
    description will be inserted.
319
347
 
320
 
    aliases
321
 
        Other accepted names for this command.
322
 
 
323
 
    takes_args
324
 
        List of argument forms, marked with whether they are optional,
325
 
        repeated, etc.
326
 
 
327
 
                Examples:
328
 
 
329
 
                ['to_location', 'from_branch?', 'file*']
330
 
 
331
 
                'to_location' is required
332
 
                'from_branch' is optional
333
 
                'file' can be specified 0 or more times
334
 
 
335
 
    takes_options
336
 
        List of options that may be given for this command.  These can
337
 
        be either strings, referring to globally-defined options,
338
 
        or option objects.  Retrieve through options().
339
 
 
340
 
    hidden
341
 
        If true, this command isn't advertised.  This is typically
 
348
    :cvar aliases: Other accepted names for this command.
 
349
 
 
350
    :cvar takes_args: List of argument forms, marked with whether they are
 
351
        optional, repeated, etc.  Examples::
 
352
 
 
353
            ['to_location', 'from_branch?', 'file*']
 
354
 
 
355
        * 'to_location' is required
 
356
        * 'from_branch' is optional
 
357
        * 'file' can be specified 0 or more times
 
358
 
 
359
    :cvar takes_options: List of options that may be given for this command.
 
360
        These can be either strings, referring to globally-defined options, or
 
361
        option objects.  Retrieve through options().
 
362
 
 
363
    :cvar hidden: If true, this command isn't advertised.  This is typically
342
364
        for commands intended for expert users.
343
365
 
344
 
    encoding_type
345
 
        Command objects will get a 'outf' attribute, which has been
346
 
        setup to properly handle encoding of unicode strings.
347
 
        encoding_type determines what will happen when characters cannot
348
 
        be encoded
349
 
            strict - abort if we cannot decode
350
 
            replace - put in a bogus character (typically '?')
351
 
            exact - do not encode sys.stdout
352
 
 
353
 
            NOTE: by default on Windows, sys.stdout is opened as a text
354
 
            stream, therefore LF line-endings are converted to CRLF.
355
 
            When a command uses encoding_type = 'exact', then
356
 
            sys.stdout is forced to be a binary stream, and line-endings
357
 
            will not mangled.
 
366
    :cvar encoding_type: Command objects will get a 'outf' attribute, which has
 
367
        been setup to properly handle encoding of unicode strings.
 
368
        encoding_type determines what will happen when characters cannot be
 
369
        encoded:
 
370
 
 
371
        * strict - abort if we cannot decode
 
372
        * replace - put in a bogus character (typically '?')
 
373
        * exact - do not encode sys.stdout
 
374
 
 
375
        NOTE: by default on Windows, sys.stdout is opened as a text stream,
 
376
        therefore LF line-endings are converted to CRLF.  When a command uses
 
377
        encoding_type = 'exact', then sys.stdout is forced to be a binary
 
378
        stream, and line-endings will not mangled.
 
379
 
 
380
    :cvar invoked_as:
 
381
        A string indicating the real name under which this command was
 
382
        invoked, before expansion of aliases.
 
383
        (This may be None if the command was constructed and run in-process.)
358
384
 
359
385
    :cvar hooks: An instance of CommandHooks.
 
386
 
 
387
    :cvar __doc__: The help shown by 'bzr help command' for this command.
 
388
        This is set by assigning explicitly to __doc__ so that -OO can
 
389
        be used::
 
390
 
 
391
            class Foo(Command):
 
392
                __doc__ = "My help goes here"
360
393
    """
361
394
    aliases = []
362
395
    takes_args = []
363
396
    takes_options = []
364
397
    encoding_type = 'strict'
 
398
    invoked_as = None
 
399
    l10n = True
365
400
 
366
401
    hidden = False
367
402
 
368
403
    def __init__(self):
369
404
        """Construct an instance of this command."""
370
 
        if self.__doc__ == Command.__doc__:
371
 
            warn("No help message set for %r" % self)
372
405
        # List of standard options directly supported
373
406
        self.supported_std_options = []
374
 
        self._operation = cleanup.OperationWithCleanups(self.run)
 
407
        self._setup_run()
375
408
 
376
409
    def add_cleanup(self, cleanup_func, *args, **kwargs):
377
410
        """Register a function to call after self.run returns or raises.
389
422
 
390
423
        This is useful for releasing expensive or contentious resources (such
391
424
        as write locks) before doing further work that does not require those
392
 
        resources (such as writing results to self.outf).
 
425
        resources (such as writing results to self.outf). Note though, that
 
426
        as it releases all resources, this may release locks that the command
 
427
        wants to hold, so use should be done with care.
393
428
        """
394
429
        self._operation.cleanup_now()
395
430
 
396
 
    @deprecated_method(deprecated_in((2, 1, 0)))
397
 
    def _maybe_expand_globs(self, file_list):
398
 
        """Glob expand file_list if the platform does not do that itself.
399
 
 
400
 
        Not used anymore, now that the bzr command-line parser globs on
401
 
        Windows.
402
 
 
403
 
        :return: A possibly empty list of unicode paths.
404
 
 
405
 
        Introduced in bzrlib 0.18.
406
 
        """
407
 
        return file_list
408
 
 
409
431
    def _usage(self):
410
432
        """Return single-line grammar for this command.
411
433
 
439
461
            usage help (e.g. Purpose, Usage, Options) with a
440
462
            message explaining how to obtain full help.
441
463
        """
 
464
        if self.l10n:
 
465
            i18n.install()  # Install i18n only for get_help_text for now.
442
466
        doc = self.help()
443
 
        if doc is None:
444
 
            raise NotImplementedError("sorry, no detailed help yet for %r" % self.name())
 
467
        if doc:
 
468
            # Note: If self.gettext() translates ':Usage:\n', the section will
 
469
            # be shown after "Description" section and we don't want to
 
470
            # translate the usage string.
 
471
            # Though, bzr export-pot don't exports :Usage: section and it must
 
472
            # not be translated.
 
473
            doc = self.gettext(doc)
 
474
        else:
 
475
            doc = gettext("No help for this command.")
445
476
 
446
477
        # Extract the summary (purpose) and sections out from the text
447
478
        purpose,sections,order = self._get_help_parts(doc)
454
485
 
455
486
        # The header is the purpose and usage
456
487
        result = ""
457
 
        result += ':Purpose: %s\n' % purpose
 
488
        result += gettext(':Purpose: %s\n') % (purpose,)
458
489
        if usage.find('\n') >= 0:
459
 
            result += ':Usage:\n%s\n' % usage
 
490
            result += gettext(':Usage:\n%s\n') % (usage,)
460
491
        else:
461
 
            result += ':Usage:   %s\n' % usage
 
492
            result += gettext(':Usage:   %s\n') % (usage,)
462
493
        result += '\n'
463
494
 
464
495
        # Add the options
466
497
        # XXX: optparse implicitly rewraps the help, and not always perfectly,
467
498
        # so we get <https://bugs.launchpad.net/bzr/+bug/249908>.  -- mbp
468
499
        # 20090319
469
 
        options = option.get_optparser(self.options()).format_option_help()
470
 
        # XXX: According to the spec, ReST option lists actually don't support 
471
 
        # options like --1.9 so that causes syntax errors (in Sphinx at least).
472
 
        # As that pattern always appears in the commands that break, we trap
473
 
        # on that and then format that block of 'format' options as a literal
474
 
        # block.
475
 
        if not plain and options.find('  --1.9  ') != -1:
 
500
        parser = option.get_optparser(self.options())
 
501
        options = parser.format_option_help()
 
502
        # FIXME: According to the spec, ReST option lists actually don't
 
503
        # support options like --1.14 so that causes syntax errors (in Sphinx
 
504
        # at least).  As that pattern always appears in the commands that
 
505
        # break, we trap on that and then format that block of 'format' options
 
506
        # as a literal block. We use the most recent format still listed so we
 
507
        # don't have to do that too often -- vila 20110514
 
508
        if not plain and options.find('  --1.14  ') != -1:
476
509
            options = options.replace(' format:\n', ' format::\n\n', 1)
477
510
        if options.startswith('Options:'):
478
 
            result += ':' + options
479
 
        elif options.startswith('options:'):
480
 
            # Python 2.4 version of optparse
481
 
            result += ':Options:' + options[len('options:'):]
 
511
            result += gettext(':Options:%s') % (options[len('options:'):],)
482
512
        else:
483
513
            result += options
484
514
        result += '\n'
489
519
            if sections.has_key(None):
490
520
                text = sections.pop(None)
491
521
                text = '\n  '.join(text.splitlines())
492
 
                result += ':%s:\n  %s\n\n' % ('Description',text)
 
522
                result += gettext(':Description:\n  %s\n\n') % (text,)
493
523
 
494
524
            # Add the custom sections (e.g. Examples). Note that there's no need
495
525
            # to indent these as they must be indented already in the source.
496
526
            if sections:
497
527
                for label in order:
498
 
                    if sections.has_key(label):
499
 
                        result += ':%s:\n%s\n' % (label,sections[label])
 
528
                    if label in sections:
 
529
                        result += ':%s:\n%s\n' % (label, sections[label])
500
530
                result += '\n'
501
531
        else:
502
 
            result += ("See bzr help %s for more details and examples.\n\n"
 
532
            result += (gettext("See bzr help %s for more details and examples.\n\n")
503
533
                % self.name())
504
534
 
505
535
        # Add the aliases, source (plug-in) and see also links, if any
506
536
        if self.aliases:
507
 
            result += ':Aliases:  '
 
537
            result += gettext(':Aliases:  ')
508
538
            result += ', '.join(self.aliases) + '\n'
509
539
        plugin_name = self.plugin_name()
510
540
        if plugin_name is not None:
511
 
            result += ':From:     plugin "%s"\n' % plugin_name
 
541
            result += gettext(':From:     plugin "%s"\n') % plugin_name
512
542
        see_also = self.get_see_also(additional_see_also)
513
543
        if see_also:
514
544
            if not plain and see_also_as_links:
520
550
                        see_also_links.append(item)
521
551
                    else:
522
552
                        # Use a Sphinx link for this entry
523
 
                        link_text = ":doc:`%s <%s-help>`" % (item, item)
 
553
                        link_text = gettext(":doc:`{0} <{1}-help>`").format(
 
554
                                                                    item, item)
524
555
                        see_also_links.append(link_text)
525
556
                see_also = see_also_links
526
 
            result += ':See also: '
527
 
            result += ', '.join(see_also) + '\n'
 
557
            result += gettext(':See also: %s') % ', '.join(see_also) + '\n'
528
558
 
529
559
        # If this will be rendered as plain text, convert it
530
560
        if plain:
611
641
    def run_argv_aliases(self, argv, alias_argv=None):
612
642
        """Parse the command line and run with extra aliases in alias_argv."""
613
643
        args, opts = parse_args(self, argv, alias_argv)
 
644
        self._setup_outf()
614
645
 
615
646
        # Process the standard options
616
647
        if 'help' in opts:  # e.g. bzr add --help
617
 
            sys.stdout.write(self.get_help_text())
 
648
            self.outf.write(self.get_help_text())
618
649
            return 0
619
650
        if 'usage' in opts:  # e.g. bzr add --usage
620
 
            sys.stdout.write(self.get_help_text(verbose=False))
 
651
            self.outf.write(self.get_help_text(verbose=False))
621
652
            return 0
622
653
        trace.set_verbosity_level(option._verbosity_level)
623
654
        if 'verbose' in self.supported_std_options:
628
659
            opts['quiet'] = trace.is_quiet()
629
660
        elif opts.has_key('quiet'):
630
661
            del opts['quiet']
631
 
 
632
662
        # mix arguments and options into one dictionary
633
663
        cmdargs = _match_argform(self.name(), self.takes_args, args)
634
664
        cmdopts = {}
638
668
        all_cmd_args = cmdargs.copy()
639
669
        all_cmd_args.update(cmdopts)
640
670
 
641
 
        self._setup_outf()
642
 
 
643
 
        return self.run_direct(**all_cmd_args)
644
 
 
645
 
    def run_direct(self, *args, **kwargs):
646
 
        """Call run directly with objects (without parsing an argv list)."""
647
 
        return self._operation.run_simple(*args, **kwargs)
 
671
        try:
 
672
            return self.run(**all_cmd_args)
 
673
        finally:
 
674
            # reset it, so that other commands run in the same process won't
 
675
            # inherit state. Before we reset it, log any activity, so that it
 
676
            # gets properly tracked.
 
677
            ui.ui_factory.log_transport_activity(
 
678
                display=('bytes' in debug.debug_flags))
 
679
            trace.set_verbosity_level(0)
 
680
 
 
681
    def _setup_run(self):
 
682
        """Wrap the defined run method on self with a cleanup.
 
683
 
 
684
        This is called by __init__ to make the Command be able to be run
 
685
        by just calling run(), as it could be before cleanups were added.
 
686
 
 
687
        If a different form of cleanups are in use by your Command subclass,
 
688
        you can override this method.
 
689
        """
 
690
        class_run = self.run
 
691
        def run(*args, **kwargs):
 
692
            self._operation = cleanup.OperationWithCleanups(class_run)
 
693
            try:
 
694
                return self._operation.run_simple(*args, **kwargs)
 
695
            finally:
 
696
                del self._operation
 
697
        self.run = run
648
698
 
649
699
    def run(self):
650
700
        """Actually run the command.
655
705
        Return 0 or None if the command was successful, or a non-zero
656
706
        shell error code if not.  It's OK for this method to allow
657
707
        an exception to raise up.
 
708
 
 
709
        This method is automatically wrapped by Command.__init__ with a 
 
710
        cleanup operation, stored as self._operation. This can be used
 
711
        via self.add_cleanup to perform automatic cleanups at the end of
 
712
        run().
 
713
 
 
714
        The argument for run are assembled by introspection. So for instance,
 
715
        if your command takes an argument files, you would declare::
 
716
 
 
717
            def run(self, files=None):
 
718
                pass
658
719
        """
659
720
        raise NotImplementedError('no implementation of command %r'
660
721
                                  % self.name())
666
727
            return None
667
728
        return getdoc(self)
668
729
 
 
730
    def gettext(self, message):
 
731
        """Returns the gettext function used to translate this command's help.
 
732
 
 
733
        Commands provided by plugins should override this to use their
 
734
        own i18n system.
 
735
        """
 
736
        return i18n.gettext_per_paragraph(message)
 
737
 
669
738
    def name(self):
 
739
        """Return the canonical name for this command.
 
740
 
 
741
        The name under which it was actually invoked is available in invoked_as.
 
742
        """
670
743
        return _unsquish_command_name(self.__class__.__name__)
671
744
 
672
745
    def plugin_name(self):
690
763
        These are all empty initially, because by default nothing should get
691
764
        notified.
692
765
        """
693
 
        Hooks.__init__(self)
694
 
        self.create_hook(HookPoint('extend_command',
 
766
        Hooks.__init__(self, "bzrlib.commands", "Command.hooks")
 
767
        self.add_hook('extend_command',
695
768
            "Called after creating a command object to allow modifications "
696
769
            "such as adding or removing options, docs etc. Called with the "
697
 
            "new bzrlib.commands.Command object.", (1, 13), None))
698
 
        self.create_hook(HookPoint('get_command',
 
770
            "new bzrlib.commands.Command object.", (1, 13))
 
771
        self.add_hook('get_command',
699
772
            "Called when creating a single command. Called with "
700
773
            "(cmd_or_None, command_name). get_command should either return "
701
774
            "the cmd_or_None parameter, or a replacement Command object that "
702
775
            "should be used for the command. Note that the Command.hooks "
703
776
            "hooks are core infrastructure. Many users will prefer to use "
704
777
            "bzrlib.commands.register_command or plugin_cmds.register_lazy.",
705
 
            (1, 17), None))
706
 
        self.create_hook(HookPoint('get_missing_command',
 
778
            (1, 17))
 
779
        self.add_hook('get_missing_command',
707
780
            "Called when creating a single command if no command could be "
708
781
            "found. Called with (command_name). get_missing_command should "
709
782
            "either return None, or a Command object to be used for the "
710
 
            "command.", (1, 17), None))
711
 
        self.create_hook(HookPoint('list_commands',
 
783
            "command.", (1, 17))
 
784
        self.add_hook('list_commands',
712
785
            "Called when enumerating commands. Called with a set of "
713
786
            "cmd_name strings for all the commands found so far. This set "
714
787
            " is safe to mutate - e.g. to remove a command. "
715
788
            "list_commands should return the updated set of command names.",
716
 
            (1, 17), None))
 
789
            (1, 17))
717
790
 
718
791
Command.hooks = CommandHooks()
719
792
 
733
806
    else:
734
807
        args = argv
735
808
 
736
 
    options, args = parser.parse_args(args)
 
809
    # for python 2.5 and later, optparse raises this exception if a non-ascii
 
810
    # option name is given.  See http://bugs.python.org/issue2931
 
811
    try:
 
812
        options, args = parser.parse_args(args)
 
813
    except UnicodeEncodeError,e:
 
814
        raise errors.BzrCommandError(
 
815
            gettext('Only ASCII permitted in option names'))
 
816
 
737
817
    opts = dict([(k, v) for k, v in options.__dict__.iteritems() if
738
818
                 v is not option.OptionParser.DEFAULT_VALUE])
739
819
    return args, opts
756
836
                argdict[argname + '_list'] = None
757
837
        elif ap[-1] == '+':
758
838
            if not args:
759
 
                raise errors.BzrCommandError("command %r needs one or more %s"
760
 
                                             % (cmd, argname.upper()))
 
839
                raise errors.BzrCommandError(gettext(
 
840
                      "command {0!r} needs one or more {1}").format(
 
841
                      cmd, argname.upper()))
761
842
            else:
762
843
                argdict[argname + '_list'] = args[:]
763
844
                args = []
764
845
        elif ap[-1] == '$': # all but one
765
846
            if len(args) < 2:
766
 
                raise errors.BzrCommandError("command %r needs one or more %s"
767
 
                                             % (cmd, argname.upper()))
 
847
                raise errors.BzrCommandError(
 
848
                      gettext("command {0!r} needs one or more {1}").format(
 
849
                                             cmd, argname.upper()))
768
850
            argdict[argname + '_list'] = args[:-1]
769
851
            args[:-1] = []
770
852
        else:
771
853
            # just a plain arg
772
854
            argname = ap
773
855
            if not args:
774
 
                raise errors.BzrCommandError("command %r requires argument %s"
775
 
                               % (cmd, argname.upper()))
 
856
                raise errors.BzrCommandError(
 
857
                     gettext("command {0!r} requires argument {1}").format(
 
858
                               cmd, argname.upper()))
776
859
            else:
777
860
                argdict[argname] = args.pop(0)
778
861
 
779
862
    if args:
780
 
        raise errors.BzrCommandError("extra argument to command %s: %s"
781
 
                                     % (cmd, args[0]))
 
863
        raise errors.BzrCommandError( gettext(
 
864
                              "extra argument to command {0}: {1}").format(
 
865
                                       cmd, args[0]) )
782
866
 
783
867
    return argdict
784
868
 
867
951
 
868
952
def apply_lsprofiled(filename, the_callable, *args, **kwargs):
869
953
    from bzrlib.lsprof import profile
870
 
    ret, stats = profile(exception_to_return_code, the_callable, *args, **kwargs)
 
954
    ret, stats = profile(exception_to_return_code, the_callable,
 
955
                         *args, **kwargs)
871
956
    stats.sort()
872
957
    if filename is None:
873
958
        stats.pprint()
874
959
    else:
875
960
        stats.save(filename)
876
 
        trace.note('Profile data written to "%s".', filename)
 
961
        trace.note(gettext('Profile data written to "%s".'), filename)
877
962
    return ret
878
963
 
879
964
 
880
 
@deprecated_function(deprecated_in((2, 2, 0)))
881
 
def shlex_split_unicode(unsplit):
882
 
    return cmdline.split(unsplit)
883
 
 
884
 
 
885
965
def get_alias(cmd, config=None):
886
966
    """Return an expanded alias, or None if no alias exists.
887
967
 
943
1023
        Specify the number of processes that can be run concurrently (selftest).
944
1024
    """
945
1025
    trace.mutter("bazaar version: " + bzrlib.__version__)
946
 
    argv = list(argv)
 
1026
    argv = _specified_or_unicode_argv(argv)
947
1027
    trace.mutter("bzr arguments: %r", argv)
948
1028
 
949
 
    opt_lsprof = opt_profile = opt_no_plugins = opt_builtin =  \
950
 
                opt_no_aliases = False
 
1029
    opt_lsprof = opt_profile = opt_no_plugins = opt_builtin = \
 
1030
            opt_no_l10n = opt_no_aliases = False
951
1031
    opt_lsprof_file = opt_coverage_dir = None
952
1032
 
953
1033
    # --no-plugins is handled specially at a very early stage. We need
956
1036
 
957
1037
    argv_copy = []
958
1038
    i = 0
 
1039
    override_config = []
959
1040
    while i < len(argv):
960
1041
        a = argv[i]
961
1042
        if a == '--profile':
970
1051
            opt_no_plugins = True
971
1052
        elif a == '--no-aliases':
972
1053
            opt_no_aliases = True
 
1054
        elif a == '--no-l10n':
 
1055
            opt_no_l10n = True
973
1056
        elif a == '--builtin':
974
1057
            opt_builtin = True
975
1058
        elif a == '--concurrency':
978
1061
        elif a == '--coverage':
979
1062
            opt_coverage_dir = argv[i + 1]
980
1063
            i += 1
 
1064
        elif a == '--profile-imports':
 
1065
            pass # already handled in startup script Bug #588277
981
1066
        elif a.startswith('-D'):
982
1067
            debug.debug_flags.add(a[2:])
 
1068
        elif a.startswith('-O'):
 
1069
            override_config.append(a[2:])
983
1070
        else:
984
1071
            argv_copy.append(a)
985
1072
        i += 1
986
1073
 
 
1074
    bzrlib.global_state.cmdline_overrides._from_cmdline(override_config)
 
1075
 
987
1076
    debug.set_debug_flags_from_config()
988
1077
 
989
1078
    if not opt_no_plugins:
1005
1094
    if not opt_no_aliases:
1006
1095
        alias_argv = get_alias(argv[0])
1007
1096
        if alias_argv:
1008
 
            user_encoding = osutils.get_user_encoding()
1009
 
            alias_argv = [a.decode(user_encoding) for a in alias_argv]
1010
1097
            argv[0] = alias_argv.pop(0)
1011
1098
 
1012
1099
    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
 
 
1017
1100
    cmd_obj = get_cmd_object(cmd, plugins_override=not opt_builtin)
 
1101
    if opt_no_l10n:
 
1102
        cmd.l10n = False
1018
1103
    run = cmd_obj.run_argv_aliases
1019
1104
    run_argv = [argv, alias_argv]
1020
1105
 
1045
1130
        if 'memory' in debug.debug_flags:
1046
1131
            trace.debug_memory('Process status after command:', short=False)
1047
1132
        option._verbosity_level = saved_verbosity_level
 
1133
        # Reset the overrides 
 
1134
        bzrlib.global_state.cmdline_overrides._reset()
1048
1135
 
1049
1136
 
1050
1137
def display_command(func):
1079
1166
        "bzr plugin commands")
1080
1167
    Command.hooks.install_named_hook("get_command", _get_external_command,
1081
1168
        "bzr external command lookup")
1082
 
    Command.hooks.install_named_hook("get_missing_command", _try_plugin_provider,
1083
 
        "bzr plugin-provider-db check")
 
1169
    Command.hooks.install_named_hook("get_missing_command",
 
1170
                                     _try_plugin_provider,
 
1171
                                     "bzr plugin-provider-db check")
1084
1172
 
1085
1173
 
1086
1174
 
1093
1181
        new_argv = []
1094
1182
        try:
1095
1183
            # ensure all arguments are unicode strings
1096
 
            for a in argv[1:]:
 
1184
            for a in argv:
1097
1185
                if isinstance(a, unicode):
1098
1186
                    new_argv.append(a)
1099
1187
                else:
1115
1203
 
1116
1204
    :return: exit code of bzr command.
1117
1205
    """
1118
 
    argv = _specified_or_unicode_argv(argv)
 
1206
    if argv is not None:
 
1207
        argv = argv[1:]
 
1208
    _register_builtin_commands()
1119
1209
    ret = run_bzr_catch_errors(argv)
1120
 
    bzrlib.ui.ui_factory.log_transport_activity(
1121
 
        display=('bytes' in debug.debug_flags))
1122
1210
    trace.mutter("return code %d", ret)
1123
1211
    return ret
1124
1212
 
1177
1265
 
1178
1266
 
1179
1267
class Provider(object):
1180
 
    '''Generic class to be overriden by plugins'''
 
1268
    """Generic class to be overriden by plugins"""
1181
1269
 
1182
1270
    def plugin_for_command(self, cmd_name):
1183
 
        '''Takes a command and returns the information for that plugin
 
1271
        """Takes a command and returns the information for that plugin
1184
1272
 
1185
1273
        :return: A dictionary with all the available information
1186
 
        for the requested plugin
1187
 
        '''
 
1274
            for the requested plugin
 
1275
        """
1188
1276
        raise NotImplementedError
1189
1277
 
1190
1278
 
1191
1279
class ProvidersRegistry(registry.Registry):
1192
 
    '''This registry exists to allow other providers to exist'''
 
1280
    """This registry exists to allow other providers to exist"""
1193
1281
 
1194
1282
    def __iter__(self):
1195
1283
        for key, provider in self.iteritems():