/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/commands.py

  • Committer: Martin Albisetti
  • Date: 2008-03-03 17:12:37 UTC
  • mto: (3350.1.1 integration)
  • mto: This revision was merged to the branch mainline in revision 3351.
  • Revision ID: beuno@beuno-laptop-20080303171237-x3ewkoecmv1ab2ue
Core code for automatic plugin suggestion

Show diffs side-by-side

added added

removed removed

Lines of Context:
 
1
# Copyright (C) 2006 Canonical Ltd
 
2
#
 
3
# This program is free software; you can redistribute it and/or modify
 
4
# it under the terms of the GNU General Public License as published by
 
5
# the Free Software Foundation; either version 2 of the License, or
 
6
# (at your option) any later version.
 
7
#
 
8
# This program is distributed in the hope that it will be useful,
 
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
 
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
11
# GNU General Public License for more details.
 
12
#
 
13
# You should have received a copy of the GNU General Public License
 
14
# along with this program; if not, write to the Free Software
 
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
16
 
 
17
 
 
18
# TODO: probably should say which arguments are candidates for glob
 
19
# expansion on windows and do that at the command level.
 
20
 
 
21
# TODO: Define arguments by objects, rather than just using names.
 
22
# 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.
 
27
 
 
28
# TODO: "--profile=cum", to change sort order.  Is there any value in leaving
 
29
# the profile output behind so it can be interactively examined?
 
30
 
 
31
import os
 
32
import sys
 
33
 
 
34
from bzrlib.lazy_import import lazy_import
 
35
lazy_import(globals(), """
 
36
import codecs
 
37
import errno
 
38
from warnings import warn
 
39
 
 
40
import bzrlib
 
41
from bzrlib import (
 
42
    debug,
 
43
    errors,
 
44
    option,
 
45
    osutils,
 
46
    trace,
 
47
    win32utils,
 
48
    registry,
 
49
    )
 
50
""")
 
51
 
 
52
from bzrlib.symbol_versioning import (
 
53
    deprecated_function,
 
54
    deprecated_method,
 
55
    )
 
56
# Compatibility
 
57
from bzrlib.option import Option
 
58
 
 
59
 
 
60
plugin_cmds = {}
 
61
 
 
62
 
 
63
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
    """
 
71
    global plugin_cmds
 
72
    k = cmd.__name__
 
73
    if k.startswith("cmd_"):
 
74
        k_unsquished = _unsquish_command_name(k)
 
75
    else:
 
76
        k_unsquished = k
 
77
    if k_unsquished not in plugin_cmds:
 
78
        plugin_cmds[k_unsquished] = cmd
 
79
        ## trace.mutter('registered plugin command %s', k_unsquished)
 
80
        if decorate and k_unsquished in builtin_command_names():
 
81
            return _builtin_commands()[k_unsquished]
 
82
    elif decorate:
 
83
        result = plugin_cmds[k_unsquished]
 
84
        plugin_cmds[k_unsquished] = cmd
 
85
        return result
 
86
    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__])
 
91
 
 
92
 
 
93
def _squish_command_name(cmd):
 
94
    return 'cmd_' + cmd.replace('-', '_')
 
95
 
 
96
 
 
97
def _unsquish_command_name(cmd):
 
98
    assert cmd.startswith("cmd_")
 
99
    return cmd[4:].replace('_','-')
 
100
 
 
101
 
 
102
def _builtin_commands():
 
103
    import bzrlib.builtins
 
104
    r = {}
 
105
    builtins = bzrlib.builtins.__dict__
 
106
    for name in builtins:
 
107
        if name.startswith("cmd_"):
 
108
            real_name = _unsquish_command_name(name)
 
109
            r[real_name] = builtins[name]
 
110
    return r
 
111
            
 
112
 
 
113
def builtin_command_names():
 
114
    """Return list of builtin command names."""
 
115
    return _builtin_commands().keys()
 
116
    
 
117
 
 
118
def plugin_command_names():
 
119
    return plugin_cmds.keys()
 
120
 
 
121
 
 
122
def _get_cmd_dict(plugins_override=True):
 
123
    """Return name->class mapping for all commands."""
 
124
    d = _builtin_commands()
 
125
    if plugins_override:
 
126
        d.update(plugin_cmds)
 
127
    return d
 
128
 
 
129
    
 
130
def get_all_cmds(plugins_override=True):
 
131
    """Return canonical name and class for all registered commands."""
 
132
    for k, v in _get_cmd_dict(plugins_override=plugins_override).iteritems():
 
133
        yield k,v
 
134
 
 
135
 
 
136
def get_cmd_object(cmd_name, plugins_override=True):
 
137
    """Return the canonical name and command class for a command.
 
