~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/commands.py

Remove all uses of compare_trees and replace with Tree.changes_from throughout bzrlib.

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
# Copyright (C) 2006, 2008 Canonical Ltd
 
1
# Copyright (C) 2006 by 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  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 sys
31
32
import os
32
 
import sys
33
 
 
34
 
from bzrlib.lazy_import import lazy_import
35
 
lazy_import(globals(), """
 
33
from warnings import warn
 
34
import errno
36
35
import codecs
37
 
import errno
38
 
import threading
39
 
from warnings import warn
40
36
 
41
37
import bzrlib
42
 
from bzrlib import (
43
 
    debug,
44
 
    errors,
45
 
    option,
46
 
    osutils,
47
 
    trace,
48
 
    win32utils,
49
 
    )
50
 
""")
51
 
 
52
 
from bzrlib.hooks import HookPoint, Hooks
53
 
# Compatibility - Option used to be in commands.
 
38
import bzrlib.errors as errors
 
39
from bzrlib.errors import (BzrError,
 
40
                           BzrCommandError,
 
41
                           BzrCheckError,
 
42
                           NotBranchError)
54
43
from bzrlib.option import Option
55
 
from bzrlib import registry
56
 
from bzrlib.symbol_versioning import (
57
 
    deprecated_function,
58
 
    deprecated_in,
59
 
    suppress_deprecation_warnings,
60
 
    )
61
 
 
62
 
 
63
 
class CommandInfo(object):
64
 
    """Information about a command."""
65
 
 
66
 
    def __init__(self, aliases):
67
 
        """The list of aliases for the command."""
68
 
        self.aliases = aliases
69
 
 
70
 
    @classmethod
71
 
    def from_command(klass, command):
72
 
        """Factory to construct a CommandInfo from a command."""
73
 
        return klass(command.aliases)
74
 
 
75
 
 
76
 
class CommandRegistry(registry.Registry):
77
 
 
78
 
    @staticmethod
79
 
    def _get_name(command_name):
80
 
        if command_name.startswith("cmd_"):
81
 
            return _unsquish_command_name(command_name)
82
 
        else:
83
 
            return command_name
84
 
 
85
 
    def register(self, cmd, decorate=False):
86
 
        """Utility function to help register a command
87
 
 
88
 
        :param cmd: Command subclass to register
89
 
        :param decorate: If true, allow overriding an existing command
90
 
            of the same name; the old command is returned by this function.
91
 
            Otherwise it is an error to try to override an existing command.
92
 
        """
93
 
        k = cmd.__name__
94
 
        k_unsquished = self._get_name(k)
95
 
        try:
96
 
            previous = self.get(k_unsquished)
97
 
        except KeyError:
98
 
            previous = _builtin_commands().get(k_unsquished)
99
 
        info = CommandInfo.from_command(cmd)
100
 
        try:
101
 
            registry.Registry.register(self, k_unsquished, cmd,
102
 
                                       override_existing=decorate, info=info)
103
 
        except KeyError:
104
 
            trace.log_error('Two plugins defined the same command: %r' % k)
105
 
            trace.log_error('Not loading the one in %r' %
106
 
                            sys.modules[cmd.__module__])
107
 
            trace.log_error('Previously this command was registered from %r' %
108
 
                            sys.modules[previous.__module__])
109
 
        return previous
110
 
 
111
 
    def register_lazy(self, command_name, aliases, module_name):
112
 
        """Register a command without loading its module.
113
 
 
114
 
        :param command_name: The primary name of the command.
115
 
        :param aliases: A list of aliases for the command.
116
 
        :module_name: The module that the command lives in.
117
 
        """
118
 
        key = self._get_name(command_name)
119
 
        registry.Registry.register_lazy(self, key, module_name, command_name,
120
 
                                        info=CommandInfo(aliases))
121
 
 
122
 
 
123
 
plugin_cmds = CommandRegistry()
 
44
import bzrlib.osutils
 
45
from bzrlib.revisionspec import RevisionSpec
 
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 = {}
124
51
 
125
52
 
126
53
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
    """
127
61
    global plugin_cmds
128
 
    return plugin_cmds.register(cmd, decorate)
 
62
    k = cmd.__name__
 
63
    if k.startswith("cmd_"):
 
64
        k_unsquished = _unsquish_command_name(k)
 
65
    else:
 
66
        k_unsquished = k
 
67
    if not plugin_cmds.has_key(k_unsquished):
 
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__])
129
79
 
130
80
 
131
81
def _squish_command_name(cmd):
133
83
 
134
84
 
135
85
def _unsquish_command_name(cmd):
 
86
    assert cmd.startswith("cmd_")
136
87
    return cmd[4:].replace('_','-')
137
88
 
138
89
 
139
90
def _builtin_commands():
140
91
    import bzrlib.builtins
141
 
    return _scan_module_for_commands(bzrlib.builtins)
142
 
 
143
 
 
144
 
def _scan_module_for_commands(module):
145
92
    r = {}
146
 
    for name, obj in module.__dict__.iteritems():
 
93
    builtins = bzrlib.builtins.__dict__
 
94
    for name in builtins:
147
95
        if name.startswith("cmd_"):
148
96
            real_name = _unsquish_command_name(name)
149
 
            r[real_name] = obj
 
97
            r[real_name] = builtins[name]
150
98
    return r
151
 
 
152
 
 
153
 
def _list_bzr_commands(names):
154
 
    """Find commands from bzr's core and plugins."""
155
 
    # to eliminate duplicates
156
 
    names.update(builtin_command_names())
157
 
    names.update(plugin_command_names())
158
 
    return names
159
 
 
160
 
 
161
 
def all_command_names():
162
 
    """Return a set of all command names."""
163
 
    names = set()
164
 
    for hook in Command.hooks['list_commands']:
165
 
        names = hook(names)
166
 
        if names is None:
167
 
            raise AssertionError(
168
 
                'hook %s returned None' % Command.hooks.get_hook_name(hook))
169
 
    return names
170
 
 
 
99
            
171
100
 
172
101
def builtin_command_names():
173
 
    """Return list of builtin command names.
174
 
    
175
 
    Use of all_command_names() is encouraged rather than builtin_command_names
176
 
    and/or plugin_command_names.
177
 
    """
 
102
    """Return list of builtin command names."""
178
103
    return _builtin_commands().keys()
179
 
 
 
104
    
180
105
 
181
106
def plugin_command_names():
182
 
    """Returns command names from commands registered by plugins."""
183
107
    return plugin_cmds.keys()
184
108
 
185
109
 
186
 
@deprecated_function(deprecated_in((1, 17, 0)))
187
 
