Merge branch 'main' into prompt-toolkit

Author: kmvanbrunt

CHANGELOG.md

@@ -47,6 +47,12 @@ shell, and the option for a persistent bottom bar that can display realtime stat
         - **max_column_completion_results**: (int) the maximum number of completion results to
           display in a single column
 
+## 3.1.3 (TBD)
+
+- Bug Fixes
+    - Fixed issue where `delimiter_complete()` could cause more matches than display matches
+    - Fixed issue where `CommandSet` registration did not respect disabled categories
+
 ## 3.1.2 (January 26, 2026)
 
 - Bug Fixes

cmd2/cmd2.py

@@ -635,11 +635,14 @@ def _(event: Any) -> None:  # pragma: no cover
         self._in_prompt = False
         self._in_prompt_lock = threading.Lock()
 
-        # Commands that have been disabled from use. This is to support commands that are only available
-        # during specific states of the application. This dictionary's keys are the command names and its
-        # values are DisabledCommand objects.
+        # Commands disabled during specific application states
+        # Key: Command name | Value: DisabledCommand object
         self.disabled_commands: dict[str, DisabledCommand] = {}
 
+        # Categories of commands to be disabled
+        # Key: Category name | Value: Message to display
+        self.disabled_categories: dict[str, str] = {}
+
         # The default key for sorting string results. Its default value performs a case-insensitive alphabetical sort.
         # If natural sorting is preferred, then set this to NATURAL_SORT_KEY.
         # cmd2 uses this key for sorting:
@@ -830,6 +833,12 @@ def register_command_set(self, cmdset: CommandSet) -> None:
                 if default_category and not hasattr(command_method, constants.CMD_ATTR_HELP_CATEGORY):
                     utils.categorize(command_method, default_category)
 
+                # If this command is in a disabled category, then disable it
+                command_category = getattr(command_method, constants.CMD_ATTR_HELP_CATEGORY, None)
+                if command_category in self.disabled_categories:
+                    message_to_print = self.disabled_categories[command_category]
+                    self.disable_command(command, message_to_print)
+
             self._installed_command_sets.add(cmdset)
 
             self._register_subcommands(cmdset)
