← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/commands.py

  • Committer: Ian Clatworthy
  • Date: 2009-01-19 02:24:15 UTC
  • mto: This revision was merged to the branch mainline in revision 3944.
  • Revision ID: ian.clatworthy@canonical.com-20090119022415-mo0mcfeiexfktgwt
apply jam's log --short fix (Ian Clatworthy)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/commands.py
1
 
# Copyright (C) 2006 by Canonical Ltd
 
1
# Copyright (C) 2006, 2008 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
28
28
# TODO: "--profile=cum", to change sort order.  Is there any value in leaving
29
29
# the profile output behind so it can be interactively examined?
30
30
 
 
31
import os
31
32
import sys
32
 
import os
 
33
 
 
34
from bzrlib.lazy_import import lazy_import
 
35
lazy_import(globals(), """
 
36
import codecs
 
37
import errno
33
38
from warnings import warn
34
 
import errno
35
 
import codecs
36
39
 
37
40
import bzrlib
38
 
from bzrlib.errors import (BzrError,
39
 
                           BzrCheckError,
40
 
                           BzrCommandError,
41
 
                           BzrOptionError,
42
 
                           NotBranchError)
 
41
from bzrlib import (
 
42
    debug,
 
43
    errors,
 
44
    option,
 
45
    osutils,
 
46
    trace,
 
47
    win32utils,
 
48
    )
 
49
""")
 
50
 
 
51
from bzrlib import registry
 
52
# Compatibility
43
53
from bzrlib.option import Option
44
 
from bzrlib.revisionspec import RevisionSpec
45
 
from bzrlib.symbol_versioning import *
46
 
import bzrlib.trace
47
 
from bzrlib.trace import mutter, note, log_error, warning, be_quiet
48
 
 
49
 
plugin_cmds = {}
 
54
 
 
55
 
 
56
class CommandInfo(object):
 
57
    """Information about a command."""
 
58
 
 
59
    def __init__(self, aliases):
 
60
        """The list of aliases for the command."""
 
61
        self.aliases = aliases
 
62
 
 
63
    @classmethod
 
64
    def from_command(klass, command):
 
65
        """Factory to construct a CommandInfo from a command."""
 
66
        return klass(command.aliases)
 
67
 
 
68
 
 
69
class CommandRegistry(registry.Registry):
 
70
 
 
71
    @staticmethod
 
72
    def _get_name(command_name):
 
73
        if command_name.startswith("cmd_"):
 
74
            return _unsquish_command_name(command_name)
 
75
        else:
 
76
            return command_name
 
77
 
 
78
    def register(self, cmd, decorate=False):
 
79
        """Utility function to help register a command
 
80
 
 
81
        :param cmd: Command subclass to register
 
82
        :param decorate: If true, allow overriding an existing command
 
83
            of the same name; the old command is returned by this function.
 
84
            Otherwise it is an error to try to override an existing command.
 
85
        """
 
86
        k = cmd.__name__
 
87
        k_unsquished = self._get_name(k)
 
88
        try:
 
89
            previous = self.get(k_unsquished)
 
90
        except KeyError:
 
91
            previous = _builtin_commands().get(k_unsquished)
 
92
        info = CommandInfo.from_command(cmd)
 
93
        try:
 
94
            registry.Registry.register(self, k_unsquished, cmd,
 
95
                                       override_existing=decorate, info=info)
 
96
        except KeyError:
 
97
            trace.log_error('Two plugins defined the same command: %r' % k)
 
98
            trace.log_error('Not loading the one in %r' %
 
99
                            sys.modules[cmd.__module__])
 
100
            trace.log_error('Previously this command was registered from %r' %
 
101
                            sys.modules[previous.__module__])
 
102
        return previous
 
103
 
 
104
    def register_lazy(self, command_name, aliases, module_name):
 
105
        """Register a command without loading its module.
 
106
 
 
107
        :param command_name: The primary name of the command.
 
108
        :param aliases: A list of aliases for the command.
 
109
        :module_name: The module that the command lives in.
 
110
        """
 
111
        key = self._get_name(command_name)
 
112
        registry.Registry.register_lazy(self, key, module_name, command_name,
 
113
                                        info=CommandInfo(aliases))
 
114
 
 
115
 
 
116
plugin_cmds = CommandRegistry()
50
117
 
51
118
 
52
119
def register_command(cmd, decorate=False):
53
 
    """Utility function to help register a command
54
 
 
55
 
    :param cmd: Command subclass to register
56
 
    :param decorate: If true, allow overriding an existing command
57
 
        of the same name; the old command is returned by this function.
58
 
        Otherwise it is an error to try to override an existing command.
59
 
    """
60
120
    global plugin_cmds
61
 
    k = cmd.__name__
62
 
    if k.startswith("cmd_"):
63
 
        k_unsquished = _unsquish_command_name(k)
64
 
    else:
65
 
        k_unsquished = k
66
 
    if not plugin_cmds.has_key(k_unsquished):
67
 
        plugin_cmds[k_unsquished] = cmd
68
 
        mutter('registered plugin command %s', k_unsquished)
69
 
        if decorate and k_unsquished in builtin_command_names():
70
 
            return _builtin_commands()[k_unsquished]
71
 
    elif decorate:
72
 
        result = plugin_cmds[k_unsquished]
73
 
        plugin_cmds[k_unsquished] = cmd
74
 
        return result
75
 
    else:
76
 
        log_error('Two plugins defined the same command: %r' % k)
