/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

merge bzr.dev.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/commands.py
1
 
# Copyright (C) 2006 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
35
35
lazy_import(globals(), """
36
36
import codecs
37
37
import errno
 
38
import threading
38
39
from warnings import warn
39
40
 
40
41
import bzrlib
48
49
    )
49
50
""")
50
51
 
51
 
from bzrlib.symbol_versioning import (
52
 
    deprecated_function,
53
 
    deprecated_method,
54
 
    zero_eight,
55
 
    zero_eleven,
56
 
    )
 
52
from bzrlib import registry
57
53
# Compatibility
 
54
from bzrlib.hooks import HookPoint, Hooks
58
55
from bzrlib.option import Option
59
56
 
60
57
 
61
 
plugin_cmds = {}
 
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()
62
119
 
63
120
 
64
121
def register_command(cmd, decorate=False):
65
 
    """Utility function to help register a command
66
 
 
67
 
    :param cmd: Command subclass to register
68
 
    :param decorate: If true, allow overriding an existing command
69
 
        of the same name; the old command is returned by this function.
70
 
        Otherwise it is an error to try to override an existing command.
71
 
    """
72
122
    global plugin_cmds
73
 
    k = cmd.__name__
74
 
    if k.startswith("cmd_"):
75
 
        k_unsquished = _unsquish_command_name(k)
76
 
    else:
77
 
        k_unsquished = k
78
 
    if k_unsquished not in plugin_cmds:
79
 
        plugin_cmds[k_unsquished] = cmd
80
 
        ## trace.mutter('registered plugin command %s', k_unsquished)
81
 
        if decorate and k_unsquished in builtin_command_names():
82
 
            return _builtin_commands()[k_unsquished]
83
 
    elif decorate:
84
 
        result = plugin_cmds[k_unsquished]
85
 
        plugin_cmds[k_unsquished] = cmd
86
 
        return result
87
 
    else:
88
 
        trace.log_error('Two plugins defined the same command: %r' % k)
89
 
        trace.log_error('Not loading the one in %r' % sys.modules[cmd.__module__])
 
123
    return plugin_cmds.register(cmd, decorate)
90
124
 
91
125
 
92
126
def _squish_command_name(cmd):
94
128
 
95
129
 
96
130
def _unsquish_command_name(cmd):
97
 
    assert cmd.startswith("cmd_")
98
131
    return cmd[4:].replace('_','-')
99
132
 
100
133
 
107
140
            real_name = _unsquish_command_name(name)
108
141
            r[real_name] = builtins[name]
109
142
    return r
110
 
            
 
143
 
111
144
 
112
145
def builtin_command_names():
113
146
    """Return list of builtin command names."""
114
147
    return _builtin_commands().keys()
115
 
    
 
148
 
116
149
 
117
150
def plugin_command_names():
118
151
    return plugin_cmds.keys()
122
155
    """Return name->class mapping for all commands."""
123
156
    d = _builtin_commands()
124
157
    if plugins_override:
125
 
        d.update(plugin_cmds)
 
158
        d.update(plugin_cmds.iteritems())
126
159
    return d
127
160
 
128
 
    
 
161
 
129
162
def get_all_cmds(plugins_override=True):
130
163
    """Return canonical name and class for all registered commands."""
131
164
    for k, v in _get_cmd_dict(plugins_override=plugins_override).iteritems():
139
172
        If true, plugin commands can override builtins.
140
173
    """
141
174
    try:
142
 
        return _get_cmd_object(cmd_name, plugins_override)
 
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
143
180
    except KeyError:
144
181
        raise errors.BzrCommandError('unknown command "%s"' % cmd_name)
145
182
 
154
191
    # In the future, we may actually support Unicode command names.
155
192
 
156
193
    # first look up this command under the specified name
157
 
    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)
158
200
    try:
159
201
        return cmds[cmd_name]()
160
202
    except KeyError:
161
203
        pass
162
 
 
 
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)()
163
209
    # look for any command which claims this as an alias
164
210
    for real_cmd_name, cmd_class in cmds.iteritems():
165
211
        if cmd_name in cmd_class.aliases:
168
214
    cmd_obj = ExternalCommand.find_command(cmd_name)
169
215
    if cmd_obj:
170
216
        return cmd_obj
 
217
 
 
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)
171
227
    raise KeyError
172
228
 
173
229
 
228
284
            sys.stdout is forced to be a binary stream, and line-endings
229
285
            will not mangled.
230
286
 
 
287
    :cvar hooks: An instance of CommandHooks.
231
288
    """