138
 
 
139
    plugins_override
 
140
        If true, plugin commands can override builtins.
 
141
    """
 
142
    try:
 
143
        return _get_cmd_object(cmd_name, plugins_override)
 
144
    except KeyError:
 
145
        raise errors.BzrCommandError('unknown command "%s"' % cmd_name)
 
146
 
 
147
 
 
148
def _get_cmd_object(cmd_name, plugins_override=True):
 
149
    """Worker for get_cmd_object which raises KeyError rather than BzrCommandError."""
 
150
    from bzrlib.externalcommand import ExternalCommand
 
151
 
 
152
    # We want only 'ascii' command names, but the user may have typed
 
153
    # in a Unicode name. In that case, they should just get a
 
154
    # 'command not found' error later.
 
155
    # In the future, we may actually support Unicode command names.
 
156
 
 
157
    # first look up this command under the specified name
 
158
    cmds = _get_cmd_dict(plugins_override=plugins_override)
 
159
    try:
 
160
        return cmds[cmd_name]()
 
161
    except KeyError:
 
162
        pass
 
163
 
 
164
    # look for any command which claims this as an alias
 
165
    for real_cmd_name, cmd_class in cmds.iteritems():
 
166
        if cmd_name in cmd_class.aliases:
 
167
            return cmd_class()
 
168
 
 
169
    cmd_obj = ExternalCommand.find_command(cmd_name)
 
170
    if cmd_obj:
 
171
        return cmd_obj
 
172
 
 
173
    # look for plugins that provide this command but aren't installed
 
174
    for provider in command_providers_registry:
 
175
        try:
 
176
            plugin_metadata = provider.plugin_for_command(cmd_name)
 
177
        except errors.NoPluginAvailable:
 
178
            pass
 
179
        else:
 
180
            raise errors.CommandAvailableInPlugin(cmd_name, plugin_metadata, provider)
 
181
 
 
182
    raise KeyError
 
183
 
 
184
 
 
185
class Command(object):
 
186
    """Base class for commands.
 
187
 
 
188
    Commands are the heart of the command-line bzr interface.
 
189
 
 
190
    The command object mostly handles the mapping of command-line
 
191
    parameters into one or more bzrlib operations, and of the results
 
192
    into textual output.
 
193
 
 
194
    Commands normally don't have any state.  All their arguments are
 
195
    passed in to the run method.  (Subclasses may take a different
 
196
    policy if the behaviour of the instance needs to depend on e.g. a
 
197
    shell plugin and not just its Python class.)
 
198
 
 
199
    The docstring for an actual command should give a single-line
 
200
    summary, then a complete description of the command.  A grammar
 
201
    description will be inserted.
 
202
 
 
203
    aliases
 
204
        Other accepted names for this command.
 
205
 
 
206
    takes_args
 
207
        List of argument forms, marked with whether they are optional,
 
208
        repeated, etc.
 
209
 
 
210
                Examples:
 
211
 
 
212
                ['to_location', 'from_branch?', 'file*']
 
213
 
 
214
                'to_location' is required
 
215
                'from_branch' is optional
 
216
                'file' can be specified 0 or more times
 
217
 
 
218
    takes_options
 
219
        List of options that may be given for this command.  These can
 
220
        be either strings, referring to globally-defined options,
 
221
        or option objects.  Retrieve through options().
 
222
 
 
223
    hidden
 
224
        If true, this command isn't advertised.  This is typically
 
225
        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
    """
 
243
    aliases = []
 
244
    takes_args = []
 
245
    takes_options = []
 
246
    encoding_type = 'strict'
 
247
 
 
248
    hidden = False
 
249
    
 
250
    def __init__(self):
 
251
        """Construct an instance of this command."""
 
252
        if self.__doc__ == Command.__doc__:
 
253
            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
                
 
286
        assert s[-1] == ' '
 
287
        s = s[:-1]
 
288
        return s
 
289
 
 
290
    def get_help_text(self, additional_see_also=None, plain=True,
 
291
                      see_also_as_links=False):
 
292
        """Return a text string with help for this command.
 
