← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/commands.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2007-08-23 00:18:12 UTC
  • mfrom: (2743.1.5 misc-fixen)
  • Revision ID: pqm@pqm.ubuntu.com-20070823001812-eermtd2vfr5o6b7o
(robertc) Several minor miscellaneous code cleanup fixes. (Robert Collins)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/commands.py
1
 
# Copyright (C) 2004, 2005 by Canonical Ltd
2
 
 
 
1
# Copyright (C) 2006 Canonical Ltd
 
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
5
5
# the Free Software Foundation; either version 2 of the License, or
6
6
# (at your option) any later version.
7
 
 
 
7
#
8
8
# This program is distributed in the hope that it will be useful,
9
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
11
11
# GNU General Public License for more details.
12
 
 
 
12
#
13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
18
18
# TODO: probably should say which arguments are candidates for glob
19
19
# expansion on windows and do that at the command level.
20
20
 
21
 
# TODO: Help messages for options.
22
 
 
23
21
# TODO: Define arguments by objects, rather than just using names.
24
22
# Those objects can specify the expected type of the argument, which
25
 
# would help with validation and shell completion.
 
23
# would help with validation and shell completion.  They could also provide
 
24
# help/explanation for that argument in a structured way.
 
25
 
 
26
# TODO: Specific "examples" property on commands for consistent formatting.
26
27
 
27
28
# TODO: "--profile=cum", to change sort order.  Is there any value in leaving
28
29
# the profile output behind so it can be interactively examined?
29
30
 
 
31
import os
30
32
import sys
31
 
import os
 
33
 
 
34
from bzrlib.lazy_import import lazy_import
 
35
lazy_import(globals(), """
 
36
import codecs
 
37
import errno
32
38
from warnings import warn
33
 
from inspect import getdoc
34
 
import errno
35
39
 
36
40
import bzrlib
37
 
import bzrlib.trace
38
 
from bzrlib.trace import mutter, note, log_error, warning, be_quiet
39
 
from bzrlib.errors import (BzrError, 
40
 
                           BzrCheckError,
41
 
                           BzrCommandError,
42
 
                           BzrOptionError,
43
 
                           NotBranchError)
44
 
from bzrlib.revisionspec import RevisionSpec
45
 
from bzrlib import BZRDIR
 
41
from bzrlib import (
 
42
    debug,
 
43
    errors,
 
44
    option,
 
45
    osutils,
 
46
    trace,
 
47
    win32utils,
 
48
    )
 
49
""")
 
50
 
 
51
from bzrlib.symbol_versioning import (
 
52
    deprecated_function,
 
53
    deprecated_method,
 
54
    )
 
55
# Compatibility
46
56
from bzrlib.option import Option
47
57
 
 
58
 
48
59
plugin_cmds = {}
49
60
 
50
61
 
51
62
def register_command(cmd, decorate=False):
52
 
    "Utility function to help register a command"
 
63
    """Utility function to help register a command
 
64
 
 
65
    :param cmd: Command subclass to register
 
66
    :param decorate: If true, allow overriding an existing command
 
67
        of the same name; the old command is returned by this function.
 
68
        Otherwise it is an error to try to override an existing command.
 
69
    """
53
70
    global plugin_cmds
54
71
    k = cmd.__name__
55
72
    if k.startswith("cmd_"):
56
73
        k_unsquished = _unsquish_command_name(k)
57
74
    else:
58
75
        k_unsquished = k
59
 
    if not plugin_cmds.has_key(k_unsquished):
 
76
    if k_unsquished not in plugin_cmds:
60
77
        plugin_cmds[k_unsquished] = cmd
61
 
        mutter('registered plugin command %s', k_unsquished)      
 
78
        ## trace.mutter('registered plugin command %s', k_unsquished)
62
79
        if decorate and k_unsquished in builtin_command_names():
63
80
            return _builtin_commands()[k_unsquished]
64
81
    elif decorate:
66
83
        plugin_cmds[k_unsquished] = cmd
67
84
        return result
68
85
    else:
69
 
        log_error('Two plugins defined the same command: %r' % k)
70
 
        log_error('Not loading the one in %r' % sys.modules[cmd.__module__])
 
86
        trace.log_error('Two plugins defined the same command: %r' % k)
 
87
        trace.log_error('Not loading the one in %r' % sys.modules[cmd.__module__])
71
88
 
72
89
 
73
90
def _squish_command_name(cmd):
85
102
    builtins = bzrlib.builtins.__dict__
86
103
    for name in builtins:
87
104
        if name.startswith("cmd_"):
88
 
            real_name = _unsquish_command_name(name)        
 