def get_all_cmds(plugins_override=False):
188
 
    """Return canonical name and class for most commands.
189
 
    
190
 
    NB: This does not return all commands since the introduction of
191
 
    command hooks, and returning the class is not sufficient to 
192
 
    get correctly setup commands, which is why it is deprecated.
193
 
 
194
 
    Use 'all_command_names' + 'get_cmd_object' instead.
195
 
    """
 
110
def _get_cmd_dict(plugins_override=True):
 
111
    """Return name->class mapping for all commands."""
196
112
    d = _builtin_commands()
197
113
    if plugins_override:
198
 
        d.update(plugin_cmds.iteritems())
199
 
    for k, v in d.iteritems():
 
114
        d.update(plugin_cmds)
 
115
    return d
 
116
 
 
117
    
 
118
def get_all_cmds(plugins_override=True):
 
119
    """Return canonical name and class for all registered commands."""
 
120
    for k, v in _get_cmd_dict(plugins_override=plugins_override).iteritems():
200
121
        yield k,v
201
122
 
202
123
 
203
124
def get_cmd_object(cmd_name, plugins_override=True):
204
 
    """Return the command object for a command.
 
125
    """Return the canonical name and command class for a command.
205
126
 
206
127
    plugins_override
207
128
        If true, plugin commands can override builtins.
208
129
    """
209
 
    try:
210
 
        return _get_cmd_object(cmd_name, plugins_override)
211
 
    except KeyError:
212
 
        raise errors.BzrCommandError('unknown command "%s"' % cmd_name)
213
 
 
214
 
 
215
 
def _get_cmd_object(cmd_name, plugins_override=True):
216
 
    """Get a command object.
217
 
 
218
 
    :param cmd_name: The name of the command.
219
 
    :param plugins_override: Allow plugins to override builtins.
220
 
    :return: A Command object instance
221
 
    :raises KeyError: If no command is found.
222
 
    """
223
 
    # We want only 'ascii' command names, but the user may have typed
224
 
    # in a Unicode name. In that case, they should just get a
225
 
    # 'command not found' error later.
226
 
    # In the future, we may actually support Unicode command names.
227
 
    cmd = None
228
 
    # Get a command
229
 
    for hook in Command.hooks['get_command']:
230
 
        cmd = hook(cmd, cmd_name)
231
 
        if cmd is not None and not plugins_override and not cmd.plugin_name():
232
 
            # We've found a non-plugin command, don't permit it to be
233
 
            # overridden.
234
 
            break
235
 
    if cmd is None:
236
 
        for hook in Command.hooks['get_missing_command']:
237
 
            cmd = hook(cmd_name)
238
 
            if cmd is not None:
239
 
                break
240
 
    if cmd is None:
241
 
        # No command found.
242
 
        raise KeyError
243
 
    # Allow plugins to extend commands
244
 
    for hook in Command.hooks['extend_command']:
245
 
        hook(cmd)
246
 
    return cmd
247
 
 
248
 
 
249
 
def _try_plugin_provider(cmd_name):
250
 
    """Probe for a plugin provider having cmd_name."""
251
 
    try:
252
 
        plugin_metadata, provider = probe_for_provider(cmd_name)
253
 
        raise errors.CommandAvailableInPlugin(cmd_name,
254
 
            plugin_metadata, provider)
255
 
    except errors.NoPluginAvailable:
256
 
        pass
257
 
 
258
 
 
259
 
def probe_for_provider(cmd_name):
260
 
    """Look for a provider for cmd_name.
261
 
 
262
 
    :param cmd_name: The command name.
263
 
    :return: plugin_metadata, provider for getting cmd_name.
264
 
    :raises NoPluginAvailable: When no provider can supply the plugin.
265
 
    """
266
 
    # look for providers that provide this command but aren't installed
267
 
    for provider in command_providers_registry:
268
 
        try:
269
 
            return provider.plugin_for_command(cmd_name), provider
270
 
        except errors.NoPluginAvailable:
271
 
            pass
272
 
    raise errors.NoPluginAvailable(cmd_name)
273
 
 
274
 
 
275
 
def _get_bzr_command(cmd_or_None, cmd_name):
276
 
    """Get a command from bzr's core."""
277
 
    cmds = _builtin_commands()
 
130
    from bzrlib.externalcommand import ExternalCommand
 
131
 
 
132
    cmd_name = str(cmd_name)            # not unicode
 
133
 
 
134
    # first look up this command under the specified name
 
135
    cmds = _get_cmd_dict(plugins_override=plugins_override)
278
136
    try:
279
137
        return cmds[cmd_name]()
280
138
    except KeyError:
281
139
        pass
 
140
 
282
141
    # look for any command which claims this as an alias
283
142
    for real_cmd_name, cmd_class in cmds.iteritems():
284
143
        if cmd_name in cmd_class.aliases:
285
144
            return cmd_class()
286
 
    return cmd_or_None
287
 
 
288
 
 
289
 
def _get_external_command(cmd_or_None, cmd_name):
290
 
    """Lookup a command that is a shell script."""
291
 
    # Only do external command lookups when no command is found so far.
292
 
    if cmd_or_None is not None:
293
 
        return cmd_or_None
294
 
    from bzrlib.externalcommand import ExternalCommand
 
145
 
295
146
    cmd_obj = ExternalCommand.find_command(cmd_name)
296
147
    if cmd_obj:
297
148
        return cmd_obj
298
149
 
299
 
 
300
 
def _get_plugin_command(cmd_or_None, cmd_name):
301
 
    """Get a command from bzr's plugins."""
302
 
    try:
303
 
        return plugin_cmds.get(cmd_name)()
304
 
    except KeyError:
305
 
        pass
306
 
    for key in plugin_cmds.keys():
307
 
        info = plugin_cmds.get_info(key)
308
 
        if cmd_name in info.aliases:
309
 
            return plugin_cmds.get(key)()
310
 
    return cmd_or_None
 
150
    raise BzrCommandError('unknown command "%s"' % cmd_name)
311
151
 
312
152
 
313
153
class Command(object):
361
201
            replace - put in a bogus character (typically '?')
362
202
            exact - do not encode sys.stdout
363
203
 
364
 
            NOTE: by default on Windows, sys.stdout is opened as a text
365
 
            stream, therefore LF line-endings are converted to CRLF.
366
 
            When a command uses encoding_type = 'exact', then
367
 
            sys.stdout is forced to be a binary stream, and line-endings
368
 
            will not mangled.
369
 
 
370
 
    :cvar hooks: An instance of CommandHooks.