77
 
        log_error('Not loading the one in %r' % sys.modules[cmd.__module__])
 
121
    return plugin_cmds.register(cmd, decorate)
78
122
 
79
123
 
80
124
def _squish_command_name(cmd):
82
126
 
83
127
 
84
128
def _unsquish_command_name(cmd):
85
 
    assert cmd.startswith("cmd_")
86
129
    return cmd[4:].replace('_','-')
87
130
 
88
131
 
110
153
    """Return name->class mapping for all commands."""
111
154
    d = _builtin_commands()
112
155
    if plugins_override:
113
 
        d.update(plugin_cmds)
 
156
        d.update(plugin_cmds.iteritems())
114
157
    return d
115
158
 
116
159
    
126
169
    plugins_override
127
170
        If true, plugin commands can override builtins.
128
171
    """
 
172
    try:
 
173
        return _get_cmd_object(cmd_name, plugins_override)
 
174
    except KeyError:
 
175
        raise errors.BzrCommandError('unknown command "%s"' % cmd_name)
 
176
 
 
177
 
 
178
def _get_cmd_object(cmd_name, plugins_override=True):
 
179
    """Worker for get_cmd_object which raises KeyError rather than BzrCommandError."""
129
180
    from bzrlib.externalcommand import ExternalCommand
130
181
 
131
 
    cmd_name = str(cmd_name)            # not unicode
 
182
    # We want only 'ascii' command names, but the user may have typed
 
183
    # in a Unicode name. In that case, they should just get a
 
184
    # 'command not found' error later.
 
185
    # In the future, we may actually support Unicode command names.
132
186
 
133
187
    # first look up this command under the specified name
134
 
    cmds = _get_cmd_dict(plugins_override=plugins_override)
 
188
    if plugins_override:
 
189
        try:
 
190
            return plugin_cmds.get(cmd_name)()
 
191
        except KeyError:
 
192
            pass
 
193
    cmds = _get_cmd_dict(plugins_override=False)
135
194
    try:
136
195
        return cmds[cmd_name]()
137
196
    except KeyError:
138
197
        pass
139
 
 
 
198
    if plugins_override:
 
199
        for key in plugin_cmds.keys():
 
200
            info = plugin_cmds.get_info(key)
 
201
            if cmd_name in info.aliases:
 
202
                return plugin_cmds.get(key)()
140
203
    # look for any command which claims this as an alias
141
204
    for real_cmd_name, cmd_class in cmds.iteritems():
142
205
        if cmd_name in cmd_class.aliases:
146
209
    if cmd_obj:
147
210
        return cmd_obj
148
211
 
149
 
    raise BzrCommandError("unknown command %r" % cmd_name)
 
212
    # look for plugins that provide this command but aren't installed
 
213
    for provider in command_providers_registry:
 
214
        try:
 
215
            plugin_metadata = provider.plugin_for_command(cmd_name)
 
216
        except errors.NoPluginAvailable:
 
217
            pass
 
218
        else:
 
219
            raise errors.CommandAvailableInPlugin(cmd_name, 
 
220
                                                  plugin_metadata, provider)
 
221
 
 
222
    raise KeyError
150
223
 
151
224
 
152
225
class Command(object):
200
273
            replace - put in a bogus character (typically '?')
201
274
            exact - do not encode sys.stdout
202
275
 
 
276
            NOTE: by default on Windows, sys.stdout is opened as a text
 
277
            stream, therefore LF line-endings are converted to CRLF.
 
278
            When a command uses encoding_type = 'exact', then
 
279
            sys.stdout is forced to be a binary stream, and line-endings
 
280
            will not mangled.
 
281
 
203
282
    """
204
283
    aliases = []
205
284
    takes_args = []
212
291
        """Construct an instance of this command."""
213
292
        if self.__doc__ == Command.__doc__:
214
293
            warn("No help message set for %r" % self)
 
294
        # List of standard options directly supported
 
295
        self.supported_std_options = []
 
296
 
 
297
    def _maybe_expand_globs(self, file_list):
 
298
        """Glob expand file_list if the platform does not do that itself.
 
299
        
 
300
        :return: A possibly empty list of unicode paths.
 
301
 
 
302
        Introduced in bzrlib 0.18.
 
303
        """
 
304
        if not file_list:
 
305
            file_list = []
 
306
        if sys.platform == 'win32':
 
307
            file_list = win32utils.glob_expand(file_list)
 
308
        return list(file_list)
 
309
 
 
310
    def _usage(self):
 
311
        """Return single-line grammar for this command.
 
312
 
 
313
        Only describes arguments, not options.
 
314
        """
 
315
        s = 'bzr ' + self.name() + ' '
 
316
        for aname in self.takes_args:
 
317
            aname = aname.upper()
 
318
            if aname[-1] in ['$', '+']:
 
319
                aname = aname[:-1] + '...'
 
320
            elif aname[-1] == '?':
 
321
                aname = '[' + aname[:-1] + ']'
 
322
            elif aname[-1] == '*':
 
323
                aname = '[' + aname[:-1] + '...]'
 
324
            s += aname + ' '
 
325
        s = s[:-1]      # remove last space
 
326
        return s
 
327
 
 
328
    def get_help_text(self, additional_see_also=None, plain=True,
 
329
                      see_also_as_links=False):
 