105
            real_name = _unsquish_command_name(name)
89
106
            r[real_name] = builtins[name]
90
107
    return r
91
 
 
92
108
            
93
109
 
94
110
def builtin_command_names():
120
136
    plugins_override
121
137
        If true, plugin commands can override builtins.
122
138
    """
 
139
    try:
 
140
        return _get_cmd_object(cmd_name, plugins_override)
 
141
    except KeyError:
 
142
        raise errors.BzrCommandError('unknown command "%s"' % cmd_name)
 
143
 
 
144
 
 
145
def _get_cmd_object(cmd_name, plugins_override=True):
 
146
    """Worker for get_cmd_object which raises KeyError rather than BzrCommandError."""
123
147
    from bzrlib.externalcommand import ExternalCommand
124
148
 
125
 
    cmd_name = str(cmd_name)            # not unicode
 
149
    # We want only 'ascii' command names, but the user may have typed
 
150
    # in a Unicode name. In that case, they should just get a
 
151
    # 'command not found' error later.
 
152
    # In the future, we may actually support Unicode command names.
126
153
 
127
154
    # first look up this command under the specified name
128
155
    cmds = _get_cmd_dict(plugins_override=plugins_override)
139
166
    cmd_obj = ExternalCommand.find_command(cmd_name)
140
167
    if cmd_obj:
141
168
        return cmd_obj
142
 
 
143
 
    raise BzrCommandError("unknown command %r" % cmd_name)
 
169
    raise KeyError
144
170
 
145
171
 
146
172
class Command(object):
168
194
        List of argument forms, marked with whether they are optional,
169
195
        repeated, etc.
170
196
 
171
 
                Examples:
172
 
 
173
 
                ['to_location', 'from_branch?', 'file*']
174
 
 
175
 
                'to_location' is required
176
 
                'from_branch' is optional
177
 
                'file' can be specified 0 or more times
 
197
                Examples:
 
198
 
 
199
                ['to_location', 'from_branch?', 'file*']
 
200
 
 
201
                'to_location' is required
 
202
                'from_branch' is optional
 
203
                'file' can be specified 0 or more times
178
204
 
179
205
    takes_options
180
206
        List of options that may be given for this command.  These can
184
210
    hidden
185
211
        If true, this command isn't advertised.  This is typically
186
212
        for commands intended for expert users.
 
213
 
 
214
    encoding_type
 
215
        Command objects will get a 'outf' attribute, which has been
 
216
        setup to properly handle encoding of unicode strings.
 
217
        encoding_type determines what will happen when characters cannot
 
218
        be encoded
 
219
            strict - abort if we cannot decode
 
220
            replace - put in a bogus character (typically '?')
 
221
            exact - do not encode sys.stdout
 
222
 
 
223
            NOTE: by default on Windows, sys.stdout is opened as a text
 
224
            stream, therefore LF line-endings are converted to CRLF.
 
225
            When a command uses encoding_type = 'exact', then
 
226
            sys.stdout is forced to be a binary stream, and line-endings
 
227
            will not mangled.
 
228
 
187
229
    """
188
230
    aliases = []
189
231
    takes_args = []
190
232
    takes_options = []
 
233
    encoding_type = 'strict'
191
234
 
192
235
    hidden = False
193
236
    
196
239
        if self.__doc__ == Command.__doc__:
197
240
            warn("No help message set for %r" % self)
198
241
 
 
242
    def _maybe_expand_globs(self, file_list):
 
243
        """Glob expand file_list if the platform does not do that itself.
 
244
        
 
245
        :return: A possibly empty list of unicode paths.
 
246
 
 
247
        Introduced in bzrlib 0.18.
 
248
        """
 
249
        if not file_list:
 
250
            file_list = []
 
251
        if sys.platform == 'win32':
 
252
            file_list = win32utils.glob_expand(file_list)
 
253
        return list(file_list)
 
254
 
 
255
    def _usage(self):
 
256
        """Return single-line grammar for this command.
 
257
 
 
258
        Only describes arguments, not options.
 
259
        """
 
260
        s = 'bzr ' + self.name() + ' '
 
261
        for aname in self.takes_args:
 
262
            aname = aname.upper()
 
263
            if aname[-1] in ['$', '+']:
 
264
                aname = aname[:-1] + '...'
 
265
            elif aname[-1] == '?':
 
266
                aname = '[' + aname[:-1] + ']'
 
267
            elif aname[-1] == '*':
 
268
                aname = '[' + aname[:-1] + '...]'
 
269
            s += aname + ' '
 
270
                
 
271
        assert s[-1] == ' '
 