371
204
    """
372
205
    aliases = []
373
206
    takes_args = []
375
208
    encoding_type = 'strict'
376
209
 
377
210
    hidden = False
378
 
 
 
211
    
379
212
    def __init__(self):
380
213
        """Construct an instance of this command."""
381
214
        if self.__doc__ == Command.__doc__:
382
215
            warn("No help message set for %r" % self)
383
 
        # List of standard options directly supported
384
 
        self.supported_std_options = []
385
 
 
386
 
    def _maybe_expand_globs(self, file_list):
387
 
        """Glob expand file_list if the platform does not do that itself.
388
 
 
389
 
        :return: A possibly empty list of unicode paths.
390
 
 
391
 
        Introduced in bzrlib 0.18.
392
 
        """
393
 
        if not file_list:
394
 
            file_list = []
395
 
        if sys.platform == 'win32':
396
 
            file_list = win32utils.glob_expand(file_list)
397
 
        return list(file_list)
398
 
 
399
 
    def _usage(self):
400
 
        """Return single-line grammar for this command.
401
 
 
402
 
        Only describes arguments, not options.
403
 
        """
404
 
        s = 'bzr ' + self.name() + ' '
405
 
        for aname in self.takes_args:
406
 
            aname = aname.upper()
407
 
            if aname[-1] in ['$', '+']:
408
 
                aname = aname[:-1] + '...'
409
 
            elif aname[-1] == '?':
410
 
                aname = '[' + aname[:-1] + ']'
411
 
            elif aname[-1] == '*':
412
 
                aname = '[' + aname[:-1] + '...]'
413
 
            s += aname + ' '
414
 
        s = s[:-1]      # remove last space
415
 
        return s
416
 
 
417
 
    def get_help_text(self, additional_see_also=None, plain=True,
418
 
                      see_also_as_links=False, verbose=True):
419
 
        """Return a text string with help for this command.
420
 
 
421
 
        :param additional_see_also: Additional help topics to be
422
 
            cross-referenced.
423
 
        :param plain: if False, raw help (reStructuredText) is
424
 
            returned instead of plain text.
425
 
        :param see_also_as_links: if True, convert items in 'See also'
426
 
            list to internal links (used by bzr_man rstx generator)
427
 
        :param verbose: if True, display the full help, otherwise
428
 
            leave out the descriptive sections and just display
429
 
            usage help (e.g. Purpose, Usage, Options) with a
430
 
            message explaining how to obtain full help.
431
 
        """
432
 
        doc = self.help()
433
 
        if doc is None:
434
 
            raise NotImplementedError("sorry, no detailed help yet for %r" % self.name())
435
 
 
436
 
        # Extract the summary (purpose) and sections out from the text
437
 
        purpose,sections,order = self._get_help_parts(doc)
438
 
 
439
 
        # If a custom usage section was provided, use it
440
 
        if sections.has_key('Usage'):
441
 
            usage = sections.pop('Usage')
442
 
        else:
443
 
            usage = self._usage()
444
 
 
445
 
        # The header is the purpose and usage
446
 
        result = ""
447
 
        result += ':Purpose: %s\n' % purpose
448
 
        if usage.find('\n') >= 0:
449
 
            result += ':Usage:\n%s\n' % usage
450
 
        else:
451
 
            result += ':Usage:   %s\n' % usage
452
 
        result += '\n'
453
 
 
454
 
        # Add the options
455
 
        #
456
 
        # XXX: optparse implicitly rewraps the help, and not always perfectly,
457
 
        # so we get <https://bugs.launchpad.net/bzr/+bug/249908>.  -- mbp
458
 
        # 20090319
459
 
        options = option.get_optparser(self.options()).format_option_help()
460
 
        if options.startswith('Options:'):
461
 
            result += ':' + options
462
 
        elif options.startswith('options:'):
463
 
            # Python 2.4 version of optparse
464
 
            result += ':Options:' + options[len('options:'):]
465
 
        else:
466
 
            result += options
467
 
        result += '\n'
468
 
 
469
 
        if verbose:
470
 
            # Add the description, indenting it 2 spaces
471
 
            # to match the indentation of the options
472
 
            if sections.has_key(None):
473
 
                text = sections.pop(None)
474
 
                text = '\n  '.join(text.splitlines())
475
 
                result += ':%s:\n  %s\n\n' % ('Description',text)
476
 
 
477
 
            # Add the custom sections (e.g. Examples). Note that there's no need
478
 
            # to indent these as they must be indented already in the source.
479
 
            if sections:
480
 
                for label in order:
481
 
                    if sections.has_key(label):
482
 
                        result += ':%s:\n%s\n' % (label,sections[label])
483
 
                result += '\n'
484
 
        else:
485
 
            result += ("See bzr help %s for more details and examples.\n\n"
486
 
                % self.name())
487
 
 
488
 
        # Add the aliases, source (plug-in) and see also links, if any
489
 
        if self.aliases:
490
 
            result += ':Aliases:  '
491
 
            result += ', '.join(self.aliases) + '\n'
492
 
        plugin_name = self.plugin_name()
493
 
        if plugin_name is not None:
494
 
            result += ':From:     plugin "%s"\n' % plugin_name
495
 
        see_also = self.get_see_also(additional_see_also)
496
 
        if see_also:
497
 
            if not plain and see_also_as_links:
498
 
                see_also_links = []
499
 
                for item in see_also:
500
 
                    if item == 'topics':
501
 
                        # topics doesn't have an independent section
502
 
                        # so don't create a real link
503
 
                        see_also_links.append(item)
504
 
                    else:
505
 
                        # Use a reST link for this entry
506
 
                        see_also_links.append("`%s`_" % (item,))
507
 
                see_also = see_also_links
508
 
            result += ':See also: '
509
 
            result += ', '.join(see_also) + '\n'
510
 
 
511
 
        # If this will be rendered as plain text, convert it
512
 
        if plain:
513
 
            import bzrlib.help_topics
514
 
            result = bzrlib.help_topics.help_as_plain_text(result)
515
 
        return result
516
 
 
517
 
    @staticmethod
518
 
    def _get_help_parts(text):
519
 
        """Split help text into a summary and named sections.
520
 
 
521
 
        :return: (summary,sections,order) where summary is the top line and
522
 
            sections is a dictionary of the rest indexed by section name.
523
 
            order is the order the section appear in the text.
524
 
            A section starts with a heading line of the form ":xxx:".
525
 
            Indented text on following lines is the section value.
526
 
            All text found outside a named section is assigned to the
527
 
            default section which is given the key of None.