@@ -1876,31 +1885,45 @@ def delimiter_complete(
         :return: a list of possible tab completions
         """
         matches = self.basic_complete(text, line, begidx, endidx, match_against)
+        if not matches:
+            return []
 
-        # Display only the portion of the match that's being completed based on delimiter
-        if matches:
-            # Set this to True for proper quoting of matches with spaces
-            self.matches_delimited = True
+        # Set this to True for proper quoting of matches with spaces
+        self.matches_delimited = True
 
-            # Get the common beginning for the matches
-            common_prefix = os.path.commonprefix(matches)
-            prefix_tokens = common_prefix.split(delimiter)
+        # Get the common beginning for the matches
+        common_prefix = os.path.commonprefix(matches)
+        prefix_tokens = common_prefix.split(delimiter)
 
-            # Calculate what portion of the match we are completing
-            display_token_index = 0
-            if prefix_tokens:
-                display_token_index = len(prefix_tokens) - 1
+        # Calculate what portion of the match we are completing
+        display_token_index = 0
+        if prefix_tokens:
+            display_token_index = len(prefix_tokens) - 1
 
-            # Get this portion for each match and store them in self.display_matches
-            for cur_match in matches:
-                match_tokens = cur_match.split(delimiter)
-                display_token = match_tokens[display_token_index]
+        # Remove from each match everything after where the user is completing.
+        # This approach can result in duplicates so we will filter those out.
+        unique_results: dict[str, str] = {}
 
-                if not display_token:
-                    display_token = delimiter
-                self.display_matches.append(display_token)
+        for cur_match in matches:
+            match_tokens = cur_match.split(delimiter)
 
-        return matches
+            filtered_match = delimiter.join(match_tokens[: display_token_index + 1])
+            display_match = match_tokens[display_token_index]
+
+            # If there are more tokens, then we aren't done completing a full item
+            if len(match_tokens) > display_token_index + 1:
+                filtered_match += delimiter
+                display_match += delimiter
+                self.allow_appended_space = False
+                self.allow_closing_quote = False
+
+            if filtered_match not in unique_results:
+                unique_results[filtered_match] = display_match
+
+        filtered_matches = list(unique_results.keys())
+        self.display_matches = list(unique_results.values())
+
+        return filtered_matches
 
     def flag_based_complete(
         self,
@@ -5620,7 +5643,7 @@ def enable_command(self, command: str) -> None:
 
         :param command: the command being enabled
         """
-        # If the commands is already enabled, then return
+        # If the command is already enabled, then return
         if command not in self.disabled_commands:
             return
 
@@ -5652,11 +5675,17 @@ def enable_category(self, category: str) -> None:
 
         :param category: the category to enable
         """
+        # If the category is already enabled, then return
+        if category not in self.disabled_categories:
+            return
+
         for cmd_name in list(self.disabled_commands):
             func = self.disabled_commands[cmd_name].command_function
             if getattr(func, constants.CMD_ATTR_HELP_CATEGORY, None) == category:
                 self.enable_command(cmd_name)
 
+        del self.disabled_categories[category]
+
     def disable_command(self, command: str, message_to_print: str) -> None:
         """Disable a command and overwrite its functions.
 
@@ -5667,7 +5696,7 @@ def disable_command(self, command: str, message_to_print: str) -> None:
                                  command being disabled.
                                  ex: message_to_print = f"{cmd2.COMMAND_NAME} is currently disabled"
         """
-        # If the commands is already disabled, then return
+        # If the command is already disabled, then return
         if command in self.disabled_commands:
             return
 
@@ -5706,13 +5735,19 @@ def disable_category(self, category: str, message_to_print: str) -> None:
                                  of the command being disabled.
                                  ex: message_to_print = f"{cmd2.COMMAND_NAME} is currently disabled"
         """
+        # If the category is already disabled, then return
+        if category in self.disabled_categories:
+            return
+
         all_commands = self.get_all_commands()
 
         for cmd_name in all_commands:
             func = self.cmd_func(cmd_name)
             if getattr(func, constants.CMD_ATTR_HELP_CATEGORY, None) == category:
                 self.disable_command(cmd_name, message_to_print)
 
+        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.
 

cmd2/utils.py

@@ -1,7 +1,6 @@
 """Shared utility functions."""
 
 import argparse
-import collections
 import contextlib
 import functools
 import glob
@@ -192,10 +191,7 @@ def remove_duplicates(list_to_prune: list[_T]) -> list[_T]:
     :param list_to_prune: the list being pruned of duplicates
     :return: The pruned list
     """
-    temp_dict: collections.OrderedDict[_T, Any] = collections.OrderedDict()
-    for item in list_to_prune:
-        temp_dict[item] = None
-
+    temp_dict = dict.fromkeys(list_to_prune)
     return list(temp_dict.keys())
 
 

tests/test_cmd2.py

@@ -20,6 +20,7 @@
     COMMAND_NAME,
     Cmd2Style,
     Color,
+    CommandSet,
     RichPrintKwargs,
     clipboard,
     constants,
@@ -3304,6 +3305,16 @@ def do_has_no_helper_funcs(self, arg) -> None:
         self.poutput("The real has_no_helper_funcs")
 
 
+class DisableCommandSet(CommandSet):
+    """Test registering a command which is in a disabled category"""
+
+    category_name = "CommandSet Test Category"
+
+    @cmd2.with_category(category_name)
+    def do_new_command(self, arg) -> None:
+        self._cmd.poutput("CommandSet function is enabled")
+
+
 @pytest.fixture
 def disable_commands_app():
     return DisableCommandsApp()
@@ -3407,7 +3418,7 @@ def test_enable_enabled_command(disable_commands_app) -> None:
     saved_len = len(disable_commands_app.disabled_commands)
     disable_commands_app.enable_command('has_helper_funcs')
 
-    # The number of disabled_commands should not have changed
+    # The number of disabled commands should not have changed
     assert saved_len == len(disable_commands_app.disabled_commands)
 
 
@@ -3421,7 +3432,7 @@ def test_disable_command_twice(disable_commands_app) -> None:
     message_to_print = 'These commands are currently disabled'
     disable_commands_app.disable_command('has_helper_funcs', message_to_print)
 
-    # The length of disabled_commands should have increased one
+    # The number of disabled commands should have increased one
     new_len = len(disable_commands_app.disabled_commands)
     assert saved_len == new_len - 1
     saved_len = new_len
@@ -3449,6 +3460,50 @@ def test_disabled_message_command_name(disable_commands_app) -> None:
     assert err[0].startswith('has_helper_funcs is currently disabled')
 
 
+def test_register_command_in_enabled_category(disable_commands_app) -> None:
+    disable_commands_app.enable_category(DisableCommandSet.category_name)
+    cs = DisableCommandSet()
+    disable_commands_app.register_command_set(cs)
+
+    out, _err = run_cmd(disable_commands_app, 'new_command')
+    assert out[0] == "CommandSet function is enabled"
+
+
+def test_register_command_in_disabled_category(disable_commands_app) -> None:
+    message_to_print = "CommandSet function is disabled"
+    disable_commands_app.disable_category(DisableCommandSet.category_name, message_to_print)
+    cs = DisableCommandSet()
+    disable_commands_app.register_command_set(cs)
+
+    _out, err = run_cmd(disable_commands_app, 'new_command')
+    assert err[0] == message_to_print
+
+
+def test_enable_enabled_category(disable_commands_app) -> None:
+    # Test enabling a category that is not disabled
+    saved_len = len(disable_commands_app.disabled_categories)
+    disable_commands_app.enable_category('Test Category')
+
+    # The number of disabled categories should not have changed
+    assert saved_len == len(disable_commands_app.disabled_categories)
+
+
+def test_disable_category_twice(disable_commands_app) -> None:
+    saved_len = len(disable_commands_app.disabled_categories)
+    message_to_print = 'These commands are currently disabled'
+    disable_commands_app.disable_category('Test Category', message_to_print)
+
+    # The number of disabled categories should have increased one
+    new_len = len(disable_commands_app.disabled_categories)
+    assert saved_len == new_len - 1
+    saved_len = new_len
+
+    # Disable again and the length should not change
+    disable_commands_app.disable_category('Test Category', message_to_print)
+    new_len = len(disable_commands_app.disabled_categories)
+    assert saved_len == new_len
+
+
 @pytest.mark.parametrize('silence_startup_script', [True, False])
 def test_startup_script(request, capsys, silence_startup_script) -> None:
     test_dir = os.path.dirname(request.module.__file__)