272
        s = s[:-1]
 
273
        return s
 
274
 
 
275
    def get_help_text(self, additional_see_also=None, plain=True,
 
276
                      see_also_as_links=False):
 
277
        """Return a text string with help for this command.
 
278
        
 
279
        :param additional_see_also: Additional help topics to be
 
280
            cross-referenced.
 
281
        :param plain: if False, raw help (reStructuredText) is
 
282
            returned instead of plain text.
 
283
        :param see_also_as_links: if True, convert items in 'See also'
 
284
            list to internal links (used by bzr_man rstx generator)
 
285
        """
 
286
        doc = self.help()
 
287
        if doc is None:
 
288
            raise NotImplementedError("sorry, no detailed help yet for %r" % self.name())
 
289
 
 
290
        # Extract the summary (purpose) and sections out from the text
 
291
        purpose,sections = self._get_help_parts(doc)
 
292
 
 
293
        # If a custom usage section was provided, use it
 
294
        if sections.has_key('Usage'):
 
295
            usage = sections.pop('Usage')
 
296
        else:
 
297
            usage = self._usage()
 
298
 
 
299
        # The header is the purpose and usage
 
300
        result = ""
 
301
        result += ':Purpose: %s\n' % purpose
 
302
        if usage.find('\n') >= 0:
 
303
            result += ':Usage:\n%s\n' % usage
 
304
        else:
 
305
            result += ':Usage:   %s\n' % usage
 
306
        result += '\n'
 
307
 
 
308
        # Add the options
 
309
        options = option.get_optparser(self.options()).format_option_help()
 
310
        if options.startswith('Options:'):
 
311
            result += ':' + options
 
312
        elif options.startswith('options:'):
 
313
            # Python 2.4 version of optparse
 
314
            result += ':Options:' + options[len('options:'):]
 
315
        else:
 
316
            result += options
 
317
        result += '\n'
 
318
 
 
319
        # Add the description, indenting it 2 spaces
 
320
        # to match the indentation of the options
 
321
        if sections.has_key(None):
 
322
            text = sections.pop(None)
 
323
            text = '\n  '.join(text.splitlines())
 
324
            result += ':%s:\n  %s\n\n' % ('Description',text)
 
325
 
 
326
        # Add the custom sections (e.g. Examples). Note that there's no need
 
327
        # to indent these as they must be indented already in the source.
 
328
        if sections:
 
329
            labels = sorted(sections.keys())
 
330
            for label in labels:
 
331
                result += ':%s:\n%s\n\n' % (label,sections[label])
 
332
 
 
333
        # Add the aliases, source (plug-in) and see also links, if any
 
334
        if self.aliases:
 
335
            result += ':Aliases:  '
 
336
            result += ', '.join(self.aliases) + '\n'
 
337
        plugin_name = self.plugin_name()
 
338
        if plugin_name is not None:
 
339
            result += ':From:     plugin "%s"\n' % plugin_name
 
340
        see_also = self.get_see_also(additional_see_also)
 
341
        if see_also:
 
342
            if not plain and see_also_as_links:
 
343
                see_also_links = []
 
344
                for item in see_also:
 
345
                    if item == 'topics':
 
346
                        # topics doesn't have an independent section
 
347
                        # so don't create a real link
 
348
                        see_also_links.append(item)
 
349
                    else:
 
350
                        # Use a reST link for this entry
 
351
                        see_also_links.append("`%s`_" % (item,))
 
352
                see_also = see_also_links
 
353
            result += ':See also: '
 
354
            result += ', '.join(see_also) + '\n'
 
355
 
 
356
        # If this will be rendered as plan text, convert it
 
357
        if plain:
 
358
            import bzrlib.help_topics
 
359
            result = bzrlib.help_topics.help_as_plain_text(result)
 
360
        return result
 
361
 
 
362
    @staticmethod
 
363
    def _get_help_parts(text):
 
364
        """Split help text into a summary and named sections.
 
365
 
 
366
        :return: (summary,sections) where summary is the top line and
 
367
            sections is a dictionary of the rest indexed by section name.
 
368
            A section starts with a heading line of the form ":xxx:".
 
369
            Indented text on following lines is the section value.
 
370
            All text found outside a named section is assigned to the
 
371
            default section which is given the key of None.
 
372
        """
 
373
        def save_section(sections, label, section):
 
374
            if len(section) > 0:
 
375
                if sections.has_key(label):
 
376
                    sections[label] += '\n' + section
 
377
                else:
 
378
                    sections[label] = section
 
379
            
 
380
        lines = text.rstrip().splitlines()
 
381
        summary = lines.pop(0)
 
