← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/commands.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2006-09-27 19:48:46 UTC
  • mfrom: (2045.1.3 jam-integration)
  • Revision ID: pqm@pqm.ubuntu.com-20060927194846-b26e0ca2dd3f8519
Lukáš Lalinský: TransportNotPossible has a bad docstring

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 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
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(), """
36
31
import codecs
37
32
import errno
 
33
import os
38
34
from warnings import warn
 
35
import sys
39
36
 
40
37
import bzrlib
41
 
from bzrlib import (
42
 
    debug,
43
 
    errors,
44
 
    option,
45
 
    osutils,
46
 
    trace,
47
 
    win32utils,
48
 
    )
49
 
""")
50
 
 
51
 
from bzrlib.symbol_versioning import (
52
 
    deprecated_function,
53
 
    deprecated_method,
54
 
    zero_eight,
55
 
    zero_eleven,
56
 
    )
57
 
# Compatibility
 
38
import bzrlib.errors as errors
 
39
from bzrlib.errors import (BzrError,
 
40
                           BzrCommandError,
 
41
                           BzrCheckError,
 
42
                           NotBranchError)
 
43
from bzrlib import option
58
44
from bzrlib.option import Option
59
 
 
 
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
60
49
 
61
50
plugin_cmds = {}
62
51
 
77
66
        k_unsquished = k
78
67
    if k_unsquished not in plugin_cmds:
79
68
        plugin_cmds[k_unsquished] = cmd
80
 
        ## trace.mutter('registered plugin command %s', k_unsquished)
 
69
        mutter('registered plugin command %s', k_unsquished)
81
70
        if decorate and k_unsquished in builtin_command_names():
82
71
            return _builtin_commands()[k_unsquished]
83
72
    elif decorate:
85
74
        plugin_cmds[k_unsquished] = cmd
86
75
        return result
87
76
    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__])
 
77
        log_error('Two plugins defined the same command: %r' % k)
 
78
        log_error('Not loading the one in %r' % sys.modules[cmd.__module__])
90
79
 
91
80
 
92
81
def _squish_command_name(cmd):
138
127
    plugins_override
139
128
        If true, plugin commands can override builtins.
140
129
    """
141
 
    try:
142
 
        return _get_cmd_object(cmd_name, plugins_override)
143
 
    except KeyError:
144
 
        raise errors.BzrCommandError('unknown command "%s"' % cmd_name)
145
 
 
146
 
 
147
 
def _get_cmd_object(cmd_name, plugins_override=True):
148
 
    """Worker for get_cmd_object which raises KeyError rather than BzrCommandError."""
149
130
    from bzrlib.externalcommand import ExternalCommand
150
131
 
151
132
    # We want only 'ascii' command names, but the user may have typed
168
149
    cmd_obj = ExternalCommand.find_command(cmd_name)
169
150
    if cmd_obj:
170
151
        return cmd_obj
171
 
    raise KeyError
 
152
 
 
153
    raise BzrCommandError('unknown command "%s"' % cmd_name)
172
154
 
173
155
 
174
156
class Command(object):
222
204
            replace - put in a bogus character (typically '?')
223
205
            exact - do not encode sys.stdout
224
206
 
225
 
            NOTE: by default on Windows, sys.stdout is opened as a text
226
 
            stream, therefore LF line-endings are converted to CRLF.
227
 
            When a command uses encoding_type = 'exact', then
228
 
            sys.stdout is forced to be a binary stream, and line-endings
229
 
            will not mangled.
230
 
 
231
207
    """
232
208
    aliases = []
233
209
    takes_args = []
241
217
        if self.__doc__ == Command.__doc__:
242
218
            warn("No help message set for %r" % self)
243
219
 
244
 
    def _maybe_expand_globs(self, file_list):
245
 
        """Glob expand file_list if the platform does not do that itself.
246
 
        
247
 
        :return: A possibly empty list of unicode paths.
248
 
 
249
 
        Introduced in bzrlib 0.18.
250
 
        """
251
 
        if not file_list:
252
 
            file_list = []
253
 
        if sys.platform == 'win32':
254
 
            file_list = win32utils.glob_expand(file_list)
255
 
        return list(file_list)
256
 
 
257
 
    def _usage(self):
258
 
        """Return single-line grammar for this command.
259
 
 
260
 
        Only describes arguments, not options.
261
 
        """