293
        
 
294
        :param additional_see_also: Additional help topics to be
 
295
            cross-referenced.
 
296
        :param plain: if False, raw help (reStructuredText) is
 
297
            returned instead of plain text.
 
298
        :param see_also_as_links: if True, convert items in 'See also'
 
299
            list to internal links (used by bzr_man rstx generator)
 
300
        """
 
301
        doc = self.help()
 
302
        if doc is None:
 
303
            raise NotImplementedError("sorry, no detailed help yet for %r" % self.name())
 
304
 
 
305
        # Extract the summary (purpose) and sections out from the text
 
306
        purpose,sections = self._get_help_parts(doc)
 
307
 
 
308
        # If a custom usage section was provided, use it
 
309
        if sections.has_key('Usage'):
 
310
            usage = sections.pop('Usage')
 
311
        else:
 
312
            usage = self._usage()
 
313
 
 
314
        # The header is the purpose and usage
 
315
        result = ""
 
316
        result += ':Purpose: %s\n' % purpose
 
317
        if usage.find('\n') >= 0:
 
318
            result += ':Usage:\n%s\n' % usage
 
319
        else:
 
320
            result += ':Usage:   %s\n' % usage
 
321
        result += '\n'
 
322
 
 
323
        # Add the options
 
324
        options = option.get_optparser(self.options()).format_option_help()
 
325
        if options.startswith('Options:'):
 
326
            result += ':' + options
 
327
        elif options.startswith('options:'):
 
328
            # Python 2.4 version of optparse
 
329
            result += ':Options:' + options[len('options:'):]
 
330
        else:
 
331
            result += options
 
332
        result += '\n'
 
333
 
 
334
        # Add the description, indenting it 2 spaces
 
335
        # to match the indentation of the options
 
336
        if sections.has_key(None):
 
337
            text = sections.pop(None)
 
338
            text = '\n  '.join(text.splitlines())
 
339
            result += ':%s:\n  %s\n\n' % ('Description',text)
 
340
 
 
341
        # Add the custom sections (e.g. Examples). Note that there's no need
 
342
        # to indent these as they must be indented already in the source.
 
343
        if sections:
 
344
            labels = sorted(sections.keys())
 
345
            for label in labels:
 
346
                result += ':%s:\n%s\n\n' % (label,sections[label])
 
347
 
 
348
        # Add the aliases, source (plug-in) and see also links, if any
 
349
        if self.aliases:
 
350
            result += ':Aliases:  '
 
351
            result += ', '.join(self.aliases) + '\n'
 
352
        plugin_name = self.plugin_name()
 
353
        if plugin_name is not None:
 
354
            result += ':From:     plugin "%s"\n' % plugin_name
 
355
        see_also = self.get_see_also(additional_see_also)
 
356
        if see_also:
 
357
            if not plain and see_also_as_links:
 
358
                see_also_links = []
 
359
                for item in see_also:
 
360
                    if item == 'topics':
 
361
                        # topics doesn't have an independent section
 
362
                        # so don't create a real link
 
363
                        see_also_links.append(item)
 
364
                    else:
 
365
                        # Use a reST link for this entry
 
366
                        see_also_links.append("`%s`_" % (item,))
 
367
                see_also = see_also_links
 
368
            result += ':See also: '
 
369
            result += ', '.join(see_also) + '\n'
 
370
 
 
371
        # If this will be rendered as plan text, convert it
 
372
        if plain:
 
373
            import bzrlib.help_topics
 
374
            result = bzrlib.help_topics.help_as_plain_text(result)
 
375
        return result
 
376
 
 
377
    @staticmethod
 
378
    def _get_help_parts(text):
 
379
        """Split help text into a summary and named sections.
 
380
 
 
381
        :return: (summary,sections) where summary is the top line and
 
382
            sections is a dictionary of the rest indexed by section name.
 
383
            A section starts with a heading line of the form ":xxx:".
 
384
            Indented text on following lines is the section value.
 
385
            All text found outside a named section is assigned to the
 