382
        sections = {}
 
383
        label,section = None,''
 
384
        for line in lines:
 
385
            if line.startswith(':') and line.endswith(':') and len(line) > 2:
 
386
                save_section(sections, label, section)
 
387
                label,section = line[1:-1],''
 
388
            elif label != None and len(line) > 1 and not line[0].isspace():
 
389
                save_section(sections, label, section)
 
390
                label,section = None,line
 
391
            else:
 
392
                if len(section) > 0:
 
393
                    section += '\n' + line
 
394
                else:
 
395
                    section = line
 
396
        save_section(sections, label, section)
 
397
        return summary, sections
 
398
 
 
399
    def get_help_topic(self):
 
400
        """Return the commands help topic - its name."""
 
401
        return self.name()
 
402
 
 
403
    def get_see_also(self, additional_terms=None):
 
404
        """Return a list of help topics that are related to this command.
 
405
        
 
406
        The list is derived from the content of the _see_also attribute. Any
 
407
        duplicates are removed and the result is in lexical order.
 
408
        :param additional_terms: Additional help topics to cross-reference.
 
409
        :return: A list of help topics.
 
410
        """
 
411
        see_also = set(getattr(self, '_see_also', []))
 
412
        if additional_terms:
 
413
            see_also.update(additional_terms)
 
414
        return sorted(see_also)
 
415
 
199
416
    def options(self):
200
417
        """Return dict of valid options for this command.
201
418
 
202
419
        Maps from long option name to option object."""
203
420
        r = dict()
204
 
        r['help'] = Option.OPTIONS['help']
 
421
        r['help'] = option._help_option
205
422
        for o in self.takes_options:
206
 
            if not isinstance(o, Option):
207
 
                o = Option.OPTIONS[o]
 
423
            if isinstance(o, basestring):
 
424
                o = option.Option.OPTIONS[o]
208
425
            r[o.name] = o
209
426
        return r
210
427
 
211
 
    def run_argv(self, argv):
212
 
        """Parse command line and run."""
213
 
        args, opts = parse_args(self, argv)
 
428
    def _setup_outf(self):
 
429
        """Return a file linked to stdout, which has proper encoding."""
 
430
        assert self.encoding_type in ['strict', 'exact', 'replace']
 
431
 
 
432
        # Originally I was using self.stdout, but that looks
 
433
        # *way* too much like sys.stdout
 
434
        if self.encoding_type == 'exact':
 
435
            # force sys.stdout to be binary stream on win32
 
436
            if sys.platform == 'win32':
 
437
                fileno = getattr(sys.stdout, 'fileno', None)
 
438
                if fileno:
 
439
                    import msvcrt
 
440
                    msvcrt.setmode(fileno(), os.O_BINARY)
 
441
            self.outf = sys.stdout
 
442
            return
 
443
 
 
444
        output_encoding = osutils.get_terminal_encoding()
 
445
 
 
446
        # use 'replace' so that we don't abort if trying to write out
 
447
        # in e.g. the default C locale.
 
448
        self.outf = codecs.getwriter(output_encoding)(sys.stdout, errors=self.encoding_type)
 
449
        # For whatever reason codecs.getwriter() does not advertise its encoding
 
450
        # it just returns the encoding of the wrapped file, which is completely
 
451
        # bogus. So set the attribute, so we can find the correct encoding later.
 
452
        self.outf.encoding = output_encoding
 
453
 
 
454
    def run_argv_aliases(self, argv, alias_argv=None):
 
455
        """Parse the command line and run with extra aliases in alias_argv."""
 
456
        if argv is None:
 
457
            warn("Passing None for [] is deprecated from bzrlib 0.10",
 
458
                 DeprecationWarning, stacklevel=2)
 
459
            argv = []
 
460
        args, opts = parse_args(self, argv, alias_argv)
214
461
        if 'help' in opts:  # e.g. bzr add --help
215
 
            from bzrlib.help import help_on_command
216
 
            help_on_command(self.name())
 
462
            sys.stdout.write(self.get_help_text())
217
463
            return 0
218
 
        # XXX: This should be handled by the parser
219
 
        allowed_names = self.options().keys()
220
 
        for oname in opts:
221
 
            if oname not in allowed_names:
222
 
                raise BzrCommandError("option '--%s' is not allowed for command %r"
223
 
                                      % (oname, self.name()))
224
464
        # mix arguments and options into one dictionary
225
465
        cmdargs = _match_argform(self.name(), self.takes_args, args)
226
466
        cmdopts = {}
230
470
        all_cmd_args = cmdargs.copy()
231
471
        all_cmd_args.update(cmdopts)