330
        """Return a text string with help for this command.
 
331
        
 
332
        :param additional_see_also: Additional help topics to be
 
333
            cross-referenced.
 
334
        :param plain: if False, raw help (reStructuredText) is
 
335
            returned instead of plain text.
 
336
        :param see_also_as_links: if True, convert items in 'See also'
 
337
            list to internal links (used by bzr_man rstx generator)
 
338
        """
 
339
        doc = self.help()
 
340
        if doc is None:
 
341
            raise NotImplementedError("sorry, no detailed help yet for %r" % self.name())
 
342
 
 
343
        # Extract the summary (purpose) and sections out from the text
 
344
        purpose,sections = self._get_help_parts(doc)
 
345
 
 
346
        # If a custom usage section was provided, use it
 
347
        if sections.has_key('Usage'):
 
348
            usage = sections.pop('Usage')
 
349
        else:
 
350
            usage = self._usage()
 
351
 
 
352
        # The header is the purpose and usage
 
353
        result = ""
 
354
        result += ':Purpose: %s\n' % purpose
 
355
        if usage.find('\n') >= 0:
 
356
            result += ':Usage:\n%s\n' % usage
 
357
        else:
 
358
            result += ':Usage:   %s\n' % usage
 
359
        result += '\n'
 
360
 
 
361
        # Add the options
 
362
        options = option.get_optparser(self.options()).format_option_help()
 
363
        if options.startswith('Options:'):
 
364
            result += ':' + options
 
365
        elif options.startswith('options:'):
 
366
            # Python 2.4 version of optparse
 
367
            result += ':Options:' + options[len('options:'):]
 
368
        else:
 
369
            result += options
 
370
        result += '\n'
 
371
 
 
372
        # Add the description, indenting it 2 spaces
 
373
        # to match the indentation of the options
 
374
        if sections.has_key(None):
 
375
            text = sections.pop(None)
 
376
            text = '\n  '.join(text.splitlines())
 
377
            result += ':%s:\n  %s\n\n' % ('Description',text)
 
378
 
 
379
        # Add the custom sections (e.g. Examples). Note that there's no need
 
380
        # to indent these as they must be indented already in the source.
 
381
        if sections:
 
382
            labels = sorted(sections.keys())
 
383
            for label in labels:
 
384
                result += ':%s:\n%s\n\n' % (label,sections[label])
 
385
 
 
386
        # Add the aliases, source (plug-in) and see also links, if any
 
387
        if self.aliases:
 
388
            result += ':Aliases:  '
 
389
            result += ', '.join(self.aliases) + '\n'
 
390
        plugin_name = self.plugin_name()
 
391
        if plugin_name is not None:
 
392
            result += ':From:     plugin "%s"\n' % plugin_name
 
393
        see_also = self.get_see_also(additional_see_also)
 
394
        if see_also:
 
395
            if not plain and see_also_as_links:
 
396
                see_also_links = []
 
397
                for item in see_also:
 
398
                    if item == 'topics':
 
399
                        # topics doesn't have an independent section
 
400
                        # so don't create a real link
 
401
                        see_also_links.append(item)
 
402
                    else:
 
403
                        # Use a reST link for this entry
 
404
                        see_also_links.append("`%s`_" % (item,))
 
405
                see_also = see_also_links
 
406
            result += ':See also: '
 
407
            result += ', '.join(see_also) + '\n'
 
408
 
 
409
        # If this will be rendered as plain text, convert it
 
410
        if plain:
 
411
            import bzrlib.help_topics
 
412
            result = bzrlib.help_topics.help_as_plain_text(result)
 
413
        return result
 
414
 
 
415
    @staticmethod
 
416
    def _get_help_parts(text):
 
417
        """Split help text into a summary and named sections.
 
418
 
 
419
        :return: (summary,sections) where summary is the top line and
 
420
            sections is a dictionary of the rest indexed by section name.
 
421
            A section starts with a heading line of the form ":xxx:".
 
422
            Indented text on following lines is the section value.
 
423
            All text found outside a named section is assigned to the
 
424
            default section which is given the key of None.
 
425
        """
 
426
        def save_section(sections, label, section):
 
427
            if len(section) > 0:
 
428
                if sections.has_key(label):
 
429
                    sections[label] += '\n' + section
 
430
                else:
 
431
                    sections[label] = section
 
432
 
 
433
        lines = text.rstrip().splitlines()
 
434
        summary = lines.pop(0)
 
435
        sections = {}
 
436
        label,section = None,''
 
437
        for line in lines:
 
438
            if line.startswith(':') and line.endswith(':') and len(line) > 2:
 
439
                save_section(sections, label, section)
 
440
                label,section = line[1:-1],''
 
441
            elif (label is not None) and len(line) > 1 and not line[0].isspace():
 
442
                save_section(sections, label, section)
 
443
                label,section = None,line
 
444
            else:
 
445
                if len(section) > 0:
 
446
                    section += '\n' + line
 
447
                else:
 
448
                    section = line
 
449
        save_section(sections, label, section)
 
450
        return summary, sections
 
451
 
 
452
    def get_help_topic(self):
 
453
        """Return the commands help topic - its name."""
 
454
        return self.name()
 
455
 
 
456
    def get_see_also(self, additional_terms=None):
 
457
        """Return a list of help topics that are related to this command.
 
458
        
 
459
        The list is derived from the content of the _see_also attribute. Any
 
460
        duplicates are removed and the result is in lexical order.
 
461
        :param additional_terms: Additional help topics to cross-reference.
 
462
        :return: A list of help topics.
 
463
        """
 
464
        see_also = set(getattr(self, '_see_also', []))
 
