/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: Robert Collins
  • Date: 2009-05-12 03:50:39 UTC
  • mto: This revision was merged to the branch mainline in revision 4593.
  • Revision ID: robertc@robertcollins.net-20090512035039-6x0pahpjpkdnm9zb
Note another possible error.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/commands.py
1
 
# Copyright (C) 2006 by Canonical Ltd
 
1
# Copyright (C) 2006, 2008 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
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
 
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
16
 
17
17
 
18
18
# TODO: probably should say which arguments are candidates for glob
28
28
# TODO: "--profile=cum", to change sort order.  Is there any value in leaving
29
29
# the profile output behind so it can be interactively examined?
30
30
 
 
31
import os
 
32
import sys
 
33
 
 
34
from bzrlib.lazy_import import lazy_import
 
35
lazy_import(globals(), """
31
36
import codecs
32
37
import errno
33
 
import os
 
38
import threading
34
39
from warnings import warn
35
 
import sys
36
40
 
37
41
import bzrlib
38
 
import bzrlib.errors as errors
39
 
from bzrlib.errors import (BzrError,
40
 
                           BzrCommandError,
41
 
                           BzrCheckError,
42
 
                           NotBranchError)
43
 
from bzrlib import option
 
42
from bzrlib import (
 
43
    debug,
 
44
    errors,
 
45
    option,
 
46
    osutils,
 
47
    trace,
 
48
    win32utils,
 
49
    )
 
50
""")
 
51
 
 
52
from bzrlib import registry
 
53
# Compatibility
 
54
from bzrlib.hooks import HookPoint, Hooks
44
55
from bzrlib.option import Option
45
 
import bzrlib.osutils
46
 
from bzrlib.symbol_versioning import (deprecated_method, zero_eight)
47
 
import bzrlib.trace
48
 
from bzrlib.trace import mutter, note, log_error, warning, be_quiet
49
 
 
50
 
plugin_cmds = {}
 
56
 
 
57
 
 
58
class CommandInfo(object):
 
59
    """Information about a command."""
 
60
 
 
61
    def __init__(self, aliases):
 
62
        """The list of aliases for the command."""
 
63
        self.aliases = aliases
 
64
 
 
65
    @classmethod
 
66
    def from_command(klass, command):
 
67
        """Factory to construct a CommandInfo from a command."""
 
68
        return klass(command.aliases)
 
69
 
 
70
 
 
71
class CommandRegistry(registry.Registry):
 
72
 
 
73
    @staticmethod
 
74
    def _get_name(command_name):
 
75
        if command_name.startswith("cmd_"):
 
76
            return _unsquish_command_name(command_name)
 
77
        else:
 
78
            return command_name
 
79
 
 
80
    def register(self, cmd, decorate=False):
 
81
        """Utility function to help register a command
 
82
 
 
83
        :param cmd: Command subclass to register
 
84
        :param decorate: If true, allow overriding an existing command
 
85
            of the same name; the old command is returned by this function.
 
86
            Otherwise it is an error to try to override an existing command.
 
87
        """
 
88
        k = cmd.__name__
 
89
        k_unsquished = self._get_name(k)
 
90
        try:
 
91
            previous = self.get(k_unsquished)
 
92
        except KeyError:
 
93
            previous = _builtin_commands().get(k_unsquished)
 
94
        info = CommandInfo.from_command(cmd)
 
95
        try:
 
96
            registry.Registry.register(self, k_unsquished, cmd,
 
97
                                       override_existing=decorate, info=info)
 
98
        except KeyError:
 
99
            trace.log_error('Two plugins defined the same command: %r' % k)
 
100
            trace.log_error('Not loading the one in %r' %
 
101
                            sys.modules[cmd.__module__])
 
102
            trace.log_error('Previously this command was registered from %r' %
 
103
                            sys.modules[previous.__module__])
 
104
        return previous
 
105
 
 
106
    def register_lazy(self, command_name, aliases, module_name):
 
107
        """Register a command without loading its module.
 
108
 
 
109
        :param command_name: The primary name of the command.
 
110
        :param aliases: A list of aliases for the command.
 
111
        :module_name: The module that the command lives in.
 
112
        """
 
113
        key = self._get_name(command_name)
 
114
        registry.Registry.register_lazy(self, key, module_name, command_name,
 
115
                                        info=CommandInfo(aliases))
 
116
 
 
117
 
 
118
plugin_cmds = CommandRegistry()
51
119
 
52
120
 
53
121
def register_command(cmd, decorate=False):
54
 
    """Utility function to help register a command
55
 
 
56
 
    :param cmd: Command subclass to register
57
 
    :param decorate: If true, allow overriding an existing command
58
 
        of the same name; the old command is returned by this function.
59
 
        Otherwise it is an error to try to override an existing command.
60
 
    """
61
122
    global plugin_cmds
62
 
    k = cmd.__name__
63
 
    if k.startswith("cmd_"):
64
 
        k_unsquished = _unsquish_command_name(k)
65
 
    else:
66
 
        k_unsquished = k
67
 
    if k_unsquished not in plugin_cmds:
68
 
        plugin_cmds[k_unsquished] = cmd
69
 
        mutter('registered plugin command %s', k_unsquished)
70
 
        if decorate and k_unsquished in builtin_command_names():
