← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/commands.py

  • Committer: Martin Pool
  • Date: 2010-04-01 04:41:18 UTC
  • mto: This revision was merged to the branch mainline in revision 5128.
  • Revision ID: mbp@sourcefrog.net-20100401044118-shyctqc02ob08ngz
ignore .testrepository

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/commands.py
222
222
    Use of all_command_names() is encouraged rather than builtin_command_names
223
223
    and/or plugin_command_names.
224
224
    """
225
 
    _register_builtin_commands()
226
225
    return builtin_command_registry.keys()
227
226
 
228
227
 
398
397
            will not mangled.
399
398
 
400
399
    :cvar hooks: An instance of CommandHooks.
401
 
    :ivar __doc__: The help shown by 'bzr help command' for this command.
402
 
        This is set by assigning explicitly to __doc__ so that -OO can
403
 
        be used::
404
 
 
405
 
        class Foo(Command):
406
 
            __doc__ = "My help goes here"
407
400
    """
408
401
    aliases = []
409
402
    takes_args = []
414
407
 
415
408
    def __init__(self):
416
409
        """Construct an instance of this command."""
 
410
        if self.__doc__ == Command.__doc__:
 
411
            warn("No help message set for %r" % self)
417
412
        # List of standard options directly supported
418
413
        self.supported_std_options = []
419
 
        self._setup_run()
 
414
        self._operation = cleanup.OperationWithCleanups(self.run)
420
415
 
421
416
    def add_cleanup(self, cleanup_func, *args, **kwargs):
422
417
        """Register a function to call after self.run returns or raises.
434
429
 
435
430
        This is useful for releasing expensive or contentious resources (such
436
431
        as write locks) before doing further work that does not require those
437
 
        resources (such as writing results to self.outf). Note though, that
438
 
        as it releases all resources, this may release locks that the command
439
 
        wants to hold, so use should be done with care.
 
432
        resources (such as writing results to self.outf).
440
433
        """
441
434
        self._operation.cleanup_now()
442
435
 
487
480
            message explaining how to obtain full help.
488
481
        """
489
482
        doc = self.help()
490
 
        if not doc:
491
 
            doc = "No help for this command."
 
483
        if doc is None:
 
484
            raise NotImplementedError("sorry, no detailed help yet for %r" % self.name())
492
485
 
493
486
        # Extract the summary (purpose) and sections out from the text
494
487
        purpose,sections,order = self._get_help_parts(doc)
687
680
 
688
681
        self._setup_outf()
689
682
 
690
 
        return self.run(**all_cmd_args)
691
 
 
692
 
    def _setup_run(self):
693
 
        """Wrap the defined run method on self with a cleanup.
694
 
 
695
 
        This is called by __init__ to make the Command be able to be run
696
 
        by just calling run(), as it could be before cleanups were added.
697
 
 
698
 
        If a different form of cleanups are in use by your Command subclass,
699
 
        you can override this method.
700
 
        """
701
 
        class_run = self.run
702
 
        def run(*args, **kwargs):
703
 
            self._operation = cleanup.OperationWithCleanups(class_run)
704
 
            try:
705
 
                return self._operation.run_simple(*args, **kwargs)
706
 
            finally:
707
 
                del self._operation
708
 
        self.run = run
709
 
 
710
 
    @deprecated_method(deprecated_in((2, 2, 0)))
 
683
        return self.run_direct(**all_cmd_args)
 
684
 
711
685
    def run_direct(self, *args, **kwargs):
712
 
        """Deprecated thunk from bzrlib 2.1."""
713
 
        return self.run(*args, **kwargs)
 
686
        """Call run directly with objects (without parsing an argv list)."""
 
687
        return self._operation.run_simple(*args, **kwargs)
714
688
 
715
689
    def run(self):
716
690
        """Actually run the command.
721
695
        Return 0 or None if the command was successful, or a non-zero
722
696
        shell error code if not.  It's OK for this method to allow
723
697
        an exception to raise up.
724
 
 
725
 
        This method is automatically wrapped by Command.__init__ with a 
726
 
        cleanup operation, stored as self._operation. This can be used
727
 
        via self.add_cleanup to perform automatic cleanups at the end of
728
 
        run().
729
 
 
730
 
        The argument for run are assembled by introspection. So for instance,
731
 
        if your command takes an argument files, you would declare::
732
 
 
733
 
            def run(self, files=None):
734
 
                pass
735
698
        """
736
699
        raise NotImplementedError('no implementation of command %r'
737
700
                                  % self.name())
1055
1018
        elif a == '--coverage':
1056
1019
            opt_coverage_dir = argv[i + 1]
1057
1020
            i += 1
1058
 
        elif a == '--profile-imports':
1059
 
            pass # already handled in startup script Bug #588277
1060
1021
        elif a.startswith('-D'):
1061
1022
            debug.debug_flags.add(a[2:])
1062
1023
        else:
1084
1045
    if not opt_no_aliases:
1085
1046
        alias_argv = get_alias(argv[0])
1086
1047
        if alias_argv:
 
1048
            user_encoding = osutils.get_user_encoding()
 
1049
            alias_argv = [a.decode(user_encoding) for a in alias_argv]
1087
1050
            argv[0] = alias_argv.pop(0)
1088
1051
 
1089
1052
    cmd = argv.pop(0)
 
1053
    # We want only 'ascii' command names, but the user may have typed
 
1054
    # in a Unicode name. In that case, they should just get a
 
1055
    # 'command not found' error later.
 
1056
 
1090
1057
    cmd_obj = get_cmd_object(cmd, plugins_override=not opt_builtin)
1091
1058
    run = cmd_obj.run_argv_aliases
1092
1059
    run_argv = [argv, alias_argv]