262
 
        s = 'bzr ' + self.name() + ' '
263
 
        for aname in self.takes_args:
264
 
            aname = aname.upper()
265
 
            if aname[-1] in ['$', '+']:
266
 
                aname = aname[:-1] + '...'
267
 
            elif aname[-1] == '?':
268
 
                aname = '[' + aname[:-1] + ']'
269
 
            elif aname[-1] == '*':
270
 
                aname = '[' + aname[:-1] + '...]'
271
 
            s += aname + ' '
272
 
                
273
 
        assert s[-1] == ' '
274
 
        s = s[:-1]
275
 
        return s
276
 
 
277
 
    def get_help_text(self, additional_see_also=None):
278
 
        """Return a text string with help for this command.
279
 
        
280
 
        :param additional_see_also: Additional help topics to be
281
 
            cross-referenced.
282
 
        """
283
 
        doc = self.help()
284
 
        if doc is None:
285
 
            raise NotImplementedError("sorry, no detailed help yet for %r" % self.name())
286
 
 
287
 
        result = ""
288
 
        result += 'usage: %s\n' % self._usage()
289
 
 
290
 
        if self.aliases:
291
 
            result += 'aliases: '
292
 
            result += ', '.join(self.aliases) + '\n'
293
 
 
294
 
        result += '\n'
295
 
 
296
 
        plugin_name = self.plugin_name()
297
 
        if plugin_name is not None:
298
 
            result += '(From plugin "%s")' % plugin_name
299
 
            result += '\n\n'
300
 
 
301
 
        result += doc
302
 
        if result[-1] != '\n':
303
 
            result += '\n'
304
 
        result += '\n'
305
 
        result += option.get_optparser(self.options()).format_option_help()
306
 
        see_also = self.get_see_also(additional_see_also)
307
 
        if see_also:
308
 
            result += '\nSee also: '
309
 
            result += ', '.join(see_also)
310
 
            result += '\n'
311
 
        return result
312
 
 
313
 
    def get_help_topic(self):
314
 
        """Return the commands help topic - its name."""
315
 
        return self.name()
316
 
 
317
 
    def get_see_also(self, additional_terms=None):
318
 
        """Return a list of help topics that are related to this ommand.
319
 
        
320
 
        The list is derived from the content of the _see_also attribute. Any
321
 
        duplicates are removed and the result is in lexical order.
322
 
        :param additional_terms: Additional help topics to cross-reference.
323
 
        :return: A list of help topics.
324
 
        """
325
 
        see_also = set(getattr(self, '_see_also', []))
326
 
        if additional_terms:
327
 
            see_also.update(additional_terms)
328
 
        return sorted(see_also)
329
 
 
330
220
    def options(self):
331
221
        """Return dict of valid options for this command.
332
222
 
333
223
        Maps from long option name to option object."""
334
224
        r = dict()
335
 
        r['help'] = option._help_option
 
225
        r['help'] = Option.OPTIONS['help']
336
226
        for o in self.takes_options:
337
227
            if isinstance(o, basestring):
338
 
                o = option.Option.OPTIONS[o]
 
228
                o = Option.OPTIONS[o]
339
229
            r[o.name] = o
340
230
        return r
341
231
 
346
236
        # Originally I was using self.stdout, but that looks
347
237
        # *way* too much like sys.stdout
348
238
        if self.encoding_type == 'exact':
349
 
            # force sys.stdout to be binary stream on win32
350
 
            if sys.platform == 'win32':
351
 
                fileno = getattr(sys.stdout, 'fileno', None)
352
 
                if fileno:
353
 
                    import msvcrt
354
 
                    msvcrt.setmode(fileno(), os.O_BINARY)
355
239
            self.outf = sys.stdout
356
240
            return
357
241
 
358
 
        output_encoding = osutils.get_terminal_encoding()
 
242
        output_encoding = bzrlib.osutils.get_terminal_encoding()
359
243
 
360
244
        # use 'replace' so that we don't abort if trying to write out
361
245
        # in e.g. the default C locale.
365
249
        # bogus. So set the attribute, so we can find the correct encoding later.
366
250
        self.outf.encoding = output_encoding
367
251
 
 
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
 
368
260
    def run_argv_aliases(self, argv, alias_argv=None):
369
261
        """Parse the command line and run with extra aliases in alias_argv."""