528
 
        """
529
 
        def save_section(sections, order, label, section):
530
 
            if len(section) > 0:
531
 
                if sections.has_key(label):
532
 
                    sections[label] += '\n' + section
533
 
                else:
534
 
                    order.append(label)
535
 
                    sections[label] = section
536
 
 
537
 
        lines = text.rstrip().splitlines()
538
 
        summary = lines.pop(0)
539
 
        sections = {}
540
 
        order = []
541
 
        label,section = None,''
542
 
        for line in lines:
543
 
            if line.startswith(':') and line.endswith(':') and len(line) > 2:
544
 
                save_section(sections, order, label, section)
545
 
                label,section = line[1:-1],''
546
 
            elif (label is not None) and len(line) > 1 and not line[0].isspace():
547
 
                save_section(sections, order, label, section)
548
 
                label,section = None,line
549
 
            else:
550
 
                if len(section) > 0:
551
 
                    section += '\n' + line
552
 
                else:
553
 
                    section = line
554
 
        save_section(sections, order, label, section)
555
 
        return summary, sections, order
556
 
 
557
 
    def get_help_topic(self):
558
 
        """Return the commands help topic - its name."""
559
 
        return self.name()
560
 
 
561
 
    def get_see_also(self, additional_terms=None):
562
 
        """Return a list of help topics that are related to this command.
563
 
 
564
 
        The list is derived from the content of the _see_also attribute. Any
565
 
        duplicates are removed and the result is in lexical order.
566
 
        :param additional_terms: Additional help topics to cross-reference.
567
 
        :return: A list of help topics.
568
 
        """
569
 
        see_also = set(getattr(self, '_see_also', []))
570
 
        if additional_terms:
571
 
            see_also.update(additional_terms)
572
 
        return sorted(see_also)
573
216
 
574
217
    def options(self):
575
218
        """Return dict of valid options for this command.
576
219
 
577
220
        Maps from long option name to option object."""
578
 
        r = Option.STD_OPTIONS.copy()
579
 
        std_names = r.keys()
 
221
        r = dict()
 
222
        r['help'] = Option.OPTIONS['help']
580
223
        for o in self.takes_options:
581
 
            if isinstance(o, basestring):
582
 
                o = option.Option.OPTIONS[o]
 
224
            if not isinstance(o, Option):
 
225
                o = Option.OPTIONS[o]
583
226
            r[o.name] = o
584
 
            if o.name in std_names:
585
 
                self.supported_std_options.append(o.name)
586
227
        return r
587
228
 
588
229
    def _setup_outf(self):
589
230
        """Return a file linked to stdout, which has proper encoding."""
 
231
        assert self.encoding_type in ['strict', 'exact', 'replace']
 
232
 
590
233
        # Originally I was using self.stdout, but that looks
591
234
        # *way* too much like sys.stdout
592
235
        if self.encoding_type == 'exact':
593
 
            # force sys.stdout to be binary stream on win32
594
 
            if sys.platform == 'win32':
595
 
                fileno = getattr(sys.stdout, 'fileno', None)
596
 
                if fileno:
597
 
                    import msvcrt
598
 
                    msvcrt.setmode(fileno(), os.O_BINARY)
599
236
            self.outf = sys.stdout
600
237
            return
601
238
 
602
 
        output_encoding = osutils.get_terminal_encoding()
 
239
        output_encoding = bzrlib.osutils.get_terminal_encoding()
603
240
 
604
 
        self.outf = codecs.getwriter(output_encoding)(sys.stdout,
605
 
                        errors=self.encoding_type)
 
241
        # use 'replace' so that we don't abort if trying to write out
 
242
        # in e.g. the default C locale.
 
243
        self.outf = codecs.getwriter(output_encoding)(sys.stdout, errors=self.encoding_type)
606
244
        # For whatever reason codecs.getwriter() does not advertise its encoding
607
245
        # it just returns the encoding of the wrapped file, which is completely
608
246
        # bogus. So set the attribute, so we can find the correct encoding later.
609
247
        self.outf.encoding = output_encoding
610
248
 
 
249
    @deprecated_method(zero_eight)
 
250
    def run_argv(self, argv):
 
251
        """Parse command line and run.
 
252
        
 
253
        See run_argv_aliases for the 0.8 and beyond api.
 
254
        """
 
255
        return self.run_argv_aliases(argv)
 
256
 
611
257
    def run_argv_aliases(self, argv, alias_argv=None):
612
258
        """Parse the command line and run with extra aliases in alias_argv."""
613
 
        if argv is None:
614
 
            warn("Passing None for [] is deprecated from bzrlib 0.10",
615
 
                 DeprecationWarning, stacklevel=2)
616
 
            argv = []
617
259
        args, opts = parse_args(self, argv, alias_argv)
618
 
 
619
 
        # Process the standard options
620
260
        if 'help' in opts:  # e.g. bzr add --help
621
 
            sys.stdout.write(self.get_help_text())
622
 
            return 0
623
 
        if 'usage' in opts:  # e.g. bzr add --usage
624
 
            sys.stdout.write(self.get_help_text(verbose=False))
625
 
            return 0
626
 
        trace.set_verbosity_level(option._verbosity_level)
627
 
        if 'verbose' in self.supported_std_options:
628
 
            opts['verbose'] = trace.is_verbose()
629
 
        elif opts.has_key('verbose'):
630
 
            del opts['verbose']
631
 
        if 'quiet' in self.supported_std_options:
632
 
            opts['quiet'] = trace.is_quiet()
633
 
        elif opts.has_key('quiet'):
634
 
            del opts['quiet']
635
 
 
 
261
            from bzrlib.help import help_on_command
 
262
            help_on_command(self.name())
 
263
            return 0
 
264
        # XXX: This should be handled by the parser
 
265
        allowed_names = self.options().keys()
 
266
        for oname in opts:
 
267
            if oname not in allowed_names:
 
268
                raise BzrOptionError("option '--%s' is not allowed for"
 
269
                                " command %r" % (oname, self.name()))
636
270
        # mix arguments and options into one dictionary
637
271
        cmdargs = _match_argform(self.name(), self.takes_args, args)
638
272
        cmdopts = {}
645
279
        self._setup_outf()
646
280
 
647
281
        return self.run(**all_cmd_args)
648
 
 
 
282
    
649
283
    def run(self):
650
284
        """Actually run the command.
651
285
 
656
290
        shell error code if not.  It's OK for this method to allow
657
291
        an exception to raise up.
658
292
        """
659
 
        raise NotImplementedError('no implementation of command %r'
 
293
        raise NotImplementedError('no implementation of command %r' 
660
294
                                  % self.name())
661
295
 
662
296
    def help(self):
681
315
            return None
682
316
 
683
317
 
684
 
class CommandHooks(Hooks):
685
 
    """Hooks related to Command object creation/enumeration."""
686
 
 
687
 
    def __init__(self):
688
 
        """Create the default hooks.
689
 
 
690
 
        These are all empty initially, because by default nothing should get
691
 
        notified.
