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