232
472
 
 
473
        self._setup_outf()
 
474
 
233
475
        return self.run(**all_cmd_args)
234
476
    
235
477
    def run(self):
242
484
        shell error code if not.  It's OK for this method to allow
243
485
        an exception to raise up.
244
486
        """
245
 
        raise NotImplementedError()
246
 
 
 
487
        raise NotImplementedError('no implementation of command %r'
 
488
                                  % self.name())
247
489
 
248
490
    def help(self):
249
491
        """Return help message for this class."""
 
492
        from inspect import getdoc
250
493
        if self.__doc__ is Command.__doc__:
251
494
            return None
252
495
        return getdoc(self)
254
497
    def name(self):
255
498
        return _unsquish_command_name(self.__class__.__name__)
256
499
 
 
500
    def plugin_name(self):
 
501
        """Get the name of the plugin that provides this command.
257
502
 
258
 
def parse_spec(spec):
259
 
    """
260
 
    >>> parse_spec(None)
261
 
    [None, None]
262
 
    >>> parse_spec("./")
263
 
    ['./', None]
264
 
    >>> parse_spec("../@")
265
 
    ['..', -1]
266
 
    >>> parse_spec("../f/@35")
267
 
    ['../f', 35]
268
 
    >>> parse_spec('./@revid:john@arbash-meinel.com-20050711044610-3ca0327c6a222f67')
269
 
    ['.', 'revid:john@arbash-meinel.com-20050711044610-3ca0327c6a222f67']
270
 
    """
271
 
    if spec is None:
272
 
        return [None, None]
273
 
    if '/@' in spec:
274
 
        parsed = spec.split('/@')
275
 
        assert len(parsed) == 2
276
 
        if parsed[1] == "":
277
 
            parsed[1] = -1
 
503
        :return: The name of the plugin or None if the command is builtin.
 
504
        """
 
505
        mod_parts = self.__module__.split('.')
 
506
        if len(mod_parts) >= 3 and mod_parts[1] == 'plugins':
 
507
            return mod_parts[2]
278
508
        else:
279
 
            try:
280
 
                parsed[1] = int(parsed[1])
281
 
            except ValueError:
282
 
                pass # We can allow stuff like ./@revid:blahblahblah
283
 
            else:
284
 
                assert parsed[1] >=0
285
 
    else:
286
 
        parsed = [spec, None]
287
 
    return parsed
288
 
 
289
 
def parse_args(command, argv):
 
509
            return None
 
510
 
 
511
 
 
512
def parse_args(command, argv, alias_argv=None):
290
513
    """Parse command line.
291
514
    
292
515
    Arguments and options are parsed at this level before being passed
294
517
    lookup table, something about the available options, what optargs
295
518
    they take, and which commands will accept them.