386
            default section which is given the key of None.
 
387
        """
 
388
        def save_section(sections, label, section):
 
389
            if len(section) > 0:
 
390
                if sections.has_key(label):
 
391
                    sections[label] += '\n' + section
 
392
                else:
 
393
                    sections[label] = section
 
394
            
 
395
        lines = text.rstrip().splitlines()
 
396
        summary = lines.pop(0)
 
397
        sections = {}
 
398
        label,section = None,''
 
399
        for line in lines:
 
400
            if line.startswith(':') and line.endswith(':') and len(line) > 2:
 
401
                save_section(sections, label, section)
 
402
                label,section = line[1:-1],''
 
403
            elif label != None and len(line) > 1 and not line[0].isspace():
 
404
                save_section(sections, label, section)
 
405
                label,section = None,line
 
406
            else:
 
407
                if len(section) > 0:
 
408
                    section += '\n' + line
 
409
                else:
 
410
                    section = line
 
411
        save_section(sections, label, section)
 
412
        return summary, sections
 
413
 
 
414
    def get_help_topic(self):
 
415
        """Return the commands help topic - its name."""
 
416
        return self.name()
 
417
 
 
418
    def get_see_also(self, additional_terms=None):
 
419
        """Return a list of help topics that are related to this command.
 
420
        
 
421
        The list is derived from the content of the _see_also attribute. Any
 
422
        duplicates are removed and the result is in lexical order.
 
423
        :param additional_terms: Additional help topics to cross-reference.
 
424
        :return: A list of help topics.
 
425
        """
 
426
        see_also = set(getattr(self, '_see_also', []))
 
427
        if additional_terms:
 
428
            see_also.update(additional_terms)
 
429
        return sorted(see_also)
 
430
 
 
431
    def options(self):
 
432
        """Return dict of valid options for this command.
 
433
 
 
434
        Maps from long option name to option object."""
 
435
        r = Option.STD_OPTIONS.copy()
 
436
        std_names = r.keys()
 
437
        for o in self.takes_options:
 
438
            if isinstance(o, basestring):
 
439
                o = option.Option.OPTIONS[o]
 
440
            r[o.name] = o
 
441
            if o.name in std_names:
 
442
                self.supported_std_options.append(o.name)
 
443
        return r
 
444
 
 
445
    def _setup_outf(self):
 
446
        """Return a file linked to stdout, which has proper encoding."""
 
447
        assert self.encoding_type in ['strict', 'exact', 'replace']
 
448
 
 
449
        # Originally I was using self.stdout, but that looks
 
450
        # *way* too much like sys.stdout
 
451
        if self.encoding_type == 'exact':
 
452
            # force sys.stdout to be binary stream on win32
 
453
            if sys.platform == 'win32':
 
454
                fileno = getattr(sys.stdout, 'fileno', None)
 
455
                if fileno:
 
456
                    import msvcrt
 
457
                    msvcrt.setmode(fileno(), os.O_BINARY)
 
458
            self.outf = sys.stdout
 
459
            return
 
460
 
 
461
        output_encoding = osutils.get_terminal_encoding()
 
462
 
 
463
        self.outf = codecs.getwriter(output_encoding)(sys.stdout,
 
464
                        errors=self.encoding_type)
 
465
        # For whatever reason codecs.getwriter() does not advertise its encoding
 
466
        # it just returns the encoding of the wrapped file, which is completely
 
467
        # bogus. So set the attribute, so we can find the correct encoding later.
 
468
        self.outf.encoding = output_encoding
 
469
 
 
470
    def run_argv_aliases(self, argv, alias_argv=None):
 
471
        """Parse the command line and run with extra aliases in alias_argv."""
 
472
        if argv is None:
 
473
            warn("Passing None for [] is deprecated from bzrlib 0.10",
 
474
                 DeprecationWarning, stacklevel=2)
 
475
            argv = []
 
476
        args, opts = parse_args(self, argv, alias_argv)
 
477
 
 
478
        # Process the standard options
 
479
        if 'help' in opts:  # e.g. bzr add --help
 
480
            sys.stdout.write(self.get_help_text())
 
481
            return 0
 
482
        trace.set_verbosity_level(option._verbosity_level)
 
483
        if 'verbose' in self.supported_std_options:
 
484
            opts['verbose'] = trace.is_verbose()
 
485
        elif opts.has_key('verbose'):
 
486
            del opts['verbose']
 
487
        if 'quiet' in self.supported_std_options:
 
488
            opts['quiet'] = trace.is_quiet()
 
489
        elif opts.has_key('quiet'):
 
490
            del opts['quiet']
 
491
 
 
492
        # mix arguments and options into one dictionary
 
493
        cmdargs = _match_argform(self.name(), self.takes_args, args)
 
494
        cmdopts = {}
 
495
        for k, v in opts.items():
 
496
            cmdopts[k.replace('-', '_')] = v
 
497
 
 
498
        all_cmd_args = cmdargs.copy()
 
499
        all_cmd_args.update(cmdopts)
 
500
 
 
501
        self._setup_outf()
 
502
 
 
503
        return self.run(**all_cmd_args)
 
504
    
 
505
    def run(self):
 
506
        """Actually run the command.
 
