fix(pt_utils): fix history synchronization and completion word detection

Fixed an issue where prompt_toolkit history was not being cleared/updated when cmd2 history changed. Restored consecutive deduplication logic in history. Improved completion word detection to use correct delimiters matching cmd2 logic.

Author: tleonhardt

cmd2/pt_utils.py

@@ -1,5 +1,6 @@
 """Utilities for integrating prompt_toolkit with cmd2."""
 
+import re
 from collections.abc import Iterable
 from typing import (
     TYPE_CHECKING,
@@ -12,7 +13,10 @@
 from prompt_toolkit.document import Document
 from prompt_toolkit.history import History
 
-from . import utils
+from . import (
+    constants,
+    utils,
+)
 
 if TYPE_CHECKING:
     from .cmd2 import Cmd
@@ -28,7 +32,15 @@ def __init__(self, cmd_app: 'Cmd', custom_settings: utils.CustomCompletionSettin
 
     def get_completions(self, document: Document, _complete_event: object) -> Iterable[Completion]:
         """Get completions for the current input."""
-        text = document.get_word_before_cursor(WORD=True)
+        # Define delimiters for completion to match cmd2/readline behavior
+        delimiters = " \t\n" + "".join(constants.QUOTES) + "".join(constants.REDIRECTION_CHARS)
+        if hasattr(self.cmd_app, 'statement_parser'):
+            delimiters += "".join(self.cmd_app.statement_parser.terminators)
+
+        # Regex pattern for a word: one or more characters that are NOT delimiters
+        pattern = re.compile(f"[^{re.escape(delimiters)}]+")
+
+        text = document.get_word_before_cursor(pattern=pattern)
 
         # We need the full line and indexes for cmd2
         line = document.text
@@ -84,18 +96,20 @@ def __init__(self, cmd_app: 'Cmd') -> None:
 
     def load_history_strings(self) -> Iterable[str]:
         """Yield strings from cmd2's history to prompt_toolkit."""
+        for item in self.cmd_app.history:
+            yield item.statement.raw
+
+    def get_strings(self) -> list[str]:
+        """Get the strings from the history."""
+        # We override this to always get the latest history from cmd2
+        # instead of caching it like the base class does.
+        strings: list[str] = []
         last_item = None
-        for item in reversed(self.cmd_app.history):
+        for item in self.cmd_app.history:
             if item.statement.raw != last_item:
-                yield item.statement.raw
+                strings.append(item.statement.raw)
                 last_item = item.statement.raw
-
-    def get_strings(self) -> list[str]:
-        """Get the strings from the history that are loaded so far."""
-        if not self._loaded:
-            self._loaded_strings = list(self.load_history_strings())
-            self._loaded = True
-        return super().get_strings()
+        return strings
 
     def store_string(self, string: str) -> None:
         """prompt_toolkit calls this when a line is accepted.

tests/test_pt_utils.py

@@ -150,7 +150,7 @@ def make_history_item(self, text):
         return item
 
     def test_load_history_strings(self, mock_cmd_app):
-        """Test loading history strings in reverse order with deduping."""
+        """Test loading history strings yields all items in forward order."""
         history = pt_utils.Cmd2History(cast(any, mock_cmd_app))
 
         # Setup history items
@@ -163,10 +163,10 @@ def test_load_history_strings(self, mock_cmd_app):
         ]
         mock_cmd_app.history = items
 
-        # Expected: cmd3, cmd2, cmd1 (duplicates removed)
+        # Expected: cmd1, cmd2, cmd2, cmd3 (raw iteration)
         result = list(history.load_history_strings())
 
-        assert result == ["cmd3", "cmd2", "cmd1"]
+        assert result == ["cmd1", "cmd2", "cmd2", "cmd3"]
 
     def test_load_history_strings_empty(self, mock_cmd_app):
         """Test loading history strings with empty history."""
@@ -179,26 +179,25 @@ def test_load_history_strings_empty(self, mock_cmd_app):
         assert result == []
 
     def test_get_strings(self, mock_cmd_app):
-        """Test get_strings uses lazy loading."""
+        """Test get_strings returns deduped strings and does not cache."""
         history = pt_utils.Cmd2History(cast(any, mock_cmd_app))
 
-        items = [self.make_history_item("test")]
+        items = [
+            self.make_history_item("cmd1"),
+            self.make_history_item("cmd2"),
+            self.make_history_item("cmd2"),  # Duplicate
+            self.make_history_item("cmd3"),
+        ]
         mock_cmd_app.history = items
 
-        # Initially not loaded
-        assert not history._loaded
-
+        # Expect deduped: cmd1, cmd2, cmd3
         strings = history.get_strings()
+        assert strings == ["cmd1", "cmd2", "cmd3"]
 
-        assert strings == ["test"]
-        assert history._loaded
-        assert history._loaded_strings == ["test"]
-
-        # Call again, should return cached strings
-        # Modify underlying history to prove it uses cache
-        mock_cmd_app.history = []
+        # Modify underlying history to prove it does NOT use cache
+        mock_cmd_app.history.append(self.make_history_item("cmd4"))
         strings2 = history.get_strings()
-        assert strings2 == ["test"]
+        assert strings2 == ["cmd1", "cmd2", "cmd3", "cmd4"]
 
     def test_store_string(self, mock_cmd_app):
         """Test store_string does nothing."""