Made is so command_parsers.get() returns parsers for disabled commands.

Author: kmvanbrunt

cmd2/cmd2.py

@@ -617,10 +617,12 @@ def __init__(
 
         # Commands disabled during specific application states
         # Key: Command name | Value: DisabledCommand object
+        # NOTE: Use disable_command() and enable_command() to modify this dictionary.
         self.disabled_commands: dict[str, DisabledCommand] = {}
 
         # Categories of commands to be disabled
         # Key: Category name | Value: Message to display
+        # NOTE: Use disable_category() and enable_category() to modify this dictionary.
         self.disabled_categories: dict[str, str] = {}
 
         # Command parsers for this Cmd instance.
@@ -1148,9 +1150,8 @@ def get_root_parser_and_subcmd_path(self, command: str) -> tuple[Cmd2ArgumentPar
         """Tokenize a command string and resolve the associated root parser and relative subcommand path.
 
         This helper handles the initial resolution of a command string (e.g., 'foo bar baz') by
-        identifying 'foo' as the root command (even if disabled), retrieving its associated
-        parser, and returning any remaining tokens (['bar', 'baz']) as a path relative
-        to that parser for further traversal.
+        identifying 'foo' as the root command, retrieving its associated parser, and returning
+        any remaining tokens (['bar', 'baz']) as a path relative to that parser for further traversal.
 
         :param command: full space-delimited command path leading to a parser (e.g. 'foo' or 'foo bar')
         :return: a tuple containing the Cmd2ArgumentParser for the root command and a list of
@@ -1166,11 +1167,7 @@ def get_root_parser_and_subcmd_path(self, command: str) -> tuple[Cmd2ArgumentPar
         subcommand_path = tokens[1:]
 
         # Search for the base command function and verify it has an argparser defined
-        if root_command in self.disabled_commands:
-            command_func = self.disabled_commands[root_command].command_function
-        else:
-            command_func = self.get_command_func(root_command)
-
+        command_func = self.get_command_func(root_command)
         if command_func is None:
             raise ValueError(f"Root command '{root_command}' not found")
 
@@ -4314,8 +4311,21 @@ def do_help(self, args: argparse.Namespace) -> None:
 
         else:
             # Getting help for a specific command
-            func = self.get_command_func(args.command)
+            disabled = args.command in self.disabled_commands
             help_func = getattr(self, constants.HELP_FUNC_PREFIX + args.command, None)
+
+            # If the command is disabled, then call the help function which was
+            # overwritten by disable_command() to print the disabled message.
+            if disabled:
+                if help_func is not None:
+                    help_func()
+                else:
+                    # This is a defensive fallback in case someone disabled a command
+                    # without using disable_command() resulting in no help function.
+                    self._report_disabled_command_usage(message_to_print=f"{args.command} is currently disabled.")
+                return
+
+            func = self.get_command_func(args.command)
             argparser = None if func is None else self.command_parsers.get(func)
 
             # If the command function uses argparse, then use argparse's help
@@ -5652,15 +5662,27 @@ def disable_command(self, command: str, message_to_print: str) -> None:
             completer_function=getattr(self, completer_func_name, None),
         )
 
-        # Overwrite the command and help functions to print the message
-        new_func = functools.partial(
-            self._report_disabled_command_usage, message_to_print=message_to_print.replace(constants.COMMAND_NAME, command)
-        )
-        setattr(self, cmd_func_name, new_func)
-        setattr(self, help_func_name, new_func)
+        # Overwrite command function to print the message
+        message_to_print = message_to_print.replace(constants.COMMAND_NAME, command)
+        new_cmd_func = functools.partial(self._report_disabled_command_usage, message_to_print=message_to_print)
 
-        # Set the completer to a function that returns a blank list
-        setattr(self, completer_func_name, lambda *_args, **_kwargs: [])
+        # Preserve the metadata of the original command function
+        functools.update_wrapper(new_cmd_func, command_function)
+        setattr(self, cmd_func_name, new_cmd_func)
+
+        # Overwrite the help function to print the message
+        new_help_func = functools.partial(self._report_disabled_command_usage, message_to_print=message_to_print)
+        if (help_function := self.disabled_commands[command].help_function) is not None:
+            # Preserve the metadata of the original help function
+            functools.update_wrapper(new_help_func, help_function)
+        setattr(self, help_func_name, new_help_func)
+
+        # Set the completer to a function that returns a nothing
+        new_completer_func = functools.partial(self._disabled_completer)
+        if (completer_function := self.disabled_commands[command].completer_function) is not None:
+            # Preserve the metadata of the original completer function
+            functools.update_wrapper(new_completer_func, completer_function)
+        setattr(self, completer_func_name, new_completer_func)
 
     def disable_category(self, category: str, message_to_print: str) -> None:
         """Disable an entire category of commands.
@@ -5685,14 +5707,23 @@ def disable_category(self, category: str, message_to_print: str) -> None:
         self.disabled_categories[category] = message_to_print
 
     def _report_disabled_command_usage(self, *_args: Any, message_to_print: str, **_kwargs: Any) -> None:
-        """Report when a disabled command has been run or had help called on it.
+        """Report when a disabled command or its help function is run.
 
         :param _args: not used
         :param message_to_print: the message reporting that the command is disabled
         :param _kwargs: not used
         """
         self.perror(message_to_print, style=None)
 
+    def _disabled_completer(self, *_args: Any, **_kwargs: Any) -> Completions:
+        """Completer function for a disabled command.
+
+        :param _args: not used
+        :param _kwargs: not used
+        :return: an empty Completions object
+        """
+        return Completions()
+
     def cmdloop(self, intro: RenderableType = "") -> int:
         """Deal with extra features provided by cmd2, this is an outer wrapper around _cmdloop().
 

tests/test_cmd2.py

@@ -3837,6 +3837,10 @@ def do_is_not_decorated(self, arg) -> None:
         """This will be in the DEFAULT_CATEGORY."""
         self.poutput("The real is_not_decorated")
 
+    @cmd2.with_argparser(cmd2.Cmd2ArgumentParser())
+    def do_argparse_command(self, args) -> None:
+        """Help for argparse_command"""
+
 
 class DisableCommandSet(CommandSet[cmd2.Cmd]):
     """Test registering a command which is in a disabled category"""
@@ -4008,14 +4012,85 @@ def test_disabled_command_not_in_history(disable_commands_app) -> None:
     assert saved_len == len(disable_commands_app.history)
 
 
-def test_disabled_message_command_name(disable_commands_app) -> None:
+def test_get_parser_while_disabled(disable_commands_app: DisableCommandsApp) -> None:
+    # Get parser before disabling
+    parser_before = disable_commands_app.command_parsers.get(disable_commands_app.do_argparse_command)
+    assert parser_before is not None
+
+    # Disable command
+    disable_commands_app.disable_command("argparse_command", "Disabled")
+
+    # Get parser after disabling - this is what was failing (returning None)
+    parser_after = disable_commands_app.command_parsers.get(disable_commands_app.do_argparse_command)
+    assert parser_after is not None
+    assert parser_after is parser_before
+
+
+def test_metadata_preservation_while_disabled(disable_commands_app: DisableCommandsApp) -> None:
+    orig_cmd_func = disable_commands_app.do_has_helper_func
+    orig_help = disable_commands_app.help_has_helper_func
+    orig_complete = disable_commands_app.complete_has_helper_func
+
+    disable_commands_app.disable_command("has_helper_func", "Disabled")
+
+    # Names and qualnames should be preserved
+    assert disable_commands_app.do_has_helper_func.__name__ == orig_cmd_func.__name__
+    assert disable_commands_app.do_has_helper_func.__qualname__ == orig_cmd_func.__qualname__
+
+    assert disable_commands_app.help_has_helper_func.__name__ == orig_help.__name__
+    assert disable_commands_app.help_has_helper_func.__qualname__ == orig_help.__qualname__
+
+    assert disable_commands_app.complete_has_helper_func.__name__ == orig_complete.__name__
+    assert disable_commands_app.complete_has_helper_func.__qualname__ == orig_complete.__qualname__
+
+    # Docstrings should be preserved
+    assert disable_commands_app.do_has_helper_func.__doc__ == orig_cmd_func.__doc__
+    assert disable_commands_app.help_has_helper_func.__doc__ == orig_help.__doc__
+    assert disable_commands_app.complete_has_helper_func.__doc__ == orig_complete.__doc__
+
+
+def test_disabled_completer_returns_empty(disable_commands_app: DisableCommandsApp) -> None:
+    disable_commands_app.disable_command("has_helper_func", "Disabled")
+    completions = disable_commands_app.complete_has_helper_func("", "has_helper_func ", 16, 16)
+    assert len(completions) == 0
+
+
+def test_disabled_message_command_name(disable_commands_app: DisableCommandsApp) -> None:
     message_to_print = f"{COMMAND_NAME} is currently disabled"
     disable_commands_app.disable_command("has_helper_func", message_to_print)
 
     _out, err = run_cmd(disable_commands_app, "has_helper_func")
     assert err[0].startswith("has_helper_func is currently disabled")
 
 
+def test_help_argparse_command_while_disabled(disable_commands_app: DisableCommandsApp) -> None:
+    message_to_print = "This command is disabled"
+    disable_commands_app.disable_command("argparse_command", message_to_print)
+
+    # help <command> should show the disabled message
+    _out, err = run_cmd(disable_commands_app, "help argparse_command")
+    assert err[0].startswith(message_to_print)
+
+    # Re-enabling should restore the real help
+    disable_commands_app.enable_command("argparse_command")
+    out, _err = run_cmd(disable_commands_app, "help argparse_command")
+    assert "Usage: argparse_command" in out[0]
+
+
+def test_help_disabled_no_help_func(base_app: cmd2.Cmd) -> None:
+    from cmd2.cmd2 import DisabledCommand
+
+    # Manually disable a command without a help function to trigger the defensive fallback
+    command = "quit"
+    command_func = base_app.get_command_func(command)
+    base_app.disabled_commands[command] = DisabledCommand(
+        command_function=command_func, help_function=None, completer_function=None
+    )
+
+    _out, err = run_cmd(base_app, f"help {command}")
+    assert err[0].startswith(f"{command} is currently disabled.")
+
+
 def test_register_command_in_enabled_category(disable_commands_app) -> None:
     # Enable commands which are decorated with a category
     disable_commands_app.enable_category(DisableCommandSet.category_name)