507
 
 
508
        This is invoked with the options and arguments bound to
 
509
        keyword parameters.
 
510
 
 
511
        Return 0 or None if the command was successful, or a non-zero
 
512
        shell error code if not.  It's OK for this method to allow
 
513
        an exception to raise up.
 
514
        """
 
515
        raise NotImplementedError('no implementation of command %r'
 
516
                                  % self.name())
 
517
 
 
518
    def help(self):
 
519
        """Return help message for this class."""
 
520
        from inspect import getdoc
 
521
        if self.__doc__ is Command.__doc__:
 
522
            return None
 
523
        return getdoc(self)
 
524
 
 
525
    def name(self):
 
526
        return _unsquish_command_name(self.__class__.__name__)
 
527
 
 
528
    def plugin_name(self):
 
529
        """Get the name of the plugin that provides this command.
 
530
 
 
531
        :return: The name of the plugin or None if the command is builtin.
 
532
        """
 
533
        mod_parts = self.__module__.split('.')
 
534
        if len(mod_parts) >= 3 and mod_parts[1] == 'plugins':
 
535
            return mod_parts[2]
 
536
        else:
 
537
            return None
 
538
 
 
539
 
 
540
def parse_args(command, argv, alias_argv=None):
 
541
    """Parse command line.
 
542
    
 
543
    Arguments and options are parsed at this level before being passed
 
544
    down to specific command handlers.  This routine knows, from a
 
545
    lookup table, something about the available options, what optargs
 
546
    they take, and which commands will accept them.
 
