Removed need for constants.EOF.

Author: kmvanbrunt

cmd2/cmd2.py

@@ -433,7 +433,7 @@ def __init__(
         self.self_in_py = False
 
         # Commands to exclude from the help menu and completion
-        self.hidden_commands = [constants.EOF, '_relative_run_script']
+        self.hidden_commands = ['_eof', '_relative_run_script']
 
         # Initialize history from a persistent history file (if present)
         self.persistent_history_file = ''
@@ -453,7 +453,7 @@ def __init__(
         self.session = self._init_session()
 
         # Commands to exclude from the history command
-        self.exclude_from_history = [constants.EOF, 'history']
+        self.exclude_from_history = ['_eof', 'history']
 
         # Dictionary of macro names and their values
         self.macros: dict[str, Macro] = {}
@@ -2821,11 +2821,6 @@ def runcmds_plus_hooks(
     def _complete_statement(self, line: str) -> Statement:
         """Keep accepting lines of input until the command is complete.
 
-        There is some pretty hacky code here to handle some quirks of
-        self._read_command_line(). It returns a literal 'eof' if the input
-        pipe runs out. We can't refactor it because we need to retain
-        backwards compatibility with the standard library version of cmd.
-
         :param line: the line being parsed
         :return: the completed Statement
         :raises Cmd2ShlexError: if a shlex error occurs (e.g. No closing quotation)
@@ -2859,12 +2854,10 @@ def _complete_statement(self, line: str) -> Statement:
                 self._multiline_in_progress = line + '\n'
 
                 # Get next line of this command
-                nextline = self._read_command_line(self.continuation_prompt)
-                if nextline == constants.EOF:
-                    # they entered either a blank line, or we hit an EOF
-                    # for some other reason. Turn the literal 'eof'
-                    # into a blank line, which serves as a command
-                    # terminator
+                try:
+                    nextline = self._read_command_line(self.continuation_prompt)
+                except EOFError:
+                    # Add a blank line, which serves as a command terminator.
                     nextline = '\n'
                     self.poutput(nextline)
 
@@ -3332,26 +3325,25 @@ def _read_command_line(self, prompt: str) -> str:
         """Read the next command line from the input stream.
 
         :param prompt: prompt to display to user
-        :return: command line text or 'eof' if an EOFError was caught
-        :raises Exception: any exceptions raised by prompt(), except EOFError
+        :return: the line read from stdin with all trailing new lines removed
+        :raises EOFError: if the input stream is closed or the user signals EOF (e.g., Ctrl+D)
+        :raises Exception: any other exceptions raised by prompt()
         """
-        try:
-            # Use dynamic prompt if the prompt matches self.prompt
-            def get_prompt() -> ANSI | str:
-                return ANSI(self.prompt)
-
-            prompt_to_use: Callable[[], ANSI | str] | ANSI | str = ANSI(prompt)
-            if prompt == self.prompt:
-                prompt_to_use = get_prompt
-
-            return self._read_raw_input(
-                prompt=prompt_to_use,
-                session=self.session,
-                completer=self.completer,
-                pre_run=self.pre_prompt,
-            )
-        except EOFError:
-            return constants.EOF
+
+        # Use dynamic prompt if the prompt matches self.prompt
+        def get_prompt() -> ANSI | str:
+            return ANSI(self.prompt)
+
+        prompt_to_use: Callable[[], ANSI | str] | ANSI | str = ANSI(prompt)
+        if prompt == self.prompt:
+            prompt_to_use = get_prompt
+
+        return self._read_raw_input(
+            prompt=prompt_to_use,
+            session=self.session,
+            completer=self.completer,
+            pre_run=self.pre_prompt,
+        )
 
     def _cmdloop(self) -> None:
         """Repeatedly issue a prompt, accept input, parse it, and dispatch to apporpriate commands.
@@ -3373,6 +3365,8 @@ def _cmdloop(self) -> None:
                 except KeyboardInterrupt:
                     self.poutput('^C')
                     line = ''
+                except EOFError:
+                    line = "_eof"
 
                 # Run the command along with all associated pre and post hooks
                 stop = self.onecmd_plus_hooks(line)
@@ -4193,17 +4187,17 @@ def do_shortcuts(self, _: argparse.Namespace) -> None:
         self.last_result = True
 
     @staticmethod
-    def _build_eof_parser() -> Cmd2ArgumentParser:
-        eof_parser = argparse_custom.DEFAULT_ARGUMENT_PARSER(description="Called when Ctrl-D is pressed.")
-        eof_parser.epilog = eof_parser.create_text_group(
+    def _build__eof_parser() -> Cmd2ArgumentParser:
+        _eof_parser = argparse_custom.DEFAULT_ARGUMENT_PARSER(description="Called when Ctrl-D is pressed.")
+        _eof_parser.epilog = _eof_parser.create_text_group(
             "Note",
             "This command is for internal use and is not intended to be called from the command line.",
         )
 
-        return eof_parser
+        return _eof_parser
 
-    @with_argparser(_build_eof_parser)
-    def do_eof(self, _: argparse.Namespace) -> bool | None:
+    @with_argparser(_build__eof_parser)
+    def do__eof(self, _: argparse.Namespace) -> bool | None:
         """Quit with no arguments, called when Ctrl-D is pressed.
 
         This can be overridden if quit should be called differently.

cmd2/constants.py

@@ -4,7 +4,6 @@
 # nothing here should be considered part of the public API of this module
 
 INFINITY = float('inf')
-EOF = 'eof'
 
 # Used for command parsing, output redirection, completion, and word breaks. Do not change.
 QUOTES = ['"', "'"]

tests/test_cmd2.py

@@ -1181,14 +1181,14 @@ def say_app():
 
 def test_ctrl_c_at_prompt(say_app, monkeypatch) -> None:
     read_command_mock = mock.MagicMock(name='_read_command_line')
-    read_command_mock.side_effect = ['say hello', KeyboardInterrupt(), 'say goodbye', constants.EOF]
+    read_command_mock.side_effect = ['say hello', KeyboardInterrupt(), 'say goodbye', 'quit']
     monkeypatch.setattr("cmd2.Cmd._read_command_line", read_command_mock)
 
     say_app.cmdloop()
 
     # And verify the expected output to stdout
     out = say_app.stdout.getvalue()
-    assert out == 'hello\n^C\ngoodbye\n\n'
+    assert out == 'hello\n^C\ngoodbye\n'
 
 
 class ShellApp(cmd2.Cmd):
@@ -1877,14 +1877,13 @@ def test_is_text_file_bad_input(base_app) -> None:
         utils.is_text_file('.')
 
 
-def test_eof(base_app) -> None:
-    # Only thing to verify is that it returns True
-    assert base_app.do_eof('')
-    assert base_app.last_result is True
+def test__eof(base_app) -> None:
+    base_app.do_quit = mock.MagicMock(return_value=True)
+    assert base_app.do__eof('')
+    base_app.do_quit.assert_called_once_with('')
 
 
 def test_quit(base_app) -> None:
-    # Only thing to verify is that it returns True
     assert base_app.do_quit('')
     assert base_app.last_result is True
 
@@ -2063,11 +2062,21 @@ def test_custom_stdout() -> None:
 
 
 def test_read_command_line_eof(base_app, monkeypatch) -> None:
+    """Test that _read_command_line passes up EOFErrors."""
+    read_raw_mock = mock.MagicMock(name='_read_raw_input', side_effect=EOFError)
+    monkeypatch.setattr("cmd2.Cmd._read_raw_input", read_raw_mock)
+
+    with pytest.raises(EOFError):
+        base_app._read_command_line("Prompt> ")
+
+
+def test_read_input_eof(base_app, monkeypatch) -> None:
+    """Test that read_input passes up EOFErrors."""
     read_raw_mock = mock.MagicMock(name='_read_raw_input', side_effect=EOFError)
     monkeypatch.setattr("cmd2.Cmd._read_raw_input", read_raw_mock)
 
-    line = base_app._read_command_line("Prompt> ")
-    assert line == constants.EOF
+    with pytest.raises(EOFError):
+        base_app.read_input("Prompt> ")
 
 
 def test_poutput_string(outsim_app) -> None:
@@ -3002,10 +3011,10 @@ def test_get_all_commands(base_app) -> None:
     # Verify that the base app has the expected commands
     commands = base_app.get_all_commands()
     expected_commands = [
+        '_eof',
         '_relative_run_script',
         'alias',
         'edit',
-        constants.EOF,
         'help',
         'history',
         'ipy',