← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/commands.py

Merge in upstream.

Show diffs side-by-side

added added

removed removed

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