370
262
        if argv is None:
371
 
            warn("Passing None for [] is deprecated from bzrlib 0.10",
 
263
            warn("Passing None for [] is deprecated from bzrlib 0.10", 
372
264
                 DeprecationWarning, stacklevel=2)
373
265
            argv = []
374
266
        args, opts = parse_args(self, argv, alias_argv)
375
267
        if 'help' in opts:  # e.g. bzr add --help
376
 
            sys.stdout.write(self.get_help_text())
 
268
            from bzrlib.help import help_on_command
 
269
            help_on_command(self.name())
377
270
            return 0
378
271
        # mix arguments and options into one dictionary
379
272
        cmdargs = _match_argform(self.name(), self.takes_args, args)
398
291
        shell error code if not.  It's OK for this method to allow
399
292
        an exception to raise up.
400
293
        """
401
 
        raise NotImplementedError('no implementation of command %r'
 
294
        raise NotImplementedError('no implementation of command %r' 
402
295
                                  % self.name())
403
296
 
404
297
    def help(self):
423
316
            return None
424
317
 
425
318
 
426
 
# Technically, this function hasn't been use in a *really* long time
427
 
# but we are only deprecating it now.
428
 
@deprecated_function(zero_eleven)
429
319
def parse_spec(spec):
430
320
    """
431
321
    >>> parse_spec(None)
473
363
        args = argv
474
364
 
475
365
    options, args = parser.parse_args(args)
476
 
    opts = dict([(k, v) for k, v in options.__dict__.iteritems() if
 
366
    opts = dict([(k, v) for k, v in options.__dict__.iteritems() if 
477
367
                 v is not option.OptionParser.DEFAULT_VALUE])
478
368
    return args, opts
479
369
 
495
385
                argdict[argname + '_list'] = None
496
386
        elif ap[-1] == '+':
497
387
            if not args:
498
 
                raise errors.BzrCommandError("command %r needs one or more %s"
499
 
                                             % (cmd, argname.upper()))
 
388
                raise BzrCommandError("command %r needs one or more %s"
 
389
                        % (cmd, argname.upper()))
500
390
            else:
501
391
                argdict[argname + '_list'] = args[:]
502
392
                args = []
503
393
        elif ap[-1] == '$': # all but one
504
394
            if len(args) < 2:
505
 
                raise errors.BzrCommandError("command %r needs one or more %s"
506
 
                                             % (cmd, argname.upper()))
 
395
                raise BzrCommandError("command %r needs one or more %s"
 
396
                        % (cmd, argname.upper()))
507
397
            argdict[argname + '_list'] = args[:-1]
508
398
            args[:-1] = []
509
399
        else:
510
400
            # just a plain arg
511
401
            argname = ap
512
402
            if not args:
513
 
                raise errors.BzrCommandError("command %r requires argument %s"
514
 
                               % (cmd, argname.upper()))
 
403
                raise BzrCommandError("command %r requires argument %s"
 
404
                        % (cmd, argname.upper()))
515
405
            else:
516
406
                argdict[argname] = args.pop(0)
517
407
            
518
408
    if args:
519
 
        raise errors.BzrCommandError("extra argument to command %s: %s"
520
 
                                     % (cmd, args[0]))
 
409
        raise BzrCommandError("extra argument to command %s: %s"
 
410
                              % (cmd, args[0]))
521
411
 
522
412
    return argdict
523
413
 
548
438
 
549
439
def apply_lsprofiled(filename, the_callable, *args, **kwargs):
550
440
    from bzrlib.lsprof import profile
 
441
    import cPickle
551
442
    ret, stats = profile(the_callable, *args, **kwargs)
552
443
    stats.sort()
553
444
    if filename is None:
554
445
        stats.pprint()
555
446
    else:
556
 
        stats.save(filename)
557
 
        trace.note('Profile data written to "%s".', filename)
 
447
        stats.freeze()
 
448
        cPickle.dump(stats, open(filename, 'w'), 2)
 
449
        print 'Profile data written to %r.' % filename
558
450
    return ret
559
451
 
560
452
 
561
 
def get_alias(cmd, config=None):
562
 
    """Return an expanded alias, or None if no alias exists.
563
 
 
564
 
    cmd
565
 
        Command to be checked for an alias.
566
 
    config
567
 
        Used to specify an alternative config to use,
568
 
        which is especially useful for testing.
569
 
        If it is unspecified, the global config will be used.
570
 
    """
571
 
    if config is None:
572
 
        import bzrlib.config
573
 
        config = bzrlib.config.GlobalConfig()
574
 
    alias = config.get_alias(cmd)
 
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)
575
457
    if (alias):
576
 
        import shlex
577
 
        return [a.decode('utf-8') for a in shlex.split(alias.encode('utf-8'))]
 
458
        return alias.split(' ')
578
459
    return None
579
460
 
580
461
 
611
492
        Run under the Python lsprof profiler.
612
493
    """
613
494
    argv = list(argv)
614
 
    trace.mutter("bzr arguments: %r", argv)
615
495
 
616
496
    opt_lsprof = opt_profile = opt_no_plugins = opt_builtin =  \
617
497
                opt_no_aliases = False
640
520
        elif a == '--builtin':
641
521
            opt_builtin = True
642
522
        elif a in ('--quiet', '-q'):
643
 
            trace.be_quiet()
644
 
        elif a.startswith('-D'):
645
 
            debug.debug_flags.add(a[2:])
 
523
            be_quiet()
646
524
        else:
647
525
            argv_copy.append(a)
648
526
        i += 1
679
557
    # 'command not found' error later.
680
558
 
681
559
    cmd_obj = get_cmd_object(cmd, plugins_override=not opt_builtin)
682
 
    run = cmd_obj.run_argv_aliases
683
 
    run_argv = [argv, alias_argv]
 
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]
684
566
 
685
567
    try:
686
568
        if opt_lsprof:
692
574
        return ret or 0
693
575
    finally:
694
576
        # reset, in case we may do other commands later within the same process
695
 
        trace.be_quiet(False)
 
577
        be_quiet(False)
696
578
 
697
579
def display_command(func):
698
580
    """Decorator that suppresses pipe/interrupt errors."""
706
588
                raise
707
589
            if e.errno != errno.EPIPE:
708
590
                # Win32 raises IOError with errno=0 on a broken pipe
709
 
                if sys.platform != 'win32' or (e.errno not in (0, errno.EINVAL)):
 
591
                if sys.platform != 'win32' or e.errno != 0:
710
592
                    raise
711
593
            pass
712
594
        except KeyboardInterrupt:
720
602
    bzrlib.ui.ui_factory = TextUIFactory()
721
603
    argv = [a.decode(bzrlib.user_encoding) for a in argv[1:]]
722
604
    ret = run_bzr_catch_errors(argv)
723
 
    trace.mutter("return code %d", ret)
 
605
    mutter("return code %d", ret)
724
606
    return ret
725
607
 
726
608
 
727
609
def run_bzr_catch_errors(argv):
728
610
    try:
729
611
        return run_bzr(argv)
 
612
        # do this here inside the exception wrappers to catch EPIPE
 
613
        sys.stdout.flush()
730
614
    except (KeyboardInterrupt, Exception), e:
731
615
        # used to handle AssertionError and KeyboardInterrupt
732
616
        # specially here, but hopefully they're handled ok by the logger now
733
 
        trace.report_exception(sys.exc_info(), sys.stderr)
 
617
        bzrlib.trace.report_exception(sys.exc_info(), sys.stderr)
734
618
        if os.environ.get('BZR_PDB'):
735
619
            print '**** entering debugger'
736
620
            import pdb
737
621
            pdb.post_mortem(sys.exc_traceback)
738
622
        return 3
739
623
 
740
 
 
741
 
class HelpCommandIndex(object):
742
 
    """A index for bzr help that returns commands."""
743
 
 
744
 
    def __init__(self):
745
 
        self.prefix = 'commands/'
746
 
 
747
 
    def get_topics(self, topic):
748
 
        """Search for topic amongst commands.
749
 
 
750
 
        :param topic: A topic to search for.
751
 
        :return: A list which is either empty or contains a single
752
 
            Command entry.
753
 
        """
754
 
        if topic and topic.startswith(self.prefix):
755
 
            topic = topic[len(self.prefix):]
756
 
        try:
757
 
            cmd = _get_cmd_object(topic)
758
 
        except KeyError:
759
 
            return []
760
 
        else:
761
 
            return [cmd]
762
 
 
763
 
 
764
624
if __name__ == '__main__':
765
625
    sys.exit(main(sys.argv))