692
 
        """
693
 
        Hooks.__init__(self)
694
 
        self.create_hook(HookPoint('extend_command',
695
 
            "Called after creating a command object to allow modifications "
696
 
            "such as adding or removing options, docs etc. Called with the "
697
 
            "new bzrlib.commands.Command object.", (1, 13), None))
698
 
        self.create_hook(HookPoint('get_command',
699
 
            "Called when creating a single command. Called with "
700
 
            "(cmd_or_None, command_name). get_command should either return "
701
 
            "the cmd_or_None parameter, or a replacement Command object that "
702
 
            "should be used for the command. Note that the Command.hooks "
703
 
            "hooks are core infrastructure. Many users will prefer to use "
704
 
            "bzrlib.commands.register_command or plugin_cmds.register_lazy.",
705
 
            (1, 17), None))
706
 
        self.create_hook(HookPoint('get_missing_command',
707
 
            "Called when creating a single command if no command could be "
708
 
            "found. Called with (command_name). get_missing_command should "
709
 
            "either return None, or a Command object to be used for the "
710
 
            "command.", (1, 17), None))
711
 
        self.create_hook(HookPoint('list_commands',
712
 
            "Called when enumerating commands. Called with a set of "
713
 
            "cmd_name strings for all the commands found so far. This set "
714
 
            " is safe to mutate - e.g. to remove a command. "
715
 
            "list_commands should return the updated set of command names.",
716
 
            (1, 17), None))
717
 
 
718
 
Command.hooks = CommandHooks()
719
 
 
 
318
def parse_spec(spec):
 
319
    """
 
320
    >>> parse_spec(None)
 
321
    [None, None]
 
322
    >>> parse_spec("./")
 
323
    ['./', None]
 
324
    >>> parse_spec("../@")
 
325
    ['..', -1]
 
326
    >>> parse_spec("../f/@35")
 
327
    ['../f', 35]
 
328
    >>> parse_spec('./@revid:john@arbash-meinel.com-20050711044610-3ca0327c6a222f67')
 
329
    ['.', 'revid:john@arbash-meinel.com-20050711044610-3ca0327c6a222f67']
 
330
    """
 
331
    if spec is None:
 
332
        return [None, None]
 
333
    if '/@' in spec:
 
334
        parsed = spec.split('/@')
 
335
        assert len(parsed) == 2
 
336
        if parsed[1] == "":
 
337
            parsed[1] = -1
 
338
        else:
 
339
            try:
 
340
                parsed[1] = int(parsed[1])
 
341
            except ValueError:
 
342
                pass # We can allow stuff like ./@revid:blahblahblah
 
343
            else:
 
344
                assert parsed[1] >=0
 
345
    else:
 
346
        parsed = [spec, None]
 
347
    return parsed
720
348
 
721
349
def parse_args(command, argv, alias_argv=None):
722
350
    """Parse command line.
723
 
 
 
351
    
724
352
    Arguments and options are parsed at this level before being passed
725
353
    down to specific command handlers.  This routine knows, from a
726
354
    lookup table, something about the available options, what optargs
727
355
    they take, and which commands will accept them.