465
        if additional_terms:
 
466
            see_also.update(additional_terms)
 
467
        return sorted(see_also)
215
468
 
216
469
    def options(self):
217
470
        """Return dict of valid options for this command.
218
471
 
219
472
        Maps from long option name to option object."""
220
 
        r = dict()
221
 
        r['help'] = Option.OPTIONS['help']
 
473
        r = Option.STD_OPTIONS.copy()
 
474
        std_names = r.keys()
222
475
        for o in self.takes_options:
223
 
            if not isinstance(o, Option):
224
 
                o = Option.OPTIONS[o]
 
476
            if isinstance(o, basestring):
 
477
                o = option.Option.OPTIONS[o]
225
478
            r[o.name] = o
 
479
            if o.name in std_names:
 
480
                self.supported_std_options.append(o.name)
226
481
        return r
227
482
 
228
483
    def _setup_outf(self):
229
484
        """Return a file linked to stdout, which has proper encoding."""
230
 
        assert self.encoding_type in ['strict', 'exact', 'replace']
231
 
 
232
485
        # Originally I was using self.stdout, but that looks
233
486
        # *way* too much like sys.stdout
234
487
        if self.encoding_type == 'exact':
 
488
            # force sys.stdout to be binary stream on win32
 
489
            if sys.platform == 'win32':
 
490
                fileno = getattr(sys.stdout, 'fileno', None)
 
491
                if fileno:
 
492
                    import msvcrt
 
493
                    msvcrt.setmode(fileno(), os.O_BINARY)
235
494
            self.outf = sys.stdout
236
495
            return
237
496
 
238
 
        output_encoding = getattr(sys.stdout, 'encoding', None)
239
 
        if not output_encoding:
240
 
            input_encoding = getattr(sys.stdin, 'encoding', None)
241
 
            if not input_encoding:
242
 
                output_encoding = bzrlib.user_encoding
243
 
                mutter('encoding stdout as bzrlib.user_encoding %r', output_encoding)
244
 
            else:
245
 
                output_encoding = input_encoding
246
 
                mutter('encoding stdout as sys.stdin encoding %r', output_encoding)
247
 
        else:
248
 
            mutter('encoding stdout as sys.stdout encoding %r', output_encoding)
 
497
        output_encoding = osutils.get_terminal_encoding()
249
498
 
250
 
        # use 'replace' so that we don't abort if trying to write out
251
 
        # in e.g. the default C locale.
252
 
        self.outf = codecs.getwriter(output_encoding)(sys.stdout, errors=self.encoding_type)
 
499
        self.outf = codecs.getwriter(output_encoding)(sys.stdout,
 
500
                        errors=self.encoding_type)
253
501
        # For whatever reason codecs.getwriter() does not advertise its encoding
254
502
        # it just returns the encoding of the wrapped file, which is completely
255
503
        # bogus. So set the attribute, so we can find the correct encoding later.
256
504
        self.outf.encoding = output_encoding
257
505
 
258
 
    @deprecated_method(zero_eight)
259
 
    def run_argv(self, argv):
260
 
        """Parse command line and run.
261
 
        
262
 
        See run_argv_aliases for the 0.8 and beyond api.
263
 
        """
264
 
        return self.run_argv_aliases(argv)
265
 
 
266
506
    def run_argv_aliases(self, argv, alias_argv=None):
267
507
        """Parse the command line and run with extra aliases in alias_argv."""
 
508
        if argv is None:
 
509
            warn("Passing None for [] is deprecated from bzrlib 0.10",
 
510
                 DeprecationWarning, stacklevel=2)
 
511
            argv = []
268
512
        args, opts = parse_args(self, argv, alias_argv)
 
513
 
 
514
        # Process the standard options
269
515
        if 'help' in opts:  # e.g. bzr add --help
270
 
            from bzrlib.help import help_on_command
271
 
            help_on_command(self.name())
 
516
            sys.stdout.write(self.get_help_text())
272
517
            return 0
273
 
        # XXX: This should be handled by the parser
274
 
        allowed_names = self.options().keys()
275
 
        for oname in opts:
276
 
            if oname not in allowed_names:
277
 
                raise BzrCommandError("option '--%s' is not allowed for"
278
 
                                      " command %r" % (oname, self.name()))
 
518
        trace.set_verbosity_level(option._verbosity_level)
 
519
        if 'verbose' in self.supported_std_options:
 
520
            opts['verbose'] = trace.is_verbose()
 
521
        elif opts.has_key('verbose'):
 
522
            del opts['verbose']
 
523
        if 'quiet' in self.supported_std_options:
 
524
            opts['quiet'] = trace.is_quiet()
 
525
        elif opts.has_key('quiet'):
 
526
            del opts['quiet']
 
527
 
279
528
        # mix arguments and options into one dictionary
280
529
        cmdargs = _match_argform(self.name(), self.takes_args, args)
281
530
        cmdopts = {}
288
537
        self._setup_outf()
289
538
 
290
539
        return self.run(**all_cmd_args)
291
 
    
 
540
 
292
541
    def run(self):
293
542
        """Actually run the command.
294
543
 
299
548
        shell error code if not.  It's OK for this method to allow
300
549
        an exception to raise up.
301
550
        """