547
    """
 
548
    # TODO: make it a method of the Command?
 
549
    parser = option.get_optparser(command.options())
 
550
    if alias_argv is not None:
 
551
        args = alias_argv + argv
 
552
    else:
 
553
        args = argv
 
554
 
 
555
    options, args = parser.parse_args(args)
 
556
    opts = dict([(k, v) for k, v in options.__dict__.iteritems() if
 
557
                 v is not option.OptionParser.DEFAULT_VALUE])
 
558
    return args, opts
 
559
 
 
560
 
 
561
def _match_argform(cmd, takes_args, args):
 
562
    argdict = {}
 
563
 
 
564
    # step through args and takes_args, allowing appropriate 0-many matches
 
565
    for ap in takes_args:
 
566
        argname = ap[:-1]
 
567
        if ap[-1] == '?':
 
568
            if args:
 
569
                argdict[argname] = args.pop(0)
 
570
        elif ap[-1] == '*': # all remaining arguments
 
571
            if args:
 
572
                argdict[argname + '_list'] = args[:]
 
573
                args = []
 
574
            else:
 
575
                argdict[argname + '_list'] = None
 
576
        elif ap[-1] == '+':
 
577
            if not args:
 
578
                raise errors.BzrCommandError("command %r needs one or more %s"
 
579
                                             % (cmd, argname.upper()))
 
580
            else:
 
581
                argdict[argname + '_list'] = args[:]
 
582
                args = []
 
583
        elif ap[-1] == '$': # all but one
 
584
            if len(args) < 2:
 
585
                raise errors.BzrCommandError("command %r needs one or more %s"
 
586
                                             % (cmd, argname.upper()))
 
587
            argdict[argname + '_list'] = args[:-1]
 
588
            args[:-1] = []
 
589
        else:
 
590
            # just a plain arg
 
591
            argname = ap
 
592
            if not args:
 
593
                raise errors.BzrCommandError("command %r requires argument %s"
 
594
                               % (cmd, argname.upper()))
 
595
            else:
 
596
                argdict[argname] = args.pop(0)
 
597
            
 
598
    if args:
 
599
        raise errors.BzrCommandError("extra argument to command %s: %s"
 
600
                                     % (cmd, args[0]))
 
601
 
 
602
    return argdict
 
603
 
 
604
def apply_coveraged(dirname, the_callable, *args, **kwargs):
 
605
    # Cannot use "import trace", as that would import bzrlib.trace instead of
 
606
    # the standard library's trace.
 
607
    trace = __import__('trace')
 
608
 
 
609
    tracer = trace.Trace(count=1, trace=0)
 
610
    sys.settrace(tracer.globaltrace)
 
611
 
 
612
    ret = the_callable(*args, **kwargs)
 
613
 
 
614
    sys.settrace(None)
 
615
    results = tracer.results()
 
616
    results.write_results(show_missing=1, summary=False,
 
617
                          coverdir=dirname)
 
618
 
 
619
 
 
620
def apply_profiled(the_callable, *args, **kwargs):
 
621
    import hotshot
 
622
    import tempfile
 
623
    import hotshot.stats
 
624
    pffileno, pfname = tempfile.mkstemp()
 
625
    try:
 
626
        prof = hotshot.Profile(pfname)
 
627
        try:
 
628
            ret = prof.runcall(the_callable, *args, **kwargs) or 0
 
629
        finally:
 
630
            prof.close()
 
631
        stats = hotshot.stats.load(pfname)
 
632
        stats.strip_dirs()
 
633
        stats.sort_stats('cum')   # 'time'
 
634
        ## XXX: Might like to write to stderr or the trace file instead but
 
635
        ## print_stats seems hardcoded to stdout
 
636
        stats.print_stats(20)
 
637
        return ret
 
638
    finally:
 
639
        os.close(pffileno)
 
640
        os.remove(pfname)
 
641
 
 
642
 
 
643
def apply_lsprofiled(filename, the_callable, *args, **kwargs):
 
644
    from bzrlib.lsprof import profile
 
645
    ret, stats = profile(the_callable, *args, **kwargs)
 
646
    stats.sort()
 
647
    if filename is None:
 
648
        stats.pprint()
 
649
    else:
 
650
        stats.save(filename)
 
651
        trace.note('Profile data written to "%s".', filename)
 
652
    return ret
 
653
 
 
654
 
 
655
def shlex_split_unicode(unsplit):
 
656
    import shlex
 
657
    return [u.decode('utf-8') for u in shlex.split(unsplit.encode('utf-8'))]
 
658
 
 
659
 
 
660
def get_alias(cmd, config=None):
 
661
    """Return an expanded alias, or None if no alias exists.
 
662
 
 
663
    cmd
 
664
        Command to be checked for an alias.
 
665
    config
 
666
        Used to specify an alternative config to use,
 
667
        which is especially useful for testing.
 
668
        If it is unspecified, the global config will be used.
 
669
    """
 
670
    if config is None:
 
671
        import bzrlib.config
 
672
        config = bzrlib.config.GlobalConfig()
 
673
    alias = config.get_alias(cmd)
 
674
    if (alias):
 
675
        return shlex_split_unicode(alias)
 
676
    return None
 
677
 
 
678
 
 
679
def run_bzr(argv):
 
680
    """Execute a command.
 
681
 
 
682
    This is similar to main(), but without all the trappings for
 
683
    logging and error handling.  
 
684
    
 
685
    argv
 
686
       The command-line arguments, without the program name from argv[0]
 
687
       These should already be decoded. All library/test code calling
 