728
356
    """
729
 
    # TODO: make it a method of the Command?
730
 
    parser = option.get_optparser(command.options())
731
 
    if alias_argv is not None:
732
 
        args = alias_argv + argv
733
 
    else:
734
 
        args = argv
735
 
 
736
 
    options, args = parser.parse_args(args)
737
 
    opts = dict([(k, v) for k, v in options.__dict__.iteritems() if
738
 
                 v is not option.OptionParser.DEFAULT_VALUE])
 
357
    # TODO: chop up this beast; make it a method of the Command
 
358
    args = []
 
359
    opts = {}
 
360
    alias_opts = {}
 
361
 
 
362
    cmd_options = command.options()
 
363
    argsover = False
 
364
    proc_aliasarg = True # Are we processing alias_argv now?
 
365
    for proc_argv in alias_argv, argv:
 
366
        while proc_argv:
 
367
            a = proc_argv.pop(0)
 
368
            if argsover:
 
369
                args.append(a)
 
370
                continue
 
371
            elif a == '-':
 
372
                args.append(a)
 
373
                continue
 
374
            elif a == '--':
 
375
                # We've received a standalone -- No more flags
 
376
                argsover = True
 
377
                continue
 
378
            if a[0] == '-':
 
379
                # option names must not be unicode
 
380
                a = str(a)
 
381
                optarg = None
 
382
                if a[1] == '-':
 
383
                    mutter("  got option %r", a)
 
384
                    if '=' in a:
 
385
                        optname, optarg = a[2:].split('=', 1)
 
386
                    else:
 
387
                        optname = a[2:]
 
388
                    if optname not in cmd_options:
 
389
                        raise BzrCommandError('unknown option "%s"' % a)
 
390
                else:
 
391
                    shortopt = a[1:]
 
392
                    if shortopt in Option.SHORT_OPTIONS:
 
393
                        # Multi-character options must have a space to delimit
 
394
                        # their value
 
395
                        # ^^^ what does this mean? mbp 20051014
 
396
                        optname = Option.SHORT_OPTIONS[shortopt].name
 
397
                    else:
 
398
                        # Single character short options, can be chained,
 
399
                        # and have their value appended to their name
 
400
                        shortopt = a[1:2]
 
401
                        if shortopt not in Option.SHORT_OPTIONS:
 
402
                            # We didn't find the multi-character name, and we
 
403
                            # didn't find the single char name
 
404
                            raise BzrCommandError('unknown option "%s"' % a)
 
405
                        optname = Option.SHORT_OPTIONS[shortopt].name
 
406
 
 
407
                        if a[2:]:
 
408
                            # There are extra things on this option
 
409
                            # see if it is the value, or if it is another
 
410
                            # short option
 
411
                            optargfn = Option.OPTIONS[optname].type
 
412
                            if optargfn is None:
 
413
                                # This option does not take an argument, so the
 
414
                                # next entry is another short option, pack it
 
415
                                # back into the list
 
416
                                proc_argv.insert(0, '-' + a[2:])
 
417
                            else:
 
418
                                # This option takes an argument, so pack it
 
419
                                # into the array
 
420
                                optarg = a[2:]
 
421
                    if optname not in cmd_options:
 
422
                        raise BzrCommandError('unknown option "%s"' % shortopt)
 
423
                if optname in opts:
 
424
                    # XXX: Do we ever want to support this, e.g. for -r?
 
425
                    if proc_aliasarg:
 
426
                        raise BzrCommandError('repeated option %r' % a)
 
427
                    elif optname in alias_opts:
 
428
                        # Replace what's in the alias with what's in the real
 
429
                        # argument
 
430
                        del alias_opts[optname]
 
431
                        del opts[optname]
 
432
                        proc_argv.insert(0, a)
 
433
                        continue
 
434
                    else:
 
435
                        raise BzrCommandError('repeated option %r' % a)
 
436
                    
 
437
                option_obj = cmd_options[optname]
 
438
                optargfn = option_obj.type
 
439
                if optargfn:
 
440
                    if optarg == None:
 
441
                        if not proc_argv:
 
442
                            raise BzrCommandError('option %r needs an argument' % a)
 
443
                        else:
 
444
                            optarg = proc_argv.pop(0)
 
445
                    opts[optname] = optargfn(optarg)
 
446
                    if proc_aliasarg:
 
447
                        alias_opts[optname] = optargfn(optarg)
 
448
                else:
 
449
                    if optarg != None:
 
450
                        raise BzrCommandError('option %r takes no argument' % optname)
 
451
                    opts[optname] = True
 
452
                    if proc_aliasarg:
 
453
                        alias_opts[optname] = True
 
454
            else:
 
455
                args.append(a)
 
456
        proc_aliasarg = False # Done with alias argv
739
457
    return args, opts
740
458
 
741
459
 
756
474
                argdict[argname + '_list'] = None
757
475
        elif ap[-1] == '+':
758
476
            if not args:
759
 
                raise errors.BzrCommandError("command %r needs one or more %s"
760
 
                                             % (cmd, argname.upper()))
 
477
                raise BzrCommandError("command %r needs one or more %s"
 
478
                        % (cmd, argname.upper()))
761
479
            else:
762
480
                argdict[argname + '_list'] = args[:]
763
481
                args = []
764
482
        elif ap[-1] == '$': # all but one
765
483
            if len(args) < 2:
766
 
                raise errors.BzrCommandError("command %r needs one or more %s"
767
 
                                             % (cmd, argname.upper()))
 
484
                raise BzrCommandError("command %r needs one or more %s"
 
485
                        % (cmd, argname.upper()))
768
486
            argdict[argname + '_list'] = args[:-1]
769
487
            args[:-1] = []
770
488
        else:
771
489
            # just a plain arg
772
490
            argname = ap
773
491
            if not args:
774
 
                raise errors.BzrCommandError("command %r requires argument %s"
775
 
                               % (cmd, argname.upper()))
 
492
                raise BzrCommandError("command %r requires argument %s"
 
493
                        % (cmd, argname.upper()))
776
494
            else:
777
495
                argdict[argname] = args.pop(0)
778
 
 
 
496
            
779
497
    if args:
780
 
        raise errors.BzrCommandError("extra argument to command %s: %s"
781
 
                                     % (cmd, args[0]))
 
498
        raise BzrCommandError("extra argument to command %s: %s"
 
499
                              % (cmd, args[0]))
782
500
 
783
501
    return argdict
784
502
 
785
 
def apply_coveraged(dirname, the_callable, *args, **kwargs):
786
 
    # Cannot use "import trace", as that would import bzrlib.trace instead of
787
 
    # the standard library's trace.
788
 
    trace = __import__('trace')
789
 
 
790
 
    tracer = trace.Trace(count=1, trace=0)
791
 
    sys.settrace(tracer.globaltrace)
792
 
    threading.settrace(tracer.globaltrace)
793
 
 
794
 
    try:
795
 
        return exception_to_return_code(the_callable, *args, **kwargs)
796
 
    finally:
797
 
        sys.settrace(None)
798
 
        results = tracer.results()
799
 
        results.write_results(show_missing=1, summary=False,
800
 
                              coverdir=dirname)
801
503
 
802
504
 
803
505
def apply_profiled(the_callable, *args, **kwargs):
808
510
    try:
809
511
        prof = hotshot.Profile(pfname)
810
512
        try:
811
 
            ret = prof.runcall(exception_to_return_code, the_callable, *args,
812
 
                **kwargs) or 0
 
513
            ret = prof.runcall(the_callable, *args, **kwargs) or 0
813
514
        finally:
814
515
            prof.close()
815
516
        stats = hotshot.stats.load(pfname)
824
525
        os.remove(pfname)
825
526
 
826
527
 
827
 
def exception_to_return_code(the_callable, *args, **kwargs):
828
 
    """UI level helper for profiling and coverage.
829
 
 
830
 
    This transforms exceptions into a return value of 3. As such its only
831
 
    relevant to the UI layer, and should never be called where catching
832
 
    exceptions may be desirable.
833
 
    """
834
 
    try:
835
 
        return the_callable(*args, **kwargs)
836
 
    except (KeyboardInterrupt, Exception), e:
837
 
        # used to handle AssertionError and KeyboardInterrupt
838
 
        # specially here, but hopefully they're handled ok by the logger now
839
 
        exc_info = sys.exc_info()
840
 
        exitcode = trace.report_exception(exc_info, sys.stderr)
841
 
        if os.environ.get('BZR_PDB'):
842
 
            print '**** entering debugger'
843
 
            tb = exc_info[2]
844
 
            import pdb
845
 
            if sys.version_info[:2] < (2, 6):
846
 
                # XXX: we want to do
847
 
                #    pdb.post_mortem(tb)
848
 
                # but because pdb.post_mortem gives bad results for tracebacks
849
 
                # from inside generators, we do it manually.
850
 
                # (http://bugs.python.org/issue4150, fixed in Python 2.6)
851
 
 
852
 
                # Setup pdb on the traceback
853
 
                p = pdb.Pdb()
854
 
                p.reset()
855
 
                p.setup(tb.tb_frame, tb)
856
 
                # Point the debugger at the deepest frame of the stack
857
 
                p.curindex = len(p.stack) - 1
858
 
                p.curframe = p.stack[p.curindex][0]
859
 
                # Start the pdb prompt.
860
 
                p.print_stack_entry(p.stack[p.curindex])
861
 
                p.execRcLines()
862
 
                p.cmdloop()
863
 
            else:
864
 
                pdb.post_mortem(tb)
865
 
        return exitcode
866
 
 
867
 
 
868
528
def apply_lsprofiled(filename, the_callable, *args, **kwargs):
869
529
    from bzrlib.lsprof import profile
870
 
    ret, stats = profile(exception_to_return_code, the_callable, *args, **kwargs)
 
530
    import cPickle
 
531
    ret, stats = profile(the_callable, *args, **kwargs)
871
532
    stats.sort()
872
533
    if filename is None:
873
534
        stats.pprint()
874
535
    else:
875
 
        stats.save(filename)
876
 
        trace.note('Profile data written to "%s".', filename)
 
536
        stats.freeze()
 
537
        cPickle.dump(stats, open(filename, 'w'), 2)
 
538
        print 'Profile data written to %r.' % filename
877
539
    return ret
878
540
 
879
541
 
880
 
def shlex_split_unicode(unsplit):
881
 
    import shlex
882
 
    return [u.decode('utf-8') for u in shlex.split(unsplit.encode('utf-8'))]
883
 
 
884
 
 
885
 
def get_alias(cmd, config=None):
886
 
    """Return an expanded alias, or None if no alias exists.