296
519
    """
297
 
    # TODO: chop up this beast; make it a method of the Command
298
 
    args = []
299
 
    opts = {}
300
 
 
301
 
    cmd_options = command.options()
302
 
    argsover = False
303
 
    while argv:
304
 
        a = argv.pop(0)
305
 
        if argsover:
306
 
            args.append(a)
307
 
            continue
308
 
        elif a == '--':
309
 
            # We've received a standalone -- No more flags
310
 
            argsover = True
311
 
            continue
312
 
        if a[0] == '-':
313
 
            # option names must not be unicode
314
 
            a = str(a)
315
 
            optarg = None
316
 
            if a[1] == '-':
317
 
                mutter("  got option %r", a)
318
 
                if '=' in a:
319
 
                    optname, optarg = a[2:].split('=', 1)
320
 
                else:
321
 
                    optname = a[2:]
322
 
                if optname not in cmd_options:
323
 
                    raise BzrOptionError('unknown long option %r for command %s'
324
 
                        % (a, command.name()))
325
 
            else:
326
 
                shortopt = a[1:]
327
 
                if shortopt in Option.SHORT_OPTIONS:
328
 
                    # Multi-character options must have a space to delimit
329
 
                    # their value
330
 
                    # ^^^ what does this mean? mbp 20051014
331
 
                    optname = Option.SHORT_OPTIONS[shortopt].name
332
 
                else:
333
 
                    # Single character short options, can be chained,
334
 
                    # and have their value appended to their name
335
 
                    shortopt = a[1:2]
336
 
                    if shortopt not in Option.SHORT_OPTIONS:
337
 
                        # We didn't find the multi-character name, and we
338
 
                        # didn't find the single char name
339
 
                        raise BzrError('unknown short option %r' % a)
340
 
                    optname = Option.SHORT_OPTIONS[shortopt].name
341
 
 
342
 
                    if a[2:]:
343
 
                        # There are extra things on this option
344
 
                        # see if it is the value, or if it is another
345
 
                        # short option
346
 
                        optargfn = Option.OPTIONS[optname].type
347
 
                        if optargfn is None:
348
 
                            # This option does not take an argument, so the
349
 
                            # next entry is another short option, pack it back
350
 
                            # into the list
351
 
                            argv.insert(0, '-' + a[2:])
352
 
                        else:
353
 
                            # This option takes an argument, so pack it
354
 
                            # into the array
355
 
                            optarg = a[2:]
356
 
            
357
 
                if optname not in cmd_options:
358
 
                    raise BzrOptionError('unknown short option %r for command'
359
 
                        ' %s' % (shortopt, command.name()))
360
 
            if optname in opts:
361
 
                # XXX: Do we ever want to support this, e.g. for -r?
362
 
                raise BzrError('repeated option %r' % a)
363
 
                
364
 
            option_obj = cmd_options[optname]
365
 
            optargfn = option_obj.type
366
 
            if optargfn:
367
 
                if optarg == None:
368
 
                    if not argv:
369
 
                        raise BzrError('option %r needs an argument' % a)
370
 
                    else:
371
 
                        optarg = argv.pop(0)
372
 
                opts[optname] = optargfn(optarg)
373
 
            else:
374
 
                if optarg != None:
375
 
                    raise BzrError('option %r takes no argument' % optname)
376
 
                opts[optname] = True
377
 
        else:
378
 
            args.append(a)
 
520
    # TODO: make it a method of the Command?
 
521
    parser = option.get_optparser(command.options())
 
522
    if alias_argv is not None:
 
523
        args = alias_argv + argv
 
524
    else:
 
525
        args = argv
 
526
 
 
527
    options, args = parser.parse_args(args)
 
528
    opts = dict([(k, v) for k, v in options.__dict__.iteritems() if
 
529
                 v is not option.OptionParser.DEFAULT_VALUE])
379
530
    return args, opts
380
531
 
381
532
 
396
547
                argdict[argname + '_list'] = None
397
548
        elif ap[-1] == '+':
398
549
            if not args:
399
 
                raise BzrCommandError("command %r needs one or more %s"
400
 
                        % (cmd, argname.upper()))
 
550
                raise errors.BzrCommandError("command %r needs one or more %s"
 
551
                                             % (cmd, argname.upper()))
401
552
            else:
402
553
                argdict[argname + '_list'] = args[:]
403
554
                args = []
404
555
        elif ap[-1] == '$': # all but one
405
556
            if len(args) < 2:
406
 
                raise BzrCommandError("command %r needs one or more %s"
407
 
                        % (cmd, argname.upper()))
 
557
                raise errors.BzrCommandError("command %r needs one or more %s"
 
558
                                             % (cmd, argname.upper()))
408
559
            argdict[argname + '_list'] = args[:-1]
409
 
            args[:-1] = []                
 
560
            args[:-1] = []
410
561
        else:
411
562
            # just a plain arg
412
563
            argname = ap
413
564
            if not args:
414
 
                raise BzrCommandError("command %r requires argument %s"
415
 
                        % (cmd, argname.upper()))
 
565
                raise errors.BzrCommandError("command %r requires argument %s"
 
566
                               % (cmd, argname.upper()))
416
567
            else:
417
568
                argdict[argname] = args.pop(0)
418
569
            
419
570
    if args:
420
 
        raise BzrCommandError("extra argument to command %s: %s"
421
 
                              % (cmd, args[0]))
 
571
        raise errors.BzrCommandError("extra argument to command %s: %s"
 
572
                                     % (cmd, args[0]))
422
573
 
423
574
    return argdict
424
575
 
447
598
        os.remove(pfname)
448
599
 
449
600
 
450
 
def apply_lsprofiled(the_callable, *args, **kwargs):
 
601
def apply_lsprofiled(filename, the_callable, *args, **kwargs):
451
602
    from bzrlib.lsprof import profile
452
 
    ret,stats = profile(the_callable,*args,**kwargs)
 
603
    ret, stats = profile(the_callable, *args, **kwargs)
453
604
    stats.sort()
454
 
    stats.pprint()
 
605
    if filename is None:
 
606
        stats.pprint()
 
607
    else:
 
608
        stats.save(filename)
 
609
        trace.note('Profile data written to "%s".', filename)
455
610
    return ret
456
611
 
 
612
 
 
613
def get_alias(cmd, config=None):
 
614
    """Return an expanded alias, or None if no alias exists.
 
615
 
 
616
    cmd
 