688
       run_bzr should be passing valid strings (don't need decoding).
 
689
    
 
690
    Returns a command status or raises an exception.
 
691
 
 
692
    Special master options: these must come before the command because
 
693
    they control how the command is interpreted.
 
694
 
 
695
    --no-plugins
 
696
        Do not load plugin modules at all
 
697
 
 
698
    --no-aliases
 
699
        Do not allow aliases
 
700
 
 
701
    --builtin
 
702
        Only use builtin commands.  (Plugins are still allowed to change
 
703
        other behaviour.)
 
704
 
 
705
    --profile
 
706
        Run under the Python hotshot profiler.
 
707
 
 
708
    --lsprof
 
709
        Run under the Python lsprof profiler.
 
710
 
 
711
    --coverage
 
712
        Generate line coverage report in the specified directory.
 
713
    """
 
714
    argv = list(argv)
 
715
    trace.mutter("bzr arguments: %r", argv)
 
716
 
 
717
    opt_lsprof = opt_profile = opt_no_plugins = opt_builtin =  \
 
718
                opt_no_aliases = False
 
719
    opt_lsprof_file = opt_coverage_dir = None
 
720
 
 
721
    # --no-plugins is handled specially at a very early stage. We need
 
722
    # to load plugins before doing other command parsing so that they
 
723
    # can override commands, but this needs to happen first.
 
724
 
 
725
    argv_copy = []
 
726
    i = 0
 
727
    while i < len(argv):
 
728
        a = argv[i]
 
729
        if a == '--profile':
 
730
            opt_profile = True
 
731
        elif a == '--lsprof':
 
732
            opt_lsprof = True
 
733
        elif a == '--lsprof-file':
 
734
            opt_lsprof = True
 
735
            opt_lsprof_file = argv[i + 1]
 
736
            i += 1
 
737
        elif a == '--no-plugins':
 
738
            opt_no_plugins = True
 
739
        elif a == '--no-aliases':
 
740
            opt_no_aliases = True
 
741
        elif a == '--builtin':
 
742
            opt_builtin = True
 
743
        elif a == '--coverage':
 
744
            opt_coverage_dir = argv[i + 1]
 
745
            i += 1
 
746
        elif a.startswith('-D'):
 
747
            debug.debug_flags.add(a[2:])
 
748
        else:
 
749
            argv_copy.append(a)
 
750
        i += 1
 
751
 
 
752
    argv = argv_copy
 
753
    if (not argv):
 
754
        from bzrlib.builtins import cmd_help
 
755
        cmd_help().run_argv_aliases([])
 
756
        return 0
 
757
 
 
758
    if argv[0] == '--version':
 
759
        from bzrlib.builtins import cmd_version
 
760
        cmd_version().run_argv_aliases([])
 
761
        return 0
 
762
        
 
763
    if not opt_no_plugins:
 
764
        from bzrlib.plugin import load_plugins
 
765
        load_plugins()
 
766
    else:
 
767
        from bzrlib.plugin import disable_plugins
 
768
        disable_plugins()
 
769
 
 
770
    alias_argv = None
 
771
 
 
772
    if not opt_no_aliases:
 
773
        alias_argv = get_alias(argv[0])
 
774
        if alias_argv:
 
775
            alias_argv = [a.decode(bzrlib.user_encoding) for a in alias_argv]
 
776
            argv[0] = alias_argv.pop(0)
 
777
 
 
778
    cmd = argv.pop(0)
 
779
    # We want only 'ascii' command names, but the user may have typed
 
780
    # in a Unicode name. In that case, they should just get a
 
781
    # 'command not found' error later.
 
782
 
 
783
    cmd_obj = get_cmd_object(cmd, plugins_override=not opt_builtin)
 
784
    run = cmd_obj.run_argv_aliases
 
785
    run_argv = [argv, alias_argv]
 
786
 
 
787
    try:
 
788
        if opt_lsprof:
 
789
            if opt_coverage_dir:
 
790
                trace.warning(
 
791
                    '--coverage ignored, because --lsprof is in use.')
 
792
            ret = apply_lsprofiled(opt_lsprof_file, run, *run_argv)
 
793
        elif opt_profile:
 
794
            if opt_coverage_dir:
 
795
                trace.warning(
 
796
                    '--coverage ignored, because --profile is in use.')
 
797
            ret = apply_profiled(run, *run_argv)
 
798
        elif opt_coverage_dir:
 
799
            ret = apply_coveraged(opt_coverage_dir, run, *run_argv)
 
800
        else:
 
801
            ret = run(*run_argv)
 
802
        return ret or 0
 
803
    finally:
 
804
        # reset, in case we may do other commands later within the same process
 
805
        option._verbosity_level = 0
 
806
 
 
807
def display_command(func):
 
808
    """Decorator that suppresses pipe/interrupt errors."""
 
809
    def ignore_pipe(*args, **kwargs):
 
810
        try:
 
811
            result = func(*args, **kwargs)
 
812
            sys.stdout.flush()
 
813
            return result
 
814
        except IOError, e:
 
815
            if getattr(e, 'errno', None) is None:
 
816
                raise
 
817
            if e.errno != errno.EPIPE:
 
818
                # Win32 raises IOError with errno=0 on a broken pipe
 
819
                if sys.platform != 'win32' or (e.errno not in (0, errno.EINVAL)):
 
820
                    raise
 
821
            pass
 
822
        except KeyboardInterrupt:
 
823
            pass
 
824
    return ignore_pipe
 
825
 
 
826
 
 
827
def main(argv):
 
828
    import bzrlib.ui
 
829
    from bzrlib.ui.text import TextUIFactory
 
830
    bzrlib.ui.ui_factory = TextUIFactory()
 
831
    try:
 
832
        argv = [a.decode(bzrlib.user_encoding) for a in argv[1:]]
 
833
    except UnicodeDecodeError:
 
834
        raise errors.BzrError(("Parameter '%r' is unsupported by the current "
 
835
                                                            "encoding." % a))
 
836
    ret = run_bzr_catch_errors(argv)
 
837
    trace.mutter("return code %d", ret)
 
838
    return ret
 
839
 
 
840
 
 
841
def run_bzr_catch_errors(argv):
 
842
    # Note: The except clause logic below should be kept in sync with the
 
843
    # profile() routine in lsprof.py.
 
844
    try:
 
845
        return run_bzr(argv)
 
846
    except (KeyboardInterrupt, Exception), e:
 
847
        # used to handle AssertionError and KeyboardInterrupt
 
848
        # specially here, but hopefully they're handled ok by the logger now
 
849
        exitcode = trace.report_exception(sys.exc_info(), sys.stderr)
 
850
        if os.environ.get('BZR_PDB'):
 
851
            print '**** entering debugger'
 
852
            import pdb
 
853
            pdb.post_mortem(sys.exc_traceback)
 
854
        return exitcode
 
855
 
 
856
 
 
857
def run_bzr_catch_user_errors(argv):
 
858
    """Run bzr and report user errors, but let internal errors propagate.
 
859
 
 
860
    This is used for the test suite, and might be useful for other programs
 
861
    that want to wrap the commandline interface.
 
862
    """
 
863
    try:
 
864
        return run_bzr(argv)
 
865
    except Exception, e:
 
866
        if (isinstance(e, (OSError, IOError))
 
867
            or not getattr(e, 'internal_error', True)):
 
868
            trace.report_exception(sys.exc_info(), sys.stderr)
 
869
            return 3
 
870
        else:
 
871
            raise
 
872
 
 
873
 
 
874
class HelpCommandIndex(object):
 
875
    """A index for bzr help that returns commands."""
 
876
 
 
877
    def __init__(self):
 
878
        self.prefix = 'commands/'
 
879
 
 
880
    def get_topics(self, topic):
 
881
        """Search for topic amongst commands.
 
882
 
 
883
        :param topic: A topic to search for.
 
884
        :return: A list which is either empty or contains a single
 
885
            Command entry.
 
886
        """
 
887
        if topic and topic.startswith(self.prefix):
 
888
            topic = topic[len(self.prefix):]
 
889
        try:
 
890
            cmd = _get_cmd_object(topic)
 
891
        except KeyError:
 
892
            return []
 
893
        else:
 
894
            return [cmd]
 
895
 
 
896
 
 
897
class Provider(object):
 
898
 
 
899
    def plugin_for_command(self, cmd_name):
 
900
        raise NotImplementedError
 
901
 
 
902
 
 
903
class ProvidersRegistry(registry.Registry):
 
904
    '''This registry exists to allow other providers to exist'''
 
905
    def __iter__(self):
 
906
        for key, provider in self.iteritems():
 
907
            yield provider
 
908
    pass
 
909
 
 
910
command_providers_registry = ProvidersRegistry()
 
911
 
 
912
 
 
913
if __name__ == '__main__':
 
914
    sys.exit(main(sys.argv))