887
 
 
888
 
    cmd
889
 
        Command to be checked for an alias.
890
 
    config
891
 
        Used to specify an alternative config to use,
892
 
        which is especially useful for testing.
893
 
        If it is unspecified, the global config will be used.
894
 
    """
895
 
    if config is None:
896
 
        import bzrlib.config
897
 
        config = bzrlib.config.GlobalConfig()
898
 
    alias = config.get_alias(cmd)
 
542
def get_alias(cmd):
 
543
    """Return an expanded alias, or None if no alias exists"""
 
544
    import bzrlib.config
 
545
    alias = bzrlib.config.GlobalConfig().get_alias(cmd)
899
546
    if (alias):
900
 
        return shlex_split_unicode(alias)
 
547
        return alias.split(' ')
901
548
    return None
902
549
 
903
550
 
904
551
def run_bzr(argv):
905
552
    """Execute a command.
906
553
 
 
554
    This is similar to main(), but without all the trappings for
 
555
    logging and error handling.  
 
556
    
907
557
    argv
908
558
       The command-line arguments, without the program name from argv[0]
909
559
       These should already be decoded. All library/test code calling
910
560
       run_bzr should be passing valid strings (don't need decoding).
911
 
 
 
561
    
912
562
    Returns a command status or raises an exception.
913
563
 
914
564
    Special master options: these must come before the command because
929
579
 
930
580
    --lsprof
931
581
        Run under the Python lsprof profiler.
932
 
 
933
 
    --coverage
934
 
        Generate line coverage report in the specified directory.
935
582
    """
936
583
    argv = list(argv)
937
 
    trace.mutter("bzr arguments: %r", argv)
938
584
 
939
585
    opt_lsprof = opt_profile = opt_no_plugins = opt_builtin =  \
940
586
                opt_no_aliases = False
941
 
    opt_lsprof_file = opt_coverage_dir = None
 
587
    opt_lsprof_file = None
942
588
 
943
589
    # --no-plugins is handled specially at a very early stage. We need
944
590
    # to load plugins before doing other command parsing so that they
962
608
            opt_no_aliases = True
963
609
        elif a == '--builtin':
964
610
            opt_builtin = True
965
 
        elif a == '--coverage':
966
 
            opt_coverage_dir = argv[i + 1]
967
 
            i += 1
968
 
        elif a.startswith('-D'):
969
 
            debug.debug_flags.add(a[2:])
 
611
        elif a in ('--quiet', '-q'):
 
612
            be_quiet()
970
613
        else:
971
614
            argv_copy.append(a)
972
615
        i += 1
973
616
 
974
 
    debug.set_debug_flags_from_config()
975
 
 
976
617
    argv = argv_copy
977
618
    if (not argv):
978
619
        from bzrlib.builtins import cmd_help
980
621
        return 0
981
622
 
982
623
    if argv[0] == '--version':
983
 
        from bzrlib.builtins import cmd_version
984
 
        cmd_version().run_argv_aliases([])
 
624
        from bzrlib.builtins import show_version
 
625
        show_version()
985
626
        return 0
986
 
 
 
627
        
987
628
    if not opt_no_plugins:
988
629
        from bzrlib.plugin import load_plugins
989
630
        load_plugins()
996
637
    if not opt_no_aliases:
997
638
        alias_argv = get_alias(argv[0])
998
639
        if alias_argv:
999
 
            user_encoding = osutils.get_user_encoding()
1000
 
            alias_argv = [a.decode(user_encoding) for a in alias_argv]
 
640
            alias_argv = [a.decode(bzrlib.user_encoding) for a in alias_argv]
1001
641
            argv[0] = alias_argv.pop(0)
1002
642
 
1003
 
    cmd = argv.pop(0)
1004
 
    # We want only 'ascii' command names, but the user may have typed
1005
 
    # in a Unicode name. In that case, they should just get a
1006
 
    # 'command not found' error later.
 
643
    cmd = str(argv.pop(0))
1007
644
 
1008
645
    cmd_obj = get_cmd_object(cmd, plugins_override=not opt_builtin)
1009
 
    run = cmd_obj.run_argv_aliases
1010
 
    run_argv = [argv, alias_argv]
 
646
    if not getattr(cmd_obj.run_argv, 'is_deprecated', False):
 
647
        run = cmd_obj.run_argv
 
648
        run_argv = [argv]
 
649
    else:
 
650
        run = cmd_obj.run_argv_aliases
 
651
        run_argv = [argv, alias_argv]
1011
652
 
1012
653
    try:
1013
 
        # We can be called recursively (tests for example), but we don't want
1014
 
        # the verbosity level to propagate.
1015
 
        saved_verbosity_level = option._verbosity_level
1016
 
        option._verbosity_level = 0
1017
654
        if opt_lsprof:
1018
 
            if opt_coverage_dir:
1019
 
                trace.warning(
1020
 
                    '--coverage ignored, because --lsprof is in use.')
1021
655
            ret = apply_lsprofiled(opt_lsprof_file, run, *run_argv)
1022
656
        elif opt_profile:
1023
 
            if opt_coverage_dir:
1024
 
                trace.warning(
1025
 
                    '--coverage ignored, because --profile is in use.')
1026
657
            ret = apply_profiled(run, *run_argv)
1027
 
        elif opt_coverage_dir:
1028
 
            ret = apply_coveraged(opt_coverage_dir, run, *run_argv)
1029
658
        else:
1030
659
            ret = run(*run_argv)
1031
 
        if 'memory' in debug.debug_flags:
1032
 
            trace.debug_memory('Process status after command:', short=False)
1033
660
        return ret or 0
1034
661
    finally:
1035
 
        # reset, in case we may do other commands later within the same
1036
 
        # process. Commands that want to execute sub-commands must propagate
1037
 
        # --verbose in their own way.
1038
 
        option._verbosity_level = saved_verbosity_level
1039
 
 
 
662
        # reset, in case we may do other commands later within the same process
 
663
        be_quiet(False)
1040
664
 
1041
665
def display_command(func):
1042
666
    """Decorator that suppresses pipe/interrupt errors."""
1046
670
            sys.stdout.flush()
1047
671
            return result
1048
672
        except IOError, e:
1049
 
            if getattr(e, 'errno', None) is None:
 
673
            if not hasattr(e, 'errno'):
1050
674
                raise
1051
675
            if e.errno != errno.EPIPE:
1052
676
                # Win32 raises IOError with errno=0 on a broken pipe
1053
 
                if sys.platform != 'win32' or (e.errno not in (0, errno.EINVAL)):
 
677
                if sys.platform != 'win32' or e.errno != 0:
1054
678
                    raise
1055
679
            pass
1056
680
        except KeyboardInterrupt:
1058
682
    return ignore_pipe
1059
683
 
1060
684
 
1061
 
def install_bzr_command_hooks():
1062
 
    """Install the hooks to supply bzr's own commands."""
1063
 
    if _list_bzr_commands in Command.hooks["list_commands"]:
1064
 
        return
1065
 
    Command.hooks.install_named_hook("list_commands", _list_bzr_commands,
1066
 
        "bzr commands")
1067
 
    Command.hooks.install_named_hook("get_command", _get_bzr_command,
1068
 
        "bzr commands")
1069
 
    Command.hooks.install_named_hook("get_command", _get_plugin_command,
1070
 
        "bzr plugin commands")
1071
 
    Command.hooks.install_named_hook("get_command", _get_external_command,
1072
 
        "bzr external command lookup")
1073
 
    Command.hooks.install_named_hook("get_missing_command", _try_plugin_provider,
1074
 
        "bzr plugin-provider-db check")
1075
 
 
1076
 
 
1077
 
def main(argv=None):
1078
 
    """Main entry point of command-line interface.
1079
 
 
1080
 
    :param argv: list of unicode command-line arguments similar to sys.argv.
1081
 
        argv[0] is script name usually, it will be ignored.
1082
 
        Don't pass here sys.argv because this list contains plain strings
1083
 
        and not unicode; pass None instead.
1084
 
 
1085
 
    :return: exit code of bzr command.
1086
 
    """
 
685
def main(argv):
1087
686
    import bzrlib.ui
1088
 
    bzrlib.ui.ui_factory = bzrlib.ui.make_ui_for_terminal(
1089
 
        sys.stdin, sys.stdout, sys.stderr)
1090
 
 
1091
 
    # Is this a final release version? If so, we should suppress warnings
1092
 
    if bzrlib.version_info[3] == 'final':
1093
 
        suppress_deprecation_warnings(override=False)
1094
 
    if argv is None:
1095
 
        argv = osutils.get_unicode_argv()
1096
 
    else:
1097
 
        new_argv = []
1098
 
        try:
1099
 
            # ensure all arguments are unicode strings
1100
 
            for a in argv[1:]:
1101
 
                if isinstance(a, unicode):
1102
 
                    new_argv.append(a)
1103
 
                else:
1104
 
                    new_argv.append(a.decode('ascii'))
1105
 
        except UnicodeDecodeError:
1106
 
            raise errors.BzrError("argv should be list of unicode strings.")
1107
 
        argv = new_argv
 
687
    from bzrlib.ui.text import TextUIFactory
 
688
    bzrlib.ui.ui_factory = TextUIFactory()
 
689
    argv = [a.decode(bzrlib.user_encoding) for a in argv[1:]]
1108
690
    ret = run_bzr_catch_errors(argv)
1109
 
    trace.mutter("return code %d", ret)
 
691
    mutter("return code %d", ret)
1110
692
    return ret
1111
693
 
1112
694
 
1113
695
def run_bzr_catch_errors(argv):
1114
 
    """Run a bzr command with parameters as described by argv.
1115
 
 
1116
 
    This function assumed that that UI layer is setup, that symbol deprecations
1117
 
    are already applied, and that unicode decoding has already been performed on argv.
1118
 
    """
1119
 
    install_bzr_command_hooks()
1120
 
    return exception_to_return_code(run_bzr, argv)
1121
 
 
1122
 
 
1123
 
def run_bzr_catch_user_errors(argv):
1124
 
    """Run bzr and report user errors, but let internal errors propagate.
1125
 
 
1126
 
    This is used for the test suite, and might be useful for other programs
1127
 
    that want to wrap the commandline interface.
1128
 
    """
1129
 
    install_bzr_command_hooks()
1130
696
    try:
1131
697
        return run_bzr(argv)
 
698
        # do this here inside the exception wrappers to catch EPIPE
 
699
        sys.stdout.flush()
1132
700
    except Exception, e:
1133
 
        if (isinstance(e, (OSError, IOError))
1134
 
            or not getattr(e, 'internal_error', True)):
1135
 
            trace.report_exception(sys.exc_info(), sys.stderr)
1136
 
            return 3
1137
 
        else:
1138
 
            raise
1139
 
 
1140
 
 
1141
 
class HelpCommandIndex(object):
1142
 
    """A index for bzr help that returns commands."""
1143
 
 
1144
 
    def __init__(self):
1145
 
        self.prefix = 'commands/'
1146
 
 
1147
 
    def get_topics(self, topic):
1148
 
        """Search for topic amongst commands.
1149
 
 
1150
 
        :param topic: A topic to search for.
1151
 
        :return: A list which is either empty or contains a single
1152
 
            Command entry.
1153
 
        """
1154
 
        if topic and topic.startswith(self.prefix):
1155
 
            topic = topic[len(self.prefix):]
1156
 
        try:
1157
 
            cmd = _get_cmd_object(topic)
1158
 
        except KeyError:
1159
 
            return []
1160
 
        else:
1161
 
            return [cmd]
1162
 
 
1163
 
 
1164
 
class Provider(object):
1165
 
    '''Generic class to be overriden by plugins'''
1166
 
 
1167
 
    def plugin_for_command(self, cmd_name):
1168
 
        '''Takes a command and returns the information for that plugin
1169
 
 
1170
 
        :return: A dictionary with all the available information
1171
 
        for the requested plugin
1172
 
        '''
1173
 
        raise NotImplementedError
1174
 
 
1175
 
 
1176
 
class ProvidersRegistry(registry.Registry):
1177
 
    '''This registry exists to allow other providers to exist'''
1178
 
 
1179
 
    def __iter__(self):
1180
 
        for key, provider in self.iteritems():
1181
 
            yield provider
1182
 
 
1183
 
command_providers_registry = ProvidersRegistry()
1184
 
 
 
701
        # used to handle AssertionError and KeyboardInterrupt
 
702
        # specially here, but hopefully they're handled ok by the logger now
 
703
        bzrlib.trace.report_exception(sys.exc_info(), sys.stderr)
 
704
        if os.environ.get('BZR_PDB'):
 
705
            print '**** entering debugger'
 
706
            import pdb
 
707
            pdb.post_mortem(sys.exc_traceback)
 
708
        return 3
1185
709
 
1186
710
if __name__ == '__main__':
1187
711
    sys.exit(main(sys.argv))