232
289
    aliases = []
233
290
    takes_args = []
235
292
    encoding_type = 'strict'
236
293
 
237
294
    hidden = False
238
 
    
 
295
 
239
296
    def __init__(self):
240
297
        """Construct an instance of this command."""
241
298
        if self.__doc__ == Command.__doc__:
242
299
            warn("No help message set for %r" % self)
 
300
        # List of standard options directly supported
 
301
        self.supported_std_options = []
243
302
 
244
303
    def _maybe_expand_globs(self, file_list):
245
304
        """Glob expand file_list if the platform does not do that itself.
246
 
        
 
305
 
247
306
        :return: A possibly empty list of unicode paths.
248
307
 
249
308
        Introduced in bzrlib 0.18.
269
328
            elif aname[-1] == '*':
270
329
                aname = '[' + aname[:-1] + '...]'
271
330
            s += aname + ' '
272
 
                
273
 
        assert s[-1] == ' '
274
 
        s = s[:-1]
 
331
        s = s[:-1]      # remove last space
275
332
        return s
276
333
 
277
334
    def get_help_text(self, additional_see_also=None, plain=True,
278
 
                      see_also_as_links=False):
 
335
                      see_also_as_links=False, verbose=True):
279
336
        """Return a text string with help for this command.
280
 
        
 
337
 
281
338
        :param additional_see_also: Additional help topics to be
282
339
            cross-referenced.
283
340
        :param plain: if False, raw help (reStructuredText) is
284
341
            returned instead of plain text.
285
342
        :param see_also_as_links: if True, convert items in 'See also'
286
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.
287
348
        """
288
349
        doc = self.help()
289
350
        if doc is None:
290
351
            raise NotImplementedError("sorry, no detailed help yet for %r" % self.name())
291
352
 
292
353
        # Extract the summary (purpose) and sections out from the text
293
 
        purpose,sections = self._get_help_parts(doc)
 
354
        purpose,sections,order = self._get_help_parts(doc)
294
355
 
295
356
        # If a custom usage section was provided, use it
296
357
        if sections.has_key('Usage'):
318
379
            result += options
319
380
        result += '\n'
320
381
 
321
 
        # Add the description, indenting it 2 spaces
322
 
        # to match the indentation of the options
323
 
        if sections.has_key(None):
324
 
            text = sections.pop(None)
325
 
            text = '\n  '.join(text.splitlines())
326
 
            result += ':%s:\n  %s\n\n' % ('Description',text)
 
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)
327
389
 
328
 
        # Add the custom sections (e.g. Examples). Note that there's no need
329
 
        # to indent these as they must be indented already in the source.
330
 
        if sections:
331
 
            labels = sorted(sections.keys())
332
 
            for label in labels:
333
 
                result += ':%s:\n%s\n\n' % (label,sections[label])
 
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())
334
400
 
335
401
        # Add the aliases, source (plug-in) and see also links, if any
336
402
        if self.aliases:
355
421
            result += ':See also: '
356
422
            result += ', '.join(see_also) + '\n'
357
423
 
358
 
        # If this will be rendered as plan text, convert it
 
424
        # If this will be rendered as plain text, convert it
359
425
        if plain:
360
426
            import bzrlib.help_topics
361
427
            result = bzrlib.help_topics.help_as_plain_text(result)
365
431
    def _get_help_parts(text):
366
432
        """Split help text into a summary and named sections.
367
433
 
368
 
        :return: (summary,sections) where summary is the top line and
 
434
        :return: (summary,sections,order) where summary is the top line and