302
 
        raise NotImplementedError('no implementation of command %r' 
 
551
        raise NotImplementedError('no implementation of command %r'
303
552
                                  % self.name())
304
553
 
305
554
    def help(self):
312
561
    def name(self):
313
562
        return _unsquish_command_name(self.__class__.__name__)
314
563
 
 
564
    def plugin_name(self):
 
565
        """Get the name of the plugin that provides this command.
315
566
 
316
 
def parse_spec(spec):
317
 
    """
318
 
    >>> parse_spec(None)
319
 
    [None, None]
320
 
    >>> parse_spec("./")
321
 
    ['./', None]
322
 
    >>> parse_spec("../@")
323
 
    ['..', -1]
324
 
    >>> parse_spec("../f/@35")
325
 
    ['../f', 35]
326
 
    >>> parse_spec('./@revid:john@arbash-meinel.com-20050711044610-3ca0327c6a222f67')
327
 
    ['.', 'revid:john@arbash-meinel.com-20050711044610-3ca0327c6a222f67']
328
 
    """
329
 
    if spec is None:
330
 
        return [None, None]
331
 
    if '/@' in spec:
332
 
        parsed = spec.split('/@')
333
 
        assert len(parsed) == 2
334
 
        if parsed[1] == "":
335
 
            parsed[1] = -1
 
567
        :return: The name of the plugin or None if the command is builtin.
 
568
        """
 
569
        mod_parts = self.__module__.split('.')
 
570
        if len(mod_parts) >= 3 and mod_parts[1] == 'plugins':
 
571
            return mod_parts[2]
336
572
        else:
337
 
            try:
338
 
                parsed[1] = int(parsed[1])
339
 
            except ValueError:
340
 
                pass # We can allow stuff like ./@revid:blahblahblah
341
 
            else:
342
 
                assert parsed[1] >=0
343
 
    else:
344
 
        parsed = [spec, None]
345
 
    return parsed
 
573
            return None
 
574
 
346
575
 
347
576
def parse_args(command, argv, alias_argv=None):
348
577
    """Parse command line.
352
581
    lookup table, something about the available options, what optargs
353
582
    they take, and which commands will accept them.
354
583
    """
355
 
    # TODO: chop up this beast; make it a method of the Command
356
 
    args = []
357
 
    opts = {}
358
 
    alias_opts = {}
359
 
 
360
 
    cmd_options = command.options()
361
 
    argsover = False
362
 
    proc_aliasarg = True # Are we processing alias_argv now?
363
 
    for proc_argv in alias_argv, argv:
364
 
        while proc_argv:
365
 
            a = proc_argv.pop(0)
366
 
            if argsover:
367
 
                args.append(a)
368
 
                continue
369
 
            elif a == '--':
370
 
                # We've received a standalone -- No more flags
371
 
                argsover = True
372
 
                continue
373
 
            if a[0] == '-':
374
 
                # option names must not be unicode
375
 
                a = str(a)
376
 
                optarg = None
377
 
                if a[1] == '-':
378
 
                    mutter("  got option %r", a)
379
 
                    if '=' in a:
380
 
                        optname, optarg = a[2:].split('=', 1)
381
 
                    else:
382
 
                        optname = a[2:]
383
 
                    if optname not in cmd_options:
384
 
                        raise BzrOptionError('unknown long option %r for'
385
 
                                             ' command %s' % 
386
 
                                             (a, command.name()))
387
 
                else:
388
 
                    shortopt = a[1:]
389
 
                    if shortopt in Option.SHORT_OPTIONS:
390
 
                        # Multi-character options must have a space to delimit
391
 
                        # their value
392
 
                        # ^^^ what does this mean? mbp 20051014
393
 
                        optname = Option.SHORT_OPTIONS[shortopt].name
394
 
                    else:
395
 
                        # Single character short options, can be chained,
396
 
                        # and have their value appended to their name
397
 
                        shortopt = a[1:2]
398
 
                        if shortopt not in Option.SHORT_OPTIONS:
399
 
                            # We didn't find the multi-character name, and we
400
 
                            # didn't find the single char name
401
 
                            raise BzrError('unknown short option %r' % a)
402
 
                        optname = Option.SHORT_OPTIONS[shortopt].name
403
 
 
404
 
                        if a[2:]:
405
 
                            # There are extra things on this option
406
 
                            # see if it is the value, or if it is another
407
 
                            # short option
408
 
                            optargfn = Option.OPTIONS[optname].type
409
 
                            if optargfn is None:
410
 
                                # This option does not take an argument, so the
411
 
                                # next entry is another short option, pack it
412
 
                                # back into the list
413
 
                                proc_argv.insert(0, '-' + a[2:])
414
 
                            else:
415
 
                                # This option takes an argument, so pack it
416
 
                                # into the array
417
 
                                optarg = a[2:]
418
 
                
419
 
                    if optname not in cmd_options:
420
 
                        raise BzrOptionError('unknown short option %r for'
421
 
                                             ' command %s' % 
422
 
                                             (shortopt, command.name()))
423
 
                if optname in opts:
424
 
                    # XXX: Do we ever want to support this, e.g. for -r?
425
 
                    if proc_aliasarg:
426
 
                        raise BzrError('repeated option %r' % a)
427
 
                    elif optname in alias_opts:
428
 
                        # Replace what's in the alias with what's in the real
429
 
                        # argument
430
 
                        del alias_opts[optname]
431
 
                        del opts[optname]
432
 
                        proc_argv.insert(0, a)
433
 
                        continue
434
 
                    else:
435
 
                        raise BzrError('repeated option %r' % a)
436
 
                    
437
 
                option_obj = cmd_options[optname]
438
 
                optargfn = option_obj.type
439
 
                if optargfn:
440
 
                    if optarg == None:
441
 
                        if not proc_argv:
442
 
                            raise BzrError('option %r needs an argument' % a)
443
 
                        else:
444
 
                            optarg = proc_argv.pop(0)
445
 
                    opts[optname] = optargfn(optarg)
446
 
                    if proc_aliasarg:
447
 
                        alias_opts[optname] = optargfn(optarg)
448
 
                else:
449
 
                    if optarg != None:
450
 
                        raise BzrError('option %r takes no argument' % optname)
451
 
                    opts[optname] = True
452
 
                    if proc_aliasarg:
453
 
                        alias_opts[optname] = True
454
 
            else:
455
 
                args.append(a)
456
 
        proc_aliasarg = False # Done with alias argv
 
584
    # TODO: make it a method of the Command?
 
585
    parser = option.get_optparser(command.options())
 
586
    if alias_argv is not None:
 
587
        args = alias_argv + argv
 
588
    else:
 
589
        args = argv
 
590
 
 
591
    options, args = parser.parse_args(args)
 
592
    opts = dict([(k, v) for k, v in options.__dict__.iteritems() if
 
593
                 v is not option.OptionParser.DEFAULT_VALUE])
457
594
    return args, opts
458
595
 
459
596
 
474
611
                argdict[argname + '_list'] = None
475
612
        elif ap[-1] == '+':
476
613
            if not args:
477
 
                raise BzrCommandError("command %r needs one or more %s"
478
 
                        % (cmd, argname.upper()))
 
614
                raise errors.BzrCommandError("command %r needs one or more %s"
 
615
                                             % (cmd, argname.upper()))
479
616
            else:
480
617
                argdict[argname + '_list'] = args[:]
481
618
                args = []
482
619
        elif ap[-1] == '$': # all but one
483
620
            if len(args) < 2:
484
 
                raise BzrCommandError("command %r needs one or more %s"
485
 
                        % (cmd, argname.upper()))
 
621
                raise errors.BzrCommandError("command %r needs one or more %s"
 
622
                                             % (cmd, argname.upper()))
486
623
            argdict[argname + '_list'] = args[:-1]
487
 
            args[:-1] = []                
 
624
            args[:-1] = []
488
625
        else:
489
626
            # just a plain arg
490
627
            argname = ap
491
628
            if not args:
492
 
                raise BzrCommandError("command %r requires argument %s"
493
 
                        % (cmd, argname.upper()))
 
629
                raise errors.BzrCommandError("command %r requires argument %s"
 
630
                               % (cmd, argname.upper()))
494
631
            else:
495
632
                argdict[argname] = args.pop(0)
496
633
            
497
634
    if args:
498
 
        raise BzrCommandError("extra argument to command %s: %s"
499
 
                              % (cmd, args[0]))
 
635
        raise errors.BzrCommandError("extra argument to command %s: %s"
 
636
                                     % (cmd, args[0]))
500
637
 
501
638
    return argdict
502
639
 
 
640
def apply_coveraged(dirname, the_callable, *args, **kwargs):
 
641
    # Cannot use "import trace", as that would import bzrlib.trace instead of
 
642
    # the standard library's trace.
 
643
    trace = __import__('trace')
 
644
 
 
645
    tracer = trace.Trace(count=1, trace=0)
 
646
    sys.settrace(tracer.globaltrace)
 
647
 
 
648
    ret = the_callable(*args, **kwargs)
 
649
 
 
650
    sys.settrace(None)
 
651
    results = tracer.results()
 
652
    results.write_results(show_missing=1, summary=False,
 
653
                          coverdir=dirname)
503
654
 
504
655
 
505
656
def apply_profiled(the_callable, *args, **kwargs):
527
678
 
528
679
def apply_lsprofiled(filename, the_callable, *args, **kwargs):
529
680
    from bzrlib.lsprof import profile
530
 
    import cPickle
531
681
    ret, stats = profile(the_callable, *args, **kwargs)
532
682
    stats.sort()
533
683
    if filename is None:
534
684
        stats.pprint()
535
685
    else:
536
 
        stats.freeze()
537
 
        cPickle.dump(stats, open(filename, 'w'), 2)
538
 
        print 'Profile data written to %r.' % filename
 
686
        stats.save(filename)
 
687
        trace.note('Profile data written to "%s".', filename)
539
688
    return ret
540
689
 
541
690
 
542
 
def get_alias(cmd):
543
 
    """Return an expanded alias, or None if no alias exists"""
544
 
    import bzrlib.config
545
 
    alias = bzrlib.config.GlobalConfig().get_alias(cmd)
 
691
def shlex_split_unicode(unsplit):
 
692
    import shlex
 
693
    return [u.decode('utf-8') for u in shlex.split(unsplit.encode('utf-8'))]
 
694
 
 
695
 
 
696
def get_alias(cmd, config=None):
 
697
    """Return an expanded alias, or None if no alias exists.
 
698
 
 
699
    cmd
 
700
        Command to be checked for an alias.
 
701
    config
 
702
        Used to specify an alternative config to use,
 
703
        which is especially useful for testing.
 
704
        If it is unspecified, the global config will be used.
 
705
    """
 
706
    if config is None:
 
707
        import bzrlib.config
 
708
        config = bzrlib.config.GlobalConfig()
 
709
    alias = config.get_alias(cmd)
546
710
    if (alias):
547
 
        return alias.split(' ')
 
711
        return shlex_split_unicode(alias)
548
712
    return None
549
713
 
550
714
 
551
715
def run_bzr(argv):
552
716
    """Execute a command.
553
717
 
554
 
    This is similar to main(), but without all the trappings for
555
 
    logging and error handling.  
556
 
    
557
718
    argv
558
719
       The command-line arguments, without the program name from argv[0]
559
720
       These should already be decoded. All library/test code calling
579
740
 
580
741
    --lsprof
581
742
        Run under the Python lsprof profiler.
 
743
 
 
744
    --coverage
 
745
        Generate line coverage report in the specified directory.
582
746
    """
583
747
    argv = list(argv)
 
748
    trace.mutter("bzr arguments: %r", argv)
584
749
 
585
750
    opt_lsprof = opt_profile = opt_no_plugins = opt_builtin =  \
586
751
                opt_no_aliases = False
587
 
    opt_lsprof_file = None
 
752
    opt_lsprof_file = opt_coverage_dir = None
588
753
 
589
754
    # --no-plugins is handled specially at a very early stage. We need
590
755
    # to load plugins before doing other command parsing so that they
599
764
        elif a == '--lsprof':
600
765
            opt_lsprof = True
601
766
        elif a == '--lsprof-file':
 
767
            opt_lsprof = True
602
768
            opt_lsprof_file = argv[i + 1]
603
769
            i += 1
604
770
        elif a == '--no-plugins':
607
773
            opt_no_aliases = True
608
774
        elif a == '--builtin':
609
775
            opt_builtin = True
610
 
        elif a in ('--quiet', '-q'):
611
 
            be_quiet()
 
776
        elif a == '--coverage':
 
777
            opt_coverage_dir = argv[i + 1]
 
778
            i += 1
 
779
        elif a.startswith('-D'):
 
780
            debug.debug_flags.add(a[2:])
612
781
        else:
613
782
            argv_copy.append(a)
614
783
        i += 1
620
789
        return 0
621
790
 
622
791
    if argv[0] == '--version':
623
 
        from bzrlib.builtins import show_version
624
 
        show_version()
 
792
        from bzrlib.builtins import cmd_version
 
793
        cmd_version().run_argv_aliases([])
625
794
        return 0
626
 
        
 
795
 
627
796
    if not opt_no_plugins:
628
797
        from bzrlib.plugin import load_plugins
629
798
        load_plugins()
636
805
    if not opt_no_aliases:
637
806
        alias_argv = get_alias(argv[0])
638
807
        if alias_argv:
639
 
            alias_argv = [a.decode(bzrlib.user_encoding) for a in alias_argv]
 
808
            user_encoding = osutils.get_user_encoding()
 
809
            alias_argv = [a.decode(user_encoding) for a in alias_argv]
640
810
            argv[0] = alias_argv.pop(0)
641
811
 
642
 
    cmd = str(argv.pop(0))
 
812
    cmd = argv.pop(0)
 
813
    # We want only 'ascii' command names, but the user may have typed
 
814
    # in a Unicode name. In that case, they should just get a
 
815
    # 'command not found' error later.
643
816
 
644
817
    cmd_obj = get_cmd_object(cmd, plugins_override=not opt_builtin)
645
 
    if not getattr(cmd_obj.run_argv, 'is_deprecated', False):
646
 
        run = cmd_obj.run_argv
647
 
        run_argv = [argv]
648
 
    else:
649
 
        run = cmd_obj.run_argv_aliases
650
 
        run_argv = [argv, alias_argv]
 
818
    run = cmd_obj.run_argv_aliases
 
819
    run_argv = [argv, alias_argv]
651
820
 
652
821
    try:
 
822
        # We can be called recursively (tests for example), but we don't want
 
823
        # the verbosity level to propagate.
 
824
        saved_verbosity_level = option._verbosity_level
 
825
        option._verbosity_level = 0
653
826
        if opt_lsprof:
 
827
            if opt_coverage_dir:
 
828
                trace.warning(
 
829
                    '--coverage ignored, because --lsprof is in use.')
654
830
            ret = apply_lsprofiled(opt_lsprof_file, run, *run_argv)
655
831
        elif opt_profile:
 
832
            if opt_coverage_dir:
 
833
                trace.warning(
 
834
                    '--coverage ignored, because --profile is in use.')
656
835
            ret = apply_profiled(run, *run_argv)
 
836
        elif opt_coverage_dir:
 
837
            ret = apply_coveraged(opt_coverage_dir, run, *run_argv)
657
838
        else:
658
839
            ret = run(*run_argv)
 
840
        if 'memory' in debug.debug_flags:
 
841
            trace.debug_memory('Process status after command:', short=False)
659
842
        return ret or 0
660
843
    finally:
661
 
        # reset, in case we may do other commands later within the same process
662
 
        be_quiet(False)
 
844
        # reset, in case we may do other commands later within the same
 
845
        # process. Commands that want to execute sub-commands must propagate
 
846
        # --verbose in their own way.
 
847
        option._verbosity_level = saved_verbosity_level
663
848
 
664
849
def display_command(func):
665
850
    """Decorator that suppresses pipe/interrupt errors."""
669
854
            sys.stdout.flush()
670
855
            return result
671
856
        except IOError, e:
672
 
            if not hasattr(e, 'errno'):
 
857
            if getattr(e, 'errno', None) is None:
673
858
                raise
674
859
            if e.errno != errno.EPIPE:
675
 
                raise
 
860
                # Win32 raises IOError with errno=0 on a broken pipe
 
861
                if sys.platform != 'win32' or (e.errno not in (0, errno.EINVAL)):
 
862
                    raise
676
863
            pass
677
864
        except KeyboardInterrupt:
678
865
            pass
681
868
 
682
869
def main(argv):
683
870
    import bzrlib.ui
684
 
    from bzrlib.ui.text import TextUIFactory
685
 
    ## bzrlib.trace.enable_default_logging()
686
 
    bzrlib.trace.log_startup(argv)
687
 
    bzrlib.ui.ui_factory = TextUIFactory()
 
871
    bzrlib.ui.ui_factory = bzrlib.ui.make_ui_for_terminal(
 
872
        sys.stdin, sys.stdout, sys.stderr)
688
873
 
689
 
    argv = [a.decode(bzrlib.user_encoding) for a in argv[1:]]
 
874
    # Is this a final release version? If so, we should suppress warnings
 
875
    if bzrlib.version_info[3] == 'final':
 
876
        from bzrlib import symbol_versioning
 
877
        symbol_versioning.suppress_deprecation_warnings(override=False)
 
878
    try:
 
879
        user_encoding = osutils.get_user_encoding()
 
880
        argv = [a.decode(user_encoding) for a in argv[1:]]
 
881
    except UnicodeDecodeError:
 
882
        raise errors.BzrError(("Parameter '%r' is unsupported by the current "
 
883
                                                            "encoding." % a))
690
884
    ret = run_bzr_catch_errors(argv)
691
 
    mutter("return code %d", ret)
 
885
    trace.mutter("return code %d", ret)
692
886
    return ret
693
887
 
694
888
 
695
889
def run_bzr_catch_errors(argv):
 
890
    # Note: The except clause logic below should be kept in sync with the
 
891
    # profile() routine in lsprof.py.
696
892
    try:
697
 
        try:
698
 
            return run_bzr(argv)
699
 
        finally:
700
 
            # do this here inside the exception wrappers to catch EPIPE
701
 
            sys.stdout.flush()
702
 
    except Exception, e:
 
893
        return run_bzr(argv)
 
894
    except (KeyboardInterrupt, Exception), e:
703
895
        # used to handle AssertionError and KeyboardInterrupt
704
896
        # specially here, but hopefully they're handled ok by the logger now
705
 
        import errno
706
 
        if (isinstance(e, IOError) 
707
 
            and hasattr(e, 'errno')
708
 
            and e.errno == errno.EPIPE):
709
 
            bzrlib.trace.note('broken pipe')
710
 
            return 3
711
 
        else:
712
 
            bzrlib.trace.log_exception()
713
 
            if os.environ.get('BZR_PDB'):
714
 
                print '**** entering debugger'
715
 
                import pdb
716
 
                pdb.post_mortem(sys.exc_traceback)
717
 
            return 3
 
897
        exitcode = trace.report_exception(sys.exc_info(), sys.stderr)
 
898
        if os.environ.get('BZR_PDB'):
 
899
            print '**** entering debugger'
 
900
            import pdb
 
901
            pdb.post_mortem(sys.exc_traceback)
 
902
        return exitcode
 
903
 
 
904
 
 
905
def run_bzr_catch_user_errors(argv):
 
906
    """Run bzr and report user errors, but let internal errors propagate.
 
907
 
 
908
    This is used for the test suite, and might be useful for other programs
 
909
    that want to wrap the commandline interface.
 
910
    """
 
911
    try:
 
912
        return run_bzr(argv)
 
913
    except Exception, e:
 
914
        if (isinstance(e, (OSError, IOError))
 
915
            or not getattr(e, 'internal_error', True)):
 
916
            trace.report_exception(sys.exc_info(), sys.stderr)
 
917
            return 3
 
918
        else:
 
919
            raise
 
920
 
 
921
 
 
922
class HelpCommandIndex(object):
 
923
    """A index for bzr help that returns commands."""
 
924
 
 
925
    def __init__(self):
 
926
        self.prefix = 'commands/'
 
927
 
 
928
    def get_topics(self, topic):
 
929
        """Search for topic amongst commands.
 
930
 
 
931
        :param topic: A topic to search for.
 
932
        :return: A list which is either empty or contains a single
 
933
            Command entry.
 
934
        """
 
935
        if topic and topic.startswith(self.prefix):
 
936
            topic = topic[len(self.prefix):]
 
937
        try:
 
938
            cmd = _get_cmd_object(topic)
 
939
        except KeyError:
 
940
            return []
 
941
        else:
 
942
            return [cmd]
 
943
 
 
944
 
 
945
class Provider(object):
 
946
    '''Generic class to be overriden by plugins'''
 
947
 
 
948
    def plugin_for_command(self, cmd_name):
 
949
        '''Takes a command and returns the information for that plugin
 
950
        
 
951
        :return: A dictionary with all the available information 
 
952
        for the requested plugin
 
953
        '''
 
954
        raise NotImplementedError
 
955
 
 
956
 
 
957
class ProvidersRegistry(registry.Registry):
 
958
    '''This registry exists to allow other providers to exist'''
 
959
 
 
960
    def __iter__(self):
 
961
        for key, provider in self.iteritems():
 
962
            yield provider
 
963
 
 
964
command_providers_registry = ProvidersRegistry()
 
965
 
718
966
 
719
967
if __name__ == '__main__':
720
968
    sys.exit(main(sys.argv))