617
        Command to be checked for an alias.
 
618
    config
 
619
        Used to specify an alternative config to use,
 
620
        which is especially useful for testing.
 
621
        If it is unspecified, the global config will be used.
 
622
    """
 
623
    if config is None:
 
624
        import bzrlib.config
 
625
        config = bzrlib.config.GlobalConfig()
 
626
    alias = config.get_alias(cmd)
 
627
    if (alias):
 
628
        import shlex
 
629
        return [a.decode('utf-8') for a in shlex.split(alias.encode('utf-8'))]
 
630
    return None
 
631
 
 
632
 
457
633
def run_bzr(argv):
458
634
    """Execute a command.
459
635
 
462
638
    
463
639
    argv
464
640
       The command-line arguments, without the program name from argv[0]
 
641
       These should already be decoded. All library/test code calling
 
642
       run_bzr should be passing valid strings (don't need decoding).
465
643
    
466
644
    Returns a command status or raises an exception.
467
645
 
471
649
    --no-plugins
472
650
        Do not load plugin modules at all
473
651
 
 
652
    --no-aliases
 
653
        Do not allow aliases
 
654
 
474
655
    --builtin
475
656
        Only use builtin commands.  (Plugins are still allowed to change
476
657
        other behaviour.)
481
662
    --lsprof
482
663
        Run under the Python lsprof profiler.
483
664
    """
484
 
    argv = [a.decode(bzrlib.user_encoding) for a in argv]
 
665
    argv = list(argv)
 
666
    trace.mutter("bzr arguments: %r", argv)
485
667
 
486
 
    opt_lsprof = opt_profile = opt_no_plugins = opt_builtin = False
 
668
    opt_lsprof = opt_profile = opt_no_plugins = opt_builtin =  \
 
669
                opt_no_aliases = False
 
670
    opt_lsprof_file = None
487
671
 
488
672
    # --no-plugins is handled specially at a very early stage. We need
489
673
    # to load plugins before doing other command parsing so that they
490
674
    # can override commands, but this needs to happen first.
491
675
 
492
 
    for a in argv:
 
676
    argv_copy = []
 
677
    i = 0
 
678
    while i < len(argv):
 
679
        a = argv[i]
493
680
        if a == '--profile':
494
681
            opt_profile = True
495
682
        elif a == '--lsprof':
496
683
            opt_lsprof = True
 
684
        elif a == '--lsprof-file':
 
685
            opt_lsprof = True
 
686
            opt_lsprof_file = argv[i + 1]
 
687
            i += 1
497
688
        elif a == '--no-plugins':
498
689
            opt_no_plugins = True
 
690
        elif a == '--no-aliases':
 
691
            opt_no_aliases = True
499
692
        elif a == '--builtin':
500
693
            opt_builtin = True
501
694
        elif a in ('--quiet', '-q'):
502
 
            be_quiet()
 
695
            trace.be_quiet()
 
696
        elif a.startswith('-D'):
 
697
            debug.debug_flags.add(a[2:])
503
698
        else:
504
 
            continue
505
 
        argv.remove(a)
 
699
            argv_copy.append(a)
 
700
        i += 1
506
701
 
507
 
    if (not argv) or (argv[0] == '--help'):
508
 
        from bzrlib.help import help
509
 
        if len(argv) > 1:
510
 
            help(argv[1])
511
 
        else:
512
 
            help()
 
702
    argv = argv_copy
 
703
    if (not argv):
 
704
        from bzrlib.builtins import cmd_help
 
705
        cmd_help().run_argv_aliases([])
513
706
        return 0
514
707
 
515
708
    if argv[0] == '--version':
516
 
        from bzrlib.builtins import show_version
 
709
        from bzrlib.version import show_version
517
710
        show_version()
518
711
        return 0
519
712
        
520
713
    if not opt_no_plugins:
521
714
        from bzrlib.plugin import load_plugins
522
715
        load_plugins()
523
 
 
524
 
    cmd = str(argv.pop(0))
 
716
    else:
 
717
        from bzrlib.plugin import disable_plugins
 
718
        disable_plugins()
 
719
 
 
720
    alias_argv = None
 
721
 
 
722
    if not opt_no_aliases:
 
723
        alias_argv = get_alias(argv[0])
 
724
        if alias_argv:
 
725
            alias_argv = [a.decode(bzrlib.user_encoding) for a in alias_argv]
 
726
            argv[0] = alias_argv.pop(0)
 
727
 
 
728
    cmd = argv.pop(0)
 
729
    # We want only 'ascii' command names, but the user may have typed
 
730
    # in a Unicode name. In that case, they should just get a
 
731
    # 'command not found' error later.
525
732
 
526
733
    cmd_obj = get_cmd_object(cmd, plugins_override=not opt_builtin)
 
734
    run = cmd_obj.run_argv_aliases
 
735
    run_argv = [argv, alias_argv]
527
736
 
528
737
    try:
529
738
        if opt_lsprof:
530
 
            ret = apply_lsprofiled(cmd_obj.run_argv, argv)
 
739
            ret = apply_lsprofiled(opt_lsprof_file, run, *run_argv)
531
740
        elif opt_profile:
532
 
            ret = apply_profiled(cmd_obj.run_argv, argv)
 
741
            ret = apply_profiled(run, *run_argv)
533
742
        else:
534
 
            ret = cmd_obj.run_argv(argv)
 
743
            ret = run(*run_argv)
535
744
        return ret or 0
536
745
    finally:
537
746
        # reset, in case we may do other commands later within the same process
538
 
        be_quiet(False)
 
747
        trace.be_quiet(False)
539
748
 
540
749
def display_command(func):
541
750
    """Decorator that suppresses pipe/interrupt errors."""
545
754
            sys.stdout.flush()
546
755
            return result
547
756
        except IOError, e:
548
 
            if not hasattr(e, 'errno'):
 
757
            if getattr(e, 'errno', None) is None:
549
758
                raise
550
759
            if e.errno != errno.EPIPE:
551
 
                raise
 
760
                # Win32 raises IOError with errno=0 on a broken pipe
 
761
                if sys.platform != 'win32' or (e.errno not in (0, errno.EINVAL)):
 
762
                    raise
552
763
            pass
553
764
        except KeyboardInterrupt:
554
765
            pass
558
769
def main(argv):
559
770
    import bzrlib.ui
560
771
    from bzrlib.ui.text import TextUIFactory
561
 
    ## bzrlib.trace.enable_default_logging()
562
 
    bzrlib.trace.log_startup(argv)
563
772
    bzrlib.ui.ui_factory = TextUIFactory()
564
 
    ret = run_bzr_catch_errors(argv[1:])
565
 
    mutter("return code %d", ret)
 
773
    argv = [a.decode(bzrlib.user_encoding) for a in argv[1:]]
 
774
    ret = run_bzr_catch_errors(argv)
 
775
    trace.mutter("return code %d", ret)
566
776
    return ret
567
777
 
568
778
 
569
779
def run_bzr_catch_errors(argv):
570
780
    try:
571
 
        try:
572
 
            return run_bzr(argv)
573
 
        finally:
574
 
            # do this here inside the exception wrappers to catch EPIPE
575
 
            sys.stdout.flush()
576
 
    except Exception, e:
 
781
        return run_bzr(argv)
 
782
    except (KeyboardInterrupt, Exception), e:
577
783
        # used to handle AssertionError and KeyboardInterrupt
578
784
        # specially here, but hopefully they're handled ok by the logger now
579
 
        import errno
580
 
        if (isinstance(e, IOError) 
581
 
            and hasattr(e, 'errno')
582
 
            and e.errno == errno.EPIPE):
583
 
            bzrlib.trace.note('broken pipe')
584
 
            return 3
 
785
        trace.report_exception(sys.exc_info(), sys.stderr)
 
786
        if os.environ.get('BZR_PDB'):
 
787
            print '**** entering debugger'
 
788
            import pdb
 
789
            pdb.post_mortem(sys.exc_traceback)
 
790
        return 3
 
791
 
 
792
 
 
793
class HelpCommandIndex(object):
 
794
    """A index for bzr help that returns commands."""
 
795
 
 
796
    def __init__(self):
 
797
        self.prefix = 'commands/'
 
798
 
 
799
    def get_topics(self, topic):
 
800
        """Search for topic amongst commands.
 
801
 
 
802
        :param topic: A topic to search for.
 
803
        :return: A list which is either empty or contains a single
 
804
            Command entry.
 
805
        """
 
806
        if topic and topic.startswith(self.prefix):
 
807
            topic = topic[len(self.prefix):]
 
808
        try:
 
809
            cmd = _get_cmd_object(topic)
 
810
        except KeyError:
 
811
            return []
585
812
        else:
586
 
            bzrlib.trace.log_exception()
587
 
            if os.environ.get('BZR_PDB'):
588
 
                print '**** entering debugger'
589
 
                import pdb
590
 
                pdb.post_mortem(sys.exc_traceback)
591
 
            return 3
 
813
            return [cmd]
 
814
 
592
815
 
593
816
if __name__ == '__main__':
594
817
    sys.exit(main(sys.argv))