369
435
            sections is a dictionary of the rest indexed by section name.
 
436
            order is the order the section appear in the text.
370
437
            A section starts with a heading line of the form ":xxx:".
371
438
            Indented text on following lines is the section value.
372
439
            All text found outside a named section is assigned to the
373
440
            default section which is given the key of None.
374
441
        """
375
 
        def save_section(sections, label, section):
 
442
        def save_section(sections, order, label, section):
376
443
            if len(section) > 0:
377
444
                if sections.has_key(label):
378
445
                    sections[label] += '\n' + section
379
446
                else:
 
447
                    order.append(label)
380
448
                    sections[label] = section
381
 
            
 
449
 
382
450
        lines = text.rstrip().splitlines()
383
451
        summary = lines.pop(0)
384
452
        sections = {}
 
453
        order = []
385
454
        label,section = None,''
386
455
        for line in lines:
387
456
            if line.startswith(':') and line.endswith(':') and len(line) > 2:
388
 
                save_section(sections, label, section)
 
457
                save_section(sections, order, label, section)
389
458
                label,section = line[1:-1],''
390
 
            elif label != None and len(line) > 1 and not line[0].isspace():
391
 
                save_section(sections, label, section)
 
459
            elif (label is not None) and len(line) > 1 and not line[0].isspace():
 
460
                save_section(sections, order, label, section)
392
461
                label,section = None,line
393
462
            else:
394
463
                if len(section) > 0:
395
464
                    section += '\n' + line
396
465
                else:
397
466
                    section = line
398
 
        save_section(sections, label, section)
399
 
        return summary, sections
 
467
        save_section(sections, order, label, section)
 
468
        return summary, sections, order
400
469
 
401
470
    def get_help_topic(self):
402
471
        """Return the commands help topic - its name."""
404
473
 
405
474
    def get_see_also(self, additional_terms=None):
406
475
        """Return a list of help topics that are related to this command.
407
 
        
 
476
 
408
477
        The list is derived from the content of the _see_also attribute. Any
409
478
        duplicates are removed and the result is in lexical order.
410
479
        :param additional_terms: Additional help topics to cross-reference.
419
488
        """Return dict of valid options for this command.
420
489
 
421
490
        Maps from long option name to option object."""
422
 
        r = dict()
423
 
        r['help'] = option._help_option
 
491
        r = Option.STD_OPTIONS.copy()
 
492
        std_names = r.keys()
424
493
        for o in self.takes_options:
425
494
            if isinstance(o, basestring):
426
495
                o = option.Option.OPTIONS[o]
427
496
            r[o.name] = o
 
497
            if o.name in std_names:
 
498
                self.supported_std_options.append(o.name)
428
499
        return r
429
500
 
430
501
    def _setup_outf(self):
431
502
        """Return a file linked to stdout, which has proper encoding."""
432
 
        assert self.encoding_type in ['strict', 'exact', 'replace']
433
 
 
434
503
        # Originally I was using self.stdout, but that looks
435
504
        # *way* too much like sys.stdout
436
505
        if self.encoding_type == 'exact':
445
514
 
446
515
        output_encoding = osutils.get_terminal_encoding()
447
516
 
448
 
        # use 'replace' so that we don't abort if trying to write out
449
 
        # in e.g. the default C locale.
450
 
        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)
451
519
        # For whatever reason codecs.getwriter() does not advertise its encoding
452
520
        # it just returns the encoding of the wrapped file, which is completely
453
521
        # bogus. So set the attribute, so we can find the correct encoding later.
460
528
                 DeprecationWarning, stacklevel=2)
461
529
            argv = []
462
530
        args, opts = parse_args(self, argv, alias_argv)
 
531
 
 
532
        # Process the standard options
463
533
        if 'help' in opts:  # e.g. bzr add --help
464
534
            sys.stdout.write(self.get_help_text())
465
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
 
466
549
        # mix arguments and options into one dictionary
467
550
        cmdargs = _match_argform(self.name(), self.takes_args, args)
468
551
        cmdopts = {}
475
558
        self._setup_outf()
476
559
 