71
 
            return _builtin_commands()[k_unsquished]
72
 
    elif decorate:
73
 
        result = plugin_cmds[k_unsquished]
74
 
        plugin_cmds[k_unsquished] = cmd
75
 
        return result
76
 
    else:
77
 
        log_error('Two plugins defined the same command: %r' % k)
78
 
        log_error('Not loading the one in %r' % sys.modules[cmd.__module__])
 
123
    return plugin_cmds.register(cmd, decorate)
79
124
 
80
125
 
81
126
def _squish_command_name(cmd):
83
128
 
84
129
 
85
130
def _unsquish_command_name(cmd):
86
 
    assert cmd.startswith("cmd_")
87
131
    return cmd[4:].replace('_','-')
88
132
 
89
133
 
96
140
            real_name = _unsquish_command_name(name)
97
141
            r[real_name] = builtins[name]
98
142
    return r
99
 
            
 
143
 
100
144
 
101
145
def builtin_command_names():
102
146
    """Return list of builtin command names."""
103
147
    return _builtin_commands().keys()
104
 
    
 
148
 
105
149
 
106
150
def plugin_command_names():
107
151
    return plugin_cmds.keys()
111
155
    """Return name->class mapping for all commands."""
112
156
    d = _builtin_commands()
113
157
    if plugins_override:
114
 
        d.update(plugin_cmds)
 
158
        d.update(plugin_cmds.iteritems())
115
159
    return d
116
160
 
117
 
    
 
161
 
118
162
def get_all_cmds(plugins_override=True):
119
163
    """Return canonical name and class for all registered commands."""
120
164
    for k, v in _get_cmd_dict(plugins_override=plugins_override).iteritems():
127
171
    plugins_override
128
172
        If true, plugin commands can override builtins.
129
173
    """
 
174
    try:
 
175
        cmd = _get_cmd_object(cmd_name, plugins_override)
 
176
        # Allow plugins to extend commands
 
177
        for hook in Command.hooks['extend_command']:
 
178
            hook(cmd)
 
179
        return cmd
 
180
    except KeyError:
 
181
        raise errors.BzrCommandError('unknown command "%s"' % cmd_name)
 
182
 
 
183
 
 
184
def _get_cmd_object(cmd_name, plugins_override=True):
 
185
    """Worker for get_cmd_object which raises KeyError rather than BzrCommandError."""
130
186
    from bzrlib.externalcommand import ExternalCommand
131
187
 
132
188
    # We want only 'ascii' command names, but the user may have typed
135
191
    # In the future, we may actually support Unicode command names.
136
192
 
137
193
    # first look up this command under the specified name
138
 
    cmds = _get_cmd_dict(plugins_override=plugins_override)
 
194
    if plugins_override:
 
195
        try:
 
196
            return plugin_cmds.get(cmd_name)()
 
197
        except KeyError:
 
198
            pass
 
199
    cmds = _get_cmd_dict(plugins_override=False)
139
200
    try:
140
201
        return cmds[cmd_name]()
141
202
    except KeyError:
142
203
        pass
143
 
 
 
204
    if plugins_override:
 
205
        for key in plugin_cmds.keys():
 
206
            info = plugin_cmds.get_info(key)
 
207
            if cmd_name in info.aliases:
 
208
                return plugin_cmds.get(key)()
144
209
    # look for any command which claims this as an alias
145
210
    for real_cmd_name, cmd_class in cmds.iteritems():
146
211
        if cmd_name in cmd_class.aliases:
150
215
    if cmd_obj:
151
216
        return cmd_obj
152
217
 
153
 
    raise BzrCommandError('unknown command "%s"' % cmd_name)
 
218
    # look for plugins that provide this command but aren't installed
 
219
    for provider in command_providers_registry:
 
220
        try:
 
221
            plugin_metadata = provider.plugin_for_command(cmd_name)
 
222
        except errors.NoPluginAvailable:
 
223
            pass
 
224
        else:
 
225
            raise errors.CommandAvailableInPlugin(cmd_name,
 
226
                                                  plugin_metadata, provider)
 
227
    raise KeyError
154
228
 
155
229
 
156
230
class Command(object):
204
278
            replace - put in a bogus character (typically '?')
205
279
            exact - do not encode sys.stdout
206
280
 
 
281
            NOTE: by default on Windows, sys.stdout is opened as a text
 
282
            stream, therefore LF line-endings are converted to CRLF.
 
283
            When a command uses encoding_type = 'exact', then
 
284
            sys.stdout is forced to be a binary stream, and line-endings
 
285
            will not mangled.
 
286
 
 
287
    :cvar hooks: An instance of CommandHooks.
207
288
    """
208
289
    aliases = []
209
290
    takes_args = []
211
292
    encoding_type = 'strict'
212
293
 
213
294
    hidden = False
214
 
    
 
295
 
215
296
    def __init__(self):
216
297
        """Construct an instance of this command."""
217
298
        if self.__doc__ == Command.__doc__:
218
299
            warn("No help message set for %r" % self)
 
300
        # List of standard options directly supported
 
301
        self.supported_std_options = []
 
302
 
 
303
    def _maybe_expand_globs(self, file_list):
 
304
        """Glob expand file_list if the platform does not do that itself.
 
305
 
 
306
        :return: A possibly empty list of unicode paths.
 
307
 
 
308
        Introduced in bzrlib 0.18.
 
309
        """
 
310
        if not file_list:
 
311
            file_list = []
 
312
        if sys.platform == 'win32':
 
313
            file_list = win32utils.glob_expand(file_list)
 
314
        return list(file_list)
 
315
 
 
316
    def _usage(self):
 
317
        """Return single-line grammar for this command.
 
318
 
 
319
        Only describes arguments, not options.
 
320
        """
 
321
        s = 'bzr ' + self.name() + ' '
 
322
        for aname in self.takes_args:
 
323
            aname = aname.upper()
 
324
            if aname[-1] in ['$', '+']:
 
325
                aname = aname[:-1] + '...'
 
326
            elif aname[-1] == '?':
 
327
                aname = '[' + aname[:-1] + ']'
 
328
            elif aname[-1] == '*':
 
329
                aname = '[' + aname[:-1] + '...]'
 
330
            s += aname + ' '
 
331
        s = s[:-1]      # remove last space
 
332
        return s
 
333
 
 
334
    def get_help_text(self, additional_see_also=None, plain=True,
 
335
                      see_also_as_links=False, verbose=True):
 
336
        """Return a text string with help for this command.
 
337
 
 
338
        :param additional_see_also: Additional help topics to be
 
339
            cross-referenced.
 
340
        :param plain: if False, raw help (reStructuredText) is
 
341
            returned instead of plain text.
 
342
        :param see_also_as_links: if True, convert items in 'See also'
 
343
            list to internal links (used by bzr_man rstx generator)
 
344
        :param verbose: if True, display the full help, otherwise
 
345
            leave out the descriptive sections and just display
 
346
            usage help (e.g. Purpose, Usage, Options) with a
 
347
            message explaining how to obtain full help.
 
348
        """
 
349
        doc = self.help()
 
350
        if doc is None:
 
351
            raise NotImplementedError("sorry, no detailed help yet for %r" % self.name())
 
352
 
 
353
        # Extract the summary (purpose) and sections out from the text
 
354
        purpose,sections,order = self._get_help_parts(doc)
 
355
 
 
356
        # If a custom usage section was provided, use it
 
357
        if sections.has_key('Usage'):
 
358
            usage = sections.pop('Usage')
 
359
        else:
 
360
            usage = self._usage()
 
361
 
 
362
        # The header is the purpose and usage
 
363
        result = ""
 
364
        result += ':Purpose: %s\n' % purpose
 
365
        if usage.find('\n') >= 0:
 
366
            result += ':Usage:\n%s\n' % usage
 
367
        else:
 
368
            result += ':Usage:   %s\n' % usage
 
369
        result += '\n'
 
370
 
 
371
        # Add the options
 
372
        options = option.get_optparser(self.options()).format_option_help()
 
373
        if options.startswith('Options:'):
 
374
            result += ':' + options
 
375
        elif options.startswith('options:'):
 
376
            # Python 2.4 version of optparse
 
377
            result += ':Options:' + options[len('options:'):]
 
378
        else:
 
379
            result += options
 
380
        result += '\n'
 
381
 
 
382
        if verbose:
 
383
            # Add the description, indenting it 2 spaces
 
384
            # to match the indentation of the options
 
385
            if sections.has_key(None):
 
386
                text = sections.pop(None)
 
387
                text = '\n  '.join(text.splitlines())
 
388
                result += ':%s:\n  %s\n\n' % ('Description',text)
 
389
 
 
390
            # Add the custom sections (e.g. Examples). Note that there's no need
 
391
            # to indent these as they must be indented already in the source.
 
392
            if sections:
 
393
                for label in order:
 
394
                    if sections.has_key(label):
 
395
                        result += ':%s:\n%s\n' % (label,sections[label])
 
396
                result += '\n'
 
397
        else:
 
398
            result += ("See bzr help %s for more details and examples.\n\n"
 
399
                % self.name())
 
400
 
 
401
        # Add the aliases, source (plug-in) and see also links, if any
 
402
        if self.aliases:
 
403
            result += ':Aliases:  '
 
404
            result += ', '.join(self.aliases) + '\n'
 
405
        plugin_name = self.plugin_name()
 
406
        if plugin_name is not None:
 
407
            result += ':From:     plugin "%s"\n' % plugin_name
 
408
        see_also = self.get_see_also(additional_see_also)
 
409
        if see_also:
 
410
            if not plain and see_also_as_links:
 
411
                see_also_links = []
 
412
                for item in see_also:
 
413
                    if item == 'topics':
 
414
                        # topics doesn't have an independent section
 
415
                        # so don't create a real link
 
416
                        see_also_links.append(item)
 
417
                    else:
 
418
                        # Use a reST link for this entry
 
419
                        see_also_links.append("`%s`_" % (item,))
 
420
                see_also = see_also_links
 
421
            result += ':See also: '
 
422
            result += ', '.join(see_also) + '\n'
 
423
 
 
424
        # If this will be rendered as plain text, convert it
 
425
        if plain:
 
426
            import bzrlib.help_topics
 
427
            result = bzrlib.help_topics.help_as_plain_text(result)
 
428
        return result
 
429
 
 
430
    @staticmethod
 
431
    def _get_help_parts(text):
 
432
        """Split help text into a summary and named sections.
 
433
 
 
434
        :return: (summary,sections,order) where summary is the top line and
 
435
            sections is a dictionary of the rest indexed by section name.
 
436
            order is the order the section appear in the text.
 
437
            A section starts with a heading line of the form ":xxx:".
 
438
            Indented text on following lines is the section value.
 
439
            All text found outside a named section is assigned to the
 
440
            default section which is given the key of None.
 
441
        """
 
442
        def save_section(sections, order, label, section):
 
443
            if len(section) > 0:
 
444
                if sections.has_key(label):
 
445
                    sections[label] += '\n' + section
 
446
                else:
 
447
                    order.append(label)
 
448
                    sections[label] = section
 
449
 
 
450
        lines = text.rstrip().splitlines()
 
451
        summary = lines.pop(0)
 
452
        sections = {}
 
453
        order = []
 
454
        label,section = None,''
 
455
        for line in lines:
 
456
            if line.startswith(':') and line.endswith(':') and len(line) > 2:
 
457
                save_section(sections, order, label, section)
 
458
                label,section = line[1:-1],''
 
459
            elif (label is not None) and len(line) > 1 and not line[0].isspace():
 
460
                save_section(sections, order, label, section)
 
461
                label,section = None,line
 
462
            else:
 
463
                if len(section) > 0:
 
464
                    section += '\n' + line
 
465
                else:
 
466
                    section = line
 
467
        save_section(sections, order, label, section)
 
468
        return summary, sections, order
 
469
 
 
470
    def get_help_topic(self):
 
471
        """Return the commands help topic - its name."""
 
472
        return self.name()
 
473
 
 
474
    def get_see_also(self, additional_terms=None):
 
475
        """Return a list of help topics that are related to this command.
 
476
 
 
477
        The list is derived from the content of the _see_also attribute. Any
 
478
        duplicates are removed and the result is in lexical order.
 
479
        :param additional_terms: Additional help topics to cross-reference.
 
480
        :return: A list of help topics.
 
481
        """
 
482
        see_also = set(getattr(self, '_see_also', []))
 
483
        if additional_terms:
 
484
            see_also.update(additional_terms)
 
485
        return sorted(see_also)
219
486
 
220
487
    def options(self):
221
488
        """Return dict of valid options for this command.
222
489
 
223
490
        Maps from long option name to option object."""
224
 
        r = dict()
225
 
        r['help'] = Option.OPTIONS['help']
 
491
        r = Option.STD_OPTIONS.copy()
 
492
        std_names = r.keys()
226
493
        for o in self.takes_options:
227
494
            if isinstance(o, basestring):
228
 
                o = Option.OPTIONS[o]
 
495
                o = option.Option.OPTIONS[o]
229
496
            r[o.name] = o
 
497
            if o.name in std_names:
 
498
                self.supported_std_options.append(o.name)
230
499
        return r
231
500
 
232
501
    def _setup_outf(self):
233
502
        """Return a file linked to stdout, which has proper encoding."""
234
 
        assert self.encoding_type in ['strict', 'exact', 'replace']
235
 
 
236
503
        # Originally I was using self.stdout, but that looks
237
504
        # *way* too much like sys.stdout
238
505
        if self.encoding_type == 'exact':
 
506
            # force sys.stdout to be binary stream on win32
 
507
            if sys.platform == 'win32':
 
508
                fileno = getattr(sys.stdout, 'fileno', None)
 
509
                if fileno:
 
510
                    import msvcrt
 
511
                    msvcrt.setmode(fileno(), os.O_BINARY)
239
512
            self.outf = sys.stdout
240
513
            return
241
514
 
242
 
        output_encoding = bzrlib.osutils.get_terminal_encoding()
 
515
        output_encoding = osutils.get_terminal_encoding()
243
516
 
244
 
        # use 'replace' so that we don't abort if trying to write out
245
 
        # in e.g. the default C locale.
246
 
        self.outf = codecs.getwriter(output_encoding)(sys.stdout, errors=self.encoding_type)
 
517
        self.outf = codecs.getwriter(output_encoding)(sys.stdout,
 
518
                        errors=self.encoding_type)
247
519
        # For whatever reason codecs.getwriter() does not advertise its encoding
248
520
        # it just returns the encoding of the wrapped file, which is completely
249
521
        # bogus. So set the attribute, so we can find the correct encoding later.
250
522
        self.outf.encoding = output_encoding
251
523
 
252
 
    @deprecated_method(zero_eight)
253
 
    def run_argv(self, argv):
254
 
        """Parse command line and run.
255
 
        
256
 
        See run_argv_aliases for the 0.8 and beyond api.
257
 
        """
258
 
        return self.run_argv_aliases(argv)
259
 
 
260
524
    def run_argv_aliases(self, argv, alias_argv=None):
261
525
        """Parse the command line and run with extra aliases in alias_argv."""
262
526
        if argv is None:
263
 
            warn("Passing None for [] is deprecated from bzrlib 0.10", 
 
527
            warn("Passing None for [] is deprecated from bzrlib 0.10",
264
528
                 DeprecationWarning, stacklevel=2)
265
529
            argv = []
266
530
        args, opts = parse_args(self, argv, alias_argv)
 
531
 
 
532
        # Process the standard options
267
533
        if 'help' in opts:  # e.g. bzr add --help
268
 
            from bzrlib.help import help_on_command
269
 
            help_on_command(self.name())
270
 
            return 0
 
534
            sys.stdout.write(self.get_help_text())
 
535
            return 0
 
536
        if 'usage' in opts:  # e.g. bzr add --usage
 
537
            sys.stdout.write(self.get_help_text(verbose=False))
 
538
            return 0
 
539
        trace.set_verbosity_level(option._verbosity_level)
 
540
        if 'verbose' in self.supported_std_options:
 
541
            opts['verbose'] = trace.is_verbose()
 
542
        elif opts.has_key('verbose'):
 
543
            del opts['verbose']
 
544
        if 'quiet' in self.supported_std_options:
 
545
            opts['quiet'] = trace.is_quiet()
 
546
        elif opts.has_key('quiet'):
 
547
            del opts['quiet']
 
548
 
271
549
        # mix arguments and options into one dictionary
272
550
        cmdargs = _match_argform(self.name(), self.takes_args, args)
273
551
        cmdopts = {}
280
558
        self._setup_outf()
281
559
 
282
560
        return self.run(**all_cmd_args)
283
 
    
 
561
 
284
562
    def run(self):
285
563
        """Actually run the command.
286
564
 
291
569
        shell error code if not.  It's OK for this method to allow
292
570
        an exception to raise up.
293
571
        """
294
 
        raise NotImplementedError('no implementation of command %r' 
 
572
        raise NotImplementedError('no implementation of command %r'
295
573
                                  % self.name())
296
574
 
297
575
    def help(self):
316
594
            return None
317
595
 
318
596
 
319
 
def parse_spec(spec):
320
 
    """
321
 
    >>> parse_spec(None)
322
 
    [None, None]
323
 
    >>> parse_spec("./")
324
 
    ['./', None]
325
 
    >>> parse_spec("../@")
326
 
    ['..', -1]
327
 
    >>> parse_spec("../f/@35")
328
 
    ['../f', 35]
329
 
    >>> parse_spec('./@revid:john@arbash-meinel.com-20050711044610-3ca0327c6a222f67')
330
 
    ['.', 'revid:john@arbash-meinel.com-20050711044610-3ca0327c6a222f67']
331
 
    """
332
 
    if spec is None:
333
 
        return [None, None]
334
 
    if '/@' in spec:
335
 
        parsed = spec.split('/@')
336
 
        assert len(parsed) == 2
337
 
        if parsed[1] == "":
338
 
            parsed[1] = -1
339
 
        else:
340
 
            try:
341
 
                parsed[1] = int(parsed[1])
342
 
            except ValueError:
343
 
                pass # We can allow stuff like ./@revid:blahblahblah
344
 
            else:
345
 
                assert parsed[1] >=0
346
 
    else:
347
 
        parsed = [spec, None]
348
 
    return parsed
 
597
class CommandHooks(Hooks):
 
598
    """Hooks related to Command object creation/enumeration."""
 
599
 
 
600
    def __init__(self):
 
601
        """Create the default hooks.
 
602
 
 
603
        These are all empty initially, because by default nothing should get
 
604
        notified.
 
605
        """
 
606
        Hooks.__init__(self)
 
607
        self.create_hook(HookPoint('extend_command',
 
608
            "Called after creating a command object to allow modifications "
 
609
            "such as adding or removing options, docs etc. Called with the "
 
610
            "new bzrlib.commands.Command object.", (1, 13), None))
 
611
 
 
612
Command.hooks = CommandHooks()
 
613
 
349
614
 
350
615
def parse_args(command, argv, alias_argv=None):
351
616
    """Parse command line.
352
 
    
 
617
 
353
618
    Arguments and options are parsed at this level before being passed
354
619
    down to specific command handlers.  This routine knows, from a
355
620
    lookup table, something about the available options, what optargs
363
628
        args = argv
364
629
 
365
630
    options, args = parser.parse_args(args)
366
 
    opts = dict([(k, v) for k, v in options.__dict__.iteritems() if 
 
631
    opts = dict([(k, v) for k, v in options.__dict__.iteritems() if
367
632
                 v is not option.OptionParser.DEFAULT_VALUE])
368
633
    return args, opts
369
634
 
385
650
                argdict[argname + '_list'] = None
386
651
        elif ap[-1] == '+':
387
652
            if not args:
388
 
                raise BzrCommandError("command %r needs one or more %s"
389
 
                        % (cmd, argname.upper()))
 
653
                raise errors.BzrCommandError("command %r needs one or more %s"
 
654
                                             % (cmd, argname.upper()))
390
655
            else:
391
656
                argdict[argname + '_list'] = args[:]
392
657
                args = []
393
658
        elif ap[-1] == '$': # all but one
394
659
            if len(args) < 2:
395
 
                raise BzrCommandError("command %r needs one or more %s"
396
 
                        % (cmd, argname.upper()))
 
660
                raise errors.BzrCommandError("command %r needs one or more %s"
 
661
                                             % (cmd, argname.upper()))
397
662
            argdict[argname + '_list'] = args[:-1]
398
663
            args[:-1] = []
399
664
        else:
400
665
            # just a plain arg
401
666
            argname = ap
402
667
            if not args:
403
 
                raise BzrCommandError("command %r requires argument %s"
404
 
                        % (cmd, argname.upper()))
 
668
                raise errors.BzrCommandError("command %r requires argument %s"
 
669
                               % (cmd, argname.upper()))
405
670
            else:
406
671
                argdict[argname] = args.pop(0)
407
 
            
 
672
 
408
673
    if args:
409
 
        raise BzrCommandError("extra argument to command %s: %s"
410
 
                              % (cmd, args[0]))
 
674
        raise errors.BzrCommandError("extra argument to command %s: %s"
 
675
                                     % (cmd, args[0]))
411
676
 
412
677
    return argdict
413
678
 
 
679
def apply_coveraged(dirname, the_callable, *args, **kwargs):
 
680
    # Cannot use "import trace", as that would import bzrlib.trace instead of
 
681
    # the standard library's trace.
 
682
    trace = __import__('trace')
 
683
 
 
684
    tracer = trace.Trace(count=1, trace=0)
 
685
    sys.settrace(tracer.globaltrace)
 
686
    threading.settrace(tracer.globaltrace)
 
687
 
 
688
    try:
 
689
        return exception_to_return_code(the_callable, *args, **kwargs)
 
690
    finally:
 
691
        sys.settrace(None)
 
692
        results = tracer.results()
 
693
        results.write_results(show_missing=1, summary=False,
 
694
                              coverdir=dirname)
414
695
 
415
696
 
416
697
def apply_profiled(the_callable, *args, **kwargs):
421
702
    try:
422
703
        prof = hotshot.Profile(pfname)
423
704
        try:
424
 
            ret = prof.runcall(the_callable, *args, **kwargs) or 0
 
705
            ret = prof.runcall(exception_to_return_code, the_callable, *args,
 
706
                **kwargs) or 0
425
707
        finally:
426
708
            prof.close()
427
709
        stats = hotshot.stats.load(pfname)
436
718
        os.remove(pfname)
437
719
 
438
720
 
 
721
def exception_to_return_code(the_callable, *args, **kwargs):
 
722
    """UI level helper for profiling and coverage.
 
723
 
 
724
    This transforms exceptions into a return value of 3. As such its only
 
725
    relevant to the UI layer, and should never be called where catching
 
726
    exceptions may be desirable.
 
727
    """
 
728
    try:
 
729
        return the_callable(*args, **kwargs)
 
730
    except (KeyboardInterrupt, Exception), e:
 
731
        # used to handle AssertionError and KeyboardInterrupt
 
732
        # specially here, but hopefully they're handled ok by the logger now
 
733
        exc_info = sys.exc_info()
 
734
        exitcode = trace.report_exception(exc_info, sys.stderr)
 
735
        if os.environ.get('BZR_PDB'):
 
736
            print '**** entering debugger'
 
737
            tb = exc_info[2]
 
738
            import pdb
 
739
            if sys.version_info[:2] < (2, 6):
 
740
                # XXX: we want to do
 
741
                #    pdb.post_mortem(tb)
 
742
                # but because pdb.post_mortem gives bad results for tracebacks
 
743
                # from inside generators, we do it manually.
 
744
                # (http://bugs.python.org/issue4150, fixed in Python 2.6)
 
745
 
 
746
                # Setup pdb on the traceback
 
747
                p = pdb.Pdb()
 
748
                p.reset()
 
749
                p.setup(tb.tb_frame, tb)
 
750
                # Point the debugger at the deepest frame of the stack
 
751
                p.curindex = len(p.stack) - 1
 
752
                p.curframe = p.stack[p.curindex][0]
 
753
                # Start the pdb prompt.
 
754
                p.print_stack_entry(p.stack[p.curindex])
 
755
                p.execRcLines()
 
756
                p.cmdloop()
 
757
            else:
 
758
                pdb.post_mortem(tb)
 
759
        return exitcode
 
760
 
 
761
 
439
762
def apply_lsprofiled(filename, the_callable, *args, **kwargs):
440
763
    from bzrlib.lsprof import profile
441
 
    import cPickle
442
 
    ret, stats = profile(the_callable, *args, **kwargs)
 
764
    ret, stats = profile(exception_to_return_code, the_callable, *args, **kwargs)
443
765
    stats.sort()
444
766
    if filename is None:
445
767
        stats.pprint()
446
768
    else:
447
 
        stats.freeze()
448
 
        cPickle.dump(stats, open(filename, 'w'), 2)
449
 
        print 'Profile data written to %r.' % filename
 
769
        stats.save(filename)
 
770
        trace.note('Profile data written to "%s".', filename)
450
771
    return ret
451
772
 
452
773
 
453
 
def get_alias(cmd):
454
 
    """Return an expanded alias, or None if no alias exists"""
455
 
    import bzrlib.config
456
 
    alias = bzrlib.config.GlobalConfig().get_alias(cmd)
 
774
def shlex_split_unicode(unsplit):
 
775
    import shlex
 
776
    return [u.decode('utf-8') for u in shlex.split(unsplit.encode('utf-8'))]
 
777
 
 
778
 
 
779
def get_alias(cmd, config=None):
 
780
    """Return an expanded alias, or None if no alias exists.
 
781
 
 
782
    cmd
 
783
        Command to be checked for an alias.
 
784
    config
 
785
        Used to specify an alternative config to use,
 
786
        which is especially useful for testing.
 
787
        If it is unspecified, the global config will be used.
 
788
    """
 
789
    if config is None:
 
790
        import bzrlib.config
 
791
        config = bzrlib.config.GlobalConfig()
 
792
    alias = config.get_alias(cmd)
457
793
    if (alias):
458
 
        return alias.split(' ')
 
794
        return shlex_split_unicode(alias)
459
795
    return None
460
796
 
461
797
 
462
798
def run_bzr(argv):
463
799
    """Execute a command.
464
800
 
465
 
    This is similar to main(), but without all the trappings for
466
 
    logging and error handling.  
467
 
    
468
801
    argv
469
802
       The command-line arguments, without the program name from argv[0]
470
803
       These should already be decoded. All library/test code calling
471
804
       run_bzr should be passing valid strings (don't need decoding).
472
 
    
 
805
 
473
806
    Returns a command status or raises an exception.
474
807
 
475
808
    Special master options: these must come before the command because
490
823
 
491
824
    --lsprof
492
825
        Run under the Python lsprof profiler.
 
826
 
 
827
    --coverage
 
828
        Generate line coverage report in the specified directory.
493
829
    """
494
830
    argv = list(argv)
 
831
    trace.mutter("bzr arguments: %r", argv)
495
832
 
496
833
    opt_lsprof = opt_profile = opt_no_plugins = opt_builtin =  \
497
834
                opt_no_aliases = False
498
 
    opt_lsprof_file = None
 
835
    opt_lsprof_file = opt_coverage_dir = None
499
836
 
500
837
    # --no-plugins is handled specially at a very early stage. We need
501
838
    # to load plugins before doing other command parsing so that they
519
856
            opt_no_aliases = True
520
857
        elif a == '--builtin':
521
858
            opt_builtin = True
522
 
        elif a in ('--quiet', '-q'):
523
 
            be_quiet()
 
859
        elif a == '--coverage':
 
860
            opt_coverage_dir = argv[i + 1]
 
861
            i += 1
 
862
        elif a.startswith('-D'):
 
863
            debug.debug_flags.add(a[2:])
524
864
        else:
525
865
            argv_copy.append(a)
526
866
        i += 1
527
867
 
 
868
    debug.set_debug_flags_from_config()
 
869
 
528
870
    argv = argv_copy
529
871
    if (not argv):
530
872
        from bzrlib.builtins import cmd_help
532
874
        return 0
533
875
 
534
876
    if argv[0] == '--version':
535
 
        from bzrlib.version import show_version
536
 
        show_version()
 
877
        from bzrlib.builtins import cmd_version
 
878
        cmd_version().run_argv_aliases([])
537
879
        return 0
538
 
        
 
880
 
539
881
    if not opt_no_plugins:
540
882
        from bzrlib.plugin import load_plugins
541
883
        load_plugins()
548
890
    if not opt_no_aliases:
549
891
        alias_argv = get_alias(argv[0])
550
892
        if alias_argv:
551
 
            alias_argv = [a.decode(bzrlib.user_encoding) for a in alias_argv]
 
893
            user_encoding = osutils.get_user_encoding()
 
894
            alias_argv = [a.decode(user_encoding) for a in alias_argv]
552
895
            argv[0] = alias_argv.pop(0)
553
896
 
554
897
    cmd = argv.pop(0)
557
900
    # 'command not found' error later.
558
901
 
559
902
    cmd_obj = get_cmd_object(cmd, plugins_override=not opt_builtin)
560
 
    if not getattr(cmd_obj.run_argv, 'is_deprecated', False):
561
 
        run = cmd_obj.run_argv
562
 
        run_argv = [argv]
563
 
    else:
564
 
        run = cmd_obj.run_argv_aliases
565
 
        run_argv = [argv, alias_argv]
 
903
    run = cmd_obj.run_argv_aliases
 
904
    run_argv = [argv, alias_argv]
566
905
 
567
906
    try:
 
907
        # We can be called recursively (tests for example), but we don't want
 
908
        # the verbosity level to propagate.
 
909
        saved_verbosity_level = option._verbosity_level
 
910
        option._verbosity_level = 0
568
911
        if opt_lsprof:
 
912
            if opt_coverage_dir:
 
913
                trace.warning(
 
914
                    '--coverage ignored, because --lsprof is in use.')
569
915
            ret = apply_lsprofiled(opt_lsprof_file, run, *run_argv)
570
916
        elif opt_profile:
 
917
            if opt_coverage_dir:
 
918
                trace.warning(
 
919
                    '--coverage ignored, because --profile is in use.')
571
920
            ret = apply_profiled(run, *run_argv)
 
921
        elif opt_coverage_dir:
 
922
            ret = apply_coveraged(opt_coverage_dir, run, *run_argv)
572
923
        else:
573
924
            ret = run(*run_argv)
 
925
        if 'memory' in debug.debug_flags:
 
926
            trace.debug_memory('Process status after command:', short=False)
574
927
        return ret or 0
575
928
    finally:
576
 
        # reset, in case we may do other commands later within the same process
577
 
        be_quiet(False)
 
929
        # reset, in case we may do other commands later within the same
 
930
        # process. Commands that want to execute sub-commands must propagate
 
931
        # --verbose in their own way.
 
932
        option._verbosity_level = saved_verbosity_level
 
933
 
578
934
 
579
935
def display_command(func):
580
936
    """Decorator that suppresses pipe/interrupt errors."""
588
944
                raise
589
945
            if e.errno != errno.EPIPE:
590
946
                # Win32 raises IOError with errno=0 on a broken pipe
591
 
                if sys.platform != 'win32' or e.errno != 0:
 
947
                if sys.platform != 'win32' or (e.errno not in (0, errno.EINVAL)):
592
948
                    raise
593
949
            pass
594
950
        except KeyboardInterrupt:
598
954
 
599
955
def main(argv):
600
956
    import bzrlib.ui
601
 
    from bzrlib.ui.text import TextUIFactory
602
 
    bzrlib.ui.ui_factory = TextUIFactory()
603
 
    argv = [a.decode(bzrlib.user_encoding) for a in argv[1:]]
 
957
    bzrlib.ui.ui_factory = bzrlib.ui.make_ui_for_terminal(
 
958
        sys.stdin, sys.stdout, sys.stderr)
 
959
 
 
960
    # Is this a final release version? If so, we should suppress warnings
 
961
    if bzrlib.version_info[3] == 'final':
 
962
        from bzrlib import symbol_versioning
 
963
        symbol_versioning.suppress_deprecation_warnings(override=False)
 
964
    try:
 
965
        user_encoding = osutils.get_user_encoding()
 
966
        argv = [a.decode(user_encoding) for a in argv[1:]]
 
967
    except UnicodeDecodeError:
 
968
        raise errors.BzrError(("Parameter '%r' is unsupported by the current "
 
969
                                                            "encoding." % a))
604
970
    ret = run_bzr_catch_errors(argv)
605
 
    mutter("return code %d", ret)
 
971
    trace.mutter("return code %d", ret)
606
972
    return ret
607
973
 
608
974
 
609
975
def run_bzr_catch_errors(argv):
 
976
    """Run a bzr command with parameters as described by argv.
 
977
 
 
978
    This function assumed that that UI layer is setup, that symbol deprecations
 
979
    are already applied, and that unicode decoding has already been performed on argv.
 
980
    """
 
981
    return exception_to_return_code(run_bzr, argv)
 
982
 
 
983
 
 
984
def run_bzr_catch_user_errors(argv):
 
985
    """Run bzr and report user errors, but let internal errors propagate.
 
986
 
 
987
    This is used for the test suite, and might be useful for other programs
 
988
    that want to wrap the commandline interface.
 
989
    """
610
990
    try:
611
991
        return run_bzr(argv)
612
 
        # do this here inside the exception wrappers to catch EPIPE
613
 
        sys.stdout.flush()
614
992
    except Exception, e:
615
 
        # used to handle AssertionError and KeyboardInterrupt
616
 
        # specially here, but hopefully they're handled ok by the logger now
617
 
        bzrlib.trace.report_exception(sys.exc_info(), sys.stderr)
618
 
        if os.environ.get('BZR_PDB'):
619
 
            print '**** entering debugger'
620
 
            import pdb
621
 
            pdb.post_mortem(sys.exc_traceback)
622
 
        return 3
 
993
        if (isinstance(e, (OSError, IOError))
 
994
            or not getattr(e, 'internal_error', True)):
 
995
            trace.report_exception(sys.exc_info(), sys.stderr)
 
996
            return 3
 
997
        else:
 
998
            raise
 
999
 
 
1000
 
 
1001
class HelpCommandIndex(object):
 
1002
    """A index for bzr help that returns commands."""
 
1003
 
 
1004
    def __init__(self):
 
1005
        self.prefix = 'commands/'
 
1006
 
 
1007
    def get_topics(self, topic):
 
1008
        """Search for topic amongst commands.
 
1009
 
 
1010
        :param topic: A topic to search for.
 
1011
        :return: A list which is either empty or contains a single
 
1012
            Command entry.
 
1013
        """
 
1014
        if topic and topic.startswith(self.prefix):
 
1015
            topic = topic[len(self.prefix):]
 
1016
        try:
 
1017
            cmd = _get_cmd_object(topic)
 
1018
        except KeyError:
 
1019
            return []
 
1020
        else:
 
1021
            return [cmd]
 
1022
 
 
1023
 
 
1024
class Provider(object):
 
1025
    '''Generic class to be overriden by plugins'''
 
1026
 
 
1027
    def plugin_for_command(self, cmd_name):
 
1028
        '''Takes a command and returns the information for that plugin
 
1029
 
 
1030
        :return: A dictionary with all the available information
 
1031
        for the requested plugin
 
1032
        '''
 
1033
        raise NotImplementedError
 
1034
 
 
1035
 
 
1036
class ProvidersRegistry(registry.Registry):
 
1037
    '''This registry exists to allow other providers to exist'''
 
1038
 
 
1039
    def __iter__(self):
 
1040
        for key, provider in self.iteritems():
 
1041
            yield provider
 
1042
 
 
1043
command_providers_registry = ProvidersRegistry()
 
1044
 
623
1045
 
624
1046
if __name__ == '__main__':
625
1047
    sys.exit(main(sys.argv))