477
560
        return self.run(**all_cmd_args)
478
 
    
 
561
 
479
562
    def run(self):
480
563
        """Actually run the command.
481
564
 
511
594
            return None
512
595
 
513
596
 
514
 
# Technically, this function hasn't been use in a *really* long time
515
 
# but we are only deprecating it now.
516
 
@deprecated_function(zero_eleven)
517
 
def parse_spec(spec):
518
 
    """
519
 
    >>> parse_spec(None)
520
 
    [None, None]
521
 
    >>> parse_spec("./")
522
 
    ['./', None]
523
 
    >>> parse_spec("../@")
524
 
    ['..', -1]
525
 
    >>> parse_spec("../f/@35")
526
 
    ['../f', 35]
527
 
    >>> parse_spec('./@revid:john@arbash-meinel.com-20050711044610-3ca0327c6a222f67')
528
 
    ['.', 'revid:john@arbash-meinel.com-20050711044610-3ca0327c6a222f67']
529
 
    """
530
 
    if spec is None:
531
 
        return [None, None]
532
 
    if '/@' in spec:
533
 
        parsed = spec.split('/@')
534
 
        assert len(parsed) == 2
535
 
        if parsed[1] == "":
536
 
            parsed[1] = -1
537
 
        else:
538
 
            try:
539
 
                parsed[1] = int(parsed[1])
540
 
            except ValueError:
541
 
                pass # We can allow stuff like ./@revid:blahblahblah
542
 
            else:
543
 
                assert parsed[1] >=0
544
 
    else:
545
 
        parsed = [spec, None]
546
 
    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
 
547
614
 
548
615
def parse_args(command, argv, alias_argv=None):
549
616
    """Parse command line.
550
 
    
 
617
 
551
618
    Arguments and options are parsed at this level before being passed
552
619
    down to specific command handlers.  This routine knows, from a
553
620
    lookup table, something about the available options, what optargs
602
669
                               % (cmd, argname.upper()))
603
670
            else:
604
671
                argdict[argname] = args.pop(0)
605
 
            
 
672
 
606
673
    if args:
607
674
        raise errors.BzrCommandError("extra argument to command %s: %s"
608
675
                                     % (cmd, args[0]))
609
676
 
610
677
    return argdict
611
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)
612
695
 
613
696
 
614
697
def apply_profiled(the_callable, *args, **kwargs):
619
702
    try:
620
703
        prof = hotshot.Profile(pfname)
621
704
        try:
622
 
            ret = prof.runcall(the_callable, *args, **kwargs) or 0
 
705
            ret = prof.runcall(exception_to_return_code, the_callable, *args,
 
706
                **kwargs) or 0
623
707
        finally:
624
708
            prof.close()
625
709
        stats = hotshot.stats.load(pfname)
634
718
        os.remove(pfname)
635
719
 
636
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
 
637
762
def apply_lsprofiled(filename, the_callable, *args, **kwargs):
638
763
    from bzrlib.lsprof import profile
639
 
    ret, stats = profile(the_callable, *args, **kwargs)
 
764
    ret, stats = profile(exception_to_return_code, the_callable, *args, **kwargs)
640
765
    stats.sort()
641
766
    if filename is None:
642
767
        stats.pprint()
646
771
    return ret
647
772
 
648
773
 
 
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
 
649
779
def get_alias(cmd, config=None):
650
780
    """Return an expanded alias, or None if no alias exists.
651
781
 
661
791
        config = bzrlib.config.GlobalConfig()
662
792
    alias = config.get_alias(cmd)
663
793
    if (alias):
664
 
        import shlex
665
 
        return [a.decode('utf-8') for a in shlex.split(alias.encode('utf-8'))]
 
794
        return shlex_split_unicode(alias)
666
795
    return None
667
796
 
668
797
 
669
798
def run_bzr(argv):
670
799
    """Execute a command.
671
800
 
672
 
    This is similar to main(), but without all the trappings for
673
 
    logging and error handling.  
674
 
    
675
801
    argv
676
802
       The command-line arguments, without the program name from argv[0]
677
803
       These should already be decoded. All library/test code calling
678
804
       run_bzr should be passing valid strings (don't need decoding).
679
 
    
 
805
 
680
806
    Returns a command status or raises an exception.
681
807
 
682
808
    Special master options: these must come before the command because
697
823
 
698
824
    --lsprof
699
825
        Run under the Python lsprof profiler.
 
826
 
 
827
    --coverage
 
828
        Generate line coverage report in the specified directory.
700
829
    """
701
830
    argv = list(argv)
702
831
    trace.mutter("bzr arguments: %r", argv)
703
832
 
704
833
    opt_lsprof = opt_profile = opt_no_plugins = opt_builtin =  \
705
834
                opt_no_aliases = False
706
 
    opt_lsprof_file = None
 
835
    opt_lsprof_file = opt_coverage_dir = None
707
836
 
708
837
    # --no-plugins is handled specially at a very early stage. We need
709
838
    # to load plugins before doing other command parsing so that they
727
856
            opt_no_aliases = True
728
857
        elif a == '--builtin':
729
858
            opt_builtin = True
730
 
        elif a in ('--quiet', '-q'):
731
 
            trace.be_quiet()
 
859
        elif a == '--coverage':
 
860
            opt_coverage_dir = argv[i + 1]
 
861
            i += 1
732
862
        elif a.startswith('-D'):
733
863
            debug.debug_flags.add(a[2:])
734
864
        else:
735
865
            argv_copy.append(a)
736
866
        i += 1
737
867
 
 
868
    debug.set_debug_flags_from_config()
 
869
 
738
870
    argv = argv_copy
739
871
    if (not argv):
740
872
        from bzrlib.builtins import cmd_help
742
874
        return 0
743
875
 
744
876
    if argv[0] == '--version':
745
 
        from bzrlib.version import show_version
746
 
        show_version()
 
877
        from bzrlib.builtins import cmd_version
 
878
        cmd_version().run_argv_aliases([])
747
879
        return 0
748
 
        
 
880
 
749
881
    if not opt_no_plugins:
750
882
        from bzrlib.plugin import load_plugins
751
883
        load_plugins()
758
890
    if not opt_no_aliases:
759
891
        alias_argv = get_alias(argv[0])
760
892
        if alias_argv:
761
 
            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]
762
895
            argv[0] = alias_argv.pop(0)
763
896
 
764
897
    cmd = argv.pop(0)
771
904
    run_argv = [argv, alias_argv]
772
905
 
773
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
774
911
        if opt_lsprof:
 
912
            if opt_coverage_dir:
 
913
                trace.warning(
 
914
                    '--coverage ignored, because --lsprof is in use.')
775
915
            ret = apply_lsprofiled(opt_lsprof_file, run, *run_argv)
776
916
        elif opt_profile:
 
917
            if opt_coverage_dir:
 
918
                trace.warning(
 
919
                    '--coverage ignored, because --profile is in use.')
777
920
            ret = apply_profiled(run, *run_argv)
 
921
        elif opt_coverage_dir:
 
922
            ret = apply_coveraged(opt_coverage_dir, run, *run_argv)
778
923
        else:
779
924
            ret = run(*run_argv)
 
925
        if 'memory' in debug.debug_flags:
 
926
            trace.debug_memory('Process status after command:', short=False)
780
927
        return ret or 0
781
928
    finally:
782
 
        # reset, in case we may do other commands later within the same process
783
 
        trace.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
 
784
934
 
785
935
def display_command(func):
786
936
    """Decorator that suppresses pipe/interrupt errors."""
802
952
    return ignore_pipe
803
953
 
804
954
 
805
 
def main(argv):
 
955
def main(argv=None):
 
956
    """Main entry point of command-line interface.
 
957
 
 
958
    :param argv: list of unicode command-line arguments similar to sys.argv.
 
959
        argv[0] is script name usually, it will be ignored.
 
960
        Don't pass here sys.argv because this list contains plain strings
 
961
        and not unicode; pass None instead.
 
962
 
 
963
    :return: exit code of bzr command.
 
964
    """
806
965
    import bzrlib.ui
807
 
    from bzrlib.ui.text import TextUIFactory
808
 
    bzrlib.ui.ui_factory = TextUIFactory()
809
 
    argv = [a.decode(bzrlib.user_encoding) for a in argv[1:]]
 
966
    bzrlib.ui.ui_factory = bzrlib.ui.make_ui_for_terminal(
 
967
        sys.stdin, sys.stdout, sys.stderr)
 
968
 
 
969
    # Is this a final release version? If so, we should suppress warnings
 
970
    if bzrlib.version_info[3] == 'final':
 
971
        from bzrlib import symbol_versioning
 
972
        symbol_versioning.suppress_deprecation_warnings(override=False)
 
973
    if argv is None:
 
974
        argv = osutils.get_unicode_argv()
 
975
    else:
 
976
        new_argv = []
 
977
        try:
 
978
            # ensure all arguments are unicode strings
 
979
            for a in argv[1:]:
 
980
                if isinstance(a, unicode):
 
981
                    new_argv.append(a)
 
982
                else:
 
983
                    new_argv.append(a.decode('ascii'))
 
984
        except UnicodeDecodeError:
 
985
            raise errors.BzrError("argv should be list of unicode strings.")
 
986
        argv = new_argv
810
987
    ret = run_bzr_catch_errors(argv)
811
988
    trace.mutter("return code %d", ret)
812
989
    return ret
813
990
 
814
991
 
815
992
def run_bzr_catch_errors(argv):
 
993
    """Run a bzr command with parameters as described by argv.
 
994
 
 
995
    This function assumed that that UI layer is setup, that symbol deprecations
 
996
    are already applied, and that unicode decoding has already been performed on argv.
 
997
    """
 
998
    return exception_to_return_code(run_bzr, argv)
 
999
 
 
1000
 
 
1001
def run_bzr_catch_user_errors(argv):
 
1002
    """Run bzr and report user errors, but let internal errors propagate.
 
1003
 
 
1004
    This is used for the test suite, and might be useful for other programs
 
1005
    that want to wrap the commandline interface.
 
1006
    """
816
1007
    try:
817
1008
        return run_bzr(argv)
818
 
    except (KeyboardInterrupt, Exception), e:
819
 
        # used to handle AssertionError and KeyboardInterrupt
820
 
        # specially here, but hopefully they're handled ok by the logger now
821
 
        trace.report_exception(sys.exc_info(), sys.stderr)
822
 
        if os.environ.get('BZR_PDB'):
823
 
            print '**** entering debugger'
824
 
            import pdb
825
 
            pdb.post_mortem(sys.exc_traceback)
826
 
        return 3
 
1009
    except Exception, e:
 
1010
        if (isinstance(e, (OSError, IOError))
 
1011
            or not getattr(e, 'internal_error', True)):
 
1012
            trace.report_exception(sys.exc_info(), sys.stderr)
 
1013
            return 3
 
1014
        else:
 
1015
            raise
827
1016
 
828
1017
 
829
1018
class HelpCommandIndex(object):
849
1038
            return [cmd]
850
1039
 
851
1040
 
 
1041
class Provider(object):
 
1042
    '''Generic class to be overriden by plugins'''
 
1043
 
 
1044
    def plugin_for_command(self, cmd_name):
 
1045
        '''Takes a command and returns the information for that plugin
 
1046
 
 
1047
        :return: A dictionary with all the available information
 
1048
        for the requested plugin
 
1049
        '''
 
1050
        raise NotImplementedError
 
1051
 
 
1052
 
 
1053
class ProvidersRegistry(registry.Registry):
 
1054
    '''This registry exists to allow other providers to exist'''
 
1055
 
 
1056
    def __iter__(self):
 
1057
        for key, provider in self.iteritems():
 
1058
            yield provider
 
1059
 
 
1060
command_providers_registry = ProvidersRegistry()
 
1061
 
 
1062
 
852
1063
if __name__ == '__main__':
853
1064
    sys.